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 #include "asterisk.h"
00040
00041 ASTERISK_FILE_VERSION(__FILE__, "$Revision: 382233 $")
00042
00043 #include <sys/mman.h>
00044 #include <dirent.h>
00045 #include <sys/socket.h>
00046 #include <netinet/in.h>
00047 #include <arpa/inet.h>
00048 #include <netinet/in_systm.h>
00049 #include <netinet/ip.h>
00050 #include <sys/time.h>
00051 #include <sys/signal.h>
00052 #include <signal.h>
00053 #include <strings.h>
00054 #include <netdb.h>
00055 #include <fcntl.h>
00056 #include <sys/stat.h>
00057 #include <regex.h>
00058
00059 #include "asterisk/paths.h"
00060
00061 #include "asterisk/lock.h"
00062 #include "asterisk/frame.h"
00063 #include "asterisk/channel.h"
00064 #include "asterisk/module.h"
00065 #include "asterisk/pbx.h"
00066 #include "asterisk/sched.h"
00067 #include "asterisk/io.h"
00068 #include "asterisk/config.h"
00069 #include "asterisk/cli.h"
00070 #include "asterisk/translate.h"
00071 #include "asterisk/md5.h"
00072 #include "asterisk/cdr.h"
00073 #include "asterisk/crypto.h"
00074 #include "asterisk/acl.h"
00075 #include "asterisk/manager.h"
00076 #include "asterisk/callerid.h"
00077 #include "asterisk/app.h"
00078 #include "asterisk/astdb.h"
00079 #include "asterisk/musiconhold.h"
00080 #include "asterisk/features.h"
00081 #include "asterisk/utils.h"
00082 #include "asterisk/causes.h"
00083 #include "asterisk/localtime.h"
00084 #include "asterisk/dnsmgr.h"
00085 #include "asterisk/devicestate.h"
00086 #include "asterisk/netsock.h"
00087 #include "asterisk/stringfields.h"
00088 #include "asterisk/linkedlists.h"
00089 #include "asterisk/event.h"
00090 #include "asterisk/astobj2.h"
00091 #include "asterisk/timing.h"
00092 #include "asterisk/taskprocessor.h"
00093 #include "asterisk/test.h"
00094 #include "asterisk/data.h"
00095 #include "asterisk/netsock2.h"
00096
00097 #include "iax2.h"
00098 #include "iax2-parser.h"
00099 #include "iax2-provision.h"
00100 #include "jitterbuf.h"
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
00211
00212
00213
00214
00215
00216
00217
00218
00219
00220
00221
00222
00223
00224
00225
00226
00227
00228
00229
00230
00231 #define SCHED_MULTITHREADED
00232
00233
00234
00235 #define DEBUG_SCHED_MULTITHREAD
00236
00237
00238 #ifdef SO_NO_CHECK
00239 static int nochecksums = 0;
00240 #endif
00241
00242 #define PTR_TO_CALLNO(a) ((unsigned short)(unsigned long)(a))
00243 #define CALLNO_TO_PTR(a) ((void *)(unsigned long)(a))
00244
00245 #define DEFAULT_THREAD_COUNT 10
00246 #define DEFAULT_MAX_THREAD_COUNT 100
00247 #define DEFAULT_RETRY_TIME 1000
00248 #define MEMORY_SIZE 100
00249 #define DEFAULT_DROP 3
00250
00251 #define DEBUG_SUPPORT
00252
00253 #define MIN_REUSE_TIME 60
00254
00255
00256 #define GAMMA (0.01)
00257
00258 static struct ast_codec_pref prefs;
00259
00260 static const char tdesc[] = "Inter Asterisk eXchange Driver (Ver 2)";
00261
00262
00263
00264
00265 #define MAX_TRUNK_MTU 1240
00266
00267 static int global_max_trunk_mtu;
00268 static int trunk_timed, trunk_untimed, trunk_maxmtu, trunk_nmaxmtu ;
00269
00270 #define DEFAULT_CONTEXT "default"
00271
00272 static char default_parkinglot[AST_MAX_CONTEXT];
00273
00274 static char language[MAX_LANGUAGE] = "";
00275 static char regcontext[AST_MAX_CONTEXT] = "";
00276
00277 static struct ast_event_sub *network_change_event_subscription;
00278 static int network_change_event_sched_id = -1;
00279
00280 static int maxauthreq = 3;
00281 static int max_retries = 4;
00282 static int ping_time = 21;
00283 static int lagrq_time = 10;
00284 static int maxjitterbuffer=1000;
00285 static int resyncthreshold=1000;
00286 static int maxjitterinterps=10;
00287 static int jittertargetextra = 40;
00288
00289 #define MAX_TRUNKDATA 640 * 200
00290
00291 static int trunkfreq = 20;
00292 static int trunkmaxsize = MAX_TRUNKDATA;
00293
00294 static int authdebug = 1;
00295 static int autokill = 0;
00296 static int iaxcompat = 0;
00297 static int last_authmethod = 0;
00298
00299 static int iaxdefaultdpcache=10 * 60;
00300
00301 static int iaxdefaulttimeout = 5;
00302
00303 static struct {
00304 unsigned int tos;
00305 unsigned int cos;
00306 } qos = { 0, 0 };
00307
00308 static int min_reg_expire;
00309 static int max_reg_expire;
00310
00311 static int srvlookup = 0;
00312
00313 static struct ast_timer *timer;
00314
00315 static struct ast_netsock_list *netsock;
00316 static struct ast_netsock_list *outsock;
00317 static int defaultsockfd = -1;
00318
00319 static int (*iax2_regfunk)(const char *username, int onoff) = NULL;
00320
00321
00322 #define IAX_CAPABILITY_FULLBANDWIDTH 0xFFFF
00323
00324 #define IAX_CAPABILITY_MEDBANDWIDTH (IAX_CAPABILITY_FULLBANDWIDTH & \
00325 ~AST_FORMAT_SLINEAR & \
00326 ~AST_FORMAT_SLINEAR16 & \
00327 ~AST_FORMAT_SIREN7 & \
00328 ~AST_FORMAT_SIREN14 & \
00329 ~AST_FORMAT_G719 & \
00330 ~AST_FORMAT_ULAW & \
00331 ~AST_FORMAT_ALAW & \
00332 ~AST_FORMAT_G722)
00333
00334 #define IAX_CAPABILITY_LOWBANDWIDTH (IAX_CAPABILITY_MEDBANDWIDTH & \
00335 ~AST_FORMAT_G726 & \
00336 ~AST_FORMAT_G726_AAL2 & \
00337 ~AST_FORMAT_ADPCM)
00338
00339 #define IAX_CAPABILITY_LOWFREE (IAX_CAPABILITY_LOWBANDWIDTH & \
00340 ~AST_FORMAT_G723_1)
00341
00342
00343 #define DEFAULT_MAXMS 2000
00344 #define DEFAULT_FREQ_OK 60 * 1000
00345 #define DEFAULT_FREQ_NOTOK 10 * 1000
00346
00347
00348 #define IAX_CALLENCRYPTED(pvt) \
00349 (ast_test_flag64(pvt, IAX_ENCRYPTED) && ast_test_flag64(pvt, IAX_KEYPOPULATED))
00350
00351 #define IAX_DEBUGDIGEST(msg, key) do { \
00352 int idx; \
00353 char digest[33] = ""; \
00354 \
00355 if (!iaxdebug) \
00356 break; \
00357 \
00358 for (idx = 0; idx < 16; idx++) \
00359 sprintf(digest + (idx << 1), "%2.2x", (unsigned char) key[idx]); \
00360 \
00361 ast_log(LOG_NOTICE, msg " IAX_COMMAND_RTKEY to rotate key to '%s'\n", digest); \
00362 } while(0)
00363
00364 static struct io_context *io;
00365 static struct ast_sched_thread *sched;
00366
00367 #define DONT_RESCHEDULE -2
00368
00369 static format_t iax2_capability = IAX_CAPABILITY_FULLBANDWIDTH;
00370
00371 static int iaxdebug = 0;
00372
00373 static int iaxtrunkdebug = 0;
00374
00375 static int test_losspct = 0;
00376 #ifdef IAXTESTS
00377 static int test_late = 0;
00378 static int test_resync = 0;
00379 static int test_jit = 0;
00380 static int test_jitpct = 0;
00381 #endif
00382
00383 static char accountcode[AST_MAX_ACCOUNT_CODE];
00384 static char mohinterpret[MAX_MUSICCLASS];
00385 static char mohsuggest[MAX_MUSICCLASS];
00386 static int amaflags = 0;
00387 static int adsi = 0;
00388 static int delayreject = 0;
00389 static int iax2_encryption = 0;
00390
00391 static struct ast_flags64 globalflags = { 0 };
00392
00393 static pthread_t netthreadid = AST_PTHREADT_NULL;
00394
00395 enum iax2_state {
00396 IAX_STATE_STARTED = (1 << 0),
00397 IAX_STATE_AUTHENTICATED = (1 << 1),
00398 IAX_STATE_TBD = (1 << 2),
00399 };
00400
00401 struct iax2_context {
00402 char context[AST_MAX_CONTEXT];
00403 struct iax2_context *next;
00404 };
00405
00406
00407 #define IAX_HASCALLERID (uint64_t)(1 << 0)
00408 #define IAX_DELME (uint64_t)(1 << 1)
00409 #define IAX_TEMPONLY (uint64_t)(1 << 2)
00410 #define IAX_TRUNK (uint64_t)(1 << 3)
00411 #define IAX_NOTRANSFER (uint64_t)(1 << 4)
00412 #define IAX_USEJITTERBUF (uint64_t)(1 << 5)
00413 #define IAX_DYNAMIC (uint64_t)(1 << 6)
00414 #define IAX_SENDANI (uint64_t)(1 << 7)
00415 #define IAX_RTSAVE_SYSNAME (uint64_t)(1 << 8)
00416 #define IAX_ALREADYGONE (uint64_t)(1 << 9)
00417 #define IAX_PROVISION (uint64_t)(1 << 10)
00418 #define IAX_QUELCH (uint64_t)(1 << 11)
00419 #define IAX_ENCRYPTED (uint64_t)(1 << 12)
00420 #define IAX_KEYPOPULATED (uint64_t)(1 << 13)
00421 #define IAX_CODEC_USER_FIRST (uint64_t)(1 << 14)
00422 #define IAX_CODEC_NOPREFS (uint64_t)(1 << 15)
00423 #define IAX_CODEC_NOCAP (uint64_t)(1 << 16)
00424 #define IAX_RTCACHEFRIENDS (uint64_t)(1 << 17)
00425 #define IAX_RTUPDATE (uint64_t)(1 << 18)
00426 #define IAX_RTAUTOCLEAR (uint64_t)(1 << 19)
00427 #define IAX_FORCEJITTERBUF (uint64_t)(1 << 20)
00428 #define IAX_RTIGNOREREGEXPIRE (uint64_t)(1 << 21)
00429 #define IAX_TRUNKTIMESTAMPS (uint64_t)(1 << 22)
00430 #define IAX_TRANSFERMEDIA (uint64_t)(1 << 23)
00431 #define IAX_MAXAUTHREQ (uint64_t)(1 << 24)
00432 #define IAX_DELAYPBXSTART (uint64_t)(1 << 25)
00433 #define IAX_ALLOWFWDOWNLOAD (uint64_t)(1 << 26)
00434 #define IAX_IMMEDIATE (uint64_t)(1 << 27)
00435 #define IAX_SENDCONNECTEDLINE (uint64_t)(1 << 28)
00436 #define IAX_RECVCONNECTEDLINE (uint64_t)(1 << 29)
00437 #define IAX_FORCE_ENCRYPT (uint64_t)(1 << 30)
00438 #define IAX_SHRINKCALLERID (uint64_t)(1 << 31)
00439 static int global_rtautoclear = 120;
00440
00441 static int reload_config(void);
00442
00443
00444
00445
00446 enum calltoken_peer_enum {
00447
00448 CALLTOKEN_DEFAULT = 0,
00449
00450 CALLTOKEN_YES = 1,
00451
00452
00453 CALLTOKEN_AUTO = 2,
00454
00455 CALLTOKEN_NO = 3,
00456 };
00457
00458 struct iax2_user {
00459 AST_DECLARE_STRING_FIELDS(
00460 AST_STRING_FIELD(name);
00461 AST_STRING_FIELD(secret);
00462 AST_STRING_FIELD(dbsecret);
00463 AST_STRING_FIELD(accountcode);
00464 AST_STRING_FIELD(mohinterpret);
00465 AST_STRING_FIELD(mohsuggest);
00466 AST_STRING_FIELD(inkeys);
00467 AST_STRING_FIELD(language);
00468 AST_STRING_FIELD(cid_num);
00469 AST_STRING_FIELD(cid_name);
00470 AST_STRING_FIELD(parkinglot);
00471 );
00472
00473 int authmethods;
00474 int encmethods;
00475 int amaflags;
00476 int adsi;
00477 uint64_t flags;
00478 format_t capability;
00479 int maxauthreq;
00480 int curauthreq;
00481 struct ast_codec_pref prefs;
00482 struct ast_ha *ha;
00483 struct iax2_context *contexts;
00484 struct ast_variable *vars;
00485 enum calltoken_peer_enum calltoken_required;
00486 };
00487
00488 struct iax2_peer {
00489 AST_DECLARE_STRING_FIELDS(
00490 AST_STRING_FIELD(name);
00491 AST_STRING_FIELD(username);
00492 AST_STRING_FIELD(secret);
00493 AST_STRING_FIELD(dbsecret);
00494 AST_STRING_FIELD(outkey);
00495
00496 AST_STRING_FIELD(regexten);
00497 AST_STRING_FIELD(context);
00498 AST_STRING_FIELD(peercontext);
00499 AST_STRING_FIELD(mailbox);
00500 AST_STRING_FIELD(mohinterpret);
00501 AST_STRING_FIELD(mohsuggest);
00502 AST_STRING_FIELD(inkeys);
00503
00504 AST_STRING_FIELD(cid_num);
00505 AST_STRING_FIELD(cid_name);
00506 AST_STRING_FIELD(zonetag);
00507 AST_STRING_FIELD(parkinglot);
00508 );
00509 struct ast_codec_pref prefs;
00510 struct ast_dnsmgr_entry *dnsmgr;
00511 struct ast_sockaddr addr;
00512 int formats;
00513 int sockfd;
00514 struct in_addr mask;
00515 int adsi;
00516 uint64_t flags;
00517
00518
00519 struct sockaddr_in defaddr;
00520 int authmethods;
00521 int encmethods;
00522
00523 int expire;
00524 int expiry;
00525 format_t capability;
00526
00527
00528 int callno;
00529 int pokeexpire;
00530 int lastms;
00531 int maxms;
00532
00533 int pokefreqok;
00534 int pokefreqnotok;
00535 int historicms;
00536 int smoothing;
00537 uint16_t maxcallno;
00538
00539 struct ast_event_sub *mwi_event_sub;
00540
00541 struct ast_ha *ha;
00542 enum calltoken_peer_enum calltoken_required;
00543 };
00544
00545 #define IAX2_TRUNK_PREFACE (sizeof(struct iax_frame) + sizeof(struct ast_iax2_meta_hdr) + sizeof(struct ast_iax2_meta_trunk_hdr))
00546
00547 struct iax2_trunk_peer {
00548 ast_mutex_t lock;
00549 int sockfd;
00550 struct sockaddr_in addr;
00551 struct timeval txtrunktime;
00552 struct timeval rxtrunktime;
00553 struct timeval lasttxtime;
00554 struct timeval trunkact;
00555 unsigned int lastsent;
00556
00557 unsigned char *trunkdata;
00558 unsigned int trunkdatalen;
00559 unsigned int trunkdataalloc;
00560 int trunkmaxmtu;
00561 int trunkerror;
00562 int calls;
00563 AST_LIST_ENTRY(iax2_trunk_peer) list;
00564 };
00565
00566 static AST_LIST_HEAD_STATIC(tpeers, iax2_trunk_peer);
00567
00568 struct iax_firmware {
00569 AST_LIST_ENTRY(iax_firmware) list;
00570 int fd;
00571 int mmaplen;
00572 int dead;
00573 struct ast_iax2_firmware_header *fwh;
00574 unsigned char *buf;
00575 };
00576
00577 enum iax_reg_state {
00578 REG_STATE_UNREGISTERED = 0,
00579 REG_STATE_REGSENT,
00580 REG_STATE_AUTHSENT,
00581 REG_STATE_REGISTERED,
00582 REG_STATE_REJECTED,
00583 REG_STATE_TIMEOUT,
00584 REG_STATE_NOAUTH
00585 };
00586
00587 enum iax_transfer_state {
00588 TRANSFER_NONE = 0,
00589 TRANSFER_BEGIN,
00590 TRANSFER_READY,
00591 TRANSFER_RELEASED,
00592 TRANSFER_PASSTHROUGH,
00593 TRANSFER_MBEGIN,
00594 TRANSFER_MREADY,
00595 TRANSFER_MRELEASED,
00596 TRANSFER_MPASSTHROUGH,
00597 TRANSFER_MEDIA,
00598 TRANSFER_MEDIAPASS
00599 };
00600
00601 struct iax2_registry {
00602 struct ast_sockaddr addr;
00603 char username[80];
00604 char secret[80];
00605 int expire;
00606 int refresh;
00607 enum iax_reg_state regstate;
00608 int messages;
00609 int callno;
00610 struct sockaddr_in us;
00611 struct ast_dnsmgr_entry *dnsmgr;
00612 AST_LIST_ENTRY(iax2_registry) entry;
00613 };
00614
00615 static AST_LIST_HEAD_STATIC(registrations, iax2_registry);
00616
00617
00618 #define MIN_RETRY_TIME 100
00619 #define MAX_RETRY_TIME 10000
00620
00621 #define MAX_JITTER_BUFFER 50
00622 #define MIN_JITTER_BUFFER 10
00623
00624 #define DEFAULT_TRUNKDATA 640 * 10
00625
00626 #define MAX_TIMESTAMP_SKEW 160
00627
00628
00629 #define TS_GAP_FOR_JB_RESYNC 5000
00630
00631
00632 #define MARK_IAX_SUBCLASS_TX 0x8000
00633
00634 static int iaxthreadcount = DEFAULT_THREAD_COUNT;
00635 static int iaxmaxthreadcount = DEFAULT_MAX_THREAD_COUNT;
00636 static int iaxdynamicthreadcount = 0;
00637 static int iaxdynamicthreadnum = 0;
00638 static int iaxactivethreadcount = 0;
00639
00640 struct iax_rr {
00641 int jitter;
00642 int losspct;
00643 int losscnt;
00644 int packets;
00645 int delay;
00646 int dropped;
00647 int ooo;
00648 };
00649
00650 struct iax2_pvt_ref;
00651
00652 struct chan_iax2_pvt {
00653
00654 int sockfd;
00655
00656 format_t voiceformat;
00657
00658 format_t videoformat;
00659
00660 format_t svoiceformat;
00661
00662 format_t svideoformat;
00663
00664 format_t capability;
00665
00666 unsigned int last;
00667
00668 unsigned int lastsent;
00669
00670 unsigned int lastvsent;
00671
00672 unsigned int nextpred;
00673
00674 int first_iax_message;
00675
00676 int last_iax_message;
00677
00678 unsigned int notsilenttx:1;
00679
00680 unsigned int pingtime;
00681
00682 int maxtime;
00683
00684 struct sockaddr_in addr;
00685
00686 struct ast_codec_pref prefs;
00687
00688 struct ast_codec_pref rprefs;
00689
00690 unsigned short callno;
00691
00692 struct callno_entry *callno_entry;
00693
00694 unsigned short peercallno;
00695
00696
00697
00698 format_t chosenformat;
00699
00700 format_t peerformat;
00701
00702 format_t peercapability;
00703
00704 struct timeval offset;
00705
00706 struct timeval rxcore;
00707
00708 jitterbuf *jb;
00709
00710 int jbid;
00711
00712 int lag;
00713
00714 int error;
00715
00716 struct ast_channel *owner;
00717
00718 struct ast_flags state;
00719
00720 int expiry;
00721
00722 unsigned char oseqno;
00723
00724 unsigned char rseqno;
00725
00726 unsigned char iseqno;
00727
00728 unsigned char aseqno;
00729
00730 AST_DECLARE_STRING_FIELDS(
00731
00732 AST_STRING_FIELD(peer);
00733
00734 AST_STRING_FIELD(context);
00735
00736 AST_STRING_FIELD(cid_num);
00737 AST_STRING_FIELD(cid_name);
00738
00739 AST_STRING_FIELD(ani);
00740
00741 AST_STRING_FIELD(dnid);
00742
00743 AST_STRING_FIELD(rdnis);
00744
00745 AST_STRING_FIELD(exten);
00746
00747 AST_STRING_FIELD(username);
00748
00749 AST_STRING_FIELD(secret);
00750
00751 AST_STRING_FIELD(challenge);
00752
00753 AST_STRING_FIELD(inkeys);
00754
00755 AST_STRING_FIELD(outkey);
00756
00757 AST_STRING_FIELD(language);
00758
00759 AST_STRING_FIELD(host);
00760
00761 AST_STRING_FIELD(dproot);
00762 AST_STRING_FIELD(accountcode);
00763 AST_STRING_FIELD(mohinterpret);
00764 AST_STRING_FIELD(mohsuggest);
00765
00766 AST_STRING_FIELD(osptoken);
00767
00768 AST_STRING_FIELD(parkinglot);
00769 );
00770
00771 int authrej;
00772
00773 int authmethods;
00774
00775 int encmethods;
00776
00777 ast_aes_encrypt_key ecx;
00778
00779 ast_aes_decrypt_key mydcx;
00780
00781 ast_aes_decrypt_key dcx;
00782
00783
00784 int keyrotateid;
00785
00786 unsigned char semirand[32];
00787
00788 struct iax2_registry *reg;
00789
00790 struct iax2_peer *peerpoke;
00791
00792 uint64_t flags;
00793 int adsi;
00794
00795
00796 enum iax_transfer_state transferring;
00797
00798 int transferid;
00799
00800 struct sockaddr_in transfer;
00801
00802 unsigned short transfercallno;
00803
00804 ast_aes_encrypt_key tdcx;
00805
00806
00807 int peeradsicpe;
00808
00809
00810 unsigned short bridgecallno;
00811
00812 int pingid;
00813 int lagid;
00814 int autoid;
00815 int authid;
00816 int authfail;
00817 int initid;
00818 int calling_ton;
00819 int calling_tns;
00820 int calling_pres;
00821 int amaflags;
00822 AST_LIST_HEAD_NOLOCK(, iax2_dpcache) dpentries;
00823
00824 struct ast_variable *vars;
00825
00826 struct ast_variable *iaxvars;
00827
00828 struct iax_rr remote_rr;
00829
00830 int min;
00831
00832 int frames_dropped;
00833
00834 int frames_received;
00835
00836 unsigned char calltoken_ie_len;
00837
00838 char hold_signaling;
00839
00840 AST_LIST_HEAD_NOLOCK(signaling_queue, signaling_queue_entry) signaling_queue;
00841 };
00842
00843 struct signaling_queue_entry {
00844 struct ast_frame f;
00845 AST_LIST_ENTRY(signaling_queue_entry) next;
00846 };
00847
00848
00849 static struct ao2_container *callno_pool;
00850
00851
00852 static struct ao2_container *callno_pool_trunk;
00853
00854 static const unsigned int CALLNO_POOL_BUCKETS = 2699;
00855
00856
00857
00858
00859
00860
00861
00862
00863
00864
00865 static AST_LIST_HEAD_NOLOCK(, iax_frame) frame_queue[IAX_MAX_CALLS];
00866
00867 static struct ast_taskprocessor *transmit_processor;
00868
00869 static int randomcalltokendata;
00870
00871 static const time_t MAX_CALLTOKEN_DELAY = 10;
00872
00873
00874
00875
00876
00877
00878
00879
00880 #ifdef LOW_MEMORY
00881 #define MAX_PEER_BUCKETS 17
00882 #else
00883 #define MAX_PEER_BUCKETS 563
00884 #endif
00885 static struct ao2_container *peers;
00886
00887 #define MAX_USER_BUCKETS MAX_PEER_BUCKETS
00888 static struct ao2_container *users;
00889
00890
00891 static struct ao2_container *peercnts;
00892
00893
00894 static struct ao2_container *callno_limits;
00895
00896
00897 static struct ao2_container *calltoken_ignores;
00898
00899 static uint16_t DEFAULT_MAXCALLNO_LIMIT = 2048;
00900
00901 static uint16_t DEFAULT_MAXCALLNO_LIMIT_NONVAL = 8192;
00902
00903 static uint16_t global_maxcallno;
00904
00905
00906 static uint16_t global_maxcallno_nonval;
00907
00908 static uint16_t total_nonval_callno_used = 0;
00909
00910
00911
00912 struct peercnt {
00913
00914 unsigned long addr;
00915
00916 uint16_t cur;
00917
00918 uint16_t limit;
00919
00920
00921 unsigned char reg;
00922 };
00923
00924
00925 struct addr_range {
00926
00927 struct ast_ha ha;
00928
00929 uint16_t limit;
00930
00931 unsigned char delme;
00932 };
00933
00934 struct callno_entry {
00935
00936 uint16_t callno;
00937
00938 unsigned char validated;
00939 };
00940
00941 static AST_LIST_HEAD_STATIC(firmwares, iax_firmware);
00942
00943 enum {
00944
00945 CACHE_FLAG_EXISTS = (1 << 0),
00946
00947 CACHE_FLAG_NONEXISTENT = (1 << 1),
00948
00949 CACHE_FLAG_CANEXIST = (1 << 2),
00950
00951 CACHE_FLAG_PENDING = (1 << 3),
00952
00953 CACHE_FLAG_TIMEOUT = (1 << 4),
00954
00955 CACHE_FLAG_TRANSMITTED = (1 << 5),
00956
00957 CACHE_FLAG_UNKNOWN = (1 << 6),
00958
00959 CACHE_FLAG_MATCHMORE = (1 << 7),
00960 };
00961
00962 struct iax2_dpcache {
00963 char peercontext[AST_MAX_CONTEXT];
00964 char exten[AST_MAX_EXTENSION];
00965 struct timeval orig;
00966 struct timeval expiry;
00967 int flags;
00968 unsigned short callno;
00969 int waiters[256];
00970 AST_LIST_ENTRY(iax2_dpcache) cache_list;
00971 AST_LIST_ENTRY(iax2_dpcache) peer_list;
00972 };
00973
00974 static AST_LIST_HEAD_STATIC(dpcache, iax2_dpcache);
00975
00976 static void reg_source_db(struct iax2_peer *p);
00977 static struct iax2_peer *realtime_peer(const char *peername, struct sockaddr_in *sin);
00978 static struct iax2_user *realtime_user(const char *username, struct sockaddr_in *sin);
00979
00980 static int ast_cli_netstats(struct mansession *s, int fd, int limit_fmt);
00981 static char *complete_iax2_peers(const char *line, const char *word, int pos, int state, uint64_t flags);
00982 static char *complete_iax2_unregister(const char *line, const char *word, int pos, int state);
00983
00984 enum iax2_thread_iostate {
00985 IAX_IOSTATE_IDLE,
00986 IAX_IOSTATE_READY,
00987 IAX_IOSTATE_PROCESSING,
00988 IAX_IOSTATE_SCHEDREADY,
00989 };
00990
00991 enum iax2_thread_type {
00992 IAX_THREAD_TYPE_POOL,
00993 IAX_THREAD_TYPE_DYNAMIC,
00994 };
00995
00996 struct iax2_pkt_buf {
00997 AST_LIST_ENTRY(iax2_pkt_buf) entry;
00998 size_t len;
00999 unsigned char buf[1];
01000 };
01001
01002 struct iax2_thread {
01003 AST_LIST_ENTRY(iax2_thread) list;
01004 enum iax2_thread_type type;
01005 enum iax2_thread_iostate iostate;
01006 #ifdef SCHED_MULTITHREADED
01007 void (*schedfunc)(const void *);
01008 const void *scheddata;
01009 #endif
01010 #ifdef DEBUG_SCHED_MULTITHREAD
01011 char curfunc[80];
01012 #endif
01013 int actions;
01014 pthread_t threadid;
01015 int threadnum;
01016 struct sockaddr_in iosin;
01017 unsigned char readbuf[4096];
01018 unsigned char *buf;
01019 ssize_t buf_len;
01020 size_t buf_size;
01021 int iofd;
01022 time_t checktime;
01023 ast_mutex_t lock;
01024 ast_cond_t cond;
01025 ast_mutex_t init_lock;
01026 ast_cond_t init_cond;
01027
01028
01029
01030
01031 struct {
01032 unsigned short callno;
01033 struct sockaddr_in sin;
01034 unsigned char type;
01035 unsigned char csub;
01036 } ffinfo;
01037
01038
01039
01040 AST_LIST_HEAD_NOLOCK(, iax2_pkt_buf) full_frames;
01041 unsigned char stop;
01042 };
01043
01044
01045 static AST_LIST_HEAD_STATIC(idle_list, iax2_thread);
01046 static AST_LIST_HEAD_STATIC(active_list, iax2_thread);
01047 static AST_LIST_HEAD_STATIC(dynamic_list, iax2_thread);
01048
01049 static void *iax2_process_thread(void *data);
01050 static void iax2_destroy(int callno);
01051
01052 static void signal_condition(ast_mutex_t *lock, ast_cond_t *cond)
01053 {
01054 ast_mutex_lock(lock);
01055 ast_cond_signal(cond);
01056 ast_mutex_unlock(lock);
01057 }
01058
01059
01060
01061
01062
01063
01064
01065
01066
01067 static struct chan_iax2_pvt *iaxs[IAX_MAX_CALLS];
01068
01069
01070
01071
01072
01073
01074
01075
01076
01077
01078 static struct ao2_container *iax_peercallno_pvts;
01079
01080
01081
01082
01083
01084
01085
01086
01087 static ast_mutex_t iaxsl[ARRAY_LEN(iaxs)];
01088
01089
01090
01091
01092
01093
01094 static struct ao2_container *iax_transfercallno_pvts;
01095
01096
01097
01098 #define TRUNK_CALL_START (IAX_MAX_CALLS / 2)
01099
01100
01101 static struct sockaddr_in debugaddr;
01102
01103 static void iax_outputframe(struct iax_frame *f, struct ast_iax2_full_hdr *fhi, int rx, struct sockaddr_in *sin, int datalen)
01104 {
01105 if (iaxdebug ||
01106 (sin && debugaddr.sin_addr.s_addr &&
01107 (!ntohs(debugaddr.sin_port) ||
01108 debugaddr.sin_port == sin->sin_port) &&
01109 debugaddr.sin_addr.s_addr == sin->sin_addr.s_addr)) {
01110 if (iaxdebug) {
01111 iax_showframe(f, fhi, rx, sin, datalen);
01112 } else {
01113 iaxdebug = 1;
01114 iax_showframe(f, fhi, rx, sin, datalen);
01115 iaxdebug = 0;
01116 }
01117 }
01118 }
01119
01120 static void iax_debug_output(const char *data)
01121 {
01122 if (iaxdebug)
01123 ast_verbose("%s", data);
01124 }
01125
01126 static void iax_error_output(const char *data)
01127 {
01128 ast_log(LOG_WARNING, "%s", data);
01129 }
01130
01131 static void __attribute__((format(printf, 1, 2))) jb_error_output(const char *fmt, ...)
01132 {
01133 va_list args;
01134 char buf[1024];
01135
01136 va_start(args, fmt);
01137 vsnprintf(buf, sizeof(buf), fmt, args);
01138 va_end(args);
01139
01140 ast_log(LOG_ERROR, "%s", buf);
01141 }
01142
01143 static void __attribute__((format(printf, 1, 2))) jb_warning_output(const char *fmt, ...)
01144 {
01145 va_list args;
01146 char buf[1024];
01147
01148 va_start(args, fmt);
01149 vsnprintf(buf, sizeof(buf), fmt, args);
01150 va_end(args);
01151
01152 ast_log(LOG_WARNING, "%s", buf);
01153 }
01154
01155 static void __attribute__((format(printf, 1, 2))) jb_debug_output(const char *fmt, ...)
01156 {
01157 va_list args;
01158 char buf[1024];
01159
01160 va_start(args, fmt);
01161 vsnprintf(buf, sizeof(buf), fmt, args);
01162 va_end(args);
01163
01164 ast_verbose("%s", buf);
01165 }
01166
01167 static enum ast_bridge_result iax2_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc, int timeoutms);
01168 static int expire_registry(const void *data);
01169 static int iax2_answer(struct ast_channel *c);
01170 static int iax2_call(struct ast_channel *c, char *dest, int timeout);
01171 static int iax2_devicestate(void *data);
01172 static int iax2_digit_begin(struct ast_channel *c, char digit);
01173 static int iax2_digit_end(struct ast_channel *c, char digit, unsigned int duration);
01174 static int iax2_do_register(struct iax2_registry *reg);
01175 static int iax2_fixup(struct ast_channel *oldchannel, struct ast_channel *newchan);
01176 static int iax2_hangup(struct ast_channel *c);
01177 static int iax2_indicate(struct ast_channel *c, int condition, const void *data, size_t datalen);
01178 static int iax2_poke_peer(struct iax2_peer *peer, int heldcall);
01179 static int iax2_provision(struct sockaddr_in *end, int sockfd, const char *dest, const char *template, int force);
01180 static int iax2_send(struct chan_iax2_pvt *pvt, struct ast_frame *f, unsigned int ts, int seqno, int now, int transfer, int final);
01181 static int iax2_sendhtml(struct ast_channel *c, int subclass, const char *data, int datalen);
01182 static int iax2_sendimage(struct ast_channel *c, struct ast_frame *img);
01183 static int iax2_sendtext(struct ast_channel *c, const char *text);
01184 static int iax2_setoption(struct ast_channel *c, int option, void *data, int datalen);
01185 static int iax2_queryoption(struct ast_channel *c, int option, void *data, int *datalen);
01186 static int iax2_transfer(struct ast_channel *c, const char *dest);
01187 static int iax2_write(struct ast_channel *c, struct ast_frame *f);
01188 static int iax2_sched_add(struct ast_sched_thread *st, int when, ast_sched_cb callback, const void *data);
01189
01190 static int send_trunk(struct iax2_trunk_peer *tpeer, struct timeval *now);
01191 static int send_command(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int);
01192 static int send_command_final(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int);
01193 static int send_command_immediate(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int);
01194 static int send_command_locked(unsigned short callno, char, int, unsigned int, const unsigned char *, int, int);
01195 static int send_command_transfer(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int);
01196 static struct ast_channel *iax2_request(const char *type, format_t format, const struct ast_channel *requestor, void *data, int *cause);
01197 static struct ast_frame *iax2_read(struct ast_channel *c);
01198 static struct iax2_peer *build_peer(const char *name, struct ast_variable *v, struct ast_variable *alt, int temponly);
01199 static struct iax2_user *build_user(const char *name, struct ast_variable *v, struct ast_variable *alt, int temponly);
01200 static void realtime_update_peer(const char *peername, struct ast_sockaddr *sockaddr, time_t regtime);
01201 static void *iax2_dup_variable_datastore(void *);
01202 static void prune_peers(void);
01203 static void prune_users(void);
01204 static void iax2_free_variable_datastore(void *);
01205
01206 static int acf_channel_read(struct ast_channel *chan, const char *funcname, char *preparse, char *buf, size_t buflen);
01207 static int decode_frame(ast_aes_decrypt_key *dcx, struct ast_iax2_full_hdr *fh, struct ast_frame *f, int *datalen);
01208 static int encrypt_frame(ast_aes_encrypt_key *ecx, struct ast_iax2_full_hdr *fh, unsigned char *poo, int *datalen);
01209 static void build_ecx_key(const unsigned char *digest, struct chan_iax2_pvt *pvt);
01210 static void build_rand_pad(unsigned char *buf, ssize_t len);
01211 static struct callno_entry *get_unused_callno(int trunk, int validated);
01212 static int replace_callno(const void *obj);
01213 static void sched_delay_remove(struct sockaddr_in *sin, struct callno_entry *callno_entry);
01214 static void network_change_event_cb(const struct ast_event *, void *);
01215
01216 static const struct ast_channel_tech iax2_tech = {
01217 .type = "IAX2",
01218 .description = tdesc,
01219 .capabilities = IAX_CAPABILITY_FULLBANDWIDTH,
01220 .properties = AST_CHAN_TP_WANTSJITTER,
01221 .requester = iax2_request,
01222 .devicestate = iax2_devicestate,
01223 .send_digit_begin = iax2_digit_begin,
01224 .send_digit_end = iax2_digit_end,
01225 .send_text = iax2_sendtext,
01226 .send_image = iax2_sendimage,
01227 .send_html = iax2_sendhtml,
01228 .call = iax2_call,
01229 .hangup = iax2_hangup,
01230 .answer = iax2_answer,
01231 .read = iax2_read,
01232 .write = iax2_write,
01233 .write_video = iax2_write,
01234 .indicate = iax2_indicate,
01235 .setoption = iax2_setoption,
01236 .queryoption = iax2_queryoption,
01237 .bridge = iax2_bridge,
01238 .transfer = iax2_transfer,
01239 .fixup = iax2_fixup,
01240 .func_channel_read = acf_channel_read,
01241 };
01242
01243
01244
01245
01246
01247
01248
01249
01250
01251
01252
01253
01254
01255
01256
01257
01258
01259
01260 static void iax2_lock_owner(int callno)
01261 {
01262 for (;;) {
01263 if (!iaxs[callno] || !iaxs[callno]->owner) {
01264
01265 break;
01266 }
01267 if (!ast_channel_trylock(iaxs[callno]->owner)) {
01268
01269 break;
01270 }
01271
01272 DEADLOCK_AVOIDANCE(&iaxsl[callno]);
01273 }
01274 }
01275
01276 static void mwi_event_cb(const struct ast_event *event, void *userdata)
01277 {
01278
01279
01280
01281 }
01282
01283 static void network_change_event_subscribe(void)
01284 {
01285 if (!network_change_event_subscription) {
01286 network_change_event_subscription = ast_event_subscribe(AST_EVENT_NETWORK_CHANGE,
01287 network_change_event_cb, "IAX2 Network Change", NULL, AST_EVENT_IE_END);
01288 }
01289 }
01290
01291 static void network_change_event_unsubscribe(void)
01292 {
01293 if (network_change_event_subscription) {
01294 network_change_event_subscription = ast_event_unsubscribe(network_change_event_subscription);
01295 }
01296 }
01297
01298 static int network_change_event_sched_cb(const void *data)
01299 {
01300 struct iax2_registry *reg;
01301 network_change_event_sched_id = -1;
01302 AST_LIST_LOCK(®istrations);
01303 AST_LIST_TRAVERSE(®istrations, reg, entry) {
01304 iax2_do_register(reg);
01305 }
01306 AST_LIST_UNLOCK(®istrations);
01307
01308 return 0;
01309 }
01310
01311 static void network_change_event_cb(const struct ast_event *event, void *userdata)
01312 {
01313 ast_debug(1, "IAX, got a network change event, renewing all IAX registrations.\n");
01314 if (network_change_event_sched_id == -1) {
01315 network_change_event_sched_id = iax2_sched_add(sched, 1000, network_change_event_sched_cb, NULL);
01316 }
01317
01318 }
01319
01320
01321
01322
01323 static void iax2_ami_channelupdate(struct chan_iax2_pvt *pvt)
01324 {
01325 manager_event(EVENT_FLAG_SYSTEM, "ChannelUpdate",
01326 "Channel: %s\r\nChanneltype: IAX2\r\nIAX2-callno-local: %d\r\nIAX2-callno-remote: %d\r\nIAX2-peer: %s\r\n",
01327 pvt->owner ? pvt->owner->name : "",
01328 pvt->callno, pvt->peercallno, pvt->peer ? pvt->peer : "");
01329 }
01330
01331 static const struct ast_datastore_info iax2_variable_datastore_info = {
01332 .type = "IAX2_VARIABLE",
01333 .duplicate = iax2_dup_variable_datastore,
01334 .destroy = iax2_free_variable_datastore,
01335 };
01336
01337 static void *iax2_dup_variable_datastore(void *old)
01338 {
01339 AST_LIST_HEAD(, ast_var_t) *oldlist = old, *newlist;
01340 struct ast_var_t *oldvar, *newvar;
01341
01342 newlist = ast_calloc(sizeof(*newlist), 1);
01343 if (!newlist) {
01344 ast_log(LOG_ERROR, "Unable to duplicate iax2 variables\n");
01345 return NULL;
01346 }
01347
01348 AST_LIST_HEAD_INIT(newlist);
01349 AST_LIST_LOCK(oldlist);
01350 AST_LIST_TRAVERSE(oldlist, oldvar, entries) {
01351 newvar = ast_var_assign(ast_var_name(oldvar), ast_var_value(oldvar));
01352 if (newvar)
01353 AST_LIST_INSERT_TAIL(newlist, newvar, entries);
01354 else
01355 ast_log(LOG_ERROR, "Unable to duplicate iax2 variable '%s'\n", ast_var_name(oldvar));
01356 }
01357 AST_LIST_UNLOCK(oldlist);
01358 return newlist;
01359 }
01360
01361 static void iax2_free_variable_datastore(void *old)
01362 {
01363 AST_LIST_HEAD(, ast_var_t) *oldlist = old;
01364 struct ast_var_t *oldvar;
01365
01366 AST_LIST_LOCK(oldlist);
01367 while ((oldvar = AST_LIST_REMOVE_HEAD(oldlist, entries))) {
01368 ast_free(oldvar);
01369 }
01370 AST_LIST_UNLOCK(oldlist);
01371 AST_LIST_HEAD_DESTROY(oldlist);
01372 ast_free(oldlist);
01373 }
01374
01375
01376
01377
01378
01379 static void insert_idle_thread(struct iax2_thread *thread)
01380 {
01381 if (thread->type == IAX_THREAD_TYPE_DYNAMIC) {
01382 AST_LIST_LOCK(&dynamic_list);
01383 AST_LIST_INSERT_TAIL(&dynamic_list, thread, list);
01384 AST_LIST_UNLOCK(&dynamic_list);
01385 } else {
01386 AST_LIST_LOCK(&idle_list);
01387 AST_LIST_INSERT_TAIL(&idle_list, thread, list);
01388 AST_LIST_UNLOCK(&idle_list);
01389 }
01390
01391 return;
01392 }
01393
01394 static struct iax2_thread *find_idle_thread(void)
01395 {
01396 struct iax2_thread *thread = NULL;
01397
01398
01399 AST_LIST_LOCK(&idle_list);
01400 thread = AST_LIST_REMOVE_HEAD(&idle_list, list);
01401 AST_LIST_UNLOCK(&idle_list);
01402
01403
01404 if (thread) {
01405 memset(&thread->ffinfo, 0, sizeof(thread->ffinfo));
01406 return thread;
01407 }
01408
01409
01410 AST_LIST_LOCK(&dynamic_list);
01411 thread = AST_LIST_REMOVE_HEAD(&dynamic_list, list);
01412 AST_LIST_UNLOCK(&dynamic_list);
01413
01414
01415 if (thread) {
01416 memset(&thread->ffinfo, 0, sizeof(thread->ffinfo));
01417 return thread;
01418 }
01419
01420
01421 if (iaxdynamicthreadcount >= iaxmaxthreadcount || !(thread = ast_calloc(1, sizeof(*thread))))
01422 return NULL;
01423
01424
01425 ast_atomic_fetchadd_int(&iaxdynamicthreadcount, 1);
01426 thread->threadnum = ast_atomic_fetchadd_int(&iaxdynamicthreadnum, 1);
01427 thread->type = IAX_THREAD_TYPE_DYNAMIC;
01428
01429
01430 ast_mutex_init(&thread->lock);
01431 ast_cond_init(&thread->cond, NULL);
01432 ast_mutex_init(&thread->init_lock);
01433 ast_cond_init(&thread->init_cond, NULL);
01434 ast_mutex_lock(&thread->init_lock);
01435
01436
01437 if (ast_pthread_create_background(&thread->threadid, NULL, iax2_process_thread, thread)) {
01438 ast_cond_destroy(&thread->cond);
01439 ast_mutex_destroy(&thread->lock);
01440 ast_mutex_unlock(&thread->init_lock);
01441 ast_cond_destroy(&thread->init_cond);
01442 ast_mutex_destroy(&thread->init_lock);
01443 ast_free(thread);
01444 return NULL;
01445 }
01446
01447
01448
01449 memset(&thread->ffinfo, 0, sizeof(thread->ffinfo));
01450
01451
01452 ast_cond_wait(&thread->init_cond, &thread->init_lock);
01453
01454
01455 ast_mutex_unlock(&thread->init_lock);
01456
01457 return thread;
01458 }
01459
01460 #ifdef SCHED_MULTITHREADED
01461 static int __schedule_action(void (*func)(const void *data), const void *data, const char *funcname)
01462 {
01463 struct iax2_thread *thread = NULL;
01464 static time_t lasterror;
01465 static time_t t;
01466
01467 thread = find_idle_thread();
01468
01469 if (thread != NULL) {
01470 thread->schedfunc = func;
01471 thread->scheddata = data;
01472 thread->iostate = IAX_IOSTATE_SCHEDREADY;
01473 #ifdef DEBUG_SCHED_MULTITHREAD
01474 ast_copy_string(thread->curfunc, funcname, sizeof(thread->curfunc));
01475 #endif
01476 signal_condition(&thread->lock, &thread->cond);
01477 return 0;
01478 }
01479 time(&t);
01480 if (t != lasterror)
01481 ast_debug(1, "Out of idle IAX2 threads for scheduling!\n");
01482 lasterror = t;
01483
01484 return -1;
01485 }
01486 #define schedule_action(func, data) __schedule_action(func, data, __PRETTY_FUNCTION__)
01487 #endif
01488
01489 static int iax2_sched_replace(int id, struct ast_sched_thread *st, int when,
01490 ast_sched_cb callback, const void *data)
01491 {
01492 ast_sched_thread_del(st, id);
01493
01494 return ast_sched_thread_add(st, when, callback, data);
01495 }
01496
01497 static int iax2_sched_add(struct ast_sched_thread *st, int when,
01498 ast_sched_cb callback, const void *data)
01499 {
01500 return ast_sched_thread_add(st, when, callback, data);
01501 }
01502
01503 static int send_ping(const void *data);
01504
01505 static void __send_ping(const void *data)
01506 {
01507 int callno = (long) data;
01508
01509 ast_mutex_lock(&iaxsl[callno]);
01510
01511 if (iaxs[callno]) {
01512 if (iaxs[callno]->peercallno) {
01513 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_PING, 0, NULL, 0, -1);
01514 if (iaxs[callno]->pingid != DONT_RESCHEDULE) {
01515 iaxs[callno]->pingid = iax2_sched_add(sched, ping_time * 1000, send_ping, data);
01516 }
01517 }
01518 } else {
01519 ast_debug(1, "I was supposed to send a PING with callno %d, but no such call exists.\n", callno);
01520 }
01521
01522 ast_mutex_unlock(&iaxsl[callno]);
01523 }
01524
01525 static int send_ping(const void *data)
01526 {
01527 int callno = (long) data;
01528 ast_mutex_lock(&iaxsl[callno]);
01529 if (iaxs[callno] && iaxs[callno]->pingid != DONT_RESCHEDULE) {
01530 iaxs[callno]->pingid = -1;
01531 }
01532 ast_mutex_unlock(&iaxsl[callno]);
01533
01534 #ifdef SCHED_MULTITHREADED
01535 if (schedule_action(__send_ping, data))
01536 #endif
01537 __send_ping(data);
01538
01539 return 0;
01540 }
01541
01542 static void encmethods_to_str(int e, struct ast_str **buf)
01543 {
01544 ast_str_set(buf, 0, "(");
01545 if (e & IAX_ENCRYPT_AES128) {
01546 ast_str_append(buf, 0, "aes128");
01547 }
01548 if (e & IAX_ENCRYPT_KEYROTATE) {
01549 ast_str_append(buf, 0, ",keyrotate");
01550 }
01551 if (ast_str_strlen(*buf) > 1) {
01552 ast_str_append(buf, 0, ")");
01553 } else {
01554 ast_str_set(buf, 0, "No");
01555 }
01556 }
01557
01558 static int get_encrypt_methods(const char *s)
01559 {
01560 int e;
01561 if (!strcasecmp(s, "aes128"))
01562 e = IAX_ENCRYPT_AES128 | IAX_ENCRYPT_KEYROTATE;
01563 else if (ast_true(s))
01564 e = IAX_ENCRYPT_AES128 | IAX_ENCRYPT_KEYROTATE;
01565 else
01566 e = 0;
01567 return e;
01568 }
01569
01570 static int send_lagrq(const void *data);
01571
01572 static void __send_lagrq(const void *data)
01573 {
01574 int callno = (long) data;
01575
01576 ast_mutex_lock(&iaxsl[callno]);
01577
01578 if (iaxs[callno]) {
01579 if (iaxs[callno]->peercallno) {
01580 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_LAGRQ, 0, NULL, 0, -1);
01581 if (iaxs[callno]->lagid != DONT_RESCHEDULE) {
01582 iaxs[callno]->lagid = iax2_sched_add(sched, lagrq_time * 1000, send_lagrq, data);
01583 }
01584 }
01585 } else {
01586 ast_debug(1, "I was supposed to send a LAGRQ with callno %d, but no such call exists.\n", callno);
01587 }
01588
01589 ast_mutex_unlock(&iaxsl[callno]);
01590 }
01591
01592 static int send_lagrq(const void *data)
01593 {
01594 int callno = (long) data;
01595 ast_mutex_lock(&iaxsl[callno]);
01596 if (iaxs[callno] && iaxs[callno]->lagid != DONT_RESCHEDULE) {
01597 iaxs[callno]->lagid = -1;
01598 }
01599 ast_mutex_unlock(&iaxsl[callno]);
01600
01601 #ifdef SCHED_MULTITHREADED
01602 if (schedule_action(__send_lagrq, data))
01603 #endif
01604 __send_lagrq(data);
01605 return 0;
01606 }
01607
01608 static unsigned char compress_subclass(format_t subclass)
01609 {
01610 int x;
01611 int power=-1;
01612
01613 if (subclass < IAX_FLAG_SC_LOG)
01614 return subclass;
01615
01616 for (x = 0; x < IAX_MAX_SHIFT; x++) {
01617 if (subclass & (1LL << x)) {
01618 if (power > -1) {
01619 ast_log(LOG_WARNING, "Can't compress subclass %lld\n", (long long) subclass);
01620 return 0;
01621 } else
01622 power = x;
01623 }
01624 }
01625 return power | IAX_FLAG_SC_LOG;
01626 }
01627
01628 static format_t uncompress_subclass(unsigned char csub)
01629 {
01630
01631 if (csub & IAX_FLAG_SC_LOG) {
01632
01633 if (csub == 0xff)
01634 return -1;
01635 else
01636 return 1LL << (csub & ~IAX_FLAG_SC_LOG & IAX_MAX_SHIFT);
01637 }
01638 else
01639 return csub;
01640 }
01641
01642
01643
01644
01645 static int peer_hash_cb(const void *obj, const int flags)
01646 {
01647 const struct iax2_peer *peer = obj;
01648
01649 return ast_str_hash(peer->name);
01650 }
01651
01652
01653
01654
01655 static int peer_cmp_cb(void *obj, void *arg, int flags)
01656 {
01657 struct iax2_peer *peer = obj, *peer2 = arg;
01658
01659 return !strcmp(peer->name, peer2->name) ? CMP_MATCH | CMP_STOP : 0;
01660 }
01661
01662
01663
01664
01665 static int user_hash_cb(const void *obj, const int flags)
01666 {
01667 const struct iax2_user *user = obj;
01668
01669 return ast_str_hash(user->name);
01670 }
01671
01672
01673
01674
01675 static int user_cmp_cb(void *obj, void *arg, int flags)
01676 {
01677 struct iax2_user *user = obj, *user2 = arg;
01678
01679 return !strcmp(user->name, user2->name) ? CMP_MATCH | CMP_STOP : 0;
01680 }
01681
01682
01683
01684
01685
01686 static struct iax2_peer *find_peer(const char *name, int realtime)
01687 {
01688 struct iax2_peer *peer = NULL;
01689 struct iax2_peer tmp_peer = {
01690 .name = name,
01691 };
01692
01693 peer = ao2_find(peers, &tmp_peer, OBJ_POINTER);
01694
01695
01696 if(!peer && realtime)
01697 peer = realtime_peer(name, NULL);
01698
01699 return peer;
01700 }
01701
01702 static struct iax2_peer *peer_ref(struct iax2_peer *peer)
01703 {
01704 ao2_ref(peer, +1);
01705 return peer;
01706 }
01707
01708 static inline struct iax2_peer *peer_unref(struct iax2_peer *peer)
01709 {
01710 ao2_ref(peer, -1);
01711 return NULL;
01712 }
01713
01714 static struct iax2_user *find_user(const char *name)
01715 {
01716 struct iax2_user tmp_user = {
01717 .name = name,
01718 };
01719
01720 return ao2_find(users, &tmp_user, OBJ_POINTER);
01721 }
01722 static inline struct iax2_user *user_ref(struct iax2_user *user)
01723 {
01724 ao2_ref(user, +1);
01725 return user;
01726 }
01727
01728 static inline struct iax2_user *user_unref(struct iax2_user *user)
01729 {
01730 ao2_ref(user, -1);
01731 return NULL;
01732 }
01733
01734 static int iax2_getpeername(struct sockaddr_in sin, char *host, int len)
01735 {
01736 struct iax2_peer *peer = NULL;
01737 int res = 0;
01738 struct ao2_iterator i;
01739
01740 i = ao2_iterator_init(peers, 0);
01741 while ((peer = ao2_iterator_next(&i))) {
01742 struct sockaddr_in peer_addr;
01743
01744 ast_sockaddr_to_sin(&peer->addr, &peer_addr);
01745
01746 if ((peer_addr.sin_addr.s_addr == sin.sin_addr.s_addr) &&
01747 (peer_addr.sin_port == sin.sin_port)) {
01748 ast_copy_string(host, peer->name, len);
01749 peer_unref(peer);
01750 res = 1;
01751 break;
01752 }
01753 peer_unref(peer);
01754 }
01755 ao2_iterator_destroy(&i);
01756
01757 if (!peer) {
01758 peer = realtime_peer(NULL, &sin);
01759 if (peer) {
01760 ast_copy_string(host, peer->name, len);
01761 peer_unref(peer);
01762 res = 1;
01763 }
01764 }
01765
01766 return res;
01767 }
01768
01769
01770
01771 static void iax2_destroy_helper(struct chan_iax2_pvt *pvt)
01772 {
01773
01774 if (ast_test_flag64(pvt, IAX_MAXAUTHREQ)) {
01775 struct iax2_user *user;
01776 struct iax2_user tmp_user = {
01777 .name = pvt->username,
01778 };
01779
01780 user = ao2_find(users, &tmp_user, OBJ_POINTER);
01781 if (user) {
01782 ast_atomic_fetchadd_int(&user->curauthreq, -1);
01783 user_unref(user);
01784 }
01785
01786 ast_clear_flag64(pvt, IAX_MAXAUTHREQ);
01787 }
01788
01789 AST_SCHED_DEL_SPINLOCK(ast_sched_thread_get_context(sched), pvt->pingid, &iaxsl[pvt->callno]);
01790 pvt->pingid = DONT_RESCHEDULE;
01791 AST_SCHED_DEL_SPINLOCK(ast_sched_thread_get_context(sched), pvt->lagid, &iaxsl[pvt->callno]);
01792 pvt->lagid = DONT_RESCHEDULE;
01793 ast_sched_thread_del(sched, pvt->autoid);
01794 ast_sched_thread_del(sched, pvt->authid);
01795 ast_sched_thread_del(sched, pvt->initid);
01796 ast_sched_thread_del(sched, pvt->jbid);
01797 ast_sched_thread_del(sched, pvt->keyrotateid);
01798 }
01799
01800 static void iax2_frame_free(struct iax_frame *fr)
01801 {
01802 ast_sched_thread_del(sched, fr->retrans);
01803 iax_frame_free(fr);
01804 }
01805
01806 static int scheduled_destroy(const void *vid)
01807 {
01808 unsigned short callno = PTR_TO_CALLNO(vid);
01809 ast_mutex_lock(&iaxsl[callno]);
01810 if (iaxs[callno]) {
01811 if (option_debug) {
01812 ast_log(LOG_DEBUG, "Really destroying %d now...\n", callno);
01813 }
01814 iax2_destroy(callno);
01815 }
01816 ast_mutex_unlock(&iaxsl[callno]);
01817 return 0;
01818 }
01819
01820 static void free_signaling_queue_entry(struct signaling_queue_entry *s)
01821 {
01822 if (s->f.datalen) {
01823 ast_free(s->f.data.ptr);
01824 }
01825 ast_free(s);
01826 }
01827
01828
01829
01830 static void send_signaling(struct chan_iax2_pvt *pvt)
01831 {
01832 struct signaling_queue_entry *s = NULL;
01833
01834 while ((s = AST_LIST_REMOVE_HEAD(&pvt->signaling_queue, next))) {
01835 iax2_send(pvt, &s->f, 0, -1, 0, 0, 0);
01836 free_signaling_queue_entry(s);
01837 }
01838 pvt->hold_signaling = 0;
01839 }
01840
01841
01842
01843 static int queue_signalling(struct chan_iax2_pvt *pvt, struct ast_frame *f)
01844 {
01845 struct signaling_queue_entry *qe;
01846
01847 if (f->frametype == AST_FRAME_IAX || !pvt->hold_signaling) {
01848 return 1;
01849 } else if (!(qe = ast_calloc(1, sizeof(struct signaling_queue_entry)))) {
01850 return -1;
01851 }
01852
01853
01854 qe->f = *f;
01855 if (qe->f.datalen) {
01856
01857 if (!(qe->f.data.ptr = ast_malloc(qe->f.datalen))) {
01858 free_signaling_queue_entry(qe);
01859 return -1;
01860 }
01861 memcpy(qe->f.data.ptr, f->data.ptr, qe->f.datalen);
01862 }
01863 AST_LIST_INSERT_TAIL(&pvt->signaling_queue, qe, next);
01864
01865 return 0;
01866 }
01867
01868 static void pvt_destructor(void *obj)
01869 {
01870 struct chan_iax2_pvt *pvt = obj;
01871 struct iax_frame *cur = NULL;
01872 struct signaling_queue_entry *s = NULL;
01873
01874 ast_mutex_lock(&iaxsl[pvt->callno]);
01875
01876 iax2_destroy_helper(pvt);
01877
01878 sched_delay_remove(&pvt->addr, pvt->callno_entry);
01879 pvt->callno_entry = NULL;
01880
01881
01882 ast_set_flag64(pvt, IAX_ALREADYGONE);
01883
01884 AST_LIST_TRAVERSE(&frame_queue[pvt->callno], cur, list) {
01885
01886 cur->retries = -1;
01887 }
01888
01889 ast_mutex_unlock(&iaxsl[pvt->callno]);
01890
01891 while ((s = AST_LIST_REMOVE_HEAD(&pvt->signaling_queue, next))) {
01892 free_signaling_queue_entry(s);
01893 }
01894
01895 if (pvt->reg) {
01896 pvt->reg->callno = 0;
01897 }
01898
01899 if (!pvt->owner) {
01900 jb_frame frame;
01901 if (pvt->vars) {
01902 ast_variables_destroy(pvt->vars);
01903 pvt->vars = NULL;
01904 }
01905
01906 while (jb_getall(pvt->jb, &frame) == JB_OK) {
01907 iax2_frame_free(frame.data);
01908 }
01909
01910 jb_destroy(pvt->jb);
01911 ast_string_field_free_memory(pvt);
01912 }
01913 }
01914
01915 static struct chan_iax2_pvt *new_iax(struct sockaddr_in *sin, const char *host)
01916 {
01917 struct chan_iax2_pvt *tmp;
01918 jb_conf jbconf;
01919
01920 if (!(tmp = ao2_alloc(sizeof(*tmp), pvt_destructor))) {
01921 return NULL;
01922 }
01923
01924 if (ast_string_field_init(tmp, 32)) {
01925 ao2_ref(tmp, -1);
01926 tmp = NULL;
01927 return NULL;
01928 }
01929
01930 tmp->prefs = prefs;
01931 tmp->pingid = -1;
01932 tmp->lagid = -1;
01933 tmp->autoid = -1;
01934 tmp->authid = -1;
01935 tmp->initid = -1;
01936 tmp->keyrotateid = -1;
01937
01938 ast_string_field_set(tmp,exten, "s");
01939 ast_string_field_set(tmp,host, host);
01940
01941 tmp->jb = jb_new();
01942 tmp->jbid = -1;
01943 jbconf.max_jitterbuf = maxjitterbuffer;
01944 jbconf.resync_threshold = resyncthreshold;
01945 jbconf.max_contig_interp = maxjitterinterps;
01946 jbconf.target_extra = jittertargetextra;
01947 jb_setconf(tmp->jb,&jbconf);
01948
01949 AST_LIST_HEAD_INIT_NOLOCK(&tmp->dpentries);
01950
01951 tmp->hold_signaling = 1;
01952 AST_LIST_HEAD_INIT_NOLOCK(&tmp->signaling_queue);
01953
01954 return tmp;
01955 }
01956
01957 static struct iax_frame *iaxfrdup2(struct iax_frame *fr)
01958 {
01959 struct iax_frame *new = iax_frame_new(DIRECTION_INGRESS, fr->af.datalen, fr->cacheable);
01960 if (new) {
01961 size_t afdatalen = new->afdatalen;
01962 memcpy(new, fr, sizeof(*new));
01963 iax_frame_wrap(new, &fr->af);
01964 new->afdatalen = afdatalen;
01965 new->data = NULL;
01966 new->datalen = 0;
01967 new->direction = DIRECTION_INGRESS;
01968 new->retrans = -1;
01969 }
01970 return new;
01971 }
01972
01973
01974 enum {
01975
01976 NEW_PREVENT = 0,
01977
01978 NEW_ALLOW = 1,
01979
01980 NEW_FORCE = 2,
01981
01982
01983 NEW_ALLOW_CALLTOKEN_VALIDATED = 3,
01984 };
01985
01986 static int match(struct sockaddr_in *sin, unsigned short callno, unsigned short dcallno, const struct chan_iax2_pvt *cur, int check_dcallno)
01987 {
01988 if ((cur->addr.sin_addr.s_addr == sin->sin_addr.s_addr) &&
01989 (cur->addr.sin_port == sin->sin_port)) {
01990
01991 if ( (cur->peercallno == 0 || cur->peercallno == callno) &&
01992 (check_dcallno ? dcallno == cur->callno : 1) ) {
01993
01994 return 1;
01995 }
01996 }
01997 if ((cur->transfer.sin_addr.s_addr == sin->sin_addr.s_addr) &&
01998 (cur->transfer.sin_port == sin->sin_port) && (cur->transferring)) {
01999
02000 if ((dcallno == cur->callno) || (cur->transferring == TRANSFER_MEDIAPASS && cur->transfercallno == callno))
02001 return 1;
02002 }
02003 return 0;
02004 }
02005
02006 #ifdef IAX_OLD_FIND
02007
02008 static int maxtrunkcall = TRUNK_CALL_START;
02009 static int maxnontrunkcall = 1;
02010
02011 #define update_max_trunk() __update_max_trunk()
02012 #define update_max_nontrunk() __update_max_nontrunk()
02013
02014 static void __update_max_trunk(void)
02015 {
02016 int max = TRUNK_CALL_START;
02017 int x;
02018
02019
02020 for (x = TRUNK_CALL_START; x < ARRAY_LEN(iaxs) - 1; x++) {
02021 if (iaxs[x]) {
02022 max = x + 1;
02023 }
02024 }
02025
02026 maxtrunkcall = max;
02027 if (iaxdebug)
02028 ast_debug(1, "New max trunk callno is %d\n", max);
02029 }
02030
02031 static void __update_max_nontrunk(void)
02032 {
02033 int max = 1;
02034 int x;
02035
02036 for (x=1;x<TRUNK_CALL_START - 1; x++) {
02037 if (iaxs[x])
02038 max = x + 1;
02039 }
02040 maxnontrunkcall = max;
02041 if (iaxdebug)
02042 ast_debug(1, "New max nontrunk callno is %d\n", max);
02043 }
02044
02045 #else
02046
02047 #define update_max_trunk() do { } while (0)
02048 #define update_max_nontrunk() do { } while (0)
02049
02050 #endif
02051
02052 static int make_trunk(unsigned short callno, int locked)
02053 {
02054 int x;
02055 int res= 0;
02056 struct callno_entry *callno_entry;
02057 if (iaxs[callno]->oseqno) {
02058 ast_log(LOG_WARNING, "Can't make trunk once a call has started!\n");
02059 return -1;
02060 }
02061 if (callno >= TRUNK_CALL_START) {
02062 ast_log(LOG_WARNING, "Call %d is already a trunk\n", callno);
02063 return -1;
02064 }
02065
02066 if (!(callno_entry = get_unused_callno(1, iaxs[callno]->callno_entry->validated))) {
02067 ast_log(LOG_WARNING, "Unable to trunk call: Insufficient space\n");
02068 return -1;
02069 }
02070
02071 x = callno_entry->callno;
02072 ast_mutex_lock(&iaxsl[x]);
02073
02074
02075
02076
02077
02078 ast_sched_thread_del(sched, iaxs[callno]->pingid);
02079 ast_sched_thread_del(sched, iaxs[callno]->lagid);
02080 iaxs[callno]->lagid = iaxs[callno]->pingid = -1;
02081 iaxs[x] = iaxs[callno];
02082 iaxs[x]->callno = x;
02083
02084
02085
02086 if (iaxs[x]->callno_entry) {
02087 iax2_sched_add(sched, MIN_REUSE_TIME * 1000, replace_callno, iaxs[x]->callno_entry);
02088 }
02089 iaxs[x]->callno_entry = callno_entry;
02090
02091 iaxs[callno] = NULL;
02092
02093 iaxs[x]->pingid = iax2_sched_add(sched,
02094 ping_time * 1000, send_ping, (void *)(long)x);
02095 iaxs[x]->lagid = iax2_sched_add(sched,
02096 lagrq_time * 1000, send_lagrq, (void *)(long)x);
02097
02098 if (locked)
02099 ast_mutex_unlock(&iaxsl[callno]);
02100 res = x;
02101 if (!locked)
02102 ast_mutex_unlock(&iaxsl[x]);
02103
02104 ast_debug(1, "Made call %d into trunk call %d\n", callno, x);
02105
02106 update_max_trunk();
02107 update_max_nontrunk();
02108 return res;
02109 }
02110
02111 static void store_by_transfercallno(struct chan_iax2_pvt *pvt)
02112 {
02113 if (!pvt->transfercallno) {
02114 ast_log(LOG_ERROR, "This should not be called without a transfer call number.\n");
02115 return;
02116 }
02117
02118 ao2_link(iax_transfercallno_pvts, pvt);
02119 }
02120
02121 static void remove_by_transfercallno(struct chan_iax2_pvt *pvt)
02122 {
02123 if (!pvt->transfercallno) {
02124 ast_log(LOG_ERROR, "This should not be called without a transfer call number.\n");
02125 return;
02126 }
02127
02128 ao2_unlink(iax_transfercallno_pvts, pvt);
02129 }
02130 static void store_by_peercallno(struct chan_iax2_pvt *pvt)
02131 {
02132 if (!pvt->peercallno) {
02133 ast_log(LOG_ERROR, "This should not be called without a peer call number.\n");
02134 return;
02135 }
02136
02137 ao2_link(iax_peercallno_pvts, pvt);
02138 }
02139
02140 static void remove_by_peercallno(struct chan_iax2_pvt *pvt)
02141 {
02142 if (!pvt->peercallno) {
02143 ast_log(LOG_ERROR, "This should not be called without a peer call number.\n");
02144 return;
02145 }
02146
02147 ao2_unlink(iax_peercallno_pvts, pvt);
02148 }
02149
02150 static int addr_range_delme_cb(void *obj, void *arg, int flags)
02151 {
02152 struct addr_range *lim = obj;
02153 lim->delme = 1;
02154 return 0;
02155 }
02156
02157 static int addr_range_hash_cb(const void *obj, const int flags)
02158 {
02159 const struct addr_range *lim = obj;
02160 struct sockaddr_in sin;
02161 ast_sockaddr_to_sin(&lim->ha.addr, &sin);
02162 return abs((int) sin.sin_addr.s_addr);
02163 }
02164
02165 static int addr_range_cmp_cb(void *obj, void *arg, int flags)
02166 {
02167 struct addr_range *lim1 = obj, *lim2 = arg;
02168 return (!(ast_sockaddr_cmp_addr(&lim1->ha.addr, &lim2->ha.addr)) &&
02169 !(ast_sockaddr_cmp_addr(&lim1->ha.netmask, &lim2->ha.netmask))) ?
02170 CMP_MATCH | CMP_STOP : 0;
02171 }
02172
02173 static int peercnt_hash_cb(const void *obj, const int flags)
02174 {
02175 const struct peercnt *peercnt = obj;
02176 return abs((int) peercnt->addr);
02177 }
02178
02179 static int peercnt_cmp_cb(void *obj, void *arg, int flags)
02180 {
02181 struct peercnt *peercnt1 = obj, *peercnt2 = arg;
02182 return (peercnt1->addr == peercnt2->addr) ? CMP_MATCH | CMP_STOP : 0;
02183 }
02184
02185 static int addr_range_match_address_cb(void *obj, void *arg, int flags)
02186 {
02187 struct addr_range *addr_range = obj;
02188 struct sockaddr_in *sin = arg;
02189 struct sockaddr_in ha_netmask_sin;
02190 struct sockaddr_in ha_addr_sin;
02191
02192 ast_sockaddr_to_sin(&addr_range->ha.netmask, &ha_netmask_sin);
02193 ast_sockaddr_to_sin(&addr_range->ha.addr, &ha_addr_sin);
02194
02195 if ((sin->sin_addr.s_addr & ha_netmask_sin.sin_addr.s_addr) == ha_addr_sin.sin_addr.s_addr) {
02196 return CMP_MATCH | CMP_STOP;
02197 }
02198 return 0;
02199 }
02200
02201
02202
02203
02204
02205
02206 static int calltoken_required(struct sockaddr_in *sin, const char *name, int subclass)
02207 {
02208 struct addr_range *addr_range;
02209 struct iax2_peer *peer = NULL;
02210 struct iax2_user *user = NULL;
02211
02212 const char *find = S_OR(name, "guest");
02213 int res = 1;
02214 int optional = 0;
02215 enum calltoken_peer_enum calltoken_required = CALLTOKEN_DEFAULT;
02216
02217
02218
02219
02220
02221
02222
02223 if ((addr_range = ao2_callback(calltoken_ignores, 0, addr_range_match_address_cb, sin))) {
02224 ao2_ref(addr_range, -1);
02225 optional = 1;
02226 }
02227
02228
02229 if ((subclass == IAX_COMMAND_NEW) && (user = find_user(find))) {
02230 calltoken_required = user->calltoken_required;
02231 } else if ((subclass == IAX_COMMAND_NEW) && (user = realtime_user(find, sin))) {
02232 calltoken_required = user->calltoken_required;
02233 } else if ((subclass != IAX_COMMAND_NEW) && (peer = find_peer(find, 0))) {
02234 calltoken_required = peer->calltoken_required;
02235 } else if ((subclass != IAX_COMMAND_NEW) && (peer = realtime_peer(find, sin))) {
02236 calltoken_required = peer->calltoken_required;
02237 }
02238
02239 if (peer) {
02240 peer_unref(peer);
02241 }
02242 if (user) {
02243 user_unref(user);
02244 }
02245
02246 ast_debug(1, "Determining if address %s with username %s requires calltoken validation. Optional = %d calltoken_required = %d \n", ast_inet_ntoa(sin->sin_addr), name, optional, calltoken_required);
02247 if (((calltoken_required == CALLTOKEN_NO) || (calltoken_required == CALLTOKEN_AUTO)) ||
02248 (optional && (calltoken_required == CALLTOKEN_DEFAULT))) {
02249 res = 0;
02250 }
02251
02252 return res;
02253 }
02254
02255
02256
02257
02258
02259
02260
02261
02262
02263
02264
02265 static void set_peercnt_limit(struct peercnt *peercnt)
02266 {
02267 uint16_t limit = global_maxcallno;
02268 struct addr_range *addr_range;
02269 struct sockaddr_in sin = {
02270 .sin_addr.s_addr = peercnt->addr,
02271 };
02272
02273
02274 if (peercnt->reg && peercnt->limit) {
02275 return;
02276 }
02277
02278 if ((addr_range = ao2_callback(callno_limits, 0, addr_range_match_address_cb, &sin))) {
02279 limit = addr_range->limit;
02280 ast_debug(1, "custom addr_range %d found for %s\n", limit, ast_inet_ntoa(sin.sin_addr));
02281 ao2_ref(addr_range, -1);
02282 }
02283
02284 peercnt->limit = limit;
02285 }
02286
02287
02288
02289
02290
02291 static int set_peercnt_limit_all_cb(void *obj, void *arg, int flags)
02292 {
02293 struct peercnt *peercnt = obj;
02294
02295 set_peercnt_limit(peercnt);
02296 ast_debug(1, "Reset limits for peercnts table\n");
02297
02298 return 0;
02299 }
02300
02301
02302
02303
02304
02305 static int prune_addr_range_cb(void *obj, void *arg, int flags)
02306 {
02307 struct addr_range *addr_range = obj;
02308
02309 return addr_range->delme ? CMP_MATCH : 0;
02310 }
02311
02312
02313
02314
02315
02316 static void peercnt_modify(unsigned char reg, uint16_t limit, struct ast_sockaddr *sockaddr)
02317 {
02318
02319 struct peercnt *peercnt;
02320 struct peercnt tmp = {
02321 .addr = 0,
02322 };
02323 struct sockaddr_in sin;
02324
02325 ast_sockaddr_to_sin(sockaddr, &sin);
02326
02327 tmp.addr = sin.sin_addr.s_addr;
02328
02329 if ((peercnt = ao2_find(peercnts, &tmp, OBJ_POINTER))) {
02330 peercnt->reg = reg;
02331 if (limit) {
02332 peercnt->limit = limit;
02333 } else {
02334 set_peercnt_limit(peercnt);
02335 }
02336 ast_debug(1, "peercnt entry %s modified limit:%d registered:%d", ast_inet_ntoa(sin.sin_addr), peercnt->limit, peercnt->reg);
02337 ao2_ref(peercnt, -1);
02338 }
02339 }
02340
02341
02342
02343
02344
02345
02346
02347
02348
02349 static int peercnt_add(struct sockaddr_in *sin)
02350 {
02351 struct peercnt *peercnt;
02352 unsigned long addr = sin->sin_addr.s_addr;
02353 int res = 0;
02354 struct peercnt tmp = {
02355 .addr = addr,
02356 };
02357
02358
02359
02360
02361
02362
02363
02364 ao2_lock(peercnts);
02365 if ((peercnt = ao2_find(peercnts, &tmp, OBJ_POINTER))) {
02366 ao2_lock(peercnt);
02367 } else if ((peercnt = ao2_alloc(sizeof(*peercnt), NULL))) {
02368 ao2_lock(peercnt);
02369
02370 peercnt->addr = addr;
02371 set_peercnt_limit(peercnt);
02372
02373
02374 ao2_link(peercnts, peercnt);
02375 } else {
02376 ao2_unlock(peercnts);
02377 return -1;
02378 }
02379
02380
02381 if (peercnt->limit > peercnt->cur) {
02382 peercnt->cur++;
02383 ast_debug(1, "ip callno count incremented to %d for %s\n", peercnt->cur, ast_inet_ntoa(sin->sin_addr));
02384 } else {
02385 ast_log(LOG_ERROR, "maxcallnumber limit of %d for %s has been reached!\n", peercnt->limit, ast_inet_ntoa(sin->sin_addr));
02386 res = -1;
02387 }
02388
02389
02390 ao2_unlock(peercnt);
02391 ao2_unlock(peercnts);
02392 ao2_ref(peercnt, -1);
02393
02394 return res;
02395 }
02396
02397
02398
02399
02400
02401 static void peercnt_remove(struct peercnt *peercnt)
02402 {
02403 struct sockaddr_in sin = {
02404 .sin_addr.s_addr = peercnt->addr,
02405 };
02406
02407
02408
02409
02410
02411
02412
02413 ao2_lock(peercnts);
02414 peercnt->cur--;
02415 ast_debug(1, "ip callno count decremented to %d for %s\n", peercnt->cur, ast_inet_ntoa(sin.sin_addr));
02416
02417 if (peercnt->cur == 0) {
02418 ao2_unlink(peercnts, peercnt);
02419 }
02420 ao2_unlock(peercnts);
02421 }
02422
02423
02424
02425
02426
02427 static int peercnt_remove_cb(const void *obj)
02428 {
02429 struct peercnt *peercnt = (struct peercnt *) obj;
02430
02431 peercnt_remove(peercnt);
02432 ao2_ref(peercnt, -1);
02433
02434 return 0;
02435 }
02436
02437
02438
02439
02440
02441 static int peercnt_remove_by_addr(struct sockaddr_in *sin)
02442 {
02443 struct peercnt *peercnt;
02444 struct peercnt tmp = {
02445 .addr = sin->sin_addr.s_addr,
02446 };
02447
02448 if ((peercnt = ao2_find(peercnts, &tmp, OBJ_POINTER))) {
02449 peercnt_remove(peercnt);
02450 ao2_ref(peercnt, -1);
02451 }
02452 return 0;
02453 }
02454
02455
02456
02457
02458
02459 static void build_callno_limits(struct ast_variable *v)
02460 {
02461 struct addr_range *addr_range = NULL;
02462 struct addr_range tmp;
02463 struct ast_ha *ha;
02464 int limit;
02465 int error;
02466 int found;
02467
02468 for (; v; v = v->next) {
02469 limit = -1;
02470 error = 0;
02471 found = 0;
02472 ha = ast_append_ha("permit", v->name, NULL, &error);
02473
02474
02475 if (error) {
02476 ast_log(LOG_ERROR, "Call number limit for %s could not be added, Invalid address range\n.", v->name);
02477 continue;
02478 } else if ((sscanf(v->value, "%d", &limit) != 1) || (limit < 0)) {
02479 ast_log(LOG_ERROR, "Call number limit for %s could not be added. Invalid limit %s\n.", v->name, v->value);
02480 ast_free_ha(ha);
02481 continue;
02482 }
02483
02484 ast_copy_ha(ha, &tmp.ha);
02485
02486 if ((addr_range = ao2_find(callno_limits, &tmp, OBJ_POINTER))) {
02487 ao2_lock(addr_range);
02488 found = 1;
02489 } else if (!(addr_range = ao2_alloc(sizeof(*addr_range), NULL))) {
02490 ast_free_ha(ha);
02491 return;
02492 }
02493
02494
02495 ast_copy_ha(ha, &addr_range->ha);
02496 ast_free_ha(ha);
02497 addr_range->limit = limit;
02498 addr_range->delme = 0;
02499
02500
02501 if (found) {
02502 ao2_unlock(addr_range);
02503 } else {
02504 ao2_link(callno_limits, addr_range);
02505 }
02506 ao2_ref(addr_range, -1);
02507 }
02508 }
02509
02510
02511
02512
02513
02514 static int add_calltoken_ignore(const char *addr)
02515 {
02516 struct addr_range tmp;
02517 struct addr_range *addr_range = NULL;
02518 struct ast_ha *ha = NULL;
02519 int error = 0;
02520
02521 if (ast_strlen_zero(addr)) {
02522 ast_log(LOG_WARNING, "invalid calltokenoptional %s\n", addr);
02523 return -1;
02524 }
02525
02526 ha = ast_append_ha("permit", addr, NULL, &error);
02527
02528
02529 if (error) {
02530 ast_log(LOG_WARNING, "Error %d creating calltokenoptional entry %s\n", error, addr);
02531 return -1;
02532 }
02533
02534 ast_copy_ha(ha, &tmp.ha);
02535
02536 if ((addr_range = ao2_find(calltoken_ignores, &tmp, OBJ_POINTER))) {
02537 ao2_lock(addr_range);
02538 addr_range->delme = 0;
02539 ao2_unlock(addr_range);
02540 } else if ((addr_range = ao2_alloc(sizeof(*addr_range), NULL))) {
02541
02542 ast_copy_ha(ha, &addr_range->ha);
02543 ao2_link(calltoken_ignores, addr_range);
02544 } else {
02545 ast_free_ha(ha);
02546 return -1;
02547 }
02548
02549 ast_free_ha(ha);
02550 ao2_ref(addr_range, -1);
02551
02552 return 0;
02553 }
02554
02555 static char *handle_cli_iax2_show_callno_limits(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
02556 {
02557 struct ao2_iterator i;
02558 struct peercnt *peercnt;
02559 struct sockaddr_in sin;
02560 int found = 0;
02561
02562 switch (cmd) {
02563 case CLI_INIT:
02564 e->command = "iax2 show callnumber usage";
02565 e->usage =
02566 "Usage: iax2 show callnumber usage [IP address]\n"
02567 " Shows current IP addresses which are consuming iax2 call numbers\n";
02568 return NULL;
02569 case CLI_GENERATE:
02570 return NULL;
02571 case CLI_HANDLER:
02572 if (a->argc < 4 || a->argc > 5)
02573 return CLI_SHOWUSAGE;
02574
02575 if (a->argc == 4) {
02576 ast_cli(a->fd, "%-15s %-12s %-12s\n", "Address", "Callno Usage", "Callno Limit");
02577 }
02578
02579 i = ao2_iterator_init(peercnts, 0);
02580 while ((peercnt = ao2_iterator_next(&i))) {
02581 sin.sin_addr.s_addr = peercnt->addr;
02582 if (a->argc == 5) {
02583 if (!strcasecmp(a->argv[4], ast_inet_ntoa(sin.sin_addr))) {
02584 ast_cli(a->fd, "%-15s %-12s %-12s\n", "Address", "Callno Usage", "Callno Limit");
02585 ast_cli(a->fd, "%-15s %-12d %-12d\n", ast_inet_ntoa(sin.sin_addr), peercnt->cur, peercnt->limit);
02586 ao2_ref(peercnt, -1);
02587 found = 1;
02588 break;
02589 }
02590 } else {
02591 ast_cli(a->fd, "%-15s %-12d %-12d\n", ast_inet_ntoa(sin.sin_addr), peercnt->cur, peercnt->limit);
02592 }
02593 ao2_ref(peercnt, -1);
02594 }
02595 ao2_iterator_destroy(&i);
02596
02597 if (a->argc == 4) {
02598 ast_cli(a->fd, "\nNon-CallToken Validation Callno Limit: %d\n"
02599 "Non-CallToken Validated Callno Used: %d\n",
02600 global_maxcallno_nonval,
02601 total_nonval_callno_used);
02602
02603 ast_cli(a->fd, "Total Available Callno: %d\n"
02604 "Regular Callno Available: %d\n"
02605 "Trunk Callno Available: %d\n",
02606 ao2_container_count(callno_pool) + ao2_container_count(callno_pool_trunk),
02607 ao2_container_count(callno_pool),
02608 ao2_container_count(callno_pool_trunk));
02609 } else if (a->argc == 5 && !found) {
02610 ast_cli(a->fd, "No call number table entries for %s found\n", a->argv[4] );
02611 }
02612
02613
02614 return CLI_SUCCESS;
02615 default:
02616 return NULL;
02617 }
02618 }
02619
02620 static struct callno_entry *get_unused_callno(int trunk, int validated)
02621 {
02622 struct callno_entry *callno_entry = NULL;
02623 if ((!ao2_container_count(callno_pool) && !trunk) || (!ao2_container_count(callno_pool_trunk) && trunk)) {
02624 ast_log(LOG_WARNING, "Out of CallNumbers\n");
02625
02626 return NULL;
02627 }
02628
02629
02630
02631 ao2_lock(callno_pool);
02632
02633
02634
02635
02636 if (!validated && (total_nonval_callno_used >= global_maxcallno_nonval)) {
02637 ast_log(LOG_WARNING, "NON-CallToken callnumber limit is reached. Current:%d Max:%d\n", total_nonval_callno_used, global_maxcallno_nonval);
02638 ao2_unlock(callno_pool);
02639 return NULL;
02640 }
02641
02642
02643
02644 callno_entry = ao2_find((trunk ? callno_pool_trunk : callno_pool), NULL, OBJ_POINTER | OBJ_UNLINK | OBJ_CONTINUE);
02645
02646 if (callno_entry) {
02647 callno_entry->validated = validated;
02648 if (!validated) {
02649 total_nonval_callno_used++;
02650 }
02651 }
02652
02653 ao2_unlock(callno_pool);
02654 return callno_entry;
02655 }
02656
02657 static int replace_callno(const void *obj)
02658 {
02659 struct callno_entry *callno_entry = (struct callno_entry *) obj;
02660
02661
02662
02663 ao2_lock(callno_pool);
02664
02665 if (!callno_entry->validated && (total_nonval_callno_used != 0)) {
02666 total_nonval_callno_used--;
02667 } else if (!callno_entry->validated && (total_nonval_callno_used == 0)) {
02668 ast_log(LOG_ERROR, "Attempted to decrement total non calltoken validated callnumbers below zero... Callno is:%d \n", callno_entry->callno);
02669 }
02670
02671 if (callno_entry->callno < TRUNK_CALL_START) {
02672 ao2_link(callno_pool, callno_entry);
02673 } else {
02674 ao2_link(callno_pool_trunk, callno_entry);
02675 }
02676 ao2_ref(callno_entry, -1);
02677
02678 ao2_unlock(callno_pool);
02679 return 0;
02680 }
02681
02682 static int callno_hash(const void *obj, const int flags)
02683 {
02684 return abs(ast_random());
02685 }
02686
02687 static int create_callno_pools(void)
02688 {
02689 uint16_t i;
02690
02691 if (!(callno_pool = ao2_container_alloc(CALLNO_POOL_BUCKETS, callno_hash, NULL))) {
02692 return -1;
02693 }
02694
02695 if (!(callno_pool_trunk = ao2_container_alloc(CALLNO_POOL_BUCKETS, callno_hash, NULL))) {
02696 return -1;
02697 }
02698
02699
02700 for (i = 2; i < IAX_MAX_CALLS; i++) {
02701 struct callno_entry *callno_entry;
02702
02703 if (!(callno_entry = ao2_alloc(sizeof(*callno_entry), NULL))) {
02704 return -1;
02705 }
02706
02707 callno_entry->callno = i;
02708
02709 if (i < TRUNK_CALL_START) {
02710 ao2_link(callno_pool, callno_entry);
02711 } else {
02712 ao2_link(callno_pool_trunk, callno_entry);
02713 }
02714
02715 ao2_ref(callno_entry, -1);
02716 }
02717
02718 return 0;
02719 }
02720
02721
02722
02723
02724
02725
02726
02727
02728
02729 static void sched_delay_remove(struct sockaddr_in *sin, struct callno_entry *callno_entry)
02730 {
02731 int i;
02732 struct peercnt *peercnt;
02733 struct peercnt tmp = {
02734 .addr = sin->sin_addr.s_addr,
02735 };
02736
02737 if ((peercnt = ao2_find(peercnts, &tmp, OBJ_POINTER))) {
02738
02739 ast_debug(1, "schedule decrement of callno used for %s in %d seconds\n", ast_inet_ntoa(sin->sin_addr), MIN_REUSE_TIME);
02740 i = iax2_sched_add(sched, MIN_REUSE_TIME * 1000, peercnt_remove_cb, peercnt);
02741 if (i == -1) {
02742 ao2_ref(peercnt, -1);
02743 }
02744 }
02745
02746 iax2_sched_add(sched, MIN_REUSE_TIME * 1000, replace_callno, callno_entry);
02747 }
02748
02749
02750
02751
02752
02753
02754
02755
02756 static inline int attribute_pure iax2_allow_new(int frametype, int subclass, int inbound)
02757 {
02758 if (frametype != AST_FRAME_IAX) {
02759 return 0;
02760 }
02761 switch (subclass) {
02762 case IAX_COMMAND_NEW:
02763 case IAX_COMMAND_REGREQ:
02764 case IAX_COMMAND_FWDOWNL:
02765 case IAX_COMMAND_REGREL:
02766 return 1;
02767 case IAX_COMMAND_POKE:
02768 if (!inbound) {
02769 return 1;
02770 }
02771 break;
02772 }
02773 return 0;
02774 }
02775
02776
02777
02778
02779 static int __find_callno(unsigned short callno, unsigned short dcallno, struct sockaddr_in *sin, int new, int sockfd, int return_locked, int check_dcallno)
02780 {
02781 int res = 0;
02782 int x;
02783
02784
02785 int validated = (new > NEW_ALLOW) ? 1 : 0;
02786 char host[80];
02787
02788 if (new <= NEW_ALLOW) {
02789 if (callno) {
02790 struct chan_iax2_pvt *pvt;
02791 struct chan_iax2_pvt tmp_pvt = {
02792 .callno = dcallno,
02793 .peercallno = callno,
02794 .transfercallno = callno,
02795
02796 .frames_received = check_dcallno,
02797 };
02798
02799 memcpy(&tmp_pvt.addr, sin, sizeof(tmp_pvt.addr));
02800
02801 if ((pvt = ao2_find(iax_peercallno_pvts, &tmp_pvt, OBJ_POINTER))) {
02802 if (return_locked) {
02803 ast_mutex_lock(&iaxsl[pvt->callno]);
02804 }
02805 res = pvt->callno;
02806 ao2_ref(pvt, -1);
02807 pvt = NULL;
02808 return res;
02809 }
02810
02811 memset(&tmp_pvt.addr, 0, sizeof(tmp_pvt.addr));
02812 memcpy(&tmp_pvt.transfer, sin, sizeof(tmp_pvt.transfer));
02813 if ((pvt = ao2_find(iax_transfercallno_pvts, &tmp_pvt, OBJ_POINTER))) {
02814 if (return_locked) {
02815 ast_mutex_lock(&iaxsl[pvt->callno]);
02816 }
02817 res = pvt->callno;
02818 ao2_ref(pvt, -1);
02819 pvt = NULL;
02820 return res;
02821 }
02822 }
02823
02824
02825 if (dcallno) {
02826 ast_mutex_lock(&iaxsl[dcallno]);
02827 }
02828 if (callno && dcallno && iaxs[dcallno] && !iaxs[dcallno]->peercallno && match(sin, callno, dcallno, iaxs[dcallno], check_dcallno)) {
02829 iaxs[dcallno]->peercallno = callno;
02830 res = dcallno;
02831 store_by_peercallno(iaxs[dcallno]);
02832 if (!res || !return_locked) {
02833 ast_mutex_unlock(&iaxsl[dcallno]);
02834 }
02835 return res;
02836 }
02837 if (dcallno) {
02838 ast_mutex_unlock(&iaxsl[dcallno]);
02839 }
02840 #ifdef IAX_OLD_FIND
02841
02842
02843
02844
02845
02846
02847
02848
02849
02850
02851
02852 for (x = 1; !res && x < maxnontrunkcall; x++) {
02853 ast_mutex_lock(&iaxsl[x]);
02854 if (iaxs[x]) {
02855
02856 if (match(sin, callno, dcallno, iaxs[x], check_dcallno)) {
02857 res = x;
02858 }
02859 }
02860 if (!res || !return_locked)
02861 ast_mutex_unlock(&iaxsl[x]);
02862 }
02863 for (x = TRUNK_CALL_START; !res && x < maxtrunkcall; x++) {
02864 ast_mutex_lock(&iaxsl[x]);
02865 if (iaxs[x]) {
02866
02867 if (match(sin, callno, dcallno, iaxs[x], check_dcallno)) {
02868 res = x;
02869 }
02870 }
02871 if (!res || !return_locked)
02872 ast_mutex_unlock(&iaxsl[x]);
02873 }
02874 #endif
02875 }
02876 if (!res && (new >= NEW_ALLOW)) {
02877 struct callno_entry *callno_entry;
02878
02879
02880
02881
02882
02883
02884 if (!iax2_getpeername(*sin, host, sizeof(host)))
02885 snprintf(host, sizeof(host), "%s:%d", ast_inet_ntoa(sin->sin_addr), ntohs(sin->sin_port));
02886
02887 if (peercnt_add(sin)) {
02888
02889
02890 return 0;
02891 }
02892
02893 if (!(callno_entry = get_unused_callno(0, validated))) {
02894
02895
02896 peercnt_remove_by_addr(sin);
02897 ast_log(LOG_WARNING, "No more space\n");
02898 return 0;
02899 }
02900 x = callno_entry->callno;
02901 ast_mutex_lock(&iaxsl[x]);
02902
02903 iaxs[x] = new_iax(sin, host);
02904 update_max_nontrunk();
02905 if (iaxs[x]) {
02906 if (iaxdebug)
02907 ast_debug(1, "Creating new call structure %d\n", x);
02908 iaxs[x]->callno_entry = callno_entry;
02909 iaxs[x]->sockfd = sockfd;
02910 iaxs[x]->addr.sin_port = sin->sin_port;
02911 iaxs[x]->addr.sin_family = sin->sin_family;
02912 iaxs[x]->addr.sin_addr.s_addr = sin->sin_addr.s_addr;
02913 iaxs[x]->peercallno = callno;
02914 iaxs[x]->callno = x;
02915 iaxs[x]->pingtime = DEFAULT_RETRY_TIME;
02916 iaxs[x]->expiry = min_reg_expire;
02917 iaxs[x]->pingid = iax2_sched_add(sched, ping_time * 1000, send_ping, (void *)(long)x);
02918 iaxs[x]->lagid = iax2_sched_add(sched, lagrq_time * 1000, send_lagrq, (void *)(long)x);
02919 iaxs[x]->amaflags = amaflags;
02920 ast_copy_flags64(iaxs[x], &globalflags, IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_FORCEJITTERBUF | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE | IAX_FORCE_ENCRYPT);
02921 ast_string_field_set(iaxs[x], accountcode, accountcode);
02922 ast_string_field_set(iaxs[x], mohinterpret, mohinterpret);
02923 ast_string_field_set(iaxs[x], mohsuggest, mohsuggest);
02924 ast_string_field_set(iaxs[x], parkinglot, default_parkinglot);
02925
02926 if (iaxs[x]->peercallno) {
02927 store_by_peercallno(iaxs[x]);
02928 }
02929 } else {
02930 ast_log(LOG_WARNING, "Out of resources\n");
02931 ast_mutex_unlock(&iaxsl[x]);
02932 replace_callno(callno_entry);
02933 return 0;
02934 }
02935 if (!return_locked)
02936 ast_mutex_unlock(&iaxsl[x]);
02937 res = x;
02938 }
02939 return res;
02940 }
02941
02942 static int find_callno(unsigned short callno, unsigned short dcallno, struct sockaddr_in *sin, int new, int sockfd, int full_frame) {
02943 return __find_callno(callno, dcallno, sin, new, sockfd, 0, full_frame);
02944 }
02945
02946 static int find_callno_locked(unsigned short callno, unsigned short dcallno, struct sockaddr_in *sin, int new, int sockfd, int full_frame) {
02947
02948 return __find_callno(callno, dcallno, sin, new, sockfd, 1, full_frame);
02949 }
02950
02951
02952
02953
02954
02955
02956
02957
02958
02959
02960
02961 static int iax2_queue_frame(int callno, struct ast_frame *f)
02962 {
02963 iax2_lock_owner(callno);
02964 if (iaxs[callno] && iaxs[callno]->owner) {
02965 ast_queue_frame(iaxs[callno]->owner, f);
02966 ast_channel_unlock(iaxs[callno]->owner);
02967 }
02968 return 0;
02969 }
02970
02971
02972
02973
02974
02975
02976
02977
02978
02979
02980
02981
02982
02983
02984 static int iax2_queue_hangup(int callno)
02985 {
02986 iax2_lock_owner(callno);
02987 if (iaxs[callno] && iaxs[callno]->owner) {
02988 ast_queue_hangup(iaxs[callno]->owner);
02989 ast_channel_unlock(iaxs[callno]->owner);
02990 }
02991 return 0;
02992 }
02993
02994
02995
02996
02997
02998
02999
03000
03001
03002
03003
03004
03005
03006
03007 static int iax2_queue_control_data(int callno,
03008 enum ast_control_frame_type control, const void *data, size_t datalen)
03009 {
03010 iax2_lock_owner(callno);
03011 if (iaxs[callno] && iaxs[callno]->owner) {
03012 ast_queue_control_data(iaxs[callno]->owner, control, data, datalen);
03013 ast_channel_unlock(iaxs[callno]->owner);
03014 }
03015 return 0;
03016 }
03017 static void destroy_firmware(struct iax_firmware *cur)
03018 {
03019
03020 if (cur->fwh) {
03021 munmap((void*)cur->fwh, ntohl(cur->fwh->datalen) + sizeof(*(cur->fwh)));
03022 }
03023 close(cur->fd);
03024 ast_free(cur);
03025 }
03026
03027 static int try_firmware(char *s)
03028 {
03029 struct stat stbuf;
03030 struct iax_firmware *cur = NULL;
03031 int ifd, fd, res, len, chunk;
03032 struct ast_iax2_firmware_header *fwh, fwh2;
03033 struct MD5Context md5;
03034 unsigned char sum[16], buf[1024];
03035 char *s2, *last;
03036
03037 s2 = ast_alloca(strlen(s) + 100);
03038
03039 last = strrchr(s, '/');
03040 if (last)
03041 last++;
03042 else
03043 last = s;
03044
03045 snprintf(s2, strlen(s) + 100, "/var/tmp/%s-%ld", last, (unsigned long)ast_random());
03046
03047 if ((res = stat(s, &stbuf) < 0)) {
03048 ast_log(LOG_WARNING, "Failed to stat '%s': %s\n", s, strerror(errno));
03049 return -1;
03050 }
03051
03052
03053 if (S_ISDIR(stbuf.st_mode))
03054 return -1;
03055 ifd = open(s, O_RDONLY);
03056 if (ifd < 0) {
03057 ast_log(LOG_WARNING, "Cannot open '%s': %s\n", s, strerror(errno));
03058 return -1;
03059 }
03060 fd = open(s2, O_RDWR | O_CREAT | O_EXCL, AST_FILE_MODE);
03061 if (fd < 0) {
03062 ast_log(LOG_WARNING, "Cannot open '%s' for writing: %s\n", s2, strerror(errno));
03063 close(ifd);
03064 return -1;
03065 }
03066
03067 unlink(s2);
03068
03069
03070 len = stbuf.st_size;
03071 while(len) {
03072 chunk = len;
03073 if (chunk > sizeof(buf))
03074 chunk = sizeof(buf);
03075 res = read(ifd, buf, chunk);
03076 if (res != chunk) {
03077 ast_log(LOG_WARNING, "Only read %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
03078 close(ifd);
03079 close(fd);
03080 return -1;
03081 }
03082 res = write(fd, buf, chunk);
03083 if (res != chunk) {
03084 ast_log(LOG_WARNING, "Only write %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
03085 close(ifd);
03086 close(fd);
03087 return -1;
03088 }
03089 len -= chunk;
03090 }
03091 close(ifd);
03092
03093 lseek(fd, 0, SEEK_SET);
03094 if ((res = read(fd, &fwh2, sizeof(fwh2))) != sizeof(fwh2)) {
03095 ast_log(LOG_WARNING, "Unable to read firmware header in '%s'\n", s);
03096 close(fd);
03097 return -1;
03098 }
03099 if (ntohl(fwh2.magic) != IAX_FIRMWARE_MAGIC) {
03100 ast_log(LOG_WARNING, "'%s' is not a valid firmware file\n", s);
03101 close(fd);
03102 return -1;
03103 }
03104 if (ntohl(fwh2.datalen) != (stbuf.st_size - sizeof(fwh2))) {
03105 ast_log(LOG_WARNING, "Invalid data length in firmware '%s'\n", s);
03106 close(fd);
03107 return -1;
03108 }
03109 if (fwh2.devname[sizeof(fwh2.devname) - 1] || ast_strlen_zero((char *)fwh2.devname)) {
03110 ast_log(LOG_WARNING, "No or invalid device type specified for '%s'\n", s);
03111 close(fd);
03112 return -1;
03113 }
03114 fwh = (struct ast_iax2_firmware_header*)mmap(NULL, stbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
03115 if (fwh == MAP_FAILED) {
03116 ast_log(LOG_WARNING, "mmap failed: %s\n", strerror(errno));
03117 close(fd);
03118 return -1;
03119 }
03120 MD5Init(&md5);
03121 MD5Update(&md5, fwh->data, ntohl(fwh->datalen));
03122 MD5Final(sum, &md5);
03123 if (memcmp(sum, fwh->chksum, sizeof(sum))) {
03124 ast_log(LOG_WARNING, "Firmware file '%s' fails checksum\n", s);
03125 munmap((void*)fwh, stbuf.st_size);
03126 close(fd);
03127 return -1;
03128 }
03129
03130 AST_LIST_TRAVERSE(&firmwares, cur, list) {
03131 if (!strcmp((char *)cur->fwh->devname, (char *)fwh->devname)) {
03132
03133 if (cur->dead || (ntohs(cur->fwh->version) < ntohs(fwh->version)))
03134
03135 break;
03136
03137
03138 munmap((void*)fwh, stbuf.st_size);
03139 close(fd);
03140 return 0;
03141 }
03142 }
03143
03144 if (!cur && ((cur = ast_calloc(1, sizeof(*cur))))) {
03145 cur->fd = -1;
03146 AST_LIST_INSERT_TAIL(&firmwares, cur, list);
03147 }
03148
03149 if (cur) {
03150 if (cur->fwh)
03151 munmap((void*)cur->fwh, cur->mmaplen);
03152 if (cur->fd > -1)
03153 close(cur->fd);
03154 cur->fwh = fwh;
03155 cur->fd = fd;
03156 cur->mmaplen = stbuf.st_size;
03157 cur->dead = 0;
03158 }
03159
03160 return 0;
03161 }
03162
03163 static int iax_check_version(char *dev)
03164 {
03165 int res = 0;
03166 struct iax_firmware *cur = NULL;
03167
03168 if (ast_strlen_zero(dev))
03169 return 0;
03170
03171 AST_LIST_LOCK(&firmwares);
03172 AST_LIST_TRAVERSE(&firmwares, cur, list) {
03173 if (!strcmp(dev, (char *)cur->fwh->devname)) {
03174 res = ntohs(cur->fwh->version);
03175 break;
03176 }
03177 }
03178 AST_LIST_UNLOCK(&firmwares);
03179
03180 return res;
03181 }
03182
03183 static int iax_firmware_append(struct iax_ie_data *ied, const unsigned char *dev, unsigned int desc)
03184 {
03185 int res = -1;
03186 unsigned int bs = desc & 0xff;
03187 unsigned int start = (desc >> 8) & 0xffffff;
03188 unsigned int bytes;
03189 struct iax_firmware *cur;
03190
03191 if (ast_strlen_zero((char *)dev) || !bs)
03192 return -1;
03193
03194 start *= bs;
03195
03196 AST_LIST_LOCK(&firmwares);
03197 AST_LIST_TRAVERSE(&firmwares, cur, list) {
03198 if (strcmp((char *)dev, (char *)cur->fwh->devname))
03199 continue;
03200 iax_ie_append_int(ied, IAX_IE_FWBLOCKDESC, desc);
03201 if (start < ntohl(cur->fwh->datalen)) {
03202 bytes = ntohl(cur->fwh->datalen) - start;
03203 if (bytes > bs)
03204 bytes = bs;
03205 iax_ie_append_raw(ied, IAX_IE_FWBLOCKDATA, cur->fwh->data + start, bytes);
03206 } else {
03207 bytes = 0;
03208 iax_ie_append(ied, IAX_IE_FWBLOCKDATA);
03209 }
03210 if (bytes == bs)
03211 res = 0;
03212 else
03213 res = 1;
03214 break;
03215 }
03216 AST_LIST_UNLOCK(&firmwares);
03217
03218 return res;
03219 }
03220
03221
03222 static void reload_firmware(int unload)
03223 {
03224 struct iax_firmware *cur = NULL;
03225 DIR *fwd;
03226 struct dirent *de;
03227 char dir[256], fn[256];
03228
03229 AST_LIST_LOCK(&firmwares);
03230
03231
03232 AST_LIST_TRAVERSE(&firmwares, cur, list)
03233 cur->dead = 1;
03234
03235
03236 if (!unload) {
03237 snprintf(dir, sizeof(dir), "%s/firmware/iax", ast_config_AST_DATA_DIR);
03238 fwd = opendir(dir);
03239 if (fwd) {
03240 while((de = readdir(fwd))) {
03241 if (de->d_name[0] != '.') {
03242 snprintf(fn, sizeof(fn), "%s/%s", dir, de->d_name);
03243 if (!try_firmware(fn)) {
03244 ast_verb(2, "Loaded firmware '%s'\n", de->d_name);
03245 }
03246 }
03247 }
03248 closedir(fwd);
03249 } else
03250 ast_log(LOG_WARNING, "Error opening firmware directory '%s': %s\n", dir, strerror(errno));
03251 }
03252
03253
03254 AST_LIST_TRAVERSE_SAFE_BEGIN(&firmwares, cur, list) {
03255 if (!cur->dead)
03256 continue;
03257 AST_LIST_REMOVE_CURRENT(list);
03258 destroy_firmware(cur);
03259 }
03260 AST_LIST_TRAVERSE_SAFE_END;
03261
03262 AST_LIST_UNLOCK(&firmwares);
03263 }
03264
03265
03266
03267
03268
03269
03270
03271
03272
03273 static int __do_deliver(void *data)
03274 {
03275
03276
03277 struct iax_frame *fr = data;
03278 fr->retrans = -1;
03279 ast_clear_flag(&fr->af, AST_FRFLAG_HAS_TIMING_INFO);
03280 if (iaxs[fr->callno] && !ast_test_flag64(iaxs[fr->callno], IAX_ALREADYGONE))
03281 iax2_queue_frame(fr->callno, &fr->af);
03282
03283 iax2_frame_free(fr);
03284
03285 return 0;
03286 }
03287
03288 static int handle_error(void)
03289 {
03290
03291
03292
03293 #if 0
03294 struct sockaddr_in *sin;
03295 int res;
03296 struct msghdr m;
03297 struct sock_extended_err e;
03298 m.msg_name = NULL;
03299 m.msg_namelen = 0;
03300 m.msg_iov = NULL;
03301 m.msg_control = &e;
03302 m.msg_controllen = sizeof(e);
03303 m.msg_flags = 0;
03304 res = recvmsg(netsocket, &m, MSG_ERRQUEUE);
03305 if (res < 0)
03306 ast_log(LOG_WARNING, "Error detected, but unable to read error: %s\n", strerror(errno));
03307 else {
03308 if (m.msg_controllen) {
03309 sin = (struct sockaddr_in *)SO_EE_OFFENDER(&e);
03310 if (sin)
03311 ast_log(LOG_WARNING, "Receive error from %s\n", ast_inet_ntoa(sin->sin_addr));
03312 else
03313 ast_log(LOG_WARNING, "No address detected??\n");
03314 } else {
03315 ast_log(LOG_WARNING, "Local error: %s\n", strerror(e.ee_errno));
03316 }
03317 }
03318 #endif
03319 return 0;
03320 }
03321
03322 static int transmit_trunk(struct iax_frame *f, struct sockaddr_in *sin, int sockfd)
03323 {
03324 int res;
03325 res = sendto(sockfd, f->data, f->datalen, 0,(struct sockaddr *)sin,
03326 sizeof(*sin));
03327 if (res < 0) {
03328 ast_debug(1, "Received error: %s\n", strerror(errno));
03329 handle_error();
03330 } else
03331 res = 0;
03332 return res;
03333 }
03334
03335 static int send_packet(struct iax_frame *f)
03336 {
03337 int res;
03338 int callno = f->callno;
03339
03340
03341 if (!callno || !iaxs[callno] || iaxs[callno]->error)
03342 return -1;
03343
03344
03345 if (iaxdebug)
03346 ast_debug(3, "Sending %d on %d/%d to %s:%d\n", f->ts, callno, iaxs[callno]->peercallno, ast_inet_ntoa(iaxs[callno]->addr.sin_addr), ntohs(iaxs[callno]->addr.sin_port));
03347
03348 if (f->transfer) {
03349 iax_outputframe(f, NULL, 0, &iaxs[callno]->transfer, f->datalen - sizeof(struct ast_iax2_full_hdr));
03350 res = sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0,(struct sockaddr *)&iaxs[callno]->transfer, sizeof(iaxs[callno]->transfer));
03351 } else {
03352 iax_outputframe(f, NULL, 0, &iaxs[callno]->addr, f->datalen - sizeof(struct ast_iax2_full_hdr));
03353 res = sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0,(struct sockaddr *)&iaxs[callno]->addr, sizeof(iaxs[callno]->addr));
03354 }
03355 if (res < 0) {
03356 if (iaxdebug)
03357 ast_debug(1, "Received error: %s\n", strerror(errno));
03358 handle_error();
03359 } else
03360 res = 0;
03361
03362 return res;
03363 }
03364
03365
03366
03367
03368
03369 static int iax2_predestroy(int callno)
03370 {
03371 struct ast_channel *c = NULL;
03372 struct chan_iax2_pvt *pvt = iaxs[callno];
03373
03374 if (!pvt)
03375 return -1;
03376
03377 if (!ast_test_flag64(pvt, IAX_ALREADYGONE)) {
03378 iax2_destroy_helper(pvt);
03379 ast_set_flag64(pvt, IAX_ALREADYGONE);
03380 }
03381
03382 if ((c = pvt->owner)) {
03383 c->tech_pvt = NULL;
03384 iax2_queue_hangup(callno);
03385 pvt->owner = NULL;
03386 ast_module_unref(ast_module_info->self);
03387 }
03388
03389 return 0;
03390 }
03391
03392 static void iax2_destroy(int callno)
03393 {
03394 struct chan_iax2_pvt *pvt = NULL;
03395 struct ast_channel *owner = NULL;
03396
03397 retry:
03398 if ((pvt = iaxs[callno])) {
03399 #if 0
03400
03401
03402
03403
03404
03405
03406
03407 iax2_destroy_helper(pvt);
03408 #endif
03409 }
03410
03411 owner = pvt ? pvt->owner : NULL;
03412
03413 if (owner) {
03414 if (ast_channel_trylock(owner)) {
03415 ast_debug(3, "Avoiding IAX destroy deadlock\n");
03416 DEADLOCK_AVOIDANCE(&iaxsl[callno]);
03417 goto retry;
03418 }
03419 }
03420
03421 if (!owner) {
03422 iaxs[callno] = NULL;
03423 }
03424
03425 if (pvt) {
03426 if (!owner) {
03427 pvt->owner = NULL;
03428 } else {
03429
03430
03431
03432 ast_queue_hangup(owner);
03433 }
03434
03435 if (pvt->peercallno) {
03436 remove_by_peercallno(pvt);
03437 }
03438
03439 if (pvt->transfercallno) {
03440 remove_by_transfercallno(pvt);
03441 }
03442
03443 if (!owner) {
03444 ao2_ref(pvt, -1);
03445 pvt = NULL;
03446 }
03447 }
03448
03449 if (owner) {
03450 ast_channel_unlock(owner);
03451 }
03452
03453 if (callno & TRUNK_CALL_START) {
03454 update_max_trunk();
03455 }
03456 }
03457
03458 static int update_packet(struct iax_frame *f)
03459 {
03460
03461 struct ast_iax2_full_hdr *fh = f->data;
03462 struct ast_frame af;
03463
03464
03465 if (f->encmethods) {
03466 decode_frame(&f->mydcx, fh, &af, &f->datalen);
03467 }
03468
03469 fh->dcallno = ntohs(IAX_FLAG_RETRANS | f->dcallno);
03470
03471 f->iseqno = iaxs[f->callno]->iseqno;
03472 fh->iseqno = f->iseqno;
03473
03474
03475 if (f->encmethods) {
03476
03477
03478 build_rand_pad(f->semirand, sizeof(f->semirand));
03479 encrypt_frame(&f->ecx, fh, f->semirand, &f->datalen);
03480 }
03481 return 0;
03482 }
03483
03484 static int attempt_transmit(const void *data);
03485 static void __attempt_transmit(const void *data)
03486 {
03487
03488
03489 struct iax_frame *f = (struct iax_frame *)data;
03490 int freeme = 0;
03491 int callno = f->callno;
03492
03493 if (callno)
03494 ast_mutex_lock(&iaxsl[callno]);
03495 if (callno && iaxs[callno]) {
03496 if ((f->retries < 0) ||
03497 (f->retries >= max_retries) ) {
03498
03499 if (f->retries >= max_retries) {
03500 if (f->transfer) {
03501
03502 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_TXREJ, 0, NULL, 0, -1);
03503 } else if (f->final) {
03504 iax2_destroy(callno);
03505 } else {
03506 if (iaxs[callno]->owner)
03507 ast_log(LOG_WARNING, "Max retries exceeded to host %s on %s (type = %d, subclass = %u, ts=%d, seqno=%d)\n", ast_inet_ntoa(iaxs[f->callno]->addr.sin_addr),iaxs[f->callno]->owner->name , f->af.frametype, f->af.subclass.integer, f->ts, f->oseqno);
03508 iaxs[callno]->error = ETIMEDOUT;
03509 if (iaxs[callno]->owner) {
03510 struct ast_frame fr = { AST_FRAME_CONTROL, { AST_CONTROL_HANGUP }, .data.uint32 = AST_CAUSE_DESTINATION_OUT_OF_ORDER };
03511
03512 iax2_queue_frame(callno, &fr);
03513
03514 if (iaxs[callno] && iaxs[callno]->owner)
03515 iaxs[callno]->owner->hangupcause = AST_CAUSE_DESTINATION_OUT_OF_ORDER;
03516 } else {
03517 if (iaxs[callno]->reg) {
03518 memset(&iaxs[callno]->reg->us, 0, sizeof(iaxs[callno]->reg->us));
03519 iaxs[callno]->reg->regstate = REG_STATE_TIMEOUT;
03520 iaxs[callno]->reg->refresh = IAX_DEFAULT_REG_EXPIRE;
03521 }
03522 iax2_destroy(callno);
03523 }
03524 }
03525
03526 }
03527 freeme = 1;
03528 } else {
03529
03530 update_packet(f);
03531
03532 send_packet(f);
03533 f->retries++;
03534
03535 f->retrytime *= 10;
03536 if (f->retrytime > MAX_RETRY_TIME)
03537 f->retrytime = MAX_RETRY_TIME;
03538
03539 if (f->transfer && (f->retrytime > 1000))
03540 f->retrytime = 1000;
03541 f->retrans = iax2_sched_add(sched, f->retrytime, attempt_transmit, f);
03542 }
03543 } else {
03544
03545 f->retries = -1;
03546 freeme = 1;
03547 }
03548
03549 if (freeme) {
03550
03551 AST_LIST_REMOVE(&frame_queue[callno], f, list);
03552 ast_mutex_unlock(&iaxsl[callno]);
03553 f->retrans = -1;
03554
03555 iax2_frame_free(f);
03556 } else if (callno) {
03557 ast_mutex_unlock(&iaxsl[callno]);
03558 }
03559 }
03560
03561 static int attempt_transmit(const void *data)
03562 {
03563 #ifdef SCHED_MULTITHREADED
03564 if (schedule_action(__attempt_transmit, data))
03565 #endif
03566 __attempt_transmit(data);
03567 return 0;
03568 }
03569
03570 static char *handle_cli_iax2_prune_realtime(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
03571 {
03572 struct iax2_peer *peer = NULL;
03573 struct iax2_user *user = NULL;
03574 static const char * const choices[] = { "all", NULL };
03575 char *cmplt;
03576
03577 switch (cmd) {
03578 case CLI_INIT:
03579 e->command = "iax2 prune realtime";
03580 e->usage =
03581 "Usage: iax2 prune realtime [<peername>|all]\n"
03582 " Prunes object(s) from the cache\n";
03583 return NULL;
03584 case CLI_GENERATE:
03585 if (a->pos == 3) {
03586 cmplt = ast_cli_complete(a->word, choices, a->n);
03587 if (!cmplt)
03588 cmplt = complete_iax2_peers(a->line, a->word, a->pos, a->n - sizeof(choices), IAX_RTCACHEFRIENDS);
03589 return cmplt;
03590 }
03591 return NULL;
03592 }
03593 if (a->argc != 4)
03594 return CLI_SHOWUSAGE;
03595 if (!strcmp(a->argv[3], "all")) {
03596 prune_users();
03597 prune_peers();
03598 ast_cli(a->fd, "Cache flushed successfully.\n");
03599 return CLI_SUCCESS;
03600 }
03601 peer = find_peer(a->argv[3], 0);
03602 user = find_user(a->argv[3]);
03603 if (peer || user) {
03604 if (peer) {
03605 if (ast_test_flag64(peer, IAX_RTCACHEFRIENDS)) {
03606 ast_set_flag64(peer, IAX_RTAUTOCLEAR);
03607 expire_registry(peer_ref(peer));
03608 ast_cli(a->fd, "Peer %s was removed from the cache.\n", a->argv[3]);
03609 } else {
03610 ast_cli(a->fd, "Peer %s is not eligible for this operation.\n", a->argv[3]);
03611 }
03612 peer_unref(peer);
03613 }
03614 if (user) {
03615 if (ast_test_flag64(user, IAX_RTCACHEFRIENDS)) {
03616 ast_set_flag64(user, IAX_RTAUTOCLEAR);
03617 ast_cli(a->fd, "User %s was removed from the cache.\n", a->argv[3]);
03618 } else {
03619 ast_cli(a->fd, "User %s is not eligible for this operation.\n", a->argv[3]);
03620 }
03621 ao2_unlink(users,user);
03622 user_unref(user);
03623 }
03624 } else {
03625 ast_cli(a->fd, "%s was not found in the cache.\n", a->argv[3]);
03626 }
03627
03628 return CLI_SUCCESS;
03629 }
03630
03631 static char *handle_cli_iax2_test_losspct(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
03632 {
03633 switch (cmd) {
03634 case CLI_INIT:
03635 e->command = "iax2 test losspct";
03636 e->usage =
03637 "Usage: iax2 test losspct <percentage>\n"
03638 " For testing, throws away <percentage> percent of incoming packets\n";
03639 return NULL;
03640 case CLI_GENERATE:
03641 return NULL;
03642 }
03643 if (a->argc != 4)
03644 return CLI_SHOWUSAGE;
03645
03646 test_losspct = atoi(a->argv[3]);
03647
03648 return CLI_SUCCESS;
03649 }
03650
03651 #ifdef IAXTESTS
03652 static char *handle_cli_iax2_test_late(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
03653 {
03654 switch (cmd) {
03655 case CLI_INIT:
03656 e->command = "iax2 test late";
03657 e->usage =
03658 "Usage: iax2 test late <ms>\n"
03659 " For testing, count the next frame as <ms> ms late\n";
03660 return NULL;
03661 case CLI_GENERATE:
03662 return NULL;
03663 }
03664
03665 if (a->argc != 4)
03666 return CLI_SHOWUSAGE;
03667
03668 test_late = atoi(a->argv[3]);
03669
03670 return CLI_SUCCESS;
03671 }
03672
03673 static char *handle_cli_iax2_test_resync(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
03674 {
03675 switch (cmd) {
03676 case CLI_INIT:
03677 e->command = "iax2 test resync";
03678 e->usage =
03679 "Usage: iax2 test resync <ms>\n"
03680 " For testing, adjust all future frames by <ms> ms\n";
03681 return NULL;
03682 case CLI_GENERATE:
03683 return NULL;
03684 }
03685
03686 if (a->argc != 4)
03687 return CLI_SHOWUSAGE;
03688
03689 test_resync = atoi(a->argv[3]);
03690
03691 return CLI_SUCCESS;
03692 }
03693
03694 static char *handle_cli_iax2_test_jitter(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
03695 {
03696 switch (cmd) {
03697 case CLI_INIT:
03698 e->command = "iax2 test jitter";
03699 e->usage =
03700 "Usage: iax2 test jitter <ms> <pct>\n"
03701 " For testing, simulate maximum jitter of +/- <ms> on <pct>\n"
03702 " percentage of packets. If <pct> is not specified, adds\n"
03703 " jitter to all packets.\n";
03704 return NULL;
03705 case CLI_GENERATE:
03706 return NULL;
03707 }
03708
03709 if (a->argc < 4 || a->argc > 5)
03710 return CLI_SHOWUSAGE;
03711
03712 test_jit = atoi(a->argv[3]);
03713 if (a->argc == 5)
03714 test_jitpct = atoi(a->argv[4]);
03715
03716 return CLI_SUCCESS;
03717 }
03718 #endif
03719
03720
03721
03722 static int peer_status(struct iax2_peer *peer, char *status, int statuslen)
03723 {
03724 int res = 0;
03725 if (peer->maxms) {
03726 if (peer->lastms < 0) {
03727 ast_copy_string(status, "UNREACHABLE", statuslen);
03728 } else if (peer->lastms > peer->maxms) {
03729 snprintf(status, statuslen, "LAGGED (%d ms)", peer->lastms);
03730 res = 1;
03731 } else if (peer->lastms) {
03732 snprintf(status, statuslen, "OK (%d ms)", peer->lastms);
03733 res = 1;
03734 } else {
03735 ast_copy_string(status, "UNKNOWN", statuslen);
03736 }
03737 } else {
03738 ast_copy_string(status, "Unmonitored", statuslen);
03739 res = -1;
03740 }
03741 return res;
03742 }
03743
03744
03745 static char *handle_cli_iax2_show_peer(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
03746 {
03747 char status[30];
03748 char cbuf[256];
03749 struct iax2_peer *peer;
03750 char codec_buf[512];
03751 struct ast_str *encmethods = ast_str_alloca(256);
03752 int x = 0, codec = 0, load_realtime = 0;
03753
03754 switch (cmd) {
03755 case CLI_INIT:
03756 e->command = "iax2 show peer";
03757 e->usage =
03758 "Usage: iax2 show peer <name>\n"
03759 " Display details on specific IAX peer\n";
03760 return NULL;
03761 case CLI_GENERATE:
03762 if (a->pos == 3)
03763 return complete_iax2_peers(a->line, a->word, a->pos, a->n, 0);
03764 return NULL;
03765 }
03766
03767 if (a->argc < 4)
03768 return CLI_SHOWUSAGE;
03769
03770 load_realtime = (a->argc == 5 && !strcmp(a->argv[4], "load")) ? 1 : 0;
03771
03772 peer = find_peer(a->argv[3], load_realtime);
03773 if (peer) {
03774 struct sockaddr_in peer_addr;
03775
03776 ast_sockaddr_to_sin(&peer->addr, &peer_addr);
03777
03778 encmethods_to_str(peer->encmethods, &encmethods);
03779 ast_cli(a->fd, "\n\n");
03780 ast_cli(a->fd, " * Name : %s\n", peer->name);
03781 ast_cli(a->fd, " Secret : %s\n", ast_strlen_zero(peer->secret) ? "<Not set>" : "<Set>");
03782 ast_cli(a->fd, " Context : %s\n", peer->context);
03783 ast_cli(a->fd, " Parking lot : %s\n", peer->parkinglot);
03784 ast_cli(a->fd, " Mailbox : %s\n", peer->mailbox);
03785 ast_cli(a->fd, " Dynamic : %s\n", ast_test_flag64(peer, IAX_DYNAMIC) ? "Yes" : "No");
03786 ast_cli(a->fd, " Callnum limit: %d\n", peer->maxcallno);
03787 ast_cli(a->fd, " Calltoken req: %s\n", (peer->calltoken_required == CALLTOKEN_YES) ? "Yes" : ((peer->calltoken_required == CALLTOKEN_AUTO) ? "Auto" : "No"));
03788 ast_cli(a->fd, " Trunk : %s\n", ast_test_flag64(peer, IAX_TRUNK) ? "Yes" : "No");
03789 ast_cli(a->fd, " Encryption : %s\n", peer->encmethods ? ast_str_buffer(encmethods) : "No");
03790 ast_cli(a->fd, " Callerid : %s\n", ast_callerid_merge(cbuf, sizeof(cbuf), peer->cid_name, peer->cid_num, "<unspecified>"));
03791 ast_cli(a->fd, " Expire : %d\n", peer->expire);
03792 ast_cli(a->fd, " ACL : %s\n", (peer->ha ? "Yes" : "No"));
03793 ast_cli(a->fd, " Addr->IP : %s Port %d\n", peer_addr.sin_addr.s_addr ? ast_inet_ntoa(peer_addr.sin_addr) : "(Unspecified)", ntohs(peer_addr.sin_port));
03794 ast_cli(a->fd, " Defaddr->IP : %s Port %d\n", ast_inet_ntoa(peer->defaddr.sin_addr), ntohs(peer->defaddr.sin_port));
03795 ast_cli(a->fd, " Username : %s\n", peer->username);
03796 ast_cli(a->fd, " Codecs : ");
03797 ast_getformatname_multiple(codec_buf, sizeof(codec_buf) -1, peer->capability);
03798 ast_cli(a->fd, "%s\n", codec_buf);
03799
03800 ast_cli(a->fd, " Codec Order : (");
03801 for(x = 0; x < 32 ; x++) {
03802 codec = ast_codec_pref_index(&peer->prefs,x);
03803 if(!codec)
03804 break;
03805 ast_cli(a->fd, "%s", ast_getformatname(codec));
03806 if(x < 31 && ast_codec_pref_index(&peer->prefs,x+1))
03807 ast_cli(a->fd, "|");
03808 }
03809
03810 if (!x)
03811 ast_cli(a->fd, "none");
03812 ast_cli(a->fd, ")\n");
03813
03814 ast_cli(a->fd, " Status : ");
03815 peer_status(peer, status, sizeof(status));
03816 ast_cli(a->fd, "%s\n",status);
03817 ast_cli(a->fd, " Qualify : every %dms when OK, every %dms when UNREACHABLE (sample smoothing %s)\n", peer->pokefreqok, peer->pokefreqnotok, peer->smoothing ? "On" : "Off");
03818 ast_cli(a->fd, "\n");
03819 peer_unref(peer);
03820 } else {
03821 ast_cli(a->fd, "Peer %s not found.\n", a->argv[3]);
03822 ast_cli(a->fd, "\n");
03823 }
03824
03825 return CLI_SUCCESS;
03826 }
03827
03828 static char *complete_iax2_peers(const char *line, const char *word, int pos, int state, uint64_t flags)
03829 {
03830 int which = 0;
03831 struct iax2_peer *peer;
03832 char *res = NULL;
03833 int wordlen = strlen(word);
03834 struct ao2_iterator i;
03835
03836 i = ao2_iterator_init(peers, 0);
03837 while ((peer = ao2_iterator_next(&i))) {
03838 if (!strncasecmp(peer->name, word, wordlen) && ++which > state
03839 && (!flags || ast_test_flag64(peer, flags))) {
03840 res = ast_strdup(peer->name);
03841 peer_unref(peer);
03842 break;
03843 }
03844 peer_unref(peer);
03845 }
03846 ao2_iterator_destroy(&i);
03847
03848 return res;
03849 }
03850
03851 static char *handle_cli_iax2_show_stats(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
03852 {
03853 struct iax_frame *cur;
03854 int cnt = 0, dead = 0, final = 0, i = 0;
03855
03856 switch (cmd) {
03857 case CLI_INIT:
03858 e->command = "iax2 show stats";
03859 e->usage =
03860 "Usage: iax2 show stats\n"
03861 " Display statistics on IAX channel driver.\n";
03862 return NULL;
03863 case CLI_GENERATE:
03864 return NULL;
03865 }
03866
03867 if (a->argc != 3)
03868 return CLI_SHOWUSAGE;
03869
03870 for (i = 0; i < ARRAY_LEN(frame_queue); i++) {
03871 ast_mutex_lock(&iaxsl[i]);
03872 AST_LIST_TRAVERSE(&frame_queue[i], cur, list) {
03873 if (cur->retries < 0)
03874 dead++;
03875 if (cur->final)
03876 final++;
03877 cnt++;
03878 }
03879 ast_mutex_unlock(&iaxsl[i]);
03880 }
03881
03882 ast_cli(a->fd, " IAX Statistics\n");
03883 ast_cli(a->fd, "---------------------\n");
03884 ast_cli(a->fd, "Outstanding frames: %d (%d ingress, %d egress)\n", iax_get_frames(), iax_get_iframes(), iax_get_oframes());
03885 ast_cli(a->fd, "%d timed and %d untimed transmits; MTU %d/%d/%d\n", trunk_timed, trunk_untimed,
03886 trunk_maxmtu, trunk_nmaxmtu, global_max_trunk_mtu);
03887 ast_cli(a->fd, "Packets in transmit queue: %d dead, %d final, %d total\n\n", dead, final, cnt);
03888
03889 trunk_timed = trunk_untimed = 0;
03890 if (trunk_maxmtu > trunk_nmaxmtu)
03891 trunk_nmaxmtu = trunk_maxmtu;
03892
03893 return CLI_SUCCESS;
03894 }
03895
03896
03897 static char *handle_cli_iax2_set_mtu(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
03898 {
03899 int mtuv;
03900
03901 switch (cmd) {
03902 case CLI_INIT:
03903 e->command = "iax2 set mtu";
03904 e->usage =
03905 "Usage: iax2 set mtu <value>\n"
03906 " Set the system-wide IAX IP mtu to <value> bytes net or\n"
03907 " zero to disable. Disabling means that the operating system\n"
03908 " must handle fragmentation of UDP packets when the IAX2 trunk\n"
03909 " packet exceeds the UDP payload size. This is substantially\n"
03910 " below the IP mtu. Try 1240 on ethernets. Must be 172 or\n"
03911 " greater for G.711 samples.\n";
03912 return NULL;
03913 case CLI_GENERATE:
03914 return NULL;
03915 }
03916
03917 if (a->argc != 4)
03918 return CLI_SHOWUSAGE;
03919 if (strncasecmp(a->argv[3], "default", strlen(a->argv[3])) == 0)
03920 mtuv = MAX_TRUNK_MTU;
03921 else
03922 mtuv = atoi(a->argv[3]);
03923
03924 if (mtuv == 0) {
03925 ast_cli(a->fd, "Trunk MTU control disabled (mtu was %d)\n", global_max_trunk_mtu);
03926 global_max_trunk_mtu = 0;
03927 return CLI_SUCCESS;
03928 }
03929 if (mtuv < 172 || mtuv > 4000) {
03930 ast_cli(a->fd, "Trunk MTU must be between 172 and 4000\n");
03931 return CLI_SHOWUSAGE;
03932 }
03933 ast_cli(a->fd, "Trunk MTU changed from %d to %d\n", global_max_trunk_mtu, mtuv);
03934 global_max_trunk_mtu = mtuv;
03935 return CLI_SUCCESS;
03936 }
03937
03938 static char *handle_cli_iax2_show_cache(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
03939 {
03940 struct iax2_dpcache *dp = NULL;
03941 char tmp[1024], *pc = NULL;
03942 int s, x, y;
03943 struct timeval now = ast_tvnow();
03944
03945 switch (cmd) {
03946 case CLI_INIT:
03947 e->command = "iax2 show cache";
03948 e->usage =
03949 "Usage: iax2 show cache\n"
03950 " Display currently cached IAX Dialplan results.\n";
03951 return NULL;
03952 case CLI_GENERATE:
03953 return NULL;
03954 }
03955
03956 AST_LIST_LOCK(&dpcache);
03957
03958 ast_cli(a->fd, "%-20.20s %-12.12s %-9.9s %-8.8s %s\n", "Peer/Context", "Exten", "Exp.", "Wait.", "Flags");
03959
03960 AST_LIST_TRAVERSE(&dpcache, dp, cache_list) {
03961 s = dp->expiry.tv_sec - now.tv_sec;
03962 tmp[0] = '\0';
03963 if (dp->flags & CACHE_FLAG_EXISTS)
03964 strncat(tmp, "EXISTS|", sizeof(tmp) - strlen(tmp) - 1);
03965 if (dp->flags & CACHE_FLAG_NONEXISTENT)
03966 strncat(tmp, "NONEXISTENT|", sizeof(tmp) - strlen(tmp) - 1);
03967 if (dp->flags & CACHE_FLAG_CANEXIST)
03968 strncat(tmp, "CANEXIST|", sizeof(tmp) - strlen(tmp) - 1);
03969 if (dp->flags & CACHE_FLAG_PENDING)
03970 strncat(tmp, "PENDING|", sizeof(tmp) - strlen(tmp) - 1);
03971 if (dp->flags & CACHE_FLAG_TIMEOUT)
03972 strncat(tmp, "TIMEOUT|", sizeof(tmp) - strlen(tmp) - 1);
03973 if (dp->flags & CACHE_FLAG_TRANSMITTED)
03974 strncat(tmp, "TRANSMITTED|", sizeof(tmp) - strlen(tmp) - 1);
03975 if (dp->flags & CACHE_FLAG_MATCHMORE)
03976 strncat(tmp, "MATCHMORE|", sizeof(tmp) - strlen(tmp) - 1);
03977 if (dp->flags & CACHE_FLAG_UNKNOWN)
03978 strncat(tmp, "UNKNOWN|", sizeof(tmp) - strlen(tmp) - 1);
03979
03980 if (!ast_strlen_zero(tmp)) {
03981 tmp[strlen(tmp) - 1] = '\0';
03982 } else {
03983 ast_copy_string(tmp, "(none)", sizeof(tmp));
03984 }
03985 y = 0;
03986 pc = strchr(dp->peercontext, '@');
03987 if (!pc) {
03988 pc = dp->peercontext;
03989 } else {
03990 pc++;
03991 }
03992 for (x = 0; x < ARRAY_LEN(dp->waiters); x++) {
03993 if (dp->waiters[x] > -1)
03994 y++;
03995 }
03996 if (s > 0) {
03997 ast_cli(a->fd, "%-20.20s %-12.12s %-9d %-8d %s\n", pc, dp->exten, s, y, tmp);
03998 } else {
03999 ast_cli(a->fd, "%-20.20s %-12.12s %-9.9s %-8d %s\n", pc, dp->exten, "(expired)", y, tmp);
04000 }
04001 }
04002
04003 AST_LIST_UNLOCK(&dpcache);
04004
04005 return CLI_SUCCESS;
04006 }
04007
04008 static unsigned int calc_rxstamp(struct chan_iax2_pvt *p, unsigned int offset);
04009
04010 static void unwrap_timestamp(struct iax_frame *fr)
04011 {
04012
04013
04014 const int ts_shift = (fr->af.frametype == AST_FRAME_VIDEO) ? 15 : 16;
04015 const int lower_mask = (1 << ts_shift) - 1;
04016 const int upper_mask = ~lower_mask;
04017 const int last_upper = iaxs[fr->callno]->last & upper_mask;
04018
04019 if ( (fr->ts & upper_mask) == last_upper ) {
04020 const int x = fr->ts - iaxs[fr->callno]->last;
04021 const int threshold = (ts_shift == 15) ? 25000 : 50000;
04022
04023 if (x < -threshold) {
04024
04025
04026
04027
04028 fr->ts = (last_upper + (1 << ts_shift)) | (fr->ts & lower_mask);
04029 if (iaxdebug)
04030 ast_debug(1, "schedule_delivery: pushed forward timestamp\n");
04031 } else if (x > threshold) {
04032
04033
04034
04035
04036 fr->ts = (last_upper - (1 << ts_shift)) | (fr->ts & lower_mask);
04037 if (iaxdebug)
04038 ast_debug(1, "schedule_delivery: pushed back timestamp\n");
04039 }
04040 }
04041 }
04042
04043 static int get_from_jb(const void *p);
04044
04045 static void update_jbsched(struct chan_iax2_pvt *pvt)
04046 {
04047 int when;
04048
04049 when = ast_tvdiff_ms(ast_tvnow(), pvt->rxcore);
04050
04051 when = jb_next(pvt->jb) - when;
04052
04053 if (when <= 0) {
04054
04055 when = 1;
04056 }
04057
04058 pvt->jbid = iax2_sched_replace(pvt->jbid, sched, when, get_from_jb,
04059 CALLNO_TO_PTR(pvt->callno));
04060 }
04061
04062 static void __get_from_jb(const void *p)
04063 {
04064 int callno = PTR_TO_CALLNO(p);
04065 struct chan_iax2_pvt *pvt = NULL;
04066 struct iax_frame *fr;
04067 jb_frame frame;
04068 int ret;
04069 long ms;
04070 long next;
04071 struct timeval now = ast_tvnow();
04072
04073
04074 ast_mutex_lock(&iaxsl[callno]);
04075 pvt = iaxs[callno];
04076 if (!pvt) {
04077
04078 ast_mutex_unlock(&iaxsl[callno]);
04079 return;
04080 }
04081
04082 pvt->jbid = -1;
04083
04084
04085
04086
04087 now.tv_usec += 1000;
04088
04089 ms = ast_tvdiff_ms(now, pvt->rxcore);
04090
04091 if(ms >= (next = jb_next(pvt->jb))) {
04092 ret = jb_get(pvt->jb,&frame,ms,ast_codec_interp_len(pvt->voiceformat));
04093 switch(ret) {
04094 case JB_OK:
04095 fr = frame.data;
04096 __do_deliver(fr);
04097
04098 pvt = iaxs[callno];
04099 break;
04100 case JB_INTERP:
04101 {
04102 struct ast_frame af = { 0, };
04103
04104
04105 af.frametype = AST_FRAME_VOICE;
04106 af.subclass.codec = pvt->voiceformat;
04107 af.samples = frame.ms * (ast_format_rate(pvt->voiceformat) / 1000);
04108 af.src = "IAX2 JB interpolation";
04109 af.delivery = ast_tvadd(pvt->rxcore, ast_samp2tv(next, 1000));
04110 af.offset = AST_FRIENDLY_OFFSET;
04111
04112
04113
04114 if (!ast_test_flag64(iaxs[callno], IAX_ALREADYGONE)) {
04115 iax2_queue_frame(callno, &af);
04116
04117 pvt = iaxs[callno];
04118 }
04119 }
04120 break;
04121 case JB_DROP:
04122 iax2_frame_free(frame.data);
04123 break;
04124 case JB_NOFRAME:
04125 case JB_EMPTY:
04126
04127 break;
04128 default:
04129
04130 break;
04131 }
04132 }
04133 if (pvt)
04134 update_jbsched(pvt);
04135 ast_mutex_unlock(&iaxsl[callno]);
04136 }
04137
04138 static int get_from_jb(const void *data)
04139 {
04140 #ifdef SCHED_MULTITHREADED
04141 if (schedule_action(__get_from_jb, data))
04142 #endif
04143 __get_from_jb(data);
04144 return 0;
04145 }
04146
04147
04148
04149
04150
04151
04152
04153 static int schedule_delivery(struct iax_frame *fr, int updatehistory, int fromtrunk, unsigned int *tsout)
04154 {
04155 int type, len;
04156 int ret;
04157 int needfree = 0;
04158 struct ast_channel *owner = NULL;
04159 struct ast_channel *bridge = NULL;
04160
04161
04162
04163
04164
04165
04166 if (!fr->af.datalen) {
04167 memset(&fr->af.data, 0, sizeof(fr->af.data));
04168 }
04169
04170
04171 unwrap_timestamp(fr);
04172
04173
04174 if ( !fromtrunk && !ast_tvzero(iaxs[fr->callno]->rxcore))
04175 fr->af.delivery = ast_tvadd(iaxs[fr->callno]->rxcore, ast_samp2tv(fr->ts, 1000));
04176 else {
04177 #if 0
04178 ast_debug(1, "schedule_delivery: set delivery to 0 as we don't have an rxcore yet, or frame is from trunk.\n");
04179 #endif
04180 fr->af.delivery = ast_tv(0,0);
04181 }
04182
04183 type = JB_TYPE_CONTROL;
04184 len = 0;
04185
04186 if(fr->af.frametype == AST_FRAME_VOICE) {
04187 type = JB_TYPE_VOICE;
04188 len = ast_codec_get_samples(&fr->af) / (ast_format_rate(fr->af.subclass.codec) / 1000);
04189 } else if(fr->af.frametype == AST_FRAME_CNG) {
04190 type = JB_TYPE_SILENCE;
04191 }
04192
04193 if ( (!ast_test_flag64(iaxs[fr->callno], IAX_USEJITTERBUF)) ) {
04194 if (tsout)
04195 *tsout = fr->ts;
04196 __do_deliver(fr);
04197 return -1;
04198 }
04199
04200 iax2_lock_owner(fr->callno);
04201 if (!iaxs[fr->callno]) {
04202
04203 iax2_frame_free(fr);
04204 return -1;
04205 }
04206 if ((owner = iaxs[fr->callno]->owner))
04207 bridge = ast_bridged_channel(owner);
04208
04209
04210
04211 if ( (!ast_test_flag64(iaxs[fr->callno], IAX_FORCEJITTERBUF)) && owner && bridge && (bridge->tech->properties & AST_CHAN_TP_WANTSJITTER) ) {
04212 jb_frame frame;
04213
04214 ast_channel_unlock(owner);
04215
04216
04217 while (jb_getall(iaxs[fr->callno]->jb, &frame) == JB_OK) {
04218 __do_deliver(frame.data);
04219
04220 if (!iaxs[fr->callno])
04221 return -1;
04222 }
04223
04224 jb_reset(iaxs[fr->callno]->jb);
04225
04226 ast_sched_thread_del(sched, iaxs[fr->callno]->jbid);
04227
04228
04229 if (tsout)
04230 *tsout = fr->ts;
04231 __do_deliver(fr);
04232 return -1;
04233 }
04234 if (owner) {
04235 ast_channel_unlock(owner);
04236 }
04237
04238
04239
04240 ret = jb_put(iaxs[fr->callno]->jb, fr, type, len, fr->ts,
04241 calc_rxstamp(iaxs[fr->callno],fr->ts));
04242 if (ret == JB_DROP) {
04243 needfree++;
04244 } else if (ret == JB_SCHED) {
04245 update_jbsched(iaxs[fr->callno]);
04246 }
04247 if (tsout)
04248 *tsout = fr->ts;
04249 if (needfree) {
04250
04251 iax2_frame_free(fr);
04252 return -1;
04253 }
04254 return 0;
04255 }
04256
04257 static int transmit_frame(void *data)
04258 {
04259 struct iax_frame *fr = data;
04260
04261 ast_mutex_lock(&iaxsl[fr->callno]);
04262
04263 fr->sentyet = 1;
04264
04265 if (iaxs[fr->callno]) {
04266 send_packet(fr);
04267 }
04268
04269 if (fr->retries < 0) {
04270 ast_mutex_unlock(&iaxsl[fr->callno]);
04271
04272 iax_frame_free(fr);
04273 } else {
04274
04275 AST_LIST_INSERT_TAIL(&frame_queue[fr->callno], fr, list);
04276 fr->retries++;
04277 fr->retrans = iax2_sched_add(sched, fr->retrytime, attempt_transmit, fr);
04278 ast_mutex_unlock(&iaxsl[fr->callno]);
04279 }
04280
04281 return 0;
04282 }
04283
04284 static int iax2_transmit(struct iax_frame *fr)
04285 {
04286 fr->sentyet = 0;
04287
04288 return ast_taskprocessor_push(transmit_processor, transmit_frame, fr);
04289 }
04290
04291 static int iax2_digit_begin(struct ast_channel *c, char digit)
04292 {
04293 return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_DTMF_BEGIN, digit, 0, NULL, 0, -1);
04294 }
04295
04296 static int iax2_digit_end(struct ast_channel *c, char digit, unsigned int duration)
04297 {
04298 return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_DTMF_END, digit, 0, NULL, 0, -1);
04299 }
04300
04301 static int iax2_sendtext(struct ast_channel *c, const char *text)
04302 {
04303
04304 return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_TEXT,
04305 0, 0, (unsigned char *)text, strlen(text) + 1, -1);
04306 }
04307
04308 static int iax2_sendimage(struct ast_channel *c, struct ast_frame *img)
04309 {
04310 return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_IMAGE, img->subclass.integer, 0, img->data.ptr, img->datalen, -1);
04311 }
04312
04313 static int iax2_sendhtml(struct ast_channel *c, int subclass, const char *data, int datalen)
04314 {
04315 return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_HTML, subclass, 0, (unsigned char *)data, datalen, -1);
04316 }
04317
04318 static int iax2_fixup(struct ast_channel *oldchannel, struct ast_channel *newchan)
04319 {
04320 unsigned short callno = PTR_TO_CALLNO(newchan->tech_pvt);
04321 ast_mutex_lock(&iaxsl[callno]);
04322 if (iaxs[callno])
04323 iaxs[callno]->owner = newchan;
04324 else
04325 ast_log(LOG_WARNING, "Uh, this isn't a good sign...\n");
04326 ast_mutex_unlock(&iaxsl[callno]);
04327 return 0;
04328 }
04329
04330
04331
04332
04333
04334 static struct iax2_peer *realtime_peer(const char *peername, struct sockaddr_in *sin)
04335 {
04336 struct ast_variable *var = NULL;
04337 struct ast_variable *tmp;
04338 struct iax2_peer *peer=NULL;
04339 time_t regseconds = 0, nowtime;
04340 int dynamic=0;
04341
04342 if (peername) {
04343 var = ast_load_realtime("iaxpeers", "name", peername, "host", "dynamic", SENTINEL);
04344 if (!var && sin)
04345 var = ast_load_realtime("iaxpeers", "name", peername, "host", ast_inet_ntoa(sin->sin_addr), SENTINEL);
04346 } else if (sin) {
04347 char porta[25];
04348 sprintf(porta, "%d", ntohs(sin->sin_port));
04349 var = ast_load_realtime("iaxpeers", "ipaddr", ast_inet_ntoa(sin->sin_addr), "port", porta, SENTINEL);
04350 if (var) {
04351
04352 for (tmp = var; tmp; tmp = tmp->next) {
04353 if (!strcasecmp(tmp->name, "name"))
04354 peername = tmp->value;
04355 }
04356 }
04357 }
04358 if (!var && peername) {
04359 var = ast_load_realtime("iaxpeers", "name", peername, SENTINEL);
04360
04361
04362
04363
04364
04365
04366 if (var && sin) {
04367 for (tmp = var; tmp; tmp = tmp->next) {
04368 if (!strcasecmp(tmp->name, "host")) {
04369 struct ast_hostent ahp;
04370 struct hostent *hp;
04371 if (!(hp = ast_gethostbyname(tmp->value, &ahp)) || memcmp(hp->h_addr, &sin->sin_addr, hp->h_length)) {
04372
04373 ast_variables_destroy(var);
04374 var = NULL;
04375 }
04376 break;
04377 }
04378 }
04379 }
04380 }
04381 if (!var)
04382 return NULL;
04383
04384 peer = build_peer(peername, var, NULL, ast_test_flag64((&globalflags), IAX_RTCACHEFRIENDS) ? 0 : 1);
04385
04386 if (!peer) {
04387 ast_variables_destroy(var);
04388 return NULL;
04389 }
04390
04391 for (tmp = var; tmp; tmp = tmp->next) {
04392
04393 if (!strcasecmp(tmp->name, "type")) {
04394 if (strcasecmp(tmp->value, "friend") &&
04395 strcasecmp(tmp->value, "peer")) {
04396
04397 peer = peer_unref(peer);
04398 break;
04399 }
04400 } else if (!strcasecmp(tmp->name, "regseconds")) {
04401 ast_get_time_t(tmp->value, ®seconds, 0, NULL);
04402 } else if (!strcasecmp(tmp->name, "ipaddr")) {
04403 if (!ast_sockaddr_parse(&peer->addr, tmp->value, PARSE_PORT_IGNORE)) {
04404 ast_log(LOG_WARNING, "Failed to parse sockaddr '%s' for ipaddr of realtime peer '%s'\n", tmp->value, tmp->name);
04405 }
04406 } else if (!strcasecmp(tmp->name, "port")) {
04407 ast_sockaddr_set_port(&peer->addr, atoi(tmp->value));
04408 } else if (!strcasecmp(tmp->name, "host")) {
04409 if (!strcasecmp(tmp->value, "dynamic"))
04410 dynamic = 1;
04411 }
04412 }
04413
04414 ast_variables_destroy(var);
04415
04416 if (!peer)
04417 return NULL;
04418
04419 if (ast_test_flag64((&globalflags), IAX_RTCACHEFRIENDS)) {
04420 ast_copy_flags64(peer, &globalflags, IAX_RTAUTOCLEAR|IAX_RTCACHEFRIENDS);
04421 if (ast_test_flag64(peer, IAX_RTAUTOCLEAR)) {
04422 if (peer->expire > -1) {
04423 if (!ast_sched_thread_del(sched, peer->expire)) {
04424 peer->expire = -1;
04425 peer_unref(peer);
04426 }
04427 }
04428 peer->expire = iax2_sched_add(sched, (global_rtautoclear) * 1000, expire_registry, peer_ref(peer));
04429 if (peer->expire == -1)
04430 peer_unref(peer);
04431 }
04432 ao2_link(peers, peer);
04433 if (ast_test_flag64(peer, IAX_DYNAMIC))
04434 reg_source_db(peer);
04435 } else {
04436 ast_set_flag64(peer, IAX_TEMPONLY);
04437 }
04438
04439 if (!ast_test_flag64(&globalflags, IAX_RTIGNOREREGEXPIRE) && dynamic) {
04440 time(&nowtime);
04441 if ((nowtime - regseconds) > IAX_DEFAULT_REG_EXPIRE) {
04442 memset(&peer->addr, 0, sizeof(peer->addr));
04443 realtime_update_peer(peer->name, &peer->addr, 0);
04444 ast_debug(1, "realtime_peer: Bah, '%s' is expired (%d/%d/%d)!\n",
04445 peername, (int)(nowtime - regseconds), (int)regseconds, (int)nowtime);
04446 }
04447 else {
04448 ast_debug(1, "realtime_peer: Registration for '%s' still active (%d/%d/%d)!\n",
04449 peername, (int)(nowtime - regseconds), (int)regseconds, (int)nowtime);
04450 }
04451 }
04452
04453 return peer;
04454 }
04455
04456 static struct iax2_user *realtime_user(const char *username, struct sockaddr_in *sin)
04457 {
04458 struct ast_variable *var;
04459 struct ast_variable *tmp;
04460 struct iax2_user *user=NULL;
04461
04462 var = ast_load_realtime("iaxusers", "name", username, "host", "dynamic", SENTINEL);
04463 if (!var)
04464 var = ast_load_realtime("iaxusers", "name", username, "host", ast_inet_ntoa(sin->sin_addr), SENTINEL);
04465 if (!var && sin) {
04466 char porta[6];
04467 snprintf(porta, sizeof(porta), "%d", ntohs(sin->sin_port));
04468 var = ast_load_realtime("iaxusers", "name", username, "ipaddr", ast_inet_ntoa(sin->sin_addr), "port", porta, SENTINEL);
04469 if (!var)
04470 var = ast_load_realtime("iaxusers", "ipaddr", ast_inet_ntoa(sin->sin_addr), "port", porta, SENTINEL);
04471 }
04472 if (!var) {
04473 var = ast_load_realtime("iaxusers", "name", username, SENTINEL);
04474
04475
04476
04477
04478
04479
04480 if (var) {
04481 for (tmp = var; tmp; tmp = tmp->next) {
04482 if (!strcasecmp(tmp->name, "host")) {
04483 struct ast_hostent ahp;
04484 struct hostent *hp;
04485 if (!(hp = ast_gethostbyname(tmp->value, &ahp)) || memcmp(hp->h_addr, &sin->sin_addr, hp->h_length)) {
04486
04487 ast_variables_destroy(var);
04488 var = NULL;
04489 }
04490 break;
04491 }
04492 }
04493 }
04494 }
04495 if (!var)
04496 return NULL;
04497
04498 tmp = var;
04499 while(tmp) {
04500
04501 if (!strcasecmp(tmp->name, "type")) {
04502 if (strcasecmp(tmp->value, "friend") &&
04503 strcasecmp(tmp->value, "user")) {
04504 return NULL;
04505 }
04506 }
04507 tmp = tmp->next;
04508 }
04509
04510 user = build_user(username, var, NULL, !ast_test_flag64((&globalflags), IAX_RTCACHEFRIENDS));
04511
04512 ast_variables_destroy(var);
04513
04514 if (!user)
04515 return NULL;
04516
04517 if (ast_test_flag64((&globalflags), IAX_RTCACHEFRIENDS)) {
04518 ast_set_flag64(user, IAX_RTCACHEFRIENDS);
04519 ao2_link(users, user);
04520 } else {
04521 ast_set_flag64(user, IAX_TEMPONLY);
04522 }
04523
04524 return user;
04525 }
04526
04527 static void realtime_update_peer(const char *peername, struct ast_sockaddr *sockaddr, time_t regtime)
04528 {
04529 char port[10];
04530 char regseconds[20];
04531 const char *sysname = ast_config_AST_SYSTEM_NAME;
04532 char *syslabel = NULL;
04533
04534 if (ast_strlen_zero(sysname))
04535 sysname = NULL;
04536 else if (ast_test_flag64(&globalflags, IAX_RTSAVE_SYSNAME))
04537 syslabel = "regserver";
04538
04539 snprintf(regseconds, sizeof(regseconds), "%d", (int)regtime);
04540 snprintf(port, sizeof(port), "%d", ast_sockaddr_port(sockaddr));
04541 ast_update_realtime("iaxpeers", "name", peername,
04542 "ipaddr", ast_sockaddr_stringify_addr(sockaddr), "port", port,
04543 "regseconds", regseconds, syslabel, sysname, SENTINEL);
04544 }
04545
04546 struct create_addr_info {
04547 format_t capability;
04548 uint64_t flags;
04549 int maxtime;
04550 int encmethods;
04551 int found;
04552 int sockfd;
04553 int adsi;
04554 char username[80];
04555 char secret[80];
04556 char outkey[80];
04557 char timezone[80];
04558 char prefs[32];
04559 char cid_num[80];
04560 char cid_name[80];
04561 char context[AST_MAX_CONTEXT];
04562 char peercontext[AST_MAX_CONTEXT];
04563 char mohinterpret[MAX_MUSICCLASS];
04564 char mohsuggest[MAX_MUSICCLASS];
04565 };
04566
04567 static int create_addr(const char *peername, struct ast_channel *c, struct sockaddr_in *sin, struct create_addr_info *cai)
04568 {
04569 struct iax2_peer *peer;
04570 int res = -1;
04571 struct ast_codec_pref ourprefs;
04572 struct sockaddr_in peer_addr;
04573
04574 ast_clear_flag64(cai, IAX_SENDANI | IAX_TRUNK);
04575 cai->sockfd = defaultsockfd;
04576 cai->maxtime = 0;
04577 sin->sin_family = AF_INET;
04578
04579 if (!(peer = find_peer(peername, 1))) {
04580 struct ast_sockaddr sin_tmp;
04581
04582 cai->found = 0;
04583 sin_tmp.ss.ss_family = AF_INET;
04584 if (ast_get_ip_or_srv(&sin_tmp, peername, srvlookup ? "_iax._udp" : NULL)) {
04585 ast_log(LOG_WARNING, "No such host: %s\n", peername);
04586 return -1;
04587 }
04588 ast_sockaddr_to_sin(&sin_tmp, sin);
04589 if (sin->sin_port == 0) {
04590 sin->sin_port = htons(IAX_DEFAULT_PORTNO);
04591 }
04592
04593
04594 memcpy(&ourprefs, &prefs, sizeof(ourprefs));
04595 if (c)
04596 ast_codec_pref_prepend(&ourprefs, c->nativeformats, 1);
04597 ast_codec_pref_convert(&ourprefs, cai->prefs, sizeof(cai->prefs), 1);
04598 return 0;
04599 }
04600
04601 cai->found = 1;
04602
04603 ast_sockaddr_to_sin(&peer->addr, &peer_addr);
04604
04605
04606 if (!(peer_addr.sin_addr.s_addr || peer->defaddr.sin_addr.s_addr)) {
04607 goto return_unref;
04608 }
04609
04610
04611 if (peer->maxms && ((peer->lastms > peer->maxms) || (peer->lastms < 0)))
04612 goto return_unref;
04613
04614 ast_copy_flags64(cai, peer, IAX_SENDANI | IAX_TRUNK | IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_FORCEJITTERBUF | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE | IAX_FORCE_ENCRYPT);
04615 cai->maxtime = peer->maxms;
04616 cai->capability = peer->capability;
04617 cai->encmethods = peer->encmethods;
04618 cai->sockfd = peer->sockfd;
04619 cai->adsi = peer->adsi;
04620 memcpy(&ourprefs, &peer->prefs, sizeof(ourprefs));
04621
04622 if (c) {
04623 ast_debug(1, "prepending %llx to prefs\n", (unsigned long long) c->nativeformats);
04624 ast_codec_pref_prepend(&ourprefs, c->nativeformats, 1);
04625 }
04626 ast_codec_pref_convert(&ourprefs, cai->prefs, sizeof(cai->prefs), 1);
04627 ast_copy_string(cai->context, peer->context, sizeof(cai->context));
04628 ast_copy_string(cai->peercontext, peer->peercontext, sizeof(cai->peercontext));
04629 ast_copy_string(cai->username, peer->username, sizeof(cai->username));
04630 ast_copy_string(cai->timezone, peer->zonetag, sizeof(cai->timezone));
04631 ast_copy_string(cai->outkey, peer->outkey, sizeof(cai->outkey));
04632 ast_copy_string(cai->cid_num, peer->cid_num, sizeof(cai->cid_num));
04633 ast_copy_string(cai->cid_name, peer->cid_name, sizeof(cai->cid_name));
04634 ast_copy_string(cai->mohinterpret, peer->mohinterpret, sizeof(cai->mohinterpret));
04635 ast_copy_string(cai->mohsuggest, peer->mohsuggest, sizeof(cai->mohsuggest));
04636 if (ast_strlen_zero(peer->dbsecret)) {
04637 ast_copy_string(cai->secret, peer->secret, sizeof(cai->secret));
04638 } else {
04639 char *family;
04640 char *key = NULL;
04641
04642 family = ast_strdupa(peer->dbsecret);
04643 key = strchr(family, '/');
04644 if (key)
04645 *key++ = '\0';
04646 if (!key || ast_db_get(family, key, cai->secret, sizeof(cai->secret))) {
04647 ast_log(LOG_WARNING, "Unable to retrieve database password for family/key '%s'!\n", peer->dbsecret);
04648 goto return_unref;
04649 }
04650 }
04651
04652 if (peer_addr.sin_addr.s_addr) {
04653 sin->sin_addr = peer_addr.sin_addr;
04654 sin->sin_port = peer_addr.sin_port;
04655 } else {
04656 sin->sin_addr = peer->defaddr.sin_addr;
04657 sin->sin_port = peer->defaddr.sin_port;
04658 }
04659
04660 res = 0;
04661
04662 return_unref:
04663 peer_unref(peer);
04664
04665 return res;
04666 }
04667
04668 static void __auto_congest(const void *nothing)
04669 {
04670 int callno = PTR_TO_CALLNO(nothing);
04671 struct ast_frame f = { AST_FRAME_CONTROL, { AST_CONTROL_CONGESTION } };
04672 ast_mutex_lock(&iaxsl[callno]);
04673 if (iaxs[callno]) {
04674 iaxs[callno]->initid = -1;
04675 iax2_queue_frame(callno, &f);
04676 ast_log(LOG_NOTICE, "Auto-congesting call due to slow response\n");
04677 }
04678 ast_mutex_unlock(&iaxsl[callno]);
04679 }
04680
04681 static int auto_congest(const void *data)
04682 {
04683 #ifdef SCHED_MULTITHREADED
04684 if (schedule_action(__auto_congest, data))
04685 #endif
04686 __auto_congest(data);
04687 return 0;
04688 }
04689
04690 static unsigned int iax2_datetime(const char *tz)
04691 {
04692 struct timeval t = ast_tvnow();
04693 struct ast_tm tm;
04694 unsigned int tmp;
04695 ast_localtime(&t, &tm, ast_strlen_zero(tz) ? NULL : tz);
04696 tmp = (tm.tm_sec >> 1) & 0x1f;
04697 tmp |= (tm.tm_min & 0x3f) << 5;
04698 tmp |= (tm.tm_hour & 0x1f) << 11;
04699 tmp |= (tm.tm_mday & 0x1f) << 16;
04700 tmp |= ((tm.tm_mon + 1) & 0xf) << 21;
04701 tmp |= ((tm.tm_year - 100) & 0x7f) << 25;
04702 return tmp;
04703 }
04704
04705 struct parsed_dial_string {
04706 char *username;
04707 char *password;
04708 char *key;
04709 char *peer;
04710 char *port;
04711 char *exten;
04712 char *context;
04713 char *options;
04714 };
04715
04716 static int send_apathetic_reply(unsigned short callno, unsigned short dcallno,
04717 struct sockaddr_in *sin, int command, int ts, unsigned char seqno,
04718 int sockfd, struct iax_ie_data *ied)
04719 {
04720 struct {
04721 struct ast_iax2_full_hdr f;
04722 struct iax_ie_data ied;
04723 } data;
04724 size_t size = sizeof(struct ast_iax2_full_hdr);
04725
04726 if (ied) {
04727 size += ied->pos;
04728 memcpy(&data.ied, ied->buf, ied->pos);
04729 }
04730
04731 data.f.scallno = htons(0x8000 | callno);
04732 data.f.dcallno = htons(dcallno & ~IAX_FLAG_RETRANS);
04733 data.f.ts = htonl(ts);
04734 data.f.iseqno = seqno;
04735 data.f.oseqno = 0;
04736 data.f.type = AST_FRAME_IAX;
04737 data.f.csub = compress_subclass(command);
04738
04739 iax_outputframe(NULL, &data.f, 0, sin, size - sizeof(struct ast_iax2_full_hdr));
04740
04741 return sendto(sockfd, &data, size, 0, (struct sockaddr *)sin, sizeof(*sin));
04742 }
04743
04744 static void add_empty_calltoken_ie(struct chan_iax2_pvt *pvt, struct iax_ie_data *ied)
04745 {
04746
04747 if (pvt && ied && (2 < ((int) sizeof(ied->buf) - ied->pos))) {
04748 ied->buf[ied->pos++] = IAX_IE_CALLTOKEN;
04749 ied->buf[ied->pos++] = 0;
04750 pvt->calltoken_ie_len = 2;
04751 }
04752 }
04753
04754 static void resend_with_token(int callno, struct iax_frame *f, const char *newtoken)
04755 {
04756 struct chan_iax2_pvt *pvt = iaxs[callno];
04757 int frametype = f->af.frametype;
04758 int subclass = f->af.subclass.integer;
04759 struct {
04760 struct ast_iax2_full_hdr fh;
04761 struct iax_ie_data ied;
04762 } data = {
04763 .ied.buf = { 0 },
04764 .ied.pos = 0,
04765 };
04766
04767 int ie_data_pos = f->datalen - sizeof(struct ast_iax2_full_hdr);
04768
04769 if (!pvt) {
04770 return;
04771 }
04772
04773
04774
04775
04776
04777
04778
04779
04780
04781
04782
04783
04784 if (f->encmethods || f->dcallno || !iax2_allow_new(frametype, subclass, 0)
04785 || !pvt->calltoken_ie_len || (pvt->calltoken_ie_len > ie_data_pos) ||
04786 (f->datalen > sizeof(data))) {
04787
04788 return;
04789 }
04790
04791
04792
04793
04794
04795
04796
04797
04798
04799
04800
04801
04802
04803
04804
04805 memcpy(&data, f->data, f->datalen);
04806 data.ied.pos = ie_data_pos;
04807
04808
04809
04810 data.ied.pos -= pvt->calltoken_ie_len;
04811 iax_ie_append_str(&data.ied, IAX_IE_CALLTOKEN, newtoken);
04812
04813
04814 pvt->calltoken_ie_len = data.ied.pos - ie_data_pos;
04815
04816
04817 AST_LIST_REMOVE(&frame_queue[callno], f, list);
04818
04819
04820 iax2_frame_free(f);
04821
04822
04823 pvt->oseqno = 0;
04824 pvt->rseqno = 0;
04825 pvt->iseqno = 0;
04826 pvt->aseqno = 0;
04827 if (pvt->peercallno) {
04828 remove_by_peercallno(pvt);
04829 pvt->peercallno = 0;
04830 }
04831
04832
04833 send_command(pvt, AST_FRAME_IAX, subclass, 0, data.ied.buf, data.ied.pos, -1);
04834 }
04835
04836 static void requirecalltoken_mark_auto(const char *name, int subclass)
04837 {
04838 struct iax2_user *user = NULL;
04839 struct iax2_peer *peer = NULL;
04840
04841 if (ast_strlen_zero(name)) {
04842 return;
04843 }
04844
04845 if ((subclass == IAX_COMMAND_NEW) && (user = find_user(name)) && (user->calltoken_required == CALLTOKEN_AUTO)) {
04846 user->calltoken_required = CALLTOKEN_YES;
04847 } else if ((subclass != IAX_COMMAND_NEW) && (peer = find_peer(name, 1)) && (peer->calltoken_required == CALLTOKEN_AUTO)) {
04848 peer->calltoken_required = CALLTOKEN_YES;
04849 }
04850
04851 if (peer) {
04852 peer_unref(peer);
04853 }
04854 if (user) {
04855 user_unref(user);
04856 }
04857 }
04858
04859
04860
04861
04862
04863
04864
04865
04866
04867
04868
04869
04870
04871
04872
04873
04874
04875
04876 static int handle_call_token(struct ast_iax2_full_hdr *fh, struct iax_ies *ies,
04877 struct sockaddr_in *sin, int fd)
04878 {
04879 #define CALLTOKEN_HASH_FORMAT "%s%d%u%d"
04880 #define CALLTOKEN_IE_FORMAT "%u?%s"
04881 struct ast_str *buf = ast_str_alloca(256);
04882 time_t t = time(NULL);
04883 char hash[41];
04884 int subclass = uncompress_subclass(fh->csub);
04885
04886
04887 if (ies->calltoken && !ies->calltokendata) {
04888 struct iax_ie_data ied = {
04889 .buf = { 0 },
04890 .pos = 0,
04891 };
04892
04893
04894 ast_str_set(&buf, 0, CALLTOKEN_HASH_FORMAT, ast_inet_ntoa(sin->sin_addr), sin->sin_port, (unsigned int) t, randomcalltokendata);
04895 ast_sha1_hash(hash, ast_str_buffer(buf));
04896
04897 ast_str_set(&buf, 0, CALLTOKEN_IE_FORMAT, (unsigned int) t, hash);
04898 iax_ie_append_str(&ied, IAX_IE_CALLTOKEN, ast_str_buffer(buf));
04899 send_apathetic_reply(1, ntohs(fh->scallno), sin, IAX_COMMAND_CALLTOKEN, ntohl(fh->ts), fh->iseqno + 1, fd, &ied);
04900
04901 return 1;
04902
04903
04904 } else if (ies->calltoken && ies->calltokendata) {
04905 char *rec_hash = NULL;
04906 char *rec_ts = NULL;
04907 unsigned int rec_time;
04908
04909
04910 rec_hash = strchr((char *) ies->calltokendata, '?');
04911 if (rec_hash) {
04912 *rec_hash++ = '\0';
04913 rec_ts = (char *) ies->calltokendata;
04914 }
04915
04916
04917 if (!rec_hash || !rec_ts) {
04918 goto reject;
04919 } else if (sscanf(rec_ts, "%u", &rec_time) != 1) {
04920 goto reject;
04921 }
04922
04923
04924 ast_str_set(&buf, 0, CALLTOKEN_HASH_FORMAT, ast_inet_ntoa(sin->sin_addr), sin->sin_port, (unsigned int) rec_time, randomcalltokendata);
04925 ast_sha1_hash(hash, ast_str_buffer(buf));
04926
04927
04928 if (strcmp(hash, rec_hash)) {
04929 ast_log(LOG_WARNING, "Address %s failed CallToken hash inspection\n", ast_inet_ntoa(sin->sin_addr));
04930 goto reject;
04931 } else if ((t < rec_time) || ((t - rec_time) >= MAX_CALLTOKEN_DELAY)) {
04932 ast_log(LOG_WARNING, "Too much delay in IAX2 calltoken timestamp from address %s\n", ast_inet_ntoa(sin->sin_addr));
04933 goto reject;
04934 }
04935
04936
04937
04938 requirecalltoken_mark_auto(ies->username, subclass);
04939 return 0;
04940
04941
04942 } else {
04943 if (calltoken_required(sin, ies->username, subclass)) {
04944 ast_log(LOG_ERROR, "Call rejected, CallToken Support required. If unexpected, resolve by placing address %s in the calltokenoptional list or setting user %s requirecalltoken=no\n", ast_inet_ntoa(sin->sin_addr), S_OR(ies->username, "guest"));
04945 goto reject;
04946 }
04947 return 0;
04948 }
04949
04950 reject:
04951
04952 if (subclass == IAX_COMMAND_REGREQ || subclass == IAX_COMMAND_REGREL) {
04953 send_apathetic_reply(1, ntohs(fh->scallno), sin, IAX_COMMAND_REGREJ, ntohl(fh->ts), fh->iseqno + 1, fd, NULL);
04954 } else {
04955 send_apathetic_reply(1, ntohs(fh->scallno), sin, IAX_COMMAND_REJECT, ntohl(fh->ts), fh->iseqno + 1, fd, NULL);
04956 }
04957
04958 return 1;
04959 }
04960
04961
04962
04963
04964
04965
04966
04967
04968
04969
04970
04971
04972
04973
04974
04975
04976
04977
04978
04979 static void parse_dial_string(char *data, struct parsed_dial_string *pds)
04980 {
04981 if (ast_strlen_zero(data))
04982 return;
04983
04984 pds->peer = strsep(&data, "/");
04985 pds->exten = strsep(&data, "/");
04986 pds->options = data;
04987
04988 if (pds->exten) {
04989 data = pds->exten;
04990 pds->exten = strsep(&data, "@");
04991 pds->context = data;
04992 }
04993
04994 if (strchr(pds->peer, '@')) {
04995 data = pds->peer;
04996 pds->username = strsep(&data, "@");
04997 pds->peer = data;
04998 }
04999
05000 if (pds->username) {
05001 data = pds->username;
05002 pds->username = strsep(&data, ":");
05003 pds->password = data;
05004 }
05005
05006 data = pds->peer;
05007 pds->peer = strsep(&data, ":");
05008 pds->port = data;
05009
05010
05011
05012
05013 if (pds->password && (pds->password[0] == '[')) {
05014 pds->key = ast_strip_quoted(pds->password, "[", "]");
05015 pds->password = NULL;
05016 }
05017 }
05018
05019 static int iax2_call(struct ast_channel *c, char *dest, int timeout)
05020 {
05021 struct sockaddr_in sin;
05022 char *l=NULL, *n=NULL, *tmpstr;
05023 struct iax_ie_data ied;
05024 char *defaultrdest = "s";
05025 unsigned short callno = PTR_TO_CALLNO(c->tech_pvt);
05026 struct parsed_dial_string pds;
05027 struct create_addr_info cai;
05028 struct ast_var_t *var;
05029 struct ast_datastore *variablestore = ast_channel_datastore_find(c, &iax2_variable_datastore_info, NULL);
05030 const char* osp_token_ptr;
05031 unsigned int osp_token_length;
05032 unsigned char osp_block_index;
05033 unsigned int osp_block_length;
05034 unsigned char osp_buffer[256];
05035
05036 if ((c->_state != AST_STATE_DOWN) && (c->_state != AST_STATE_RESERVED)) {
05037 ast_log(LOG_WARNING, "Channel is already in use (%s)?\n", c->name);
05038 return -1;
05039 }
05040
05041 memset(&cai, 0, sizeof(cai));
05042 cai.encmethods = iax2_encryption;
05043
05044 memset(&pds, 0, sizeof(pds));
05045 tmpstr = ast_strdupa(dest);
05046 parse_dial_string(tmpstr, &pds);
05047
05048 if (ast_strlen_zero(pds.peer)) {
05049 ast_log(LOG_WARNING, "No peer provided in the IAX2 dial string '%s'\n", dest);
05050 return -1;
05051 }
05052 if (!pds.exten) {
05053 pds.exten = defaultrdest;
05054 }
05055 if (create_addr(pds.peer, c, &sin, &cai)) {
05056 ast_log(LOG_WARNING, "No address associated with '%s'\n", pds.peer);
05057 return -1;
05058 }
05059 if (ast_test_flag64(iaxs[callno], IAX_FORCE_ENCRYPT) && !cai.encmethods) {
05060 ast_log(LOG_WARNING, "Encryption forced for call, but not enabled\n");
05061 c->hangupcause = AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
05062 return -1;
05063 }
05064 if (ast_strlen_zero(cai.secret) && ast_test_flag64(iaxs[callno], IAX_FORCE_ENCRYPT)) {
05065 ast_log(LOG_WARNING, "Call terminated. No secret given and force encrypt enabled\n");
05066 return -1;
05067 }
05068 if (!pds.username && !ast_strlen_zero(cai.username))
05069 pds.username = cai.username;
05070 if (!pds.password && !ast_strlen_zero(cai.secret))
05071 pds.password = cai.secret;
05072 if (!pds.key && !ast_strlen_zero(cai.outkey))
05073 pds.key = cai.outkey;
05074 if (!pds.context && !ast_strlen_zero(cai.peercontext))
05075 pds.context = cai.peercontext;
05076
05077
05078 ast_copy_string(c->context, cai.context, sizeof(c->context));
05079
05080 if (pds.port)
05081 sin.sin_port = htons(atoi(pds.port));
05082
05083 l = c->connected.id.number.valid ? c->connected.id.number.str : NULL;
05084 n = c->connected.id.name.valid ? c->connected.id.name.str : NULL;
05085
05086
05087 memset(&ied, 0, sizeof(ied));
05088
05089
05090 iax_ie_append_short(&ied, IAX_IE_VERSION, IAX_PROTO_VERSION);
05091 iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, pds.exten);
05092 if (pds.options && strchr(pds.options, 'a')) {
05093
05094 iax_ie_append(&ied, IAX_IE_AUTOANSWER);
05095 }
05096
05097
05098 iax_ie_append_str(&ied, IAX_IE_CODEC_PREFS, cai.prefs);
05099
05100 if (l) {
05101 iax_ie_append_str(&ied, IAX_IE_CALLING_NUMBER, l);
05102 iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES,
05103 ast_party_id_presentation(&c->connected.id));
05104 } else if (n) {
05105 iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES,
05106 ast_party_id_presentation(&c->connected.id));
05107 } else {
05108 iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES, AST_PRES_NUMBER_NOT_AVAILABLE);
05109 }
05110
05111 iax_ie_append_byte(&ied, IAX_IE_CALLINGTON, c->connected.id.number.plan);
05112 iax_ie_append_short(&ied, IAX_IE_CALLINGTNS, c->dialed.transit_network_select);
05113
05114 if (n)
05115 iax_ie_append_str(&ied, IAX_IE_CALLING_NAME, n);
05116 if (ast_test_flag64(iaxs[callno], IAX_SENDANI)
05117 && c->connected.ani.number.valid
05118 && c->connected.ani.number.str) {
05119 iax_ie_append_str(&ied, IAX_IE_CALLING_ANI, c->connected.ani.number.str);
05120 }
05121
05122 if (!ast_strlen_zero(c->language))
05123 iax_ie_append_str(&ied, IAX_IE_LANGUAGE, c->language);
05124 if (!ast_strlen_zero(c->dialed.number.str)) {
05125 iax_ie_append_str(&ied, IAX_IE_DNID, c->dialed.number.str);
05126 }
05127 if (c->redirecting.from.number.valid
05128 && !ast_strlen_zero(c->redirecting.from.number.str)) {
05129 iax_ie_append_str(&ied, IAX_IE_RDNIS, c->redirecting.from.number.str);
05130 }
05131
05132 if (pds.context)
05133 iax_ie_append_str(&ied, IAX_IE_CALLED_CONTEXT, pds.context);
05134
05135 if (pds.username)
05136 iax_ie_append_str(&ied, IAX_IE_USERNAME, pds.username);
05137
05138 if (cai.encmethods)
05139 iax_ie_append_short(&ied, IAX_IE_ENCRYPTION, cai.encmethods);
05140
05141 ast_mutex_lock(&iaxsl[callno]);
05142
05143 if (!ast_strlen_zero(c->context))
05144 ast_string_field_set(iaxs[callno], context, c->context);
05145
05146 if (pds.username)
05147 ast_string_field_set(iaxs[callno], username, pds.username);
05148
05149 iaxs[callno]->encmethods = cai.encmethods;
05150
05151 iaxs[callno]->adsi = cai.adsi;
05152
05153 ast_string_field_set(iaxs[callno], mohinterpret, cai.mohinterpret);
05154 ast_string_field_set(iaxs[callno], mohsuggest, cai.mohsuggest);
05155
05156 if (pds.key)
05157 ast_string_field_set(iaxs[callno], outkey, pds.key);
05158 if (pds.password)
05159 ast_string_field_set(iaxs[callno], secret, pds.password);
05160
05161 iax_ie_append_int(&ied, IAX_IE_FORMAT, (int) c->nativeformats);
05162 iax_ie_append_versioned_uint64(&ied, IAX_IE_FORMAT2, 0, c->nativeformats);
05163 iax_ie_append_int(&ied, IAX_IE_CAPABILITY, (int) iaxs[callno]->capability);
05164 iax_ie_append_versioned_uint64(&ied, IAX_IE_CAPABILITY2, 0, iaxs[callno]->capability);
05165 iax_ie_append_short(&ied, IAX_IE_ADSICPE, c->adsicpe);
05166 iax_ie_append_int(&ied, IAX_IE_DATETIME, iax2_datetime(cai.timezone));
05167
05168 if (iaxs[callno]->maxtime) {
05169
05170 iaxs[callno]->pingtime = iaxs[callno]->maxtime / 2;
05171 iaxs[callno]->initid = iax2_sched_add(sched, iaxs[callno]->maxtime * 2, auto_congest, CALLNO_TO_PTR(callno));
05172 } else if (autokill) {
05173 iaxs[callno]->pingtime = autokill / 2;
05174 iaxs[callno]->initid = iax2_sched_add(sched, autokill * 2, auto_congest, CALLNO_TO_PTR(callno));
05175 }
05176
05177
05178 osp_token_ptr = pbx_builtin_getvar_helper(c, "IAX2OSPTOKEN");
05179 if (!ast_strlen_zero(osp_token_ptr)) {
05180 if ((osp_token_length = strlen(osp_token_ptr)) <= IAX_MAX_OSPTOKEN_SIZE) {
05181 osp_block_index = 0;
05182 while (osp_token_length > 0) {
05183 osp_block_length = IAX_MAX_OSPBLOCK_SIZE < osp_token_length ? IAX_MAX_OSPBLOCK_SIZE : osp_token_length;
05184 osp_buffer[0] = osp_block_index;
05185 memcpy(osp_buffer + 1, osp_token_ptr, osp_block_length);
05186 iax_ie_append_raw(&ied, IAX_IE_OSPTOKEN, osp_buffer, osp_block_length + 1);
05187 osp_block_index++;
05188 osp_token_ptr += osp_block_length;
05189 osp_token_length -= osp_block_length;
05190 }
05191 } else
05192 ast_log(LOG_WARNING, "OSP token is too long\n");
05193 } else if (iaxdebug)
05194 ast_debug(1, "OSP token is undefined\n");
05195
05196
05197 iaxs[callno]->sockfd = cai.sockfd;
05198
05199
05200 if (variablestore) {
05201 AST_LIST_HEAD(, ast_var_t) *variablelist = variablestore->data;
05202 ast_debug(1, "Found an IAX variable store on this channel\n");
05203 AST_LIST_LOCK(variablelist);
05204 AST_LIST_TRAVERSE(variablelist, var, entries) {
05205 char tmp[256];
05206 int i;
05207 ast_debug(1, "Found IAXVAR '%s' with value '%s' (to transmit)\n", ast_var_name(var), ast_var_value(var));
05208
05209 for (i = 0; i < strlen(ast_var_value(var)); i += 255 - (strlen(ast_var_name(var)) + 1)) {
05210 snprintf(tmp, sizeof(tmp), "%s=%s", ast_var_name(var), ast_var_value(var) + i);
05211 iax_ie_append_str(&ied, IAX_IE_VARIABLE, tmp);
05212 }
05213 }
05214 AST_LIST_UNLOCK(variablelist);
05215 }
05216
05217
05218 add_empty_calltoken_ie(iaxs[callno], &ied);
05219 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_NEW, 0, ied.buf, ied.pos, -1);
05220
05221 ast_mutex_unlock(&iaxsl[callno]);
05222 ast_setstate(c, AST_STATE_RINGING);
05223
05224 return 0;
05225 }
05226
05227 static int iax2_hangup(struct ast_channel *c)
05228 {
05229 unsigned short callno = PTR_TO_CALLNO(c->tech_pvt);
05230 struct iax_ie_data ied;
05231 int alreadygone;
05232 memset(&ied, 0, sizeof(ied));
05233 ast_mutex_lock(&iaxsl[callno]);
05234 if (callno && iaxs[callno]) {
05235 ast_debug(1, "We're hanging up %s now...\n", c->name);
05236 alreadygone = ast_test_flag64(iaxs[callno], IAX_ALREADYGONE);
05237
05238 iax_ie_append_byte(&ied, IAX_IE_CAUSECODE, (unsigned char)c->hangupcause);
05239 if (!iaxs[callno]->error && !alreadygone) {
05240 if (send_command_final(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_HANGUP, 0, ied.buf, ied.pos, -1)) {
05241 ast_log(LOG_WARNING, "No final packet could be sent for callno %d\n", callno);
05242 }
05243 if (!iaxs[callno]) {
05244 ast_mutex_unlock(&iaxsl[callno]);
05245 return 0;
05246 }
05247 }
05248
05249 iax2_predestroy(callno);
05250
05251 if (iaxs[callno] && alreadygone) {
05252 ast_debug(1, "Really destroying %s now...\n", c->name);
05253 iax2_destroy(callno);
05254 } else if (iaxs[callno]) {
05255 if (ast_sched_thread_add(sched, 10000, scheduled_destroy, CALLNO_TO_PTR(callno)) < 0) {
05256 ast_log(LOG_ERROR, "Unable to schedule iax2 callno %d destruction?!! Destroying immediately.\n", callno);
05257 iax2_destroy(callno);
05258 }
05259 }
05260 } else if (c->tech_pvt) {
05261
05262
05263
05264
05265 c->tech_pvt = NULL;
05266 }
05267 ast_mutex_unlock(&iaxsl[callno]);
05268 ast_verb(3, "Hungup '%s'\n", c->name);
05269 return 0;
05270 }
05271
05272
05273
05274
05275 static int wait_for_peercallno(struct chan_iax2_pvt *pvt)
05276 {
05277 unsigned short callno = pvt->callno;
05278
05279 if (!pvt->peercallno) {
05280
05281 int count = 10;
05282 while (count-- && pvt && !pvt->peercallno) {
05283 DEADLOCK_AVOIDANCE(&iaxsl[callno]);
05284 pvt = iaxs[callno];
05285 }
05286 if (!pvt || !pvt->peercallno) {
05287 return -1;
05288 }
05289 }
05290
05291 return 0;
05292 }
05293
05294 static int iax2_setoption(struct ast_channel *c, int option, void *data, int datalen)
05295 {
05296 struct ast_option_header *h;
05297 int res;
05298
05299 switch (option) {
05300 case AST_OPTION_TXGAIN:
05301 case AST_OPTION_RXGAIN:
05302
05303 errno = ENOSYS;
05304 return -1;
05305 case AST_OPTION_OPRMODE:
05306 errno = EINVAL;
05307 return -1;
05308 case AST_OPTION_SECURE_SIGNALING:
05309 case AST_OPTION_SECURE_MEDIA:
05310 {
05311 unsigned short callno = PTR_TO_CALLNO(c->tech_pvt);
05312 ast_mutex_lock(&iaxsl[callno]);
05313 if ((*(int *) data)) {
05314 ast_set_flag64(iaxs[callno], IAX_FORCE_ENCRYPT);
05315 } else {
05316 ast_clear_flag64(iaxs[callno], IAX_FORCE_ENCRYPT);
05317 }
05318 ast_mutex_unlock(&iaxsl[callno]);
05319 return 0;
05320 }
05321
05322
05323
05324
05325 case AST_OPTION_TONE_VERIFY:
05326 case AST_OPTION_TDD:
05327 case AST_OPTION_RELAXDTMF:
05328 case AST_OPTION_AUDIO_MODE:
05329 case AST_OPTION_DIGIT_DETECT:
05330 case AST_OPTION_FAX_DETECT:
05331 {
05332 unsigned short callno = PTR_TO_CALLNO(c->tech_pvt);
05333 struct chan_iax2_pvt *pvt;
05334
05335 ast_mutex_lock(&iaxsl[callno]);
05336 pvt = iaxs[callno];
05337
05338 if (wait_for_peercallno(pvt)) {
05339 ast_mutex_unlock(&iaxsl[callno]);
05340 return -1;
05341 }
05342
05343 ast_mutex_unlock(&iaxsl[callno]);
05344
05345 if (!(h = ast_malloc(datalen + sizeof(*h)))) {
05346 return -1;
05347 }
05348
05349 h->flag = AST_OPTION_FLAG_REQUEST;
05350 h->option = htons(option);
05351 memcpy(h->data, data, datalen);
05352 res = send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_CONTROL,
05353 AST_CONTROL_OPTION, 0, (unsigned char *) h,
05354 datalen + sizeof(*h), -1);
05355 ast_free(h);
05356 return res;
05357 }
05358 default:
05359 return -1;
05360 }
05361
05362
05363 return -1;
05364 }
05365
05366 static int iax2_queryoption(struct ast_channel *c, int option, void *data, int *datalen)
05367 {
05368 switch (option) {
05369 case AST_OPTION_SECURE_SIGNALING:
05370 case AST_OPTION_SECURE_MEDIA:
05371 {
05372 unsigned short callno = PTR_TO_CALLNO(c->tech_pvt);
05373 ast_mutex_lock(&iaxsl[callno]);
05374 *((int *) data) = ast_test_flag64(iaxs[callno], IAX_FORCE_ENCRYPT) ? 1 : 0;
05375 ast_mutex_unlock(&iaxsl[callno]);
05376 return 0;
05377 }
05378 default:
05379 return -1;
05380 }
05381 }
05382
05383 static struct ast_frame *iax2_read(struct ast_channel *c)
05384 {
05385 ast_debug(1, "I should never be called!\n");
05386 return &ast_null_frame;
05387 }
05388
05389 static int iax2_key_rotate(const void *vpvt)
05390 {
05391 int res = 0;
05392 struct chan_iax2_pvt *pvt = (void *) vpvt;
05393 struct MD5Context md5;
05394 char key[17] = "";
05395 struct iax_ie_data ied = {
05396 .pos = 0,
05397 };
05398
05399 ast_mutex_lock(&iaxsl[pvt->callno]);
05400 pvt->keyrotateid =
05401 ast_sched_thread_add(sched, 120000 + (ast_random() % 180001), iax2_key_rotate, vpvt);
05402
05403 snprintf(key, sizeof(key), "%lX", ast_random());
05404
05405 MD5Init(&md5);
05406 MD5Update(&md5, (unsigned char *) key, strlen(key));
05407 MD5Final((unsigned char *) key, &md5);
05408
05409 IAX_DEBUGDIGEST("Sending", key);
05410
05411 iax_ie_append_raw(&ied, IAX_IE_CHALLENGE, key, 16);
05412
05413 res = send_command(pvt, AST_FRAME_IAX, IAX_COMMAND_RTKEY, 0, ied.buf, ied.pos, -1);
05414
05415 build_ecx_key((unsigned char *) key, pvt);
05416
05417 ast_mutex_unlock(&iaxsl[pvt->callno]);
05418
05419 return res;
05420 }
05421
05422 static int iax2_start_transfer(unsigned short callno0, unsigned short callno1, int mediaonly)
05423 {
05424 int res;
05425 struct iax_ie_data ied0;
05426 struct iax_ie_data ied1;
05427 unsigned int transferid = (unsigned int)ast_random();
05428
05429 if (IAX_CALLENCRYPTED(iaxs[callno0]) || IAX_CALLENCRYPTED(iaxs[callno1])) {
05430 ast_debug(1, "transfers are not supported for encrypted calls at this time\n");
05431 ast_set_flag64(iaxs[callno0], IAX_NOTRANSFER);
05432 ast_set_flag64(iaxs[callno1], IAX_NOTRANSFER);
05433 return 0;
05434 }
05435
05436 memset(&ied0, 0, sizeof(ied0));
05437 iax_ie_append_addr(&ied0, IAX_IE_APPARENT_ADDR, &iaxs[callno1]->addr);
05438 iax_ie_append_short(&ied0, IAX_IE_CALLNO, iaxs[callno1]->peercallno);
05439 iax_ie_append_int(&ied0, IAX_IE_TRANSFERID, transferid);
05440
05441 memset(&ied1, 0, sizeof(ied1));
05442 iax_ie_append_addr(&ied1, IAX_IE_APPARENT_ADDR, &iaxs[callno0]->addr);
05443 iax_ie_append_short(&ied1, IAX_IE_CALLNO, iaxs[callno0]->peercallno);
05444 iax_ie_append_int(&ied1, IAX_IE_TRANSFERID, transferid);
05445
05446 res = send_command(iaxs[callno0], AST_FRAME_IAX, IAX_COMMAND_TXREQ, 0, ied0.buf, ied0.pos, -1);
05447 if (res)
05448 return -1;
05449 res = send_command(iaxs[callno1], AST_FRAME_IAX, IAX_COMMAND_TXREQ, 0, ied1.buf, ied1.pos, -1);
05450 if (res)
05451 return -1;
05452 iaxs[callno0]->transferring = mediaonly ? TRANSFER_MBEGIN : TRANSFER_BEGIN;
05453 iaxs[callno1]->transferring = mediaonly ? TRANSFER_MBEGIN : TRANSFER_BEGIN;
05454 return 0;
05455 }
05456
05457 static void lock_both(unsigned short callno0, unsigned short callno1)
05458 {
05459 ast_mutex_lock(&iaxsl[callno0]);
05460 while (ast_mutex_trylock(&iaxsl[callno1])) {
05461 DEADLOCK_AVOIDANCE(&iaxsl[callno0]);
05462 }
05463 }
05464
05465 static void unlock_both(unsigned short callno0, unsigned short callno1)
05466 {
05467 ast_mutex_unlock(&iaxsl[callno1]);
05468 ast_mutex_unlock(&iaxsl[callno0]);
05469 }
05470
05471 static enum ast_bridge_result iax2_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc, int timeoutms)
05472 {
05473 struct ast_channel *cs[3];
05474 struct ast_channel *who, *other;
05475 int to = -1;
05476 int res = -1;
05477 int transferstarted=0;
05478 struct ast_frame *f;
05479 unsigned short callno0 = PTR_TO_CALLNO(c0->tech_pvt);
05480 unsigned short callno1 = PTR_TO_CALLNO(c1->tech_pvt);
05481 struct timeval waittimer = {0, 0};
05482
05483
05484 if (timeoutms > 0) {
05485 return AST_BRIDGE_FAILED;
05486 }
05487
05488 timeoutms = -1;
05489
05490 lock_both(callno0, callno1);
05491 if (!iaxs[callno0] || !iaxs[callno1]) {
05492 unlock_both(callno0, callno1);
05493 return AST_BRIDGE_FAILED;
05494 }
05495
05496 if (!(flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1))) {
05497 iaxs[callno0]->bridgecallno = callno1;
05498 iaxs[callno1]->bridgecallno = callno0;
05499 }
05500 unlock_both(callno0, callno1);
05501
05502
05503 cs[0] = c0;
05504 cs[1] = c1;
05505 for (;;) {
05506
05507 if ((c0->tech != &iax2_tech) || (c1->tech != &iax2_tech)) {
05508 ast_verb(3, "Can't masquerade, we're different...\n");
05509
05510 if (c0->tech == &iax2_tech) {
05511 ast_mutex_lock(&iaxsl[callno0]);
05512 iaxs[callno0]->bridgecallno = 0;
05513 ast_mutex_unlock(&iaxsl[callno0]);
05514 }
05515 if (c1->tech == &iax2_tech) {
05516 ast_mutex_lock(&iaxsl[callno1]);
05517 iaxs[callno1]->bridgecallno = 0;
05518 ast_mutex_unlock(&iaxsl[callno1]);
05519 }
05520 return AST_BRIDGE_FAILED_NOWARN;
05521 }
05522 if (c0->nativeformats != c1->nativeformats) {
05523 char buf0[256];
05524 char buf1[256];
05525 ast_getformatname_multiple(buf0, sizeof(buf0), c0->nativeformats);
05526 ast_getformatname_multiple(buf1, sizeof(buf1), c1->nativeformats);
05527 ast_verb(3, "Operating with different codecs [%s] [%s] , can't native bridge...\n", buf0, buf1);
05528
05529 lock_both(callno0, callno1);
05530 if (iaxs[callno0])
05531 iaxs[callno0]->bridgecallno = 0;
05532 if (iaxs[callno1])
05533 iaxs[callno1]->bridgecallno = 0;
05534 unlock_both(callno0, callno1);
05535 return AST_BRIDGE_FAILED_NOWARN;
05536 }
05537
05538 if (!transferstarted && !ast_test_flag64(iaxs[callno0], IAX_NOTRANSFER) && !ast_test_flag64(iaxs[callno1], IAX_NOTRANSFER)) {
05539
05540 if (iax2_start_transfer(callno0, callno1, (flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1)) ||
05541 ast_test_flag64(iaxs[callno0], IAX_TRANSFERMEDIA) | ast_test_flag64(iaxs[callno1], IAX_TRANSFERMEDIA)))
05542 ast_log(LOG_WARNING, "Unable to start the transfer\n");
05543 transferstarted = 1;
05544 }
05545 if ((iaxs[callno0]->transferring == TRANSFER_RELEASED) && (iaxs[callno1]->transferring == TRANSFER_RELEASED)) {
05546
05547 struct timeval now = ast_tvnow();
05548 if (ast_tvzero(waittimer)) {
05549 waittimer = now;
05550 } else if (now.tv_sec - waittimer.tv_sec > IAX_LINGER_TIMEOUT) {
05551 c0->_softhangup |= AST_SOFTHANGUP_DEV;
05552 c1->_softhangup |= AST_SOFTHANGUP_DEV;
05553 *fo = NULL;
05554 *rc = c0;
05555 res = AST_BRIDGE_COMPLETE;
05556 break;
05557 }
05558 }
05559 to = 1000;
05560 who = ast_waitfor_n(cs, 2, &to);
05561
05562
05563
05564
05565
05566 if (timeoutms > -1) {
05567 timeoutms -= (1000 - to);
05568 if (timeoutms < 0)
05569 timeoutms = 0;
05570 }
05571 if (!who) {
05572 if (!timeoutms) {
05573 res = AST_BRIDGE_RETRY;
05574 break;
05575 }
05576 if (ast_check_hangup(c0) || ast_check_hangup(c1)) {
05577 res = AST_BRIDGE_FAILED;
05578 break;
05579 }
05580 continue;
05581 }
05582 f = ast_read(who);
05583 if (!f) {
05584 *fo = NULL;
05585 *rc = who;
05586 res = AST_BRIDGE_COMPLETE;
05587 break;
05588 }
05589 if ((f->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS) && (f->subclass.integer != AST_CONTROL_SRCUPDATE)) {
05590 *fo = f;
05591 *rc = who;
05592 res = AST_BRIDGE_COMPLETE;
05593 break;
05594 }
05595 other = (who == c0) ? c1 : c0;
05596 if ((f->frametype == AST_FRAME_VOICE) ||
05597 (f->frametype == AST_FRAME_TEXT) ||
05598 (f->frametype == AST_FRAME_VIDEO) ||
05599 (f->frametype == AST_FRAME_IMAGE) ||
05600 (f->frametype == AST_FRAME_DTMF) ||
05601 (f->frametype == AST_FRAME_CONTROL)) {
05602
05603
05604
05605 int monitored_source = (who == c0) ? AST_BRIDGE_DTMF_CHANNEL_0 : AST_BRIDGE_DTMF_CHANNEL_1;
05606 if (f->frametype == AST_FRAME_DTMF && (flags & monitored_source)) {
05607 *rc = who;
05608 *fo = f;
05609 res = AST_BRIDGE_COMPLETE;
05610
05611 break;
05612 }
05613
05614 ast_write(other, f);
05615 }
05616 ast_frfree(f);
05617
05618 cs[2] = cs[0];
05619 cs[0] = cs[1];
05620 cs[1] = cs[2];
05621 }
05622 lock_both(callno0, callno1);
05623 if(iaxs[callno0])
05624 iaxs[callno0]->bridgecallno = 0;
05625 if(iaxs[callno1])
05626 iaxs[callno1]->bridgecallno = 0;
05627 unlock_both(callno0, callno1);
05628 return res;
05629 }
05630
05631 static int iax2_answer(struct ast_channel *c)
05632 {
05633 unsigned short callno = PTR_TO_CALLNO(c->tech_pvt);
05634 ast_debug(1, "Answering IAX2 call\n");
05635 ast_mutex_lock(&iaxsl[callno]);
05636 if (iaxs[callno])
05637 iax2_ami_channelupdate(iaxs[callno]);
05638 ast_mutex_unlock(&iaxsl[callno]);
05639 return send_command_locked(callno, AST_FRAME_CONTROL, AST_CONTROL_ANSWER, 0, NULL, 0, -1);
05640 }
05641
05642 static int iax2_indicate(struct ast_channel *c, int condition, const void *data, size_t datalen)
05643 {
05644 unsigned short callno = PTR_TO_CALLNO(c->tech_pvt);
05645 struct chan_iax2_pvt *pvt;
05646 int res = 0;
05647
05648 if (iaxdebug)
05649 ast_debug(1, "Indicating condition %d\n", condition);
05650
05651 ast_mutex_lock(&iaxsl[callno]);
05652 pvt = iaxs[callno];
05653
05654 if (wait_for_peercallno(pvt)) {
05655 res = -1;
05656 goto done;
05657 }
05658
05659 switch (condition) {
05660 case AST_CONTROL_HOLD:
05661 if (strcasecmp(pvt->mohinterpret, "passthrough")) {
05662 ast_moh_start(c, data, pvt->mohinterpret);
05663 goto done;
05664 }
05665 break;
05666 case AST_CONTROL_UNHOLD:
05667 if (strcasecmp(pvt->mohinterpret, "passthrough")) {
05668 ast_moh_stop(c);
05669 goto done;
05670 }
05671 break;
05672 case AST_CONTROL_CONNECTED_LINE:
05673 if (!ast_test_flag64(pvt, IAX_SENDCONNECTEDLINE))
05674 goto done;
05675 break;
05676 }
05677
05678 res = send_command(pvt, AST_FRAME_CONTROL, condition, 0, data, datalen, -1);
05679
05680 done:
05681 ast_mutex_unlock(&iaxsl[callno]);
05682
05683 return res;
05684 }
05685
05686 static int iax2_transfer(struct ast_channel *c, const char *dest)
05687 {
05688 unsigned short callno = PTR_TO_CALLNO(c->tech_pvt);
05689 struct iax_ie_data ied = { "", };
05690 char tmp[256], *context;
05691 enum ast_control_transfer message = AST_TRANSFER_SUCCESS;
05692 ast_copy_string(tmp, dest, sizeof(tmp));
05693 context = strchr(tmp, '@');
05694 if (context) {
05695 *context = '\0';
05696 context++;
05697 }
05698 iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, tmp);
05699 if (context)
05700 iax_ie_append_str(&ied, IAX_IE_CALLED_CONTEXT, context);
05701 ast_debug(1, "Transferring '%s' to '%s'\n", c->name, dest);
05702 ast_queue_control_data(c, AST_CONTROL_TRANSFER, &message, sizeof(message));
05703 return send_command_locked(callno, AST_FRAME_IAX, IAX_COMMAND_TRANSFER, 0, ied.buf, ied.pos, -1);
05704 }
05705
05706 static int iax2_getpeertrunk(struct sockaddr_in sin)
05707 {
05708 struct iax2_peer *peer;
05709 int res = 0;
05710 struct ao2_iterator i;
05711
05712 i = ao2_iterator_init(peers, 0);
05713 while ((peer = ao2_iterator_next(&i))) {
05714 struct sockaddr_in peer_addr;
05715
05716 ast_sockaddr_to_sin(&peer->addr, &peer_addr);
05717
05718 if ((peer_addr.sin_addr.s_addr == sin.sin_addr.s_addr) &&
05719 (peer_addr.sin_port == sin.sin_port)) {
05720 res = ast_test_flag64(peer, IAX_TRUNK);
05721 peer_unref(peer);
05722 break;
05723 }
05724 peer_unref(peer);
05725 }
05726 ao2_iterator_destroy(&i);
05727
05728 return res;
05729 }
05730
05731
05732 static struct ast_channel *ast_iax2_new(int callno, int state, format_t capability, const char *linkedid, unsigned int cachable)
05733 {
05734 struct ast_channel *tmp;
05735 struct chan_iax2_pvt *i;
05736 struct ast_variable *v = NULL;
05737
05738 if (!(i = iaxs[callno])) {
05739 ast_log(LOG_WARNING, "No IAX2 pvt found for callno '%d' !\n", callno);
05740 return NULL;
05741 }
05742
05743
05744 ast_mutex_unlock(&iaxsl[callno]);
05745 tmp = ast_channel_alloc(1, state, i->cid_num, i->cid_name, i->accountcode, i->exten, i->context, linkedid, i->amaflags, "IAX2/%s-%d", i->host, i->callno);
05746 ast_mutex_lock(&iaxsl[callno]);
05747 if (i != iaxs[callno]) {
05748 if (tmp) {
05749
05750 ast_mutex_unlock(&iaxsl[callno]);
05751 tmp = ast_channel_release(tmp);
05752 ast_mutex_lock(&iaxsl[callno]);
05753 }
05754 return NULL;
05755 }
05756 iax2_ami_channelupdate(i);
05757 if (!tmp)
05758 return NULL;
05759 tmp->tech = &iax2_tech;
05760
05761 tmp->nativeformats = capability;
05762 tmp->readformat = tmp->rawreadformat = ast_best_codec(capability);
05763 tmp->writeformat = tmp->rawwriteformat = ast_best_codec(capability);
05764 tmp->tech_pvt = CALLNO_TO_PTR(i->callno);
05765
05766 if (!ast_strlen_zero(i->parkinglot))
05767 ast_string_field_set(tmp, parkinglot, i->parkinglot);
05768
05769
05770 if (!ast_strlen_zero(i->ani)) {
05771 tmp->caller.ani.number.valid = 1;
05772 tmp->caller.ani.number.str = ast_strdup(i->ani);
05773 } else if (!ast_strlen_zero(i->cid_num)) {
05774 tmp->caller.ani.number.valid = 1;
05775 tmp->caller.ani.number.str = ast_strdup(i->cid_num);
05776 }
05777 tmp->dialed.number.str = ast_strdup(i->dnid);
05778 if (!ast_strlen_zero(i->rdnis)) {
05779 tmp->redirecting.from.number.valid = 1;
05780 tmp->redirecting.from.number.str = ast_strdup(i->rdnis);
05781 }
05782 tmp->caller.id.name.presentation = i->calling_pres;
05783 tmp->caller.id.number.presentation = i->calling_pres;
05784 tmp->caller.id.number.plan = i->calling_ton;
05785 tmp->dialed.transit_network_select = i->calling_tns;
05786 if (!ast_strlen_zero(i->language))
05787 ast_string_field_set(tmp, language, i->language);
05788 if (!ast_strlen_zero(i->accountcode))
05789 ast_string_field_set(tmp, accountcode, i->accountcode);
05790 if (i->amaflags)
05791 tmp->amaflags = i->amaflags;
05792 ast_copy_string(tmp->context, i->context, sizeof(tmp->context));
05793 ast_copy_string(tmp->exten, i->exten, sizeof(tmp->exten));
05794 if (i->adsi)
05795 tmp->adsicpe = i->peeradsicpe;
05796 else
05797 tmp->adsicpe = AST_ADSI_UNAVAILABLE;
05798 i->owner = tmp;
05799 i->capability = capability;
05800
05801 if (!cachable) {
05802 tmp->flags |= AST_FLAG_DISABLE_DEVSTATE_CACHE;
05803 }
05804
05805
05806 if (i->vars) {
05807 for (v = i->vars ; v ; v = v->next)
05808 pbx_builtin_setvar_helper(tmp, v->name, v->value);
05809 }
05810 if (i->iaxvars) {
05811 struct ast_datastore *variablestore;
05812 struct ast_variable *var, *prev = NULL;
05813 AST_LIST_HEAD(, ast_var_t) *varlist;
05814 ast_debug(1, "Loading up the channel with IAXVARs\n");
05815 varlist = ast_calloc(1, sizeof(*varlist));
05816 variablestore = ast_datastore_alloc(&iax2_variable_datastore_info, NULL);
05817 if (variablestore && varlist) {
05818 variablestore->data = varlist;
05819 variablestore->inheritance = DATASTORE_INHERIT_FOREVER;
05820 AST_LIST_HEAD_INIT(varlist);
05821 for (var = i->iaxvars; var; var = var->next) {
05822 struct ast_var_t *newvar = ast_var_assign(var->name, var->value);
05823 if (prev)
05824 ast_free(prev);
05825 prev = var;
05826 if (!newvar) {
05827
05828 ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
05829 } else {
05830 AST_LIST_INSERT_TAIL(varlist, newvar, entries);
05831 }
05832 }
05833 if (prev)
05834 ast_free(prev);
05835 i->iaxvars = NULL;
05836 ast_channel_datastore_add(i->owner, variablestore);
05837 } else {
05838 if (variablestore) {
05839 ast_datastore_free(variablestore);
05840 }
05841 if (varlist) {
05842 ast_free(varlist);
05843 }
05844 }
05845 }
05846
05847 if (state != AST_STATE_DOWN) {
05848 if (ast_pbx_start(tmp)) {
05849 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
05850 ast_hangup(tmp);
05851 i->owner = NULL;
05852 return NULL;
05853 }
05854 }
05855
05856 ast_module_ref(ast_module_info->self);
05857 return tmp;
05858 }
05859
05860 static unsigned int calc_txpeerstamp(struct iax2_trunk_peer *tpeer, int sampms, struct timeval *now)
05861 {
05862 unsigned long int mssincetx;
05863 long int ms, pred;
05864
05865 tpeer->trunkact = *now;
05866 mssincetx = ast_tvdiff_ms(*now, tpeer->lasttxtime);
05867 if (mssincetx > 5000 || ast_tvzero(tpeer->txtrunktime)) {
05868
05869 tpeer->txtrunktime = *now;
05870 tpeer->lastsent = 999999;
05871 }
05872
05873 tpeer->lasttxtime = *now;
05874
05875
05876 ms = ast_tvdiff_ms(*now, tpeer->txtrunktime);
05877
05878 pred = tpeer->lastsent + sampms;
05879 if (abs(ms - pred) < MAX_TIMESTAMP_SKEW)
05880 ms = pred;
05881
05882
05883 if (ms == tpeer->lastsent)
05884 ms = tpeer->lastsent + 1;
05885 tpeer->lastsent = ms;
05886 return ms;
05887 }
05888
05889 static unsigned int fix_peerts(struct timeval *rxtrunktime, int callno, unsigned int ts)
05890 {
05891 long ms;
05892 if (ast_tvzero(iaxs[callno]->rxcore)) {
05893
05894 iaxs[callno]->rxcore = ast_tvnow();
05895
05896 iaxs[callno]->rxcore.tv_usec -= iaxs[callno]->rxcore.tv_usec % 20000;
05897 }
05898
05899 ms = ast_tvdiff_ms(*rxtrunktime, iaxs[callno]->rxcore);
05900
05901 return ms + ts;
05902 }
05903
05904 static unsigned int calc_timestamp(struct chan_iax2_pvt *p, unsigned int ts, struct ast_frame *f)
05905 {
05906 int ms;
05907 int voice = 0;
05908 int genuine = 0;
05909 int adjust;
05910 int rate = ast_format_rate(f->subclass.codec) / 1000;
05911 struct timeval *delivery = NULL;
05912
05913
05914
05915
05916
05917
05918
05919
05920 if (f->frametype == AST_FRAME_VOICE) {
05921 voice = 1;
05922 delivery = &f->delivery;
05923 } else if (f->frametype == AST_FRAME_IAX) {
05924 genuine = 1;
05925 } else if (f->frametype == AST_FRAME_CNG) {
05926 p->notsilenttx = 0;
05927 }
05928
05929 if (ast_tvzero(p->offset)) {
05930 p->offset = ast_tvnow();
05931
05932 p->offset.tv_usec -= p->offset.tv_usec % 20000;
05933 }
05934
05935 if (ts)
05936 return ts;
05937
05938 if (delivery && !ast_tvzero(*delivery)) {
05939 ms = ast_tvdiff_ms(*delivery, p->offset);
05940 if (ms < 0) {
05941 ms = 0;
05942 }
05943 if (iaxdebug)
05944 ast_debug(3, "calc_timestamp: call %d/%d: Timestamp slaved to delivery time\n", p->callno, iaxs[p->callno]->peercallno);
05945 } else {
05946 ms = ast_tvdiff_ms(ast_tvnow(), p->offset);
05947 if (ms < 0)
05948 ms = 0;
05949 if (voice) {
05950
05951 if (p->notsilenttx && abs(ms - p->nextpred) <= MAX_TIMESTAMP_SKEW) {
05952
05953
05954
05955
05956
05957
05958
05959
05960
05961
05962
05963
05964
05965
05966
05967
05968
05969
05970 adjust = (ms - p->nextpred);
05971 if (adjust < 0)
05972 p->offset = ast_tvsub(p->offset, ast_samp2tv(abs(adjust), 10000));
05973 else if (adjust > 0)
05974 p->offset = ast_tvadd(p->offset, ast_samp2tv(adjust, 10000));
05975
05976 if (!p->nextpred) {
05977 p->nextpred = ms;
05978 if (p->nextpred <= p->lastsent)
05979 p->nextpred = p->lastsent + 3;
05980 }
05981 ms = p->nextpred;
05982 } else {
05983
05984
05985
05986
05987
05988
05989
05990
05991
05992 if (iaxdebug && abs(ms - p->nextpred) > MAX_TIMESTAMP_SKEW )
05993 ast_debug(1, "predicted timestamp skew (%u) > max (%u), using real ts instead.\n",
05994 abs(ms - p->nextpred), MAX_TIMESTAMP_SKEW);
05995
05996 if (f->samples >= rate)
05997 {
05998 int diff = ms % (f->samples / rate);
05999 if (diff)
06000 ms += f->samples/rate - diff;
06001 }
06002
06003 p->nextpred = ms;
06004 p->notsilenttx = 1;
06005 }
06006 } else if ( f->frametype == AST_FRAME_VIDEO ) {
06007
06008
06009
06010
06011
06012
06013
06014
06015 if ( (unsigned int)ms < p->lastsent )
06016 ms = p->lastsent;
06017 } else {
06018
06019
06020 if (genuine) {
06021
06022 if (ms <= p->lastsent)
06023 ms = p->lastsent + 3;
06024 } else if (abs(ms - p->lastsent) <= MAX_TIMESTAMP_SKEW) {
06025
06026 ms = p->lastsent + 3;
06027 }
06028 }
06029 }
06030 p->lastsent = ms;
06031 if (voice)
06032 p->nextpred = p->nextpred + f->samples / rate;
06033 return ms;
06034 }
06035
06036 static unsigned int calc_rxstamp(struct chan_iax2_pvt *p, unsigned int offset)
06037 {
06038
06039
06040 int ms;
06041 #ifdef IAXTESTS
06042 int jit;
06043 #endif
06044
06045 if (ast_tvzero(p->rxcore)) {
06046 p->rxcore = ast_tvnow();
06047 if (iaxdebug)
06048 ast_debug(1, "calc_rxstamp: call=%d: rxcore set to %d.%6.6d - %dms\n",
06049 p->callno, (int)(p->rxcore.tv_sec), (int)(p->rxcore.tv_usec), offset);
06050 p->rxcore = ast_tvsub(p->rxcore, ast_samp2tv(offset, 1000));
06051 #if 1
06052 if (iaxdebug)
06053 ast_debug(1, "calc_rxstamp: call=%d: works out as %d.%6.6d\n",
06054 p->callno, (int)(p->rxcore.tv_sec),(int)( p->rxcore.tv_usec));
06055 #endif
06056 }
06057
06058 ms = ast_tvdiff_ms(ast_tvnow(), p->rxcore);
06059 #ifdef IAXTESTS
06060 if (test_jit) {
06061 if (!test_jitpct || ((100.0 * ast_random() / (RAND_MAX + 1.0)) < test_jitpct)) {
06062 jit = (int)((float)test_jit * ast_random() / (RAND_MAX + 1.0));
06063 if ((int)(2.0 * ast_random() / (RAND_MAX + 1.0)))
06064 jit = -jit;
06065 ms += jit;
06066 }
06067 }
06068 if (test_late) {
06069 ms += test_late;
06070 test_late = 0;
06071 }
06072 #endif
06073 return ms;
06074 }
06075
06076 static struct iax2_trunk_peer *find_tpeer(struct sockaddr_in *sin, int fd)
06077 {
06078 struct iax2_trunk_peer *tpeer = NULL;
06079
06080
06081 AST_LIST_LOCK(&tpeers);
06082
06083 AST_LIST_TRAVERSE(&tpeers, tpeer, list) {
06084 if (!inaddrcmp(&tpeer->addr, sin)) {
06085 ast_mutex_lock(&tpeer->lock);
06086 break;
06087 }
06088 }
06089
06090 if (!tpeer) {
06091 if ((tpeer = ast_calloc(1, sizeof(*tpeer)))) {
06092 ast_mutex_init(&tpeer->lock);
06093 tpeer->lastsent = 9999;
06094 memcpy(&tpeer->addr, sin, sizeof(tpeer->addr));
06095 tpeer->trunkact = ast_tvnow();
06096 ast_mutex_lock(&tpeer->lock);
06097 tpeer->sockfd = fd;
06098 #ifdef SO_NO_CHECK
06099 setsockopt(tpeer->sockfd, SOL_SOCKET, SO_NO_CHECK, &nochecksums, sizeof(nochecksums));
06100 #endif
06101 ast_debug(1, "Created trunk peer for '%s:%d'\n", ast_inet_ntoa(tpeer->addr.sin_addr), ntohs(tpeer->addr.sin_port));
06102 AST_LIST_INSERT_TAIL(&tpeers, tpeer, list);
06103 }
06104 }
06105
06106 AST_LIST_UNLOCK(&tpeers);
06107
06108 return tpeer;
06109 }
06110
06111 static int iax2_trunk_queue(struct chan_iax2_pvt *pvt, struct iax_frame *fr)
06112 {
06113 struct ast_frame *f;
06114 struct iax2_trunk_peer *tpeer;
06115 void *tmp, *ptr;
06116 struct timeval now;
06117 struct ast_iax2_meta_trunk_entry *met;
06118 struct ast_iax2_meta_trunk_mini *mtm;
06119
06120 f = &fr->af;
06121 tpeer = find_tpeer(&pvt->addr, pvt->sockfd);
06122 if (tpeer) {
06123 if (tpeer->trunkdatalen + f->datalen + 4 >= tpeer->trunkdataalloc) {
06124
06125 if (tpeer->trunkdataalloc < trunkmaxsize) {
06126 if (!(tmp = ast_realloc(tpeer->trunkdata, tpeer->trunkdataalloc + DEFAULT_TRUNKDATA + IAX2_TRUNK_PREFACE))) {
06127 ast_mutex_unlock(&tpeer->lock);
06128 return -1;
06129 }
06130
06131 tpeer->trunkdataalloc += DEFAULT_TRUNKDATA;
06132 tpeer->trunkdata = tmp;
06133 ast_debug(1, "Expanded trunk '%s:%d' to %d bytes\n", ast_inet_ntoa(tpeer->addr.sin_addr), ntohs(tpeer->addr.sin_port), tpeer->trunkdataalloc);
06134 } else {
06135 ast_log(LOG_WARNING, "Maximum trunk data space exceeded to %s:%d\n", ast_inet_ntoa(tpeer->addr.sin_addr), ntohs(tpeer->addr.sin_port));
06136 ast_mutex_unlock(&tpeer->lock);
06137 return -1;
06138 }
06139 }
06140
06141
06142 ptr = tpeer->trunkdata + IAX2_TRUNK_PREFACE + tpeer->trunkdatalen;
06143 if (ast_test_flag64(&globalflags, IAX_TRUNKTIMESTAMPS)) {
06144 mtm = (struct ast_iax2_meta_trunk_mini *)ptr;
06145 mtm->len = htons(f->datalen);
06146 mtm->mini.callno = htons(pvt->callno);
06147 mtm->mini.ts = htons(0xffff & fr->ts);
06148 ptr += sizeof(struct ast_iax2_meta_trunk_mini);
06149 tpeer->trunkdatalen += sizeof(struct ast_iax2_meta_trunk_mini);
06150 } else {
06151 met = (struct ast_iax2_meta_trunk_entry *)ptr;
06152
06153 met->callno = htons(pvt->callno);
06154 met->len = htons(f->datalen);
06155
06156 ptr += sizeof(struct ast_iax2_meta_trunk_entry);
06157 tpeer->trunkdatalen += sizeof(struct ast_iax2_meta_trunk_entry);
06158 }
06159
06160 memcpy(ptr, f->data.ptr, f->datalen);
06161 tpeer->trunkdatalen += f->datalen;
06162
06163 tpeer->calls++;
06164
06165
06166 if (tpeer->trunkdatalen + f->datalen + 4 > trunk_maxmtu)
06167 trunk_maxmtu = tpeer->trunkdatalen + f->datalen + 4 ;
06168
06169
06170 if (global_max_trunk_mtu > 0 && tpeer->trunkdatalen + f->datalen + 4 >= global_max_trunk_mtu) {
06171 now = ast_tvnow();
06172 send_trunk(tpeer, &now);
06173 trunk_untimed ++;
06174 }
06175
06176 ast_mutex_unlock(&tpeer->lock);
06177 }
06178 return 0;
06179 }
06180
06181
06182
06183 static void build_rand_pad(unsigned char *buf, ssize_t len)
06184 {
06185 long tmp;
06186 for (tmp = ast_random(); len > 0; tmp = ast_random()) {
06187 memcpy(buf, (unsigned char *) &tmp, (len > sizeof(tmp)) ? sizeof(tmp) : len);
06188 buf += sizeof(tmp);
06189 len -= sizeof(tmp);
06190 }
06191 }
06192
06193 static void build_encryption_keys(const unsigned char *digest, struct chan_iax2_pvt *pvt)
06194 {
06195 build_ecx_key(digest, pvt);
06196 ast_aes_set_decrypt_key(digest, &pvt->dcx);
06197 }
06198
06199 static void build_ecx_key(const unsigned char *digest, struct chan_iax2_pvt *pvt)
06200 {
06201
06202
06203
06204 build_rand_pad(pvt->semirand, sizeof(pvt->semirand));
06205 ast_aes_set_encrypt_key(digest, &pvt->ecx);
06206 ast_aes_set_decrypt_key(digest, &pvt->mydcx);
06207 }
06208
06209 static void memcpy_decrypt(unsigned char *dst, const unsigned char *src, int len, ast_aes_decrypt_key *dcx)
06210 {
06211 #if 0
06212
06213 int x;
06214 if (len % 16)
06215 ast_log(LOG_WARNING, "len should be multiple of 16, not %d!\n", len);
06216 for (x=0;x<len;x++)
06217 dst[x] = src[x] ^ 0xff;
06218 #else
06219 unsigned char lastblock[16] = { 0 };
06220 int x;
06221 while(len > 0) {
06222 ast_aes_decrypt(src, dst, dcx);
06223 for (x=0;x<16;x++)
06224 dst[x] ^= lastblock[x];
06225 memcpy(lastblock, src, sizeof(lastblock));
06226 dst += 16;
06227 src += 16;
06228 len -= 16;
06229 }
06230 #endif
06231 }
06232
06233 static void memcpy_encrypt(unsigned char *dst, const unsigned char *src, int len, ast_aes_encrypt_key *ecx)
06234 {
06235 #if 0
06236
06237 int x;
06238 if (len % 16)
06239 ast_log(LOG_WARNING, "len should be multiple of 16, not %d!\n", len);
06240 for (x=0;x<len;x++)
06241 dst[x] = src[x] ^ 0xff;
06242 #else
06243 unsigned char curblock[16] = { 0 };
06244 int x;
06245 while(len > 0) {
06246 for (x=0;x<16;x++)
06247 curblock[x] ^= src[x];
06248 ast_aes_encrypt(curblock, dst, ecx);
06249 memcpy(curblock, dst, sizeof(curblock));
06250 dst += 16;
06251 src += 16;
06252 len -= 16;
06253 }
06254 #endif
06255 }
06256
06257 static int decode_frame(ast_aes_decrypt_key *dcx, struct ast_iax2_full_hdr *fh, struct ast_frame *f, int *datalen)
06258 {
06259 int padding;
06260 unsigned char *workspace;
06261
06262 workspace = ast_alloca(*datalen);
06263 memset(f, 0, sizeof(*f));
06264 if (ntohs(fh->scallno) & IAX_FLAG_FULL) {
06265 struct ast_iax2_full_enc_hdr *efh = (struct ast_iax2_full_enc_hdr *)fh;
06266 if (*datalen < 16 + sizeof(struct ast_iax2_full_hdr))
06267 return -1;
06268
06269 memcpy_decrypt(workspace, efh->encdata, *datalen - sizeof(struct ast_iax2_full_enc_hdr), dcx);
06270
06271 padding = 16 + (workspace[15] & 0x0f);
06272 if (iaxdebug)
06273 ast_debug(1, "Decoding full frame with length %d (padding = %d) (15=%02x)\n", *datalen, padding, workspace[15]);
06274 if (*datalen < padding + sizeof(struct ast_iax2_full_hdr))
06275 return -1;
06276
06277 *datalen -= padding;
06278 memcpy(efh->encdata, workspace + padding, *datalen - sizeof(struct ast_iax2_full_enc_hdr));
06279 f->frametype = fh->type;
06280 if (f->frametype == AST_FRAME_VIDEO) {
06281 f->subclass.codec = uncompress_subclass(fh->csub & ~0x40) | ((fh->csub >> 6) & 0x1);
06282 } else if (f->frametype == AST_FRAME_VOICE) {
06283 f->subclass.codec = uncompress_subclass(fh->csub);
06284 } else {
06285 f->subclass.integer = uncompress_subclass(fh->csub);
06286 }
06287 } else {
06288 struct ast_iax2_mini_enc_hdr *efh = (struct ast_iax2_mini_enc_hdr *)fh;
06289 if (iaxdebug)
06290 ast_debug(1, "Decoding mini with length %d\n", *datalen);
06291 if (*datalen < 16 + sizeof(struct ast_iax2_mini_hdr))
06292 return -1;
06293
06294 memcpy_decrypt(workspace, efh->encdata, *datalen - sizeof(struct ast_iax2_mini_enc_hdr), dcx);
06295 padding = 16 + (workspace[15] & 0x0f);
06296 if (*datalen < padding + sizeof(struct ast_iax2_mini_hdr))
06297 return -1;
06298 *datalen -= padding;
06299 memcpy(efh->encdata, workspace + padding, *datalen - sizeof(struct ast_iax2_mini_enc_hdr));
06300 }
06301 return 0;
06302 }
06303
06304 static int encrypt_frame(ast_aes_encrypt_key *ecx, struct ast_iax2_full_hdr *fh, unsigned char *poo, int *datalen)
06305 {
06306 int padding;
06307 unsigned char *workspace;
06308 workspace = ast_alloca(*datalen + 32);
06309 if (ntohs(fh->scallno) & IAX_FLAG_FULL) {
06310 struct ast_iax2_full_enc_hdr *efh = (struct ast_iax2_full_enc_hdr *)fh;
06311 if (iaxdebug)
06312 ast_debug(1, "Encoding full frame %d/%d with length %d\n", fh->type, fh->csub, *datalen);
06313 padding = 16 - ((*datalen - sizeof(struct ast_iax2_full_enc_hdr)) % 16);
06314 padding = 16 + (padding & 0xf);
06315 memcpy(workspace, poo, padding);
06316 memcpy(workspace + padding, efh->encdata, *datalen - sizeof(struct ast_iax2_full_enc_hdr));
06317 workspace[15] &= 0xf0;
06318 workspace[15] |= (padding & 0xf);
06319 if (iaxdebug)
06320 ast_debug(1, "Encoding full frame %d/%d with length %d + %d padding (15=%02x)\n", fh->type, fh->csub, *datalen, padding, workspace[15]);
06321 *datalen += padding;
06322 memcpy_encrypt(efh->encdata, workspace, *datalen - sizeof(struct ast_iax2_full_enc_hdr), ecx);
06323 if (*datalen >= 32 + sizeof(struct ast_iax2_full_enc_hdr))
06324 memcpy(poo, workspace + *datalen - 32, 32);
06325 } else {
06326 struct ast_iax2_mini_enc_hdr *efh = (struct ast_iax2_mini_enc_hdr *)fh;
06327 if (iaxdebug)
06328 ast_debug(1, "Encoding mini frame with length %d\n", *datalen);
06329 padding = 16 - ((*datalen - sizeof(struct ast_iax2_mini_enc_hdr)) % 16);
06330 padding = 16 + (padding & 0xf);
06331 memcpy(workspace, poo, padding);
06332 memcpy(workspace + padding, efh->encdata, *datalen - sizeof(struct ast_iax2_mini_enc_hdr));
06333 workspace[15] &= 0xf0;
06334 workspace[15] |= (padding & 0x0f);
06335 *datalen += padding;
06336 memcpy_encrypt(efh->encdata, workspace, *datalen - sizeof(struct ast_iax2_mini_enc_hdr), ecx);
06337 if (*datalen >= 32 + sizeof(struct ast_iax2_mini_enc_hdr))
06338 memcpy(poo, workspace + *datalen - 32, 32);
06339 }
06340 return 0;
06341 }
06342
06343 static int decrypt_frame(int callno, struct ast_iax2_full_hdr *fh, struct ast_frame *f, int *datalen)
06344 {
06345 int res=-1;
06346 if (!ast_test_flag64(iaxs[callno], IAX_KEYPOPULATED)) {
06347
06348 struct MD5Context md5;
06349 unsigned char digest[16];
06350 char *tmppw, *stringp;
06351
06352 tmppw = ast_strdupa(iaxs[callno]->secret);
06353 stringp = tmppw;
06354 while ((tmppw = strsep(&stringp, ";"))) {
06355 MD5Init(&md5);
06356 MD5Update(&md5, (unsigned char *)iaxs[callno]->challenge, strlen(iaxs[callno]->challenge));
06357 MD5Update(&md5, (unsigned char *)tmppw, strlen(tmppw));
06358 MD5Final(digest, &md5);
06359 build_encryption_keys(digest, iaxs[callno]);
06360 res = decode_frame(&iaxs[callno]->dcx, fh, f, datalen);
06361 if (!res) {
06362 ast_set_flag64(iaxs[callno], IAX_KEYPOPULATED);
06363 break;
06364 }
06365 }
06366 } else
06367 res = decode_frame(&iaxs[callno]->dcx, fh, f, datalen);
06368 return res;
06369 }
06370
06371 static int iax2_send(struct chan_iax2_pvt *pvt, struct ast_frame *f, unsigned int ts, int seqno, int now, int transfer, int final)
06372 {
06373
06374
06375
06376 struct ast_iax2_full_hdr *fh;
06377 struct ast_iax2_mini_hdr *mh;
06378 struct ast_iax2_video_hdr *vh;
06379 struct {
06380 struct iax_frame fr2;
06381 unsigned char buffer[4096];
06382 } frb;
06383 struct iax_frame *fr;
06384 int res;
06385 int sendmini=0;
06386 unsigned int lastsent;
06387 unsigned int fts;
06388
06389 frb.fr2.afdatalen = sizeof(frb.buffer);
06390
06391 if (!pvt) {
06392 ast_log(LOG_WARNING, "No private structure for packet?\n");
06393 return -1;
06394 }
06395
06396 lastsent = pvt->lastsent;
06397
06398
06399 fts = calc_timestamp(pvt, ts, f);
06400
06401
06402
06403
06404 if(f->frametype == AST_FRAME_VOICE && f->datalen == 0)
06405 return 0;
06406 #if 0
06407 ast_log(LOG_NOTICE,
06408 "f->frametype %c= AST_FRAME_VOICE, %sencrypted, %srotation scheduled...\n",
06409 *("=!" + (f->frametype == AST_FRAME_VOICE)),
06410 IAX_CALLENCRYPTED(pvt) ? "" : "not ",
06411 pvt->keyrotateid != -1 ? "" : "no "
06412 );
06413 #endif
06414 if (pvt->keyrotateid == -1 && f->frametype == AST_FRAME_VOICE && IAX_CALLENCRYPTED(pvt)) {
06415 iax2_key_rotate(pvt);
06416 }
06417
06418 if ((ast_test_flag64(pvt, IAX_TRUNK) ||
06419 (((fts & 0xFFFF0000L) == (lastsent & 0xFFFF0000L)) ||
06420 ((fts & 0xFFFF0000L) == ((lastsent + 0x10000) & 0xFFFF0000L))))
06421 &&
06422 (f->frametype == AST_FRAME_VOICE)
06423 &&
06424 (f->subclass.codec == pvt->svoiceformat)
06425 ) {
06426
06427 now = 1;
06428
06429 sendmini = 1;
06430 }
06431 if ( f->frametype == AST_FRAME_VIDEO ) {
06432
06433
06434
06435
06436
06437 if (((fts & 0xFFFF8000L) == (pvt->lastvsent & 0xFFFF8000L)) &&
06438 ((f->subclass.codec & ~0x1LL) == pvt->svideoformat)
06439 ) {
06440 now = 1;
06441 sendmini = 1;
06442 } else {
06443 now = 0;
06444 sendmini = 0;
06445 }
06446 pvt->lastvsent = fts;
06447 }
06448 if (f->frametype == AST_FRAME_IAX) {
06449
06450 pvt->last_iax_message = f->subclass.integer | MARK_IAX_SUBCLASS_TX;
06451 if (!pvt->first_iax_message) {
06452 pvt->first_iax_message = pvt->last_iax_message;
06453 }
06454 }
06455
06456 if (now) {
06457 fr = &frb.fr2;
06458 } else
06459 fr = iax_frame_new(DIRECTION_OUTGRESS, ast_test_flag64(pvt, IAX_ENCRYPTED) ? f->datalen + 32 : f->datalen, (f->frametype == AST_FRAME_VOICE) || (f->frametype == AST_FRAME_VIDEO));
06460 if (!fr) {
06461 ast_log(LOG_WARNING, "Out of memory\n");
06462 return -1;
06463 }
06464
06465 iax_frame_wrap(fr, f);
06466
06467 fr->ts = fts;
06468 fr->callno = pvt->callno;
06469 fr->transfer = transfer;
06470 fr->final = final;
06471 fr->encmethods = 0;
06472 if (!sendmini) {
06473
06474 if (seqno > -1)
06475 fr->oseqno = seqno;
06476 else
06477 fr->oseqno = pvt->oseqno++;
06478 fr->iseqno = pvt->iseqno;
06479 fh = (struct ast_iax2_full_hdr *)(fr->af.data.ptr - sizeof(struct ast_iax2_full_hdr));
06480 fh->scallno = htons(fr->callno | IAX_FLAG_FULL);
06481 fh->ts = htonl(fr->ts);
06482 fh->oseqno = fr->oseqno;
06483 if (transfer) {
06484 fh->iseqno = 0;
06485 } else
06486 fh->iseqno = fr->iseqno;
06487
06488 if (!transfer)
06489 pvt->aseqno = fr->iseqno;
06490 fh->type = fr->af.frametype & 0xFF;
06491
06492 if (fr->af.frametype == AST_FRAME_VIDEO) {
06493 fh->csub = compress_subclass(fr->af.subclass.codec & ~0x1LL) | ((fr->af.subclass.codec & 0x1LL) << 6);
06494 } else if (fr->af.frametype == AST_FRAME_VOICE) {
06495 fh->csub = compress_subclass(fr->af.subclass.codec);
06496 } else {
06497 fh->csub = compress_subclass(fr->af.subclass.integer);
06498 }
06499
06500 if (transfer) {
06501 fr->dcallno = pvt->transfercallno;
06502 } else
06503 fr->dcallno = pvt->peercallno;
06504 fh->dcallno = htons(fr->dcallno);
06505 fr->datalen = fr->af.datalen + sizeof(struct ast_iax2_full_hdr);
06506 fr->data = fh;
06507 fr->retries = 0;
06508
06509 fr->retrytime = pvt->pingtime * 2;
06510 if (fr->retrytime < MIN_RETRY_TIME)
06511 fr->retrytime = MIN_RETRY_TIME;
06512 if (fr->retrytime > MAX_RETRY_TIME)
06513 fr->retrytime = MAX_RETRY_TIME;
06514
06515 if ((f->frametype == AST_FRAME_IAX) && (f->subclass.integer == IAX_COMMAND_ACK))
06516 fr->retries = -1;
06517 else if (f->frametype == AST_FRAME_VOICE)
06518 pvt->svoiceformat = f->subclass.codec;
06519 else if (f->frametype == AST_FRAME_VIDEO)
06520 pvt->svideoformat = f->subclass.codec & ~0x1LL;
06521 if (ast_test_flag64(pvt, IAX_ENCRYPTED)) {
06522 if (ast_test_flag64(pvt, IAX_KEYPOPULATED)) {
06523 if (fr->transfer)
06524 iax_outputframe(fr, NULL, 2, &pvt->transfer, fr->datalen - sizeof(struct ast_iax2_full_hdr));
06525 else
06526 iax_outputframe(fr, NULL, 2, &pvt->addr, fr->datalen - sizeof(struct ast_iax2_full_hdr));
06527 encrypt_frame(&pvt->ecx, fh, pvt->semirand, &fr->datalen);
06528 fr->encmethods = pvt->encmethods;
06529 fr->ecx = pvt->ecx;
06530 fr->mydcx = pvt->mydcx;
06531 memcpy(fr->semirand, pvt->semirand, sizeof(fr->semirand));
06532 } else
06533 ast_log(LOG_WARNING, "Supposed to send packet encrypted, but no key?\n");
06534 }
06535
06536 if (now) {
06537 res = send_packet(fr);
06538 } else
06539 res = iax2_transmit(fr);
06540 } else {
06541 if (ast_test_flag64(pvt, IAX_TRUNK)) {
06542 iax2_trunk_queue(pvt, fr);
06543 res = 0;
06544 } else if (fr->af.frametype == AST_FRAME_VIDEO) {
06545
06546 fr->oseqno = -1;
06547 fr->iseqno = -1;
06548 vh = (struct ast_iax2_video_hdr *)(fr->af.data.ptr - sizeof(struct ast_iax2_video_hdr));
06549 vh->zeros = 0;
06550 vh->callno = htons(0x8000 | fr->callno);
06551 vh->ts = htons((fr->ts & 0x7FFF) | (fr->af.subclass.codec & 0x1LL ? 0x8000 : 0));
06552 fr->datalen = fr->af.datalen + sizeof(struct ast_iax2_video_hdr);
06553 fr->data = vh;
06554 fr->retries = -1;
06555 res = send_packet(fr);
06556 } else {
06557
06558 fr->oseqno = -1;
06559 fr->iseqno = -1;
06560
06561 mh = (struct ast_iax2_mini_hdr *)(fr->af.data.ptr - sizeof(struct ast_iax2_mini_hdr));
06562 mh->callno = htons(fr->callno);
06563 mh->ts = htons(fr->ts & 0xFFFF);
06564 fr->datalen = fr->af.datalen + sizeof(struct ast_iax2_mini_hdr);
06565 fr->data = mh;
06566 fr->retries = -1;
06567 if (pvt->transferring == TRANSFER_MEDIAPASS)
06568 fr->transfer = 1;
06569 if (ast_test_flag64(pvt, IAX_ENCRYPTED)) {
06570 if (ast_test_flag64(pvt, IAX_KEYPOPULATED)) {
06571 encrypt_frame(&pvt->ecx, (struct ast_iax2_full_hdr *)mh, pvt->semirand, &fr->datalen);
06572 } else
06573 ast_log(LOG_WARNING, "Supposed to send packet encrypted, but no key?\n");
06574 }
06575 res = send_packet(fr);
06576 }
06577 }
06578 return res;
06579 }
06580
06581 static char *handle_cli_iax2_show_users(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
06582 {
06583 regex_t regexbuf;
06584 int havepattern = 0;
06585
06586 #define FORMAT "%-15.15s %-20.20s %-15.15s %-15.15s %-5.5s %-5.10s\n"
06587 #define FORMAT2 "%-15.15s %-20.20s %-15.15d %-15.15s %-5.5s %-5.10s\n"
06588
06589 struct iax2_user *user = NULL;
06590 char auth[90];
06591 char *pstr = "";
06592 struct ao2_iterator i;
06593
06594 switch (cmd) {
06595 case CLI_INIT:
06596 e->command = "iax2 show users [like]";
06597 e->usage =
06598 "Usage: iax2 show users [like <pattern>]\n"
06599 " Lists all known IAX2 users.\n"
06600 " Optional regular expression pattern is used to filter the user list.\n";
06601 return NULL;
06602 case CLI_GENERATE:
06603 return NULL;
06604 }
06605
06606 switch (a->argc) {
06607 case 5:
06608 if (!strcasecmp(a->argv[3], "like")) {
06609 if (regcomp(®exbuf, a->argv[4], REG_EXTENDED | REG_NOSUB))
06610 return CLI_SHOWUSAGE;
06611 havepattern = 1;
06612 } else
06613 return CLI_SHOWUSAGE;
06614 case 3:
06615 break;
06616 default:
06617 return CLI_SHOWUSAGE;
06618 }
06619
06620 ast_cli(a->fd, FORMAT, "Username", "Secret", "Authen", "Def.Context", "A/C","Codec Pref");
06621 i = ao2_iterator_init(users, 0);
06622 for (; (user = ao2_iterator_next(&i)); user_unref(user)) {
06623 if (havepattern && regexec(®exbuf, user->name, 0, NULL, 0))
06624 continue;
06625
06626 if (!ast_strlen_zero(user->secret)) {
06627 ast_copy_string(auth,user->secret, sizeof(auth));
06628 } else if (!ast_strlen_zero(user->inkeys)) {
06629 snprintf(auth, sizeof(auth), "Key: %-15.15s ", user->inkeys);
06630 } else
06631 ast_copy_string(auth, "-no secret-", sizeof(auth));
06632
06633 if(ast_test_flag64(user, IAX_CODEC_NOCAP))
06634 pstr = "REQ Only";
06635 else if(ast_test_flag64(user, IAX_CODEC_NOPREFS))
06636 pstr = "Disabled";
06637 else
06638 pstr = ast_test_flag64(user, IAX_CODEC_USER_FIRST) ? "Caller" : "Host";
06639
06640 ast_cli(a->fd, FORMAT2, user->name, auth, user->authmethods,
06641 user->contexts ? user->contexts->context : DEFAULT_CONTEXT,
06642 user->ha ? "Yes" : "No", pstr);
06643 }
06644 ao2_iterator_destroy(&i);
06645
06646 if (havepattern)
06647 regfree(®exbuf);
06648
06649 return CLI_SUCCESS;
06650 #undef FORMAT
06651 #undef FORMAT2
06652 }
06653
06654 static int __iax2_show_peers(int fd, int *total, struct mansession *s, const int argc, const char * const argv[])
06655 {
06656 regex_t regexbuf;
06657 int havepattern = 0;
06658 int total_peers = 0;
06659 int online_peers = 0;
06660 int offline_peers = 0;
06661 int unmonitored_peers = 0;
06662 struct ao2_iterator i;
06663
06664 #define FORMAT2 "%-15.15s %-15.15s %s %-15.15s %-8s %s %-10s\n"
06665 #define FORMAT "%-15.15s %-15.15s %s %-15.15s %-5d%s %s %-10s\n"
06666
06667 struct iax2_peer *peer = NULL;
06668 char name[256];
06669 struct ast_str *encmethods = ast_str_alloca(256);
06670 int registeredonly=0;
06671 char idtext[256] = "";
06672 switch (argc) {
06673 case 6:
06674 if (!strcasecmp(argv[3], "registered"))
06675 registeredonly = 1;
06676 else
06677 return RESULT_SHOWUSAGE;
06678 if (!strcasecmp(argv[4], "like")) {
06679 if (regcomp(®exbuf, argv[5], REG_EXTENDED | REG_NOSUB))
06680 return RESULT_SHOWUSAGE;
06681 havepattern = 1;
06682 } else
06683 return RESULT_SHOWUSAGE;
06684 break;
06685 case 5:
06686 if (!strcasecmp(argv[3], "like")) {
06687 if (regcomp(®exbuf, argv[4], REG_EXTENDED | REG_NOSUB))
06688 return RESULT_SHOWUSAGE;
06689 havepattern = 1;
06690 } else
06691 return RESULT_SHOWUSAGE;
06692 break;
06693 case 4:
06694 if (!strcasecmp(argv[3], "registered"))
06695 registeredonly = 1;
06696 else
06697 return RESULT_SHOWUSAGE;
06698 break;
06699 case 3:
06700 break;
06701 default:
06702 return RESULT_SHOWUSAGE;
06703 }
06704
06705
06706 if (!s)
06707 ast_cli(fd, FORMAT2, "Name/Username", "Host", " ", "Mask", "Port", " ", "Status");
06708
06709 i = ao2_iterator_init(peers, 0);
06710 for (; (peer = ao2_iterator_next(&i)); peer_unref(peer)) {
06711 char nm[20];
06712 char status[20];
06713 int retstatus;
06714 struct sockaddr_in peer_addr;
06715
06716 ast_sockaddr_to_sin(&peer->addr, &peer_addr);
06717
06718 if (registeredonly && !peer_addr.sin_addr.s_addr) {
06719 continue;
06720 }
06721 if (havepattern && regexec(®exbuf, peer->name, 0, NULL, 0)) {
06722 continue;
06723 }
06724
06725 if (!ast_strlen_zero(peer->username))
06726 snprintf(name, sizeof(name), "%s/%s", peer->name, peer->username);
06727 else
06728 ast_copy_string(name, peer->name, sizeof(name));
06729
06730 encmethods_to_str(peer->encmethods, &encmethods);
06731 retstatus = peer_status(peer, status, sizeof(status));
06732 if (retstatus > 0)
06733 online_peers++;
06734 else if (!retstatus)
06735 offline_peers++;
06736 else
06737 unmonitored_peers++;
06738
06739 ast_copy_string(nm, ast_inet_ntoa(peer->mask), sizeof(nm));
06740
06741 if (s) {
06742 astman_append(s,
06743 "Event: PeerEntry\r\n%s"
06744 "Channeltype: IAX2\r\n"
06745 "ObjectName: %s\r\n"
06746 "ChanObjectType: peer\r\n"
06747 "IPaddress: %s\r\n"
06748 "IPport: %d\r\n"
06749 "Dynamic: %s\r\n"
06750 "Trunk: %s\r\n"
06751 "Encryption: %s\r\n"
06752 "Status: %s\r\n\r\n",
06753 idtext,
06754 name,
06755 ast_sockaddr_stringify_addr(&peer->addr),
06756 ast_sockaddr_port(&peer->addr),
06757 ast_test_flag64(peer, IAX_DYNAMIC) ? "yes" : "no",
06758 ast_test_flag64(peer, IAX_TRUNK) ? "yes" : "no",
06759 peer->encmethods ? ast_str_buffer(encmethods) : "no",
06760 status);
06761 } else {
06762 ast_cli(fd, FORMAT, name,
06763 ast_sockaddr_stringify_addr(&peer->addr),
06764 ast_test_flag64(peer, IAX_DYNAMIC) ? "(D)" : "(S)",
06765 nm,
06766 ast_sockaddr_port(&peer->addr),
06767 ast_test_flag64(peer, IAX_TRUNK) ? "(T)" : " ",
06768 peer->encmethods ? "(E)" : " ",
06769 status);
06770 }
06771 total_peers++;
06772 }
06773 ao2_iterator_destroy(&i);
06774
06775 if (!s)
06776 ast_cli(fd,"%d iax2 peers [%d online, %d offline, %d unmonitored]\n",
06777 total_peers, online_peers, offline_peers, unmonitored_peers);
06778
06779 if (havepattern)
06780 regfree(®exbuf);
06781
06782 if (total)
06783 *total = total_peers;
06784
06785 return RESULT_SUCCESS;
06786 #undef FORMAT
06787 #undef FORMAT2
06788 }
06789
06790 static char *handle_cli_iax2_show_threads(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
06791 {
06792 struct iax2_thread *thread = NULL;
06793 time_t t;
06794 int threadcount = 0, dynamiccount = 0;
06795 char type;
06796
06797 switch (cmd) {
06798 case CLI_INIT:
06799 e->command = "iax2 show threads";
06800 e->usage =
06801 "Usage: iax2 show threads\n"
06802 " Lists status of IAX helper threads\n";
06803 return NULL;
06804 case CLI_GENERATE:
06805 return NULL;
06806 }
06807 if (a->argc != 3)
06808 return CLI_SHOWUSAGE;
06809
06810 ast_cli(a->fd, "IAX2 Thread Information\n");
06811 time(&t);
06812 ast_cli(a->fd, "Idle Threads:\n");
06813 AST_LIST_LOCK(&idle_list);
06814 AST_LIST_TRAVERSE(&idle_list, thread, list) {
06815 #ifdef DEBUG_SCHED_MULTITHREAD
06816 ast_cli(a->fd, "Thread %d: state=%d, update=%d, actions=%d, func='%s'\n",
06817 thread->threadnum, thread->iostate, (int)(t - thread->checktime), thread->actions, thread->curfunc);
06818 #else
06819 ast_cli(a->fd, "Thread %d: state=%d, update=%d, actions=%d\n",
06820 thread->threadnum, thread->iostate, (int)(t - thread->checktime), thread->actions);
06821 #endif
06822 threadcount++;
06823 }
06824 AST_LIST_UNLOCK(&idle_list);
06825 ast_cli(a->fd, "Active Threads:\n");
06826 AST_LIST_LOCK(&active_list);
06827 AST_LIST_TRAVERSE(&active_list, thread, list) {
06828 if (thread->type == IAX_THREAD_TYPE_DYNAMIC)
06829 type = 'D';
06830 else
06831 type = 'P';
06832 #ifdef DEBUG_SCHED_MULTITHREAD
06833 ast_cli(a->fd, "Thread %c%d: state=%d, update=%d, actions=%d, func='%s'\n",
06834 type, thread->threadnum, thread->iostate, (int)(t - thread->checktime), thread->actions, thread->curfunc);
06835 #else
06836 ast_cli(a->fd, "Thread %c%d: state=%d, update=%d, actions=%d\n",
06837 type, thread->threadnum, thread->iostate, (int)(t - thread->checktime), thread->actions);
06838 #endif
06839 threadcount++;
06840 }
06841 AST_LIST_UNLOCK(&active_list);
06842 ast_cli(a->fd, "Dynamic Threads:\n");
06843 AST_LIST_LOCK(&dynamic_list);
06844 AST_LIST_TRAVERSE(&dynamic_list, thread, list) {
06845 #ifdef DEBUG_SCHED_MULTITHREAD
06846 ast_cli(a->fd, "Thread %d: state=%d, update=%d, actions=%d, func='%s'\n",
06847 thread->threadnum, thread->iostate, (int)(t - thread->checktime), thread->actions, thread->curfunc);
06848 #else
06849 ast_cli(a->fd, "Thread %d: state=%d, update=%d, actions=%d\n",
06850 thread->threadnum, thread->iostate, (int)(t - thread->checktime), thread->actions);
06851 #endif
06852 dynamiccount++;
06853 }
06854 AST_LIST_UNLOCK(&dynamic_list);
06855 ast_cli(a->fd, "%d of %d threads accounted for with %d dynamic threads\n", threadcount, iaxthreadcount, dynamiccount);
06856 return CLI_SUCCESS;
06857 }
06858
06859 static char *handle_cli_iax2_unregister(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
06860 {
06861 struct iax2_peer *p;
06862
06863 switch (cmd) {
06864 case CLI_INIT:
06865 e->command = "iax2 unregister";
06866 e->usage =
06867 "Usage: iax2 unregister <peername>\n"
06868 " Unregister (force expiration) an IAX2 peer from the registry.\n";
06869 return NULL;
06870 case CLI_GENERATE:
06871 return complete_iax2_unregister(a->line, a->word, a->pos, a->n);
06872 }
06873
06874 if (a->argc != 3)
06875 return CLI_SHOWUSAGE;
06876
06877 p = find_peer(a->argv[2], 1);
06878 if (p) {
06879 if (p->expire > 0) {
06880 struct iax2_peer tmp_peer = {
06881 .name = a->argv[2],
06882 };
06883 struct iax2_peer *peer;
06884
06885 peer = ao2_find(peers, &tmp_peer, OBJ_POINTER);
06886 if (peer) {
06887 expire_registry(peer_ref(peer));
06888 peer_unref(peer);
06889 ast_cli(a->fd, "Peer %s unregistered\n", a->argv[2]);
06890 } else {
06891 ast_cli(a->fd, "Peer %s not found\n", a->argv[2]);
06892 }
06893 } else {
06894 ast_cli(a->fd, "Peer %s not registered\n", a->argv[2]);
06895 }
06896 peer_unref(p);
06897 } else {
06898 ast_cli(a->fd, "Peer unknown: %s. Not unregistered\n", a->argv[2]);
06899 }
06900 return CLI_SUCCESS;
06901 }
06902
06903 static char *complete_iax2_unregister(const char *line, const char *word, int pos, int state)
06904 {
06905 int which = 0;
06906 struct iax2_peer *p = NULL;
06907 char *res = NULL;
06908 int wordlen = strlen(word);
06909
06910
06911 if (pos == 2) {
06912 struct ao2_iterator i = ao2_iterator_init(peers, 0);
06913 while ((p = ao2_iterator_next(&i))) {
06914 if (!strncasecmp(p->name, word, wordlen) &&
06915 ++which > state && p->expire > 0) {
06916 res = ast_strdup(p->name);
06917 peer_unref(p);
06918 break;
06919 }
06920 peer_unref(p);
06921 }
06922 ao2_iterator_destroy(&i);
06923 }
06924
06925 return res;
06926 }
06927
06928 static char *handle_cli_iax2_show_peers(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
06929 {
06930 switch (cmd) {
06931 case CLI_INIT:
06932 e->command = "iax2 show peers";
06933 e->usage =
06934 "Usage: iax2 show peers [registered] [like <pattern>]\n"
06935 " Lists all known IAX2 peers.\n"
06936 " Optional 'registered' argument lists only peers with known addresses.\n"
06937 " Optional regular expression pattern is used to filter the peer list.\n";
06938 return NULL;
06939 case CLI_GENERATE:
06940 return NULL;
06941 }
06942
06943 switch (__iax2_show_peers(a->fd, NULL, NULL, a->argc, a->argv)) {
06944 case RESULT_SHOWUSAGE:
06945 return CLI_SHOWUSAGE;
06946 case RESULT_FAILURE:
06947 return CLI_FAILURE;
06948 default:
06949 return CLI_SUCCESS;
06950 }
06951 }
06952
06953 static int manager_iax2_show_netstats(struct mansession *s, const struct message *m)
06954 {
06955 ast_cli_netstats(s, -1, 0);
06956 astman_append(s, "\r\n");
06957 return RESULT_SUCCESS;
06958 }
06959
06960 static char *handle_cli_iax2_show_firmware(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
06961 {
06962 struct iax_firmware *cur = NULL;
06963
06964 switch (cmd) {
06965 case CLI_INIT:
06966 e->command = "iax2 show firmware";
06967 e->usage =
06968 "Usage: iax2 show firmware\n"
06969 " Lists all known IAX firmware images.\n";
06970 return NULL;
06971 case CLI_GENERATE:
06972 return NULL;
06973 }
06974
06975 if (a->argc != 3 && a->argc != 4)
06976 return CLI_SHOWUSAGE;
06977
06978 ast_cli(a->fd, "%-15.15s %-15.15s %-15.15s\n", "Device", "Version", "Size");
06979 AST_LIST_LOCK(&firmwares);
06980 AST_LIST_TRAVERSE(&firmwares, cur, list) {
06981 if ((a->argc == 3) || (!strcasecmp(a->argv[3], (char *) cur->fwh->devname))) {
06982 ast_cli(a->fd, "%-15.15s %-15d %-15d\n", cur->fwh->devname,
06983 ntohs(cur->fwh->version), (int)ntohl(cur->fwh->datalen));
06984 }
06985 }
06986 AST_LIST_UNLOCK(&firmwares);
06987
06988 return CLI_SUCCESS;
06989 }
06990
06991
06992 static int manager_iax2_show_peers(struct mansession *s, const struct message *m)
06993 {
06994 static const char * const a[] = { "iax2", "show", "peers" };
06995 const char *id = astman_get_header(m,"ActionID");
06996 char idtext[256] = "";
06997 int total = 0;
06998
06999 if (!ast_strlen_zero(id))
07000 snprintf(idtext, sizeof(idtext), "ActionID: %s\r\n", id);
07001
07002 astman_send_listack(s, m, "Peer status list will follow", "start");
07003
07004 __iax2_show_peers(-1, &total, s, 3, a);
07005
07006 astman_append(s,
07007 "Event: PeerlistComplete\r\n"
07008 "EventList: Complete\r\n"
07009 "ListItems: %d\r\n"
07010 "%s"
07011 "\r\n", total, idtext);
07012 return 0;
07013 }
07014
07015
07016 static int manager_iax2_show_peer_list(struct mansession *s, const struct message *m)
07017 {
07018 struct iax2_peer *peer = NULL;
07019 int peer_count = 0;
07020 char nm[20];
07021 char status[20];
07022 const char *id = astman_get_header(m,"ActionID");
07023 char idtext[256] = "";
07024 struct ast_str *encmethods = ast_str_alloca(256);
07025 struct ao2_iterator i;
07026
07027 if (!ast_strlen_zero(id))
07028 snprintf(idtext, sizeof(idtext), "ActionID: %s\r\n", id);
07029
07030 astman_append(s, "Response: Success\r\n%sMessage: IAX Peer status list will follow\r\n\r\n", idtext);
07031
07032
07033 i = ao2_iterator_init(peers, 0);
07034 for (; (peer = ao2_iterator_next(&i)); peer_unref(peer)) {
07035 encmethods_to_str(peer->encmethods, &encmethods);
07036 astman_append(s, "Event: PeerEntry\r\n%sChanneltype: IAX\r\n", idtext);
07037 if (!ast_strlen_zero(peer->username)) {
07038 astman_append(s, "ObjectName: %s\r\nObjectUsername: %s\r\n", peer->name, peer->username);
07039 } else {
07040 astman_append(s, "ObjectName: %s\r\n", peer->name);
07041 }
07042 astman_append(s, "ChanObjectType: peer\r\n");
07043 astman_append(s, "IPaddress: %s\r\n", ast_sockaddr_stringify_addr(&peer->addr));
07044 ast_copy_string(nm, ast_inet_ntoa(peer->mask), sizeof(nm));
07045 astman_append(s, "Mask: %s\r\n", nm);
07046 astman_append(s, "Port: %d\r\n", ast_sockaddr_port(&peer->addr));
07047 astman_append(s, "Dynamic: %s\r\n", ast_test_flag64(peer, IAX_DYNAMIC) ? "Yes" : "No");
07048 astman_append(s, "Trunk: %s\r\n", ast_test_flag64(peer, IAX_TRUNK) ? "Yes" : "No");
07049 astman_append(s, "Encryption: %s\r\n", peer->encmethods ? ast_str_buffer(encmethods) : "No");
07050 peer_status(peer, status, sizeof(status));
07051 astman_append(s, "Status: %s\r\n\r\n", status);
07052 peer_count++;
07053 }
07054 ao2_iterator_destroy(&i);
07055
07056 astman_append(s, "Event: PeerlistComplete\r\n%sListItems: %d\r\n\r\n", idtext, peer_count);
07057 return RESULT_SUCCESS;
07058 }
07059
07060
07061 static char *regstate2str(int regstate)
07062 {
07063 switch(regstate) {
07064 case REG_STATE_UNREGISTERED:
07065 return "Unregistered";
07066 case REG_STATE_REGSENT:
07067 return "Request Sent";
07068 case REG_STATE_AUTHSENT:
07069 return "Auth. Sent";
07070 case REG_STATE_REGISTERED:
07071 return "Registered";
07072 case REG_STATE_REJECTED:
07073 return "Rejected";
07074 case REG_STATE_TIMEOUT:
07075 return "Timeout";
07076 case REG_STATE_NOAUTH:
07077 return "No Authentication";
07078 default:
07079 return "Unknown";
07080 }
07081 }
07082
07083 static char *handle_cli_iax2_show_registry(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
07084 {
07085 #define FORMAT2 "%-20.20s %-6.6s %-10.10s %-20.20s %8.8s %s\n"
07086 #define FORMAT "%-20.20s %-6.6s %-10.10s %-20.20s %8d %s\n"
07087 struct iax2_registry *reg = NULL;
07088 char host[80];
07089 char perceived[80];
07090 int counter = 0;
07091
07092 switch (cmd) {
07093 case CLI_INIT:
07094 e->command = "iax2 show registry";
07095 e->usage =
07096 "Usage: iax2 show registry\n"
07097 " Lists all registration requests and status.\n";
07098 return NULL;
07099 case CLI_GENERATE:
07100 return NULL;
07101 }
07102 if (a->argc != 3)
07103 return CLI_SHOWUSAGE;
07104 ast_cli(a->fd, FORMAT2, "Host", "dnsmgr", "Username", "Perceived", "Refresh", "State");
07105 AST_LIST_LOCK(®istrations);
07106 AST_LIST_TRAVERSE(®istrations, reg, entry) {
07107 snprintf(host, sizeof(host), "%s", ast_sockaddr_stringify(®->addr));
07108 if (reg->us.sin_addr.s_addr)
07109 snprintf(perceived, sizeof(perceived), "%s:%d", ast_inet_ntoa(reg->us.sin_addr), ntohs(reg->us.sin_port));
07110 else
07111 ast_copy_string(perceived, "<Unregistered>", sizeof(perceived));
07112 ast_cli(a->fd, FORMAT, host,
07113 (reg->dnsmgr) ? "Y" : "N",
07114 reg->username, perceived, reg->refresh, regstate2str(reg->regstate));
07115 counter++;
07116 }
07117 AST_LIST_UNLOCK(®istrations);
07118 ast_cli(a->fd, "%d IAX2 registrations.\n", counter);
07119 return CLI_SUCCESS;
07120 #undef FORMAT
07121 #undef FORMAT2
07122 }
07123
07124 static int manager_iax2_show_registry(struct mansession *s, const struct message *m)
07125 {
07126 const char *id = astman_get_header(m, "ActionID");
07127 struct iax2_registry *reg = NULL;
07128 char idtext[256] = "";
07129 char host[80] = "";
07130 char perceived[80] = "";
07131 int total = 0;
07132
07133 if (!ast_strlen_zero(id))
07134 snprintf(idtext, sizeof(idtext), "ActionID: %s\r\n", id);
07135
07136 astman_send_listack(s, m, "Registrations will follow", "start");
07137
07138 AST_LIST_LOCK(®istrations);
07139 AST_LIST_TRAVERSE(®istrations, reg, entry) {
07140 snprintf(host, sizeof(host), "%s", ast_sockaddr_stringify(®->addr));
07141
07142 if (reg->us.sin_addr.s_addr) {
07143 snprintf(perceived, sizeof(perceived), "%s:%d", ast_inet_ntoa(reg->us.sin_addr), ntohs(reg->us.sin_port));
07144 } else {
07145 ast_copy_string(perceived, "<Unregistered>", sizeof(perceived));
07146 }
07147
07148 astman_append(s,
07149 "Event: RegistryEntry\r\n"
07150 "%s"
07151 "Host: %s\r\n"
07152 "DNSmanager: %s\r\n"
07153 "Username: %s\r\n"
07154 "Perceived: %s\r\n"
07155 "Refresh: %d\r\n"
07156 "State: %s\r\n"
07157 "\r\n", idtext, host, (reg->dnsmgr) ? "Y" : "N", reg->username, perceived,
07158 reg->refresh, regstate2str(reg->regstate));
07159
07160 total++;
07161 }
07162 AST_LIST_UNLOCK(®istrations);
07163
07164 astman_append(s,
07165 "Event: RegistrationsComplete\r\n"
07166 "EventList: Complete\r\n"
07167 "ListItems: %d\r\n"
07168 "%s"
07169 "\r\n", total, idtext);
07170
07171 return 0;
07172 }
07173
07174 static char *handle_cli_iax2_show_channels(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
07175 {
07176 #define FORMAT2 "%-20.20s %-15.15s %-10.10s %-11.11s %-11.11s %-7.7s %-6.6s %-6.6s %s %s %9s\n"
07177 #define FORMAT "%-20.20s %-15.15s %-10.10s %5.5d/%5.5d %5.5d/%5.5d %-5.5dms %-4.4dms %-4.4dms %-6.6s %s%s %3s%s\n"
07178 #define FORMATB "%-20.20s %-15.15s %-10.10s %5.5d/%5.5d %5.5d/%5.5d [Native Bridged to ID=%5.5d]\n"
07179 int x;
07180 int numchans = 0;
07181 char first_message[10] = { 0, };
07182 char last_message[10] = { 0, };
07183
07184 switch (cmd) {
07185 case CLI_INIT:
07186 e->command = "iax2 show channels";
07187 e->usage =
07188 "Usage: iax2 show channels\n"
07189 " Lists all currently active IAX channels.\n";
07190 return NULL;
07191 case CLI_GENERATE:
07192 return NULL;
07193 }
07194
07195 if (a->argc != 3)
07196 return CLI_SHOWUSAGE;
07197 ast_cli(a->fd, FORMAT2, "Channel", "Peer", "Username", "ID (Lo/Rem)", "Seq (Tx/Rx)", "Lag", "Jitter", "JitBuf", "Format", "FirstMsg", "LastMsg");
07198 for (x = 0; x < ARRAY_LEN(iaxs); x++) {
07199 ast_mutex_lock(&iaxsl[x]);
07200 if (iaxs[x]) {
07201 int lag, jitter, localdelay;
07202 jb_info jbinfo;
07203 if (ast_test_flag64(iaxs[x], IAX_USEJITTERBUF)) {
07204 jb_getinfo(iaxs[x]->jb, &jbinfo);
07205 jitter = jbinfo.jitter;
07206 localdelay = jbinfo.current - jbinfo.min;
07207 } else {
07208 jitter = -1;
07209 localdelay = 0;
07210 }
07211
07212 iax_frame_subclass2str(iaxs[x]->first_iax_message & ~MARK_IAX_SUBCLASS_TX, first_message, sizeof(first_message));
07213 iax_frame_subclass2str(iaxs[x]->last_iax_message & ~MARK_IAX_SUBCLASS_TX, last_message, sizeof(last_message));
07214 lag = iaxs[x]->remote_rr.delay;
07215 ast_cli(a->fd, FORMAT,
07216 iaxs[x]->owner ? iaxs[x]->owner->name : "(None)",
07217 ast_inet_ntoa(iaxs[x]->addr.sin_addr),
07218 S_OR(iaxs[x]->username, "(None)"),
07219 iaxs[x]->callno, iaxs[x]->peercallno,
07220 iaxs[x]->oseqno, iaxs[x]->iseqno,
07221 lag,
07222 jitter,
07223 localdelay,
07224 ast_getformatname(iaxs[x]->voiceformat),
07225 (iaxs[x]->first_iax_message & MARK_IAX_SUBCLASS_TX) ? "Tx:" : "Rx:",
07226 first_message,
07227 (iaxs[x]->last_iax_message & MARK_IAX_SUBCLASS_TX) ? "Tx:" : "Rx:",
07228 last_message);
07229 numchans++;
07230 }
07231 ast_mutex_unlock(&iaxsl[x]);
07232 }
07233 ast_cli(a->fd, "%d active IAX channel%s\n", numchans, (numchans != 1) ? "s" : "");
07234 return CLI_SUCCESS;
07235 #undef FORMAT
07236 #undef FORMAT2
07237 #undef FORMATB
07238 }
07239
07240 static int ast_cli_netstats(struct mansession *s, int fd, int limit_fmt)
07241 {
07242 int x;
07243 int numchans = 0;
07244 char first_message[10] = { 0, };
07245 char last_message[10] = { 0, };
07246 #define ACN_FORMAT1 "%-20.25s %4d %4d %4d %5d %3d %5d %4d %6d %4d %4d %5d %3d %5d %4d %6d %s%s %4s%s\n"
07247 #define ACN_FORMAT2 "%s %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %s%s %s%s\n"
07248 for (x = 0; x < ARRAY_LEN(iaxs); x++) {
07249 ast_mutex_lock(&iaxsl[x]);
07250 if (iaxs[x]) {
07251 int localjitter, localdelay, locallost, locallosspct, localdropped, localooo;
07252 jb_info jbinfo;
07253 iax_frame_subclass2str(iaxs[x]->first_iax_message & ~MARK_IAX_SUBCLASS_TX, first_message, sizeof(first_message));
07254 iax_frame_subclass2str(iaxs[x]->last_iax_message & ~MARK_IAX_SUBCLASS_TX, last_message, sizeof(last_message));
07255
07256 if(ast_test_flag64(iaxs[x], IAX_USEJITTERBUF)) {
07257 jb_getinfo(iaxs[x]->jb, &jbinfo);
07258 localjitter = jbinfo.jitter;
07259 localdelay = jbinfo.current - jbinfo.min;
07260 locallost = jbinfo.frames_lost;
07261 locallosspct = jbinfo.losspct/1000;
07262 localdropped = jbinfo.frames_dropped;
07263 localooo = jbinfo.frames_ooo;
07264 } else {
07265 localjitter = -1;
07266 localdelay = 0;
07267 locallost = -1;
07268 locallosspct = -1;
07269 localdropped = 0;
07270 localooo = -1;
07271 }
07272 if (s)
07273 astman_append(s, limit_fmt ? ACN_FORMAT1 : ACN_FORMAT2,
07274 iaxs[x]->owner ? iaxs[x]->owner->name : "(None)",
07275 iaxs[x]->pingtime,
07276 localjitter,
07277 localdelay,
07278 locallost,
07279 locallosspct,
07280 localdropped,
07281 localooo,
07282 iaxs[x]->frames_received/1000,
07283 iaxs[x]->remote_rr.jitter,
07284 iaxs[x]->remote_rr.delay,
07285 iaxs[x]->remote_rr.losscnt,
07286 iaxs[x]->remote_rr.losspct,
07287 iaxs[x]->remote_rr.dropped,
07288 iaxs[x]->remote_rr.ooo,
07289 iaxs[x]->remote_rr.packets/1000,
07290 (iaxs[x]->first_iax_message & MARK_IAX_SUBCLASS_TX) ? "Tx:" : "Rx:",
07291 first_message,
07292 (iaxs[x]->last_iax_message & MARK_IAX_SUBCLASS_TX) ? "Tx:" : "Rx:",
07293 last_message);
07294 else
07295 ast_cli(fd, limit_fmt ? ACN_FORMAT1 : ACN_FORMAT2,
07296 iaxs[x]->owner ? iaxs[x]->owner->name : "(None)",
07297 iaxs[x]->pingtime,
07298 localjitter,
07299 localdelay,
07300 locallost,
07301 locallosspct,
07302 localdropped,
07303 localooo,
07304 iaxs[x]->frames_received/1000,
07305 iaxs[x]->remote_rr.jitter,
07306 iaxs[x]->remote_rr.delay,
07307 iaxs[x]->remote_rr.losscnt,
07308 iaxs[x]->remote_rr.losspct,
07309 iaxs[x]->remote_rr.dropped,
07310 iaxs[x]->remote_rr.ooo,
07311 iaxs[x]->remote_rr.packets/1000,
07312 (iaxs[x]->first_iax_message & MARK_IAX_SUBCLASS_TX) ? "Tx:" : "Rx:",
07313 first_message,
07314 (iaxs[x]->last_iax_message & MARK_IAX_SUBCLASS_TX) ? "Tx:" : "Rx:",
07315 last_message);
07316 numchans++;
07317 }
07318 ast_mutex_unlock(&iaxsl[x]);
07319 }
07320
07321 return numchans;
07322 }
07323
07324 static char *handle_cli_iax2_show_netstats(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
07325 {
07326 int numchans = 0;
07327
07328 switch (cmd) {
07329 case CLI_INIT:
07330 e->command = "iax2 show netstats";
07331 e->usage =
07332 "Usage: iax2 show netstats\n"
07333 " Lists network status for all currently active IAX channels.\n";
07334 return NULL;
07335 case CLI_GENERATE:
07336 return NULL;
07337 }
07338 if (a->argc != 3)
07339 return CLI_SHOWUSAGE;
07340 ast_cli(a->fd, " -------- LOCAL --------------------- -------- REMOTE --------------------\n");
07341 ast_cli(a->fd, "Channel RTT Jit Del Lost %% Drop OOO Kpkts Jit Del Lost %% Drop OOO Kpkts FirstMsg LastMsg\n");
07342 numchans = ast_cli_netstats(NULL, a->fd, 1);
07343 ast_cli(a->fd, "%d active IAX channel%s\n", numchans, (numchans != 1) ? "s" : "");
07344 return CLI_SUCCESS;
07345 }
07346
07347 static char *handle_cli_iax2_set_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
07348 {
07349 switch (cmd) {
07350 case CLI_INIT:
07351 e->command = "iax2 set debug {on|off|peer}";
07352 e->usage =
07353 "Usage: iax2 set debug {on|off|peer peername}\n"
07354 " Enables/Disables dumping of IAX packets for debugging purposes.\n";
07355 return NULL;
07356 case CLI_GENERATE:
07357 if (a->pos == 4 && !strcasecmp(a->argv[3], "peer"))
07358 return complete_iax2_peers(a->line, a->word, a->pos, a->n, 0);
07359 return NULL;
07360 }
07361
07362 if (a->argc < e->args || a->argc > e->args + 1)
07363 return CLI_SHOWUSAGE;
07364
07365 if (!strcasecmp(a->argv[3], "peer")) {
07366 struct iax2_peer *peer;
07367 struct sockaddr_in peer_addr;
07368
07369
07370 if (a->argc != e->args + 1)
07371 return CLI_SHOWUSAGE;
07372
07373 peer = find_peer(a->argv[4], 1);
07374
07375 if (!peer) {
07376 ast_cli(a->fd, "IAX2 peer '%s' does not exist\n", a->argv[e->args-1]);
07377 return CLI_FAILURE;
07378 }
07379
07380 ast_sockaddr_to_sin(&peer->addr, &peer_addr);
07381
07382 debugaddr.sin_addr = peer_addr.sin_addr;
07383 debugaddr.sin_port = peer_addr.sin_port;
07384
07385 ast_cli(a->fd, "IAX2 Debugging Enabled for IP: %s:%d\n",
07386 ast_inet_ntoa(debugaddr.sin_addr), ntohs(debugaddr.sin_port));
07387
07388 ao2_ref(peer, -1);
07389 } else if (!strncasecmp(a->argv[3], "on", 2)) {
07390 iaxdebug = 1;
07391 ast_cli(a->fd, "IAX2 Debugging Enabled\n");
07392 } else {
07393 iaxdebug = 0;
07394 memset(&debugaddr, 0, sizeof(debugaddr));
07395 ast_cli(a->fd, "IAX2 Debugging Disabled\n");
07396 }
07397 return CLI_SUCCESS;
07398 }
07399
07400 static char *handle_cli_iax2_set_debug_trunk(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
07401 {
07402 switch (cmd) {
07403 case CLI_INIT:
07404 e->command = "iax2 set debug trunk {on|off}";
07405 e->usage =
07406 "Usage: iax2 set debug trunk {on|off}\n"
07407 " Enables/Disables debugging of IAX trunking\n";
07408 return NULL;
07409 case CLI_GENERATE:
07410 return NULL;
07411 }
07412
07413 if (a->argc != e->args)
07414 return CLI_SHOWUSAGE;
07415
07416 if (!strncasecmp(a->argv[e->args - 1], "on", 2)) {
07417 iaxtrunkdebug = 1;
07418 ast_cli(a->fd, "IAX2 Trunk Debugging Enabled\n");
07419 } else {
07420 iaxtrunkdebug = 0;
07421 ast_cli(a->fd, "IAX2 Trunk Debugging Disabled\n");
07422 }
07423 return CLI_SUCCESS;
07424 }
07425
07426 static char *handle_cli_iax2_set_debug_jb(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
07427 {
07428 switch (cmd) {
07429 case CLI_INIT:
07430 e->command = "iax2 set debug jb {on|off}";
07431 e->usage =
07432 "Usage: iax2 set debug jb {on|off}\n"
07433 " Enables/Disables jitterbuffer debugging information\n";
07434 return NULL;
07435 case CLI_GENERATE:
07436 return NULL;
07437 }
07438
07439 if (a->argc != e->args)
07440 return CLI_SHOWUSAGE;
07441
07442 if (!strncasecmp(a->argv[e->args -1], "on", 2)) {
07443 jb_setoutput(jb_error_output, jb_warning_output, jb_debug_output);
07444 ast_cli(a->fd, "IAX2 Jitterbuffer Debugging Enabled\n");
07445 } else {
07446 jb_setoutput(jb_error_output, jb_warning_output, NULL);
07447 ast_cli(a->fd, "IAX2 Jitterbuffer Debugging Disabled\n");
07448 }
07449 return CLI_SUCCESS;
07450 }
07451
07452 static int iax2_write(struct ast_channel *c, struct ast_frame *f)
07453 {
07454 unsigned short callno = PTR_TO_CALLNO(c->tech_pvt);
07455 int res = -1;
07456 ast_mutex_lock(&iaxsl[callno]);
07457 if (iaxs[callno]) {
07458
07459 if (!iaxs[callno]->error) {
07460 if (ast_test_flag64(iaxs[callno], IAX_ALREADYGONE))
07461 res = 0;
07462
07463 else if (f->frametype == AST_FRAME_NULL)
07464 res = 0;
07465 else if ((f->frametype == AST_FRAME_VOICE) && ast_test_flag64(iaxs[callno], IAX_QUELCH))
07466 res = 0;
07467 else if (!ast_test_flag(&iaxs[callno]->state, IAX_STATE_STARTED))
07468 res = 0;
07469 else
07470
07471 res = iax2_send(iaxs[callno], f, 0, -1, 0, 0, 0);
07472 } else {
07473 ast_debug(1, "Write error: %s\n", strerror(errno));
07474 }
07475 }
07476
07477 ast_mutex_unlock(&iaxsl[callno]);
07478 return res;
07479 }
07480
07481 static int __send_command(struct chan_iax2_pvt *i, char type, int command, unsigned int ts, const unsigned char *data, int datalen, int seqno,
07482 int now, int transfer, int final)
07483 {
07484 struct ast_frame f = { 0, };
07485 int res = 0;
07486
07487 f.frametype = type;
07488 f.subclass.integer = command;
07489 f.datalen = datalen;
07490 f.src = __FUNCTION__;
07491 f.data.ptr = (void *) data;
07492
07493 if ((res = queue_signalling(i, &f)) <= 0) {
07494 return res;
07495 }
07496
07497 return iax2_send(i, &f, ts, seqno, now, transfer, final);
07498 }
07499
07500 static int send_command(struct chan_iax2_pvt *i, char type, int command, unsigned int ts, const unsigned char *data, int datalen, int seqno)
07501 {
07502 return __send_command(i, type, command, ts, data, datalen, seqno, 0, 0, 0);
07503 }
07504
07505 static int send_command_locked(unsigned short callno, char type, int command, unsigned int ts, const unsigned char *data, int datalen, int seqno)
07506 {
07507 int res;
07508 ast_mutex_lock(&iaxsl[callno]);
07509 res = send_command(iaxs[callno], type, command, ts, data, datalen, seqno);
07510 ast_mutex_unlock(&iaxsl[callno]);
07511 return res;
07512 }
07513
07514
07515
07516
07517
07518
07519 static int send_command_final(struct chan_iax2_pvt *i, char type, int command, unsigned int ts, const unsigned char *data, int datalen, int seqno)
07520 {
07521 int call_num = i->callno;
07522
07523 iax2_predestroy(i->callno);
07524 if (!iaxs[call_num])
07525 return -1;
07526 return __send_command(i, type, command, ts, data, datalen, seqno, 0, 0, 1);
07527 }
07528
07529 static int send_command_immediate(struct chan_iax2_pvt *i, char type, int command, unsigned int ts, const unsigned char *data, int datalen, int seqno)
07530 {
07531 return __send_command(i, type, command, ts, data, datalen, seqno, 1, 0, 0);
07532 }
07533
07534 static int send_command_transfer(struct chan_iax2_pvt *i, char type, int command, unsigned int ts, const unsigned char *data, int datalen)
07535 {
07536 return __send_command(i, type, command, ts, data, datalen, 0, 0, 1, 0);
07537 }
07538
07539 static int apply_context(struct iax2_context *con, const char *context)
07540 {
07541 while(con) {
07542 if (!strcmp(con->context, context) || !strcmp(con->context, "*"))
07543 return -1;
07544 con = con->next;
07545 }
07546 return 0;
07547 }
07548
07549
07550 static int check_access(int callno, struct sockaddr_in *sin, struct iax_ies *ies)
07551 {
07552
07553 int res = -1;
07554 int version = 2;
07555 struct iax2_user *user = NULL, *best = NULL;
07556 int bestscore = 0;
07557 int gotcapability = 0;
07558 struct ast_variable *v = NULL, *tmpvar = NULL;
07559 struct ao2_iterator i;
07560 struct ast_sockaddr addr;
07561
07562 if (!iaxs[callno])
07563 return res;
07564 if (ies->called_number)
07565 ast_string_field_set(iaxs[callno], exten, ies->called_number);
07566 if (ies->calling_number) {
07567 if (ast_test_flag64(&globalflags, IAX_SHRINKCALLERID)) {
07568 ast_shrink_phone_number(ies->calling_number);
07569 }
07570 ast_string_field_set(iaxs[callno], cid_num, ies->calling_number);
07571 }
07572 if (ies->calling_name)
07573 ast_string_field_set(iaxs[callno], cid_name, ies->calling_name);
07574 if (ies->calling_ani)
07575 ast_string_field_set(iaxs[callno], ani, ies->calling_ani);
07576 if (ies->dnid)
07577 ast_string_field_set(iaxs[callno], dnid, ies->dnid);
07578 if (ies->rdnis)
07579 ast_string_field_set(iaxs[callno], rdnis, ies->rdnis);
07580 if (ies->called_context)
07581 ast_string_field_set(iaxs[callno], context, ies->called_context);
07582 if (ies->language)
07583 ast_string_field_set(iaxs[callno], language, ies->language);
07584 if (ies->username)
07585 ast_string_field_set(iaxs[callno], username, ies->username);
07586 if (ies->calling_ton > -1)
07587 iaxs[callno]->calling_ton = ies->calling_ton;
07588 if (ies->calling_tns > -1)
07589 iaxs[callno]->calling_tns = ies->calling_tns;
07590 if (ies->calling_pres > -1)
07591 iaxs[callno]->calling_pres = ies->calling_pres;
07592 if (ies->format)
07593 iaxs[callno]->peerformat = ies->format;
07594 if (ies->adsicpe)
07595 iaxs[callno]->peeradsicpe = ies->adsicpe;
07596 if (ies->capability) {
07597 gotcapability = 1;
07598 iaxs[callno]->peercapability = ies->capability;
07599 }
07600 if (ies->version)
07601 version = ies->version;
07602
07603
07604 if (ies->codec_prefs) {
07605 ast_codec_pref_convert(&iaxs[callno]->rprefs, ies->codec_prefs, 32, 0);
07606 ast_codec_pref_convert(&iaxs[callno]->prefs, ies->codec_prefs, 32, 0);
07607 }
07608
07609 if (!gotcapability)
07610 iaxs[callno]->peercapability = iaxs[callno]->peerformat;
07611 if (version > IAX_PROTO_VERSION) {
07612 ast_log(LOG_WARNING, "Peer '%s' has too new a protocol version (%d) for me\n",
07613 ast_inet_ntoa(sin->sin_addr), version);
07614 return res;
07615 }
07616
07617 ast_sockaddr_from_sin(&addr, sin);
07618 i = ao2_iterator_init(users, 0);
07619 while ((user = ao2_iterator_next(&i))) {
07620 if ((ast_strlen_zero(iaxs[callno]->username) ||
07621 !strcmp(iaxs[callno]->username, user->name))
07622 && ast_apply_ha(user->ha, &addr) == AST_SENSE_ALLOW
07623 && (ast_strlen_zero(iaxs[callno]->context) ||
07624 apply_context(user->contexts, iaxs[callno]->context))) {
07625 if (!ast_strlen_zero(iaxs[callno]->username)) {
07626
07627 if (best)
07628 user_unref(best);
07629 best = user;
07630 break;
07631 } else if (ast_strlen_zero(user->secret) && ast_strlen_zero(user->dbsecret) && ast_strlen_zero(user->inkeys)) {
07632
07633 if (user->ha) {
07634
07635 if (bestscore < 4) {
07636 bestscore = 4;
07637 if (best)
07638 user_unref(best);
07639 best = user;
07640 continue;
07641 }
07642 } else {
07643
07644 if (bestscore < 3) {
07645 bestscore = 3;
07646 if (best)
07647 user_unref(best);
07648 best = user;
07649 continue;
07650 }
07651 }
07652 } else {
07653 if (user->ha) {
07654
07655 if (bestscore < 2) {
07656 bestscore = 2;
07657 if (best)
07658 user_unref(best);
07659 best = user;
07660 continue;
07661 }
07662 } else {
07663
07664 if (bestscore < 1) {
07665 bestscore = 1;
07666 if (best)
07667 user_unref(best);
07668 best = user;
07669 continue;
07670 }
07671 }
07672 }
07673 }
07674 user_unref(user);
07675 }
07676 ao2_iterator_destroy(&i);
07677 user = best;
07678 if (!user && !ast_strlen_zero(iaxs[callno]->username)) {
07679 user = realtime_user(iaxs[callno]->username, sin);
07680 if (user && (ast_apply_ha(user->ha, &addr) == AST_SENSE_DENY
07681 || (!ast_strlen_zero(iaxs[callno]->context) &&
07682 !apply_context(user->contexts, iaxs[callno]->context)))) {
07683 user = user_unref(user);
07684 }
07685 }
07686 if (user) {
07687
07688
07689 for (v = user->vars ; v ; v = v->next) {
07690 if((tmpvar = ast_variable_new(v->name, v->value, v->file))) {
07691 tmpvar->next = iaxs[callno]->vars;
07692 iaxs[callno]->vars = tmpvar;
07693 }
07694 }
07695
07696 if (user->maxauthreq > 0)
07697 ast_set_flag64(iaxs[callno], IAX_MAXAUTHREQ);
07698 iaxs[callno]->prefs = user->prefs;
07699 ast_copy_flags64(iaxs[callno], user, IAX_CODEC_USER_FIRST | IAX_IMMEDIATE | IAX_CODEC_NOPREFS | IAX_CODEC_NOCAP | IAX_FORCE_ENCRYPT);
07700 iaxs[callno]->encmethods = user->encmethods;
07701
07702 if (ast_strlen_zero(iaxs[callno]->username))
07703 ast_string_field_set(iaxs[callno], username, user->name);
07704
07705 ast_copy_flags64(iaxs[callno], user, IAX_TRUNK);
07706 iaxs[callno]->capability = user->capability;
07707
07708 if (ast_strlen_zero(iaxs[callno]->context)) {
07709 if (user->contexts)
07710 ast_string_field_set(iaxs[callno], context, user->contexts->context);
07711 else
07712 ast_string_field_set(iaxs[callno], context, DEFAULT_CONTEXT);
07713 }
07714
07715 ast_string_field_set(iaxs[callno], inkeys, user->inkeys);
07716
07717 iaxs[callno]->authmethods = user->authmethods;
07718 iaxs[callno]->adsi = user->adsi;
07719
07720 if (ast_test_flag64(user, IAX_HASCALLERID)) {
07721 iaxs[callno]->calling_tns = 0;
07722 iaxs[callno]->calling_ton = 0;
07723 ast_string_field_set(iaxs[callno], cid_num, user->cid_num);
07724 ast_string_field_set(iaxs[callno], cid_name, user->cid_name);
07725 ast_string_field_set(iaxs[callno], ani, user->cid_num);
07726 iaxs[callno]->calling_pres = AST_PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN;
07727 } else if (ast_strlen_zero(iaxs[callno]->cid_num) && ast_strlen_zero(iaxs[callno]->cid_name)) {
07728 iaxs[callno]->calling_pres = AST_PRES_NUMBER_NOT_AVAILABLE;
07729 }
07730 if (!ast_strlen_zero(user->accountcode))
07731 ast_string_field_set(iaxs[callno], accountcode, user->accountcode);
07732 if (!ast_strlen_zero(user->mohinterpret))
07733 ast_string_field_set(iaxs[callno], mohinterpret, user->mohinterpret);
07734 if (!ast_strlen_zero(user->mohsuggest))
07735 ast_string_field_set(iaxs[callno], mohsuggest, user->mohsuggest);
07736 if (!ast_strlen_zero(user->parkinglot))
07737 ast_string_field_set(iaxs[callno], parkinglot, user->parkinglot);
07738 if (user->amaflags)
07739 iaxs[callno]->amaflags = user->amaflags;
07740 if (!ast_strlen_zero(user->language))
07741 ast_string_field_set(iaxs[callno], language, user->language);
07742 ast_copy_flags64(iaxs[callno], user, IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_FORCEJITTERBUF | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
07743
07744 if (!ast_strlen_zero(user->dbsecret)) {
07745 char *family, *key=NULL;
07746 char buf[80];
07747 family = ast_strdupa(user->dbsecret);
07748 key = strchr(family, '/');
07749 if (key) {
07750 *key = '\0';
07751 key++;
07752 }
07753 if (!key || ast_db_get(family, key, buf, sizeof(buf)))
07754 ast_log(LOG_WARNING, "Unable to retrieve database password for family/key '%s'!\n", user->dbsecret);
07755 else
07756 ast_string_field_set(iaxs[callno], secret, buf);
07757 } else
07758 ast_string_field_set(iaxs[callno], secret, user->secret);
07759 res = 0;
07760 user = user_unref(user);
07761 } else {
07762
07763
07764
07765
07766 iaxs[callno]->authmethods = last_authmethod ? last_authmethod : (IAX_AUTH_MD5 | IAX_AUTH_PLAINTEXT);
07767 ast_string_field_set(iaxs[callno], secret, "badsecret");
07768 iaxs[callno]->authrej = 1;
07769 if (!ast_strlen_zero(iaxs[callno]->username)) {
07770
07771 res = 0;
07772 }
07773 }
07774 ast_set2_flag64(iaxs[callno], iax2_getpeertrunk(*sin), IAX_TRUNK);
07775 return res;
07776 }
07777
07778 static int raw_hangup(struct sockaddr_in *sin, unsigned short src, unsigned short dst, int sockfd)
07779 {
07780 struct ast_iax2_full_hdr fh;
07781 fh.scallno = htons(src | IAX_FLAG_FULL);
07782 fh.dcallno = htons(dst);
07783 fh.ts = 0;
07784 fh.oseqno = 0;
07785 fh.iseqno = 0;
07786 fh.type = AST_FRAME_IAX;
07787 fh.csub = compress_subclass(IAX_COMMAND_INVAL);
07788 iax_outputframe(NULL, &fh, 0, sin, 0);
07789 #if 0
07790 if (option_debug)
07791 #endif
07792 ast_debug(1, "Raw Hangup %s:%d, src=%d, dst=%d\n",
07793 ast_inet_ntoa(sin->sin_addr), ntohs(sin->sin_port), src, dst);
07794 return sendto(sockfd, &fh, sizeof(fh), 0, (struct sockaddr *)sin, sizeof(*sin));
07795 }
07796
07797 static void merge_encryption(struct chan_iax2_pvt *p, unsigned int enc)
07798 {
07799
07800 p->encmethods &= enc;
07801 if (p->encmethods) {
07802 if (!(p->encmethods & IAX_ENCRYPT_KEYROTATE)){
07803 p->keyrotateid = -2;
07804 }
07805 if (p->encmethods & IAX_ENCRYPT_AES128)
07806 p->encmethods = IAX_ENCRYPT_AES128;
07807 else
07808 p->encmethods = 0;
07809 }
07810 }
07811
07812
07813
07814
07815
07816
07817
07818 static int authenticate_request(int call_num)
07819 {
07820 struct iax_ie_data ied;
07821 int res = -1, authreq_restrict = 0;
07822 char challenge[10];
07823 struct chan_iax2_pvt *p = iaxs[call_num];
07824
07825 memset(&ied, 0, sizeof(ied));
07826
07827
07828 if (ast_test_flag64(p, IAX_MAXAUTHREQ)) {
07829 struct iax2_user *user, tmp_user = {
07830 .name = p->username,
07831 };
07832
07833 user = ao2_find(users, &tmp_user, OBJ_POINTER);
07834 if (user) {
07835 if (user->curauthreq == user->maxauthreq)
07836 authreq_restrict = 1;
07837 else
07838 user->curauthreq++;
07839 user = user_unref(user);
07840 }
07841 }
07842
07843
07844 if (authreq_restrict) {
07845 iax_ie_append_str(&ied, IAX_IE_CAUSE, "Unauthenticated call limit reached");
07846 iax_ie_append_byte(&ied, IAX_IE_CAUSECODE, AST_CAUSE_CALL_REJECTED);
07847 send_command_final(p, AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied.buf, ied.pos, -1);
07848 return 0;
07849 }
07850
07851 iax_ie_append_short(&ied, IAX_IE_AUTHMETHODS, p->authmethods);
07852 if (p->authmethods & (IAX_AUTH_MD5 | IAX_AUTH_RSA)) {
07853 snprintf(challenge, sizeof(challenge), "%d", (int)ast_random());
07854 ast_string_field_set(p, challenge, challenge);
07855
07856 iax_ie_append_str(&ied, IAX_IE_CHALLENGE, p->challenge);
07857 }
07858 if (p->encmethods)
07859 iax_ie_append_short(&ied, IAX_IE_ENCRYPTION, p->encmethods);
07860
07861 iax_ie_append_str(&ied,IAX_IE_USERNAME, p->username);
07862
07863 res = send_command(p, AST_FRAME_IAX, IAX_COMMAND_AUTHREQ, 0, ied.buf, ied.pos, -1);
07864
07865 if (p->encmethods)
07866 ast_set_flag64(p, IAX_ENCRYPTED);
07867
07868 return res;
07869 }
07870
07871 static int authenticate_verify(struct chan_iax2_pvt *p, struct iax_ies *ies)
07872 {
07873 char requeststr[256];
07874 char md5secret[256] = "";
07875 char secret[256] = "";
07876 char rsasecret[256] = "";
07877 int res = -1;
07878 int x;
07879 struct iax2_user *user, tmp_user = {
07880 .name = p->username,
07881 };
07882
07883 if (p->authrej) {
07884 return res;
07885 }
07886 user = ao2_find(users, &tmp_user, OBJ_POINTER);
07887 if (user) {
07888 if (ast_test_flag64(p, IAX_MAXAUTHREQ)) {
07889 ast_atomic_fetchadd_int(&user->curauthreq, -1);
07890 ast_clear_flag64(p, IAX_MAXAUTHREQ);
07891 }
07892 ast_string_field_set(p, host, user->name);
07893 user = user_unref(user);
07894 }
07895 if (ast_test_flag64(p, IAX_FORCE_ENCRYPT) && !p->encmethods) {
07896 ast_log(LOG_NOTICE, "Call Terminated, Incoming call is unencrypted while force encrypt is enabled.\n");
07897 return res;
07898 }
07899 if (!ast_test_flag(&p->state, IAX_STATE_AUTHENTICATED))
07900 return res;
07901 if (ies->password)
07902 ast_copy_string(secret, ies->password, sizeof(secret));
07903 if (ies->md5_result)
07904 ast_copy_string(md5secret, ies->md5_result, sizeof(md5secret));
07905 if (ies->rsa_result)
07906 ast_copy_string(rsasecret, ies->rsa_result, sizeof(rsasecret));
07907 if ((p->authmethods & IAX_AUTH_RSA) && !ast_strlen_zero(rsasecret) && !ast_strlen_zero(p->inkeys)) {
07908 struct ast_key *key;
07909 char *keyn;
07910 char tmpkey[256];
07911 char *stringp=NULL;
07912 ast_copy_string(tmpkey, p->inkeys, sizeof(tmpkey));
07913 stringp=tmpkey;
07914 keyn = strsep(&stringp, ":");
07915 while(keyn) {
07916 key = ast_key_get(keyn, AST_KEY_PUBLIC);
07917 if (key && !ast_check_signature(key, p->challenge, rsasecret)) {
07918 res = 0;
07919 break;
07920 } else if (!key)
07921 ast_log(LOG_WARNING, "requested inkey '%s' for RSA authentication does not exist\n", keyn);
07922 keyn = strsep(&stringp, ":");
07923 }
07924 } else if (p->authmethods & IAX_AUTH_MD5) {
07925 struct MD5Context md5;
07926 unsigned char digest[16];
07927 char *tmppw, *stringp;
07928
07929 tmppw = ast_strdupa(p->secret);
07930 stringp = tmppw;
07931 while((tmppw = strsep(&stringp, ";"))) {
07932 MD5Init(&md5);
07933 MD5Update(&md5, (unsigned char *)p->challenge, strlen(p->challenge));
07934 MD5Update(&md5, (unsigned char *)tmppw, strlen(tmppw));
07935 MD5Final(digest, &md5);
07936
07937 for (x=0;x<16;x++)
07938 sprintf(requeststr + (x << 1), "%2.2x", digest[x]);
07939 if (!strcasecmp(requeststr, md5secret)) {
07940 res = 0;
07941 break;
07942 }
07943 }
07944 } else if (p->authmethods & IAX_AUTH_PLAINTEXT) {
07945 if (!strcmp(secret, p->secret))
07946 res = 0;
07947 }
07948 return res;
07949 }
07950
07951
07952 static int register_verify(int callno, struct sockaddr_in *sin, struct iax_ies *ies)
07953 {
07954 char requeststr[256] = "";
07955 char peer[256] = "";
07956 char md5secret[256] = "";
07957 char rsasecret[256] = "";
07958 char secret[256] = "";
07959 struct iax2_peer *p = NULL;
07960 struct ast_key *key;
07961 char *keyn;
07962 int x;
07963 int expire = 0;
07964 int res = -1;
07965 struct ast_sockaddr addr;
07966
07967 ast_clear_flag(&iaxs[callno]->state, IAX_STATE_AUTHENTICATED);
07968
07969 if (ies->username)
07970 ast_copy_string(peer, ies->username, sizeof(peer));
07971 if (ies->password)
07972 ast_copy_string(secret, ies->password, sizeof(secret));
07973 if (ies->md5_result)
07974 ast_copy_string(md5secret, ies->md5_result, sizeof(md5secret));
07975 if (ies->rsa_result)
07976 ast_copy_string(rsasecret, ies->rsa_result, sizeof(rsasecret));
07977 if (ies->refresh)
07978 expire = ies->refresh;
07979
07980 if (ast_strlen_zero(peer)) {
07981 ast_log(LOG_NOTICE, "Empty registration from %s\n", ast_inet_ntoa(sin->sin_addr));
07982 return -1;
07983 }
07984
07985
07986 ast_mutex_unlock(&iaxsl[callno]);
07987 p = find_peer(peer, 1);
07988 ast_mutex_lock(&iaxsl[callno]);
07989 if (!p || !iaxs[callno]) {
07990 if (iaxs[callno]) {
07991 int plaintext = ((last_authmethod & IAX_AUTH_PLAINTEXT) | (iaxs[callno]->authmethods & IAX_AUTH_PLAINTEXT));
07992
07993 ast_string_field_set(iaxs[callno], secret, "badsecret");
07994
07995
07996
07997
07998
07999
08000
08001
08002
08003 if (ast_strlen_zero(iaxs[callno]->challenge) &&
08004 !(!ast_strlen_zero(secret) && plaintext)) {
08005
08006 res = 0;
08007 }
08008 }
08009 if (authdebug && !p)
08010 ast_log(LOG_NOTICE, "No registration for peer '%s' (from %s)\n", peer, ast_inet_ntoa(sin->sin_addr));
08011 goto return_unref;
08012 }
08013
08014 if (!ast_test_flag64(p, IAX_DYNAMIC)) {
08015 if (authdebug)
08016 ast_log(LOG_NOTICE, "Peer '%s' is not dynamic (from %s)\n", peer, ast_inet_ntoa(sin->sin_addr));
08017 goto return_unref;
08018 }
08019
08020 ast_sockaddr_from_sin(&addr, sin);
08021 if (!ast_apply_ha(p->ha, &addr)) {
08022 if (authdebug)
08023 ast_log(LOG_NOTICE, "Host %s denied access to register peer '%s'\n", ast_inet_ntoa(sin->sin_addr), p->name);
08024 goto return_unref;
08025 }
08026 ast_string_field_set(iaxs[callno], secret, p->secret);
08027 ast_string_field_set(iaxs[callno], inkeys, p->inkeys);
08028
08029 if (!ast_strlen_zero(rsasecret) && (p->authmethods & IAX_AUTH_RSA) && !ast_strlen_zero(iaxs[callno]->challenge)) {
08030 if (!ast_strlen_zero(p->inkeys)) {
08031 char tmpkeys[256];
08032 char *stringp=NULL;
08033 ast_copy_string(tmpkeys, p->inkeys, sizeof(tmpkeys));
08034 stringp=tmpkeys;
08035 keyn = strsep(&stringp, ":");
08036 while(keyn) {
08037 key = ast_key_get(keyn, AST_KEY_PUBLIC);
08038 if (key && !ast_check_signature(key, iaxs[callno]->challenge, rsasecret)) {
08039 ast_set_flag(&iaxs[callno]->state, IAX_STATE_AUTHENTICATED);
08040 break;
08041 } else if (!key)
08042 ast_log(LOG_WARNING, "requested inkey '%s' does not exist\n", keyn);
08043 keyn = strsep(&stringp, ":");
08044 }
08045 if (!keyn) {
08046 if (authdebug)
08047 ast_log(LOG_NOTICE, "Host %s failed RSA authentication with inkeys '%s'\n", peer, p->inkeys);
08048 goto return_unref;
08049 }
08050 } else {
08051 if (authdebug)
08052 ast_log(LOG_NOTICE, "Host '%s' trying to do RSA authentication, but we have no inkeys\n", peer);
08053 goto return_unref;
08054 }
08055 } else if (!ast_strlen_zero(md5secret) && (p->authmethods & IAX_AUTH_MD5) && !ast_strlen_zero(iaxs[callno]->challenge)) {
08056 struct MD5Context md5;
08057 unsigned char digest[16];
08058 char *tmppw, *stringp;
08059
08060 tmppw = ast_strdupa(p->secret);
08061 stringp = tmppw;
08062 while((tmppw = strsep(&stringp, ";"))) {
08063 MD5Init(&md5);
08064 MD5Update(&md5, (unsigned char *)iaxs[callno]->challenge, strlen(iaxs[callno]->challenge));
08065 MD5Update(&md5, (unsigned char *)tmppw, strlen(tmppw));
08066 MD5Final(digest, &md5);
08067 for (x=0;x<16;x++)
08068 sprintf(requeststr + (x << 1), "%2.2x", digest[x]);
08069 if (!strcasecmp(requeststr, md5secret))
08070 break;
08071 }
08072 if (tmppw) {
08073 ast_set_flag(&iaxs[callno]->state, IAX_STATE_AUTHENTICATED);
08074 } else {
08075 if (authdebug)
08076 ast_log(LOG_NOTICE, "Host %s failed MD5 authentication for '%s' (%s != %s)\n", ast_inet_ntoa(sin->sin_addr), p->name, requeststr, md5secret);
08077 goto return_unref;
08078 }
08079 } else if (!ast_strlen_zero(secret) && (p->authmethods & IAX_AUTH_PLAINTEXT)) {
08080
08081 if (strcmp(secret, p->secret)) {
08082 if (authdebug)
08083 ast_log(LOG_NOTICE, "Host %s did not provide proper plaintext password for '%s'\n", ast_inet_ntoa(sin->sin_addr), p->name);
08084 goto return_unref;
08085 } else
08086 ast_set_flag(&iaxs[callno]->state, IAX_STATE_AUTHENTICATED);
08087 } else if (!ast_strlen_zero(iaxs[callno]->challenge) && ast_strlen_zero(md5secret) && ast_strlen_zero(rsasecret)) {
08088
08089 goto return_unref;
08090 }
08091 ast_devstate_changed(AST_DEVICE_UNKNOWN, AST_DEVSTATE_CACHABLE, "IAX2/%s", p->name);
08092
08093
08094 res = 0;
08095
08096 return_unref:
08097 if (iaxs[callno]) {
08098 ast_string_field_set(iaxs[callno], peer, peer);
08099
08100
08101 if (expire && (expire < iaxs[callno]->expiry)) {
08102 iaxs[callno]->expiry = expire;
08103 }
08104 }
08105
08106 if (p) {
08107 peer_unref(p);
08108 }
08109 return res;
08110 }
08111
08112 static int authenticate(const char *challenge, const char *secret, const char *keyn, int authmethods, struct iax_ie_data *ied, struct sockaddr_in *sin, struct chan_iax2_pvt *pvt)
08113 {
08114 int res = -1;
08115 int x;
08116 if (!ast_strlen_zero(keyn)) {
08117 if (!(authmethods & IAX_AUTH_RSA)) {
08118 if (ast_strlen_zero(secret))
08119 ast_log(LOG_NOTICE, "Asked to authenticate to %s with an RSA key, but they don't allow RSA authentication\n", ast_inet_ntoa(sin->sin_addr));
08120 } else if (ast_strlen_zero(challenge)) {
08121 ast_log(LOG_NOTICE, "No challenge provided for RSA authentication to %s\n", ast_inet_ntoa(sin->sin_addr));
08122 } else {
08123 char sig[256];
08124 struct ast_key *key;
08125 key = ast_key_get(keyn, AST_KEY_PRIVATE);
08126 if (!key) {
08127 ast_log(LOG_NOTICE, "Unable to find private key '%s'\n", keyn);
08128 } else {
08129 if (ast_sign(key, (char*)challenge, sig)) {
08130 ast_log(LOG_NOTICE, "Unable to sign challenge with key\n");
08131 res = -1;
08132 } else {
08133 iax_ie_append_str(ied, IAX_IE_RSA_RESULT, sig);
08134 res = 0;
08135 }
08136 }
08137 }
08138 }
08139
08140 if (res && !ast_strlen_zero(secret)) {
08141 if ((authmethods & IAX_AUTH_MD5) && !ast_strlen_zero(challenge)) {
08142 struct MD5Context md5;
08143 unsigned char digest[16];
08144 char digres[128];
08145 MD5Init(&md5);
08146 MD5Update(&md5, (unsigned char *)challenge, strlen(challenge));
08147 MD5Update(&md5, (unsigned char *)secret, strlen(secret));
08148 MD5Final(digest, &md5);
08149
08150 for (x=0;x<16;x++)
08151 sprintf(digres + (x << 1), "%2.2x", digest[x]);
08152 if (pvt) {
08153 build_encryption_keys(digest, pvt);
08154 }
08155 iax_ie_append_str(ied, IAX_IE_MD5_RESULT, digres);
08156 res = 0;
08157 } else if (authmethods & IAX_AUTH_PLAINTEXT) {
08158 iax_ie_append_str(ied, IAX_IE_PASSWORD, secret);
08159 res = 0;
08160 } else
08161 ast_log(LOG_NOTICE, "No way to send secret to peer '%s' (their methods: %d)\n", ast_inet_ntoa(sin->sin_addr), authmethods);
08162 }
08163 return res;
08164 }
08165
08166
08167
08168
08169
08170 static int authenticate_reply(struct chan_iax2_pvt *p, struct sockaddr_in *sin, struct iax_ies *ies, const char *override, const char *okey)
08171 {
08172 struct iax2_peer *peer = NULL;
08173
08174 int res = -1;
08175 int authmethods = 0;
08176 struct iax_ie_data ied;
08177 uint16_t callno = p->callno;
08178
08179 memset(&ied, 0, sizeof(ied));
08180
08181 if (ies->username)
08182 ast_string_field_set(p, username, ies->username);
08183 if (ies->challenge)
08184 ast_string_field_set(p, challenge, ies->challenge);
08185 if (ies->authmethods)
08186 authmethods = ies->authmethods;
08187 if (authmethods & IAX_AUTH_MD5)
08188 merge_encryption(p, ies->encmethods);
08189 else
08190 p->encmethods = 0;
08191
08192
08193 if (!ast_strlen_zero(override) || !ast_strlen_zero(okey)) {
08194
08195 res = authenticate(p->challenge, override, okey, authmethods, &ied, sin, p);
08196 } else {
08197 struct ao2_iterator i = ao2_iterator_init(peers, 0);
08198 while ((peer = ao2_iterator_next(&i))) {
08199 struct sockaddr_in peer_addr;
08200
08201 ast_sockaddr_to_sin(&peer->addr, &peer_addr);
08202
08203 if ((ast_strlen_zero(p->peer) || !strcmp(p->peer, peer->name))
08204
08205 && (ast_strlen_zero(peer->username) || (!strcmp(peer->username, p->username)))
08206
08207 && (!peer_addr.sin_addr.s_addr || ((sin->sin_addr.s_addr & peer->mask.s_addr) == (peer_addr.sin_addr.s_addr & peer->mask.s_addr)))
08208
08209 ) {
08210 res = authenticate(p->challenge, peer->secret, peer->outkey, authmethods, &ied, sin, p);
08211 if (!res) {
08212 peer_unref(peer);
08213 break;
08214 }
08215 }
08216 peer_unref(peer);
08217 }
08218 ao2_iterator_destroy(&i);
08219 if (!peer) {
08220
08221
08222 const char *peer_name = ast_strdupa(p->peer);
08223 ast_mutex_unlock(&iaxsl[callno]);
08224 if ((peer = realtime_peer(peer_name, NULL))) {
08225 ast_mutex_lock(&iaxsl[callno]);
08226 if (!(p = iaxs[callno])) {
08227 peer_unref(peer);
08228 return -1;
08229 }
08230 res = authenticate(p->challenge, peer->secret,peer->outkey, authmethods, &ied, sin, p);
08231 peer_unref(peer);
08232 }
08233 if (!peer) {
08234 ast_mutex_lock(&iaxsl[callno]);
08235 if (!(p = iaxs[callno]))
08236 return -1;
08237 }
08238 }
08239 }
08240
08241 if (ies->encmethods) {
08242 ast_set_flag64(p, IAX_ENCRYPTED | IAX_KEYPOPULATED);
08243 } else if (ast_test_flag64(iaxs[callno], IAX_FORCE_ENCRYPT)) {
08244 ast_log(LOG_NOTICE, "Call initiated without encryption while forceencryption=yes option is set\n");
08245 return -1;
08246 }
08247 if (!res) {
08248 struct ast_datastore *variablestore;
08249 struct ast_variable *var, *prev = NULL;
08250 AST_LIST_HEAD(, ast_var_t) *varlist;
08251 varlist = ast_calloc(1, sizeof(*varlist));
08252 variablestore = ast_datastore_alloc(&iax2_variable_datastore_info, NULL);
08253 if (variablestore && varlist && p->owner) {
08254 variablestore->data = varlist;
08255 variablestore->inheritance = DATASTORE_INHERIT_FOREVER;
08256 AST_LIST_HEAD_INIT(varlist);
08257 for (var = ies->vars; var; var = var->next) {
08258 struct ast_var_t *newvar = ast_var_assign(var->name, var->value);
08259 if (prev)
08260 ast_free(prev);
08261 prev = var;
08262 if (!newvar) {
08263
08264 ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
08265 } else {
08266 AST_LIST_INSERT_TAIL(varlist, newvar, entries);
08267 }
08268 }
08269 if (prev)
08270 ast_free(prev);
08271 ies->vars = NULL;
08272 ast_channel_datastore_add(p->owner, variablestore);
08273 } else {
08274 if (p->owner)
08275 ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
08276 if (variablestore)
08277 ast_datastore_free(variablestore);
08278 if (varlist)
08279 ast_free(varlist);
08280 }
08281 }
08282
08283 if (!res)
08284 res = send_command(p, AST_FRAME_IAX, IAX_COMMAND_AUTHREP, 0, ied.buf, ied.pos, -1);
08285 return res;
08286 }
08287
08288 static int iax2_do_register(struct iax2_registry *reg);
08289
08290 static void __iax2_do_register_s(const void *data)
08291 {
08292 struct iax2_registry *reg = (struct iax2_registry *)data;
08293 reg->expire = -1;
08294 iax2_do_register(reg);
08295 }
08296
08297 static int iax2_do_register_s(const void *data)
08298 {
08299 #ifdef SCHED_MULTITHREADED
08300 if (schedule_action(__iax2_do_register_s, data))
08301 #endif
08302 __iax2_do_register_s(data);
08303 return 0;
08304 }
08305
08306 static int try_transfer(struct chan_iax2_pvt *pvt, struct iax_ies *ies)
08307 {
08308 int newcall = 0;
08309 char newip[256];
08310 struct iax_ie_data ied;
08311 struct sockaddr_in new = { 0, };
08312
08313 memset(&ied, 0, sizeof(ied));
08314 if (ies->apparent_addr)
08315 memmove(&new, ies->apparent_addr, sizeof(new));
08316 if (ies->callno)
08317 newcall = ies->callno;
08318 if (!newcall || !new.sin_addr.s_addr || !new.sin_port) {
08319 ast_log(LOG_WARNING, "Invalid transfer request\n");
08320 return -1;
08321 }
08322 pvt->transfercallno = newcall;
08323 memcpy(&pvt->transfer, &new, sizeof(pvt->transfer));
08324 inet_aton(newip, &pvt->transfer.sin_addr);
08325 pvt->transfer.sin_family = AF_INET;
08326 pvt->transferid = ies->transferid;
08327
08328
08329 if (pvt->transferring == TRANSFER_NONE) {
08330 store_by_transfercallno(pvt);
08331 }
08332 pvt->transferring = TRANSFER_BEGIN;
08333
08334 if (ies->transferid)
08335 iax_ie_append_int(&ied, IAX_IE_TRANSFERID, ies->transferid);
08336 send_command_transfer(pvt, AST_FRAME_IAX, IAX_COMMAND_TXCNT, 0, ied.buf, ied.pos);
08337 return 0;
08338 }
08339
08340 static int complete_dpreply(struct chan_iax2_pvt *pvt, struct iax_ies *ies)
08341 {
08342 char exten[256] = "";
08343 int status = CACHE_FLAG_UNKNOWN, expiry = iaxdefaultdpcache, x, matchmore = 0;
08344 struct iax2_dpcache *dp = NULL;
08345
08346 if (ies->called_number)
08347 ast_copy_string(exten, ies->called_number, sizeof(exten));
08348
08349 if (ies->dpstatus & IAX_DPSTATUS_EXISTS)
08350 status = CACHE_FLAG_EXISTS;
08351 else if (ies->dpstatus & IAX_DPSTATUS_CANEXIST)
08352 status = CACHE_FLAG_CANEXIST;
08353 else if (ies->dpstatus & IAX_DPSTATUS_NONEXISTENT)
08354 status = CACHE_FLAG_NONEXISTENT;
08355
08356 if (ies->refresh)
08357 expiry = ies->refresh;
08358 if (ies->dpstatus & IAX_DPSTATUS_MATCHMORE)
08359 matchmore = CACHE_FLAG_MATCHMORE;
08360
08361 AST_LIST_LOCK(&dpcache);
08362 AST_LIST_TRAVERSE_SAFE_BEGIN(&dpcache, dp, peer_list) {
08363 if (strcmp(dp->exten, exten))
08364 continue;
08365 AST_LIST_REMOVE_CURRENT(peer_list);
08366 dp->callno = 0;
08367 dp->expiry.tv_sec = dp->orig.tv_sec + expiry;
08368 if (dp->flags & CACHE_FLAG_PENDING) {
08369 dp->flags &= ~CACHE_FLAG_PENDING;
08370 dp->flags |= status;
08371 dp->flags |= matchmore;
08372 }
08373
08374 for (x = 0; x < ARRAY_LEN(dp->waiters); x++) {
08375 if (dp->waiters[x] > -1) {
08376 if (write(dp->waiters[x], "asdf", 4) < 0) {
08377 }
08378 }
08379 }
08380 }
08381 AST_LIST_TRAVERSE_SAFE_END;
08382 AST_LIST_UNLOCK(&dpcache);
08383
08384 return 0;
08385 }
08386
08387 static int complete_transfer(int callno, struct iax_ies *ies)
08388 {
08389 int peercallno = 0;
08390 struct chan_iax2_pvt *pvt = iaxs[callno];
08391 struct iax_frame *cur;
08392 jb_frame frame;
08393
08394 if (ies->callno)
08395 peercallno = ies->callno;
08396
08397 if (peercallno < 1) {
08398 ast_log(LOG_WARNING, "Invalid transfer request\n");
08399 return -1;
08400 }
08401 remove_by_transfercallno(pvt);
08402
08403
08404
08405 peercnt_remove_by_addr(&pvt->addr);
08406 peercnt_add(&pvt->transfer);
08407
08408 memcpy(&pvt->addr, &pvt->transfer, sizeof(pvt->addr));
08409 memset(&pvt->transfer, 0, sizeof(pvt->transfer));
08410
08411 pvt->oseqno = 0;
08412 pvt->rseqno = 0;
08413 pvt->iseqno = 0;
08414 pvt->aseqno = 0;
08415
08416 if (pvt->peercallno) {
08417 remove_by_peercallno(pvt);
08418 }
08419 pvt->peercallno = peercallno;
08420
08421 store_by_peercallno(pvt);
08422 pvt->transferring = TRANSFER_NONE;
08423 pvt->svoiceformat = -1;
08424 pvt->voiceformat = 0;
08425 pvt->svideoformat = -1;
08426 pvt->videoformat = 0;
08427 pvt->transfercallno = 0;
08428 memset(&pvt->rxcore, 0, sizeof(pvt->rxcore));
08429 memset(&pvt->offset, 0, sizeof(pvt->offset));
08430
08431 while(jb_getall(pvt->jb,&frame) == JB_OK)
08432 iax2_frame_free(frame.data);
08433 jb_reset(pvt->jb);
08434 pvt->lag = 0;
08435 pvt->last = 0;
08436 pvt->lastsent = 0;
08437 pvt->nextpred = 0;
08438 pvt->pingtime = DEFAULT_RETRY_TIME;
08439 AST_LIST_TRAVERSE(&frame_queue[callno], cur, list) {
08440
08441
08442
08443 cur->retries = -1;
08444 }
08445 return 0;
08446 }
08447
08448
08449 static int iax2_ack_registry(struct iax_ies *ies, struct sockaddr_in *sin, int callno)
08450 {
08451 struct iax2_registry *reg;
08452
08453 char peer[256] = "";
08454 char msgstatus[60];
08455 int refresh = 60;
08456 char ourip[256] = "<Unspecified>";
08457 struct sockaddr_in oldus;
08458 struct sockaddr_in us;
08459 int oldmsgs;
08460 struct sockaddr_in reg_addr;
08461
08462 memset(&us, 0, sizeof(us));
08463 if (ies->apparent_addr) {
08464 memmove(&us, ies->apparent_addr, sizeof(us));
08465 }
08466 if (ies->username) {
08467 ast_copy_string(peer, ies->username, sizeof(peer));
08468 }
08469 if (ies->refresh) {
08470 refresh = ies->refresh;
08471 }
08472 if (ies->calling_number) {
08473
08474 }
08475 reg = iaxs[callno]->reg;
08476 if (!reg) {
08477 ast_log(LOG_WARNING, "Registry acknowledge on unknown registry '%s'\n", peer);
08478 return -1;
08479 }
08480 memcpy(&oldus, ®->us, sizeof(oldus));
08481 oldmsgs = reg->messages;
08482 ast_sockaddr_to_sin(®->addr, ®_addr);
08483 if (inaddrcmp(®_addr, sin)) {
08484 ast_log(LOG_WARNING, "Received unsolicited registry ack from '%s'\n", ast_inet_ntoa(sin->sin_addr));
08485 return -1;
08486 }
08487 memcpy(®->us, &us, sizeof(reg->us));
08488 if (ies->msgcount >= 0) {
08489 reg->messages = ies->msgcount & 0xffff;
08490 }
08491
08492
08493
08494 reg->refresh = refresh;
08495 reg->expire = iax2_sched_replace(reg->expire, sched,
08496 (5 * reg->refresh / 6) * 1000, iax2_do_register_s, reg);
08497 if (inaddrcmp(&oldus, ®->us) || (reg->messages != oldmsgs)) {
08498 if (reg->messages > 255) {
08499 snprintf(msgstatus, sizeof(msgstatus), " with %d new and %d old messages waiting", reg->messages & 0xff, reg->messages >> 8);
08500 } else if (reg->messages > 1) {
08501 snprintf(msgstatus, sizeof(msgstatus), " with %d new messages waiting", reg->messages);
08502 } else if (reg->messages > 0) {
08503 ast_copy_string(msgstatus, " with 1 new message waiting", sizeof(msgstatus));
08504 } else {
08505 ast_copy_string(msgstatus, " with no messages waiting", sizeof(msgstatus));
08506 }
08507 snprintf(ourip, sizeof(ourip), "%s:%d", ast_inet_ntoa(reg->us.sin_addr), ntohs(reg->us.sin_port));
08508 ast_verb(3, "Registered IAX2 to '%s', who sees us as %s%s\n", ast_inet_ntoa(sin->sin_addr), ourip, msgstatus);
08509 manager_event(EVENT_FLAG_SYSTEM, "Registry", "ChannelType: IAX2\r\nDomain: %s\r\nStatus: Registered\r\n", ast_inet_ntoa(sin->sin_addr));
08510 }
08511 reg->regstate = REG_STATE_REGISTERED;
08512 return 0;
08513 }
08514
08515 static int iax2_append_register(const char *hostname, const char *username,
08516 const char *secret, const char *porta)
08517 {
08518 struct iax2_registry *reg;
08519
08520 if (!(reg = ast_calloc(1, sizeof(*reg))))
08521 return -1;
08522
08523 reg->addr.ss.ss_family = AF_INET;
08524 if (ast_dnsmgr_lookup(hostname, ®->addr, ®->dnsmgr, srvlookup ? "_iax._udp" : NULL) < 0) {
08525 ast_free(reg);
08526 return -1;
08527 }
08528
08529 ast_copy_string(reg->username, username, sizeof(reg->username));
08530
08531 if (secret)
08532 ast_copy_string(reg->secret, secret, sizeof(reg->secret));
08533
08534 reg->expire = -1;
08535 reg->refresh = IAX_DEFAULT_REG_EXPIRE;
08536 ast_sockaddr_set_port(®->addr, porta ? atoi(porta) : IAX_DEFAULT_PORTNO);
08537
08538 AST_LIST_LOCK(®istrations);
08539 AST_LIST_INSERT_HEAD(®istrations, reg, entry);
08540 AST_LIST_UNLOCK(®istrations);
08541
08542 return 0;
08543 }
08544
08545 static int iax2_register(const char *value, int lineno)
08546 {
08547 char copy[256];
08548 char *username, *hostname, *secret;
08549 char *porta;
08550 char *stringp=NULL;
08551
08552 if (!value)
08553 return -1;
08554
08555 ast_copy_string(copy, value, sizeof(copy));
08556 stringp = copy;
08557 username = strsep(&stringp, "@");
08558 hostname = strsep(&stringp, "@");
08559
08560 if (!hostname) {
08561 ast_log(LOG_WARNING, "Format for registration is user[:secret]@host[:port] at line %d\n", lineno);
08562 return -1;
08563 }
08564
08565 stringp = username;
08566 username = strsep(&stringp, ":");
08567 secret = strsep(&stringp, ":");
08568 stringp = hostname;
08569 hostname = strsep(&stringp, ":");
08570 porta = strsep(&stringp, ":");
08571
08572 if (porta && !atoi(porta)) {
08573 ast_log(LOG_WARNING, "%s is not a valid port number at line %d\n", porta, lineno);
08574 return -1;
08575 }
08576
08577 return iax2_append_register(hostname, username, secret, porta);
08578 }
08579
08580
08581 static void register_peer_exten(struct iax2_peer *peer, int onoff)
08582 {
08583 char multi[256];
08584 char *stringp, *ext;
08585 if (!ast_strlen_zero(regcontext)) {
08586 ast_copy_string(multi, S_OR(peer->regexten, peer->name), sizeof(multi));
08587 stringp = multi;
08588 while((ext = strsep(&stringp, "&"))) {
08589 if (onoff) {
08590 if (!ast_exists_extension(NULL, regcontext, ext, 1, NULL))
08591 ast_add_extension(regcontext, 1, ext, 1, NULL, NULL,
08592 "Noop", ast_strdup(peer->name), ast_free_ptr, "IAX2");
08593 } else
08594 ast_context_remove_extension(regcontext, ext, 1, NULL);
08595 }
08596 }
08597 }
08598 static void prune_peers(void);
08599
08600 static void unlink_peer(struct iax2_peer *peer)
08601 {
08602 if (peer->expire > -1) {
08603 if (!ast_sched_thread_del(sched, peer->expire)) {
08604 peer->expire = -1;
08605 peer_unref(peer);
08606 }
08607 }
08608
08609 if (peer->pokeexpire > -1) {
08610 if (!ast_sched_thread_del(sched, peer->pokeexpire)) {
08611 peer->pokeexpire = -1;
08612 peer_unref(peer);
08613 }
08614 }
08615
08616 ao2_unlink(peers, peer);
08617 }
08618
08619 static void __expire_registry(const void *data)
08620 {
08621 struct iax2_peer *peer = (struct iax2_peer *) data;
08622
08623 if (!peer)
08624 return;
08625 if (peer->expire == -1) {
08626
08627 return;
08628 }
08629
08630 peer->expire = -1;
08631
08632 ast_debug(1, "Expiring registration for peer '%s'\n", peer->name);
08633 if (ast_test_flag64((&globalflags), IAX_RTUPDATE) && (ast_test_flag64(peer, IAX_TEMPONLY|IAX_RTCACHEFRIENDS)))
08634 realtime_update_peer(peer->name, &peer->addr, 0);
08635 manager_event(EVENT_FLAG_SYSTEM, "PeerStatus", "ChannelType: IAX2\r\nPeer: IAX2/%s\r\nPeerStatus: Unregistered\r\nCause: Expired\r\n", peer->name);
08636
08637 peercnt_modify(0, 0, &peer->addr);
08638
08639 memset(&peer->addr, 0, sizeof(peer->addr));
08640
08641 peer->expiry = min_reg_expire;
08642 if (!ast_test_flag64(peer, IAX_TEMPONLY))
08643 ast_db_del("IAX/Registry", peer->name);
08644 register_peer_exten(peer, 0);
08645 ast_devstate_changed(AST_DEVICE_UNAVAILABLE, AST_DEVSTATE_CACHABLE, "IAX2/%s", peer->name);
08646 if (iax2_regfunk)
08647 iax2_regfunk(peer->name, 0);
08648
08649 if (ast_test_flag64(peer, IAX_RTAUTOCLEAR))
08650 unlink_peer(peer);
08651
08652 peer_unref(peer);
08653 }
08654
08655 static int expire_registry(const void *data)
08656 {
08657 #ifdef SCHED_MULTITHREADED
08658 if (schedule_action(__expire_registry, data))
08659 #endif
08660 __expire_registry(data);
08661 return 0;
08662 }
08663
08664 static int iax2_poke_peer(struct iax2_peer *peer, int heldcall);
08665
08666 static void reg_source_db(struct iax2_peer *p)
08667 {
08668 char data[80];
08669 char *expiry;
08670
08671 if (ast_test_flag64(p, IAX_TEMPONLY) || ast_db_get("IAX/Registry", p->name, data, sizeof(data))) {
08672 return;
08673 }
08674
08675 expiry = strrchr(data, ':');
08676 if (!expiry) {
08677 ast_log(LOG_NOTICE, "IAX/Registry astdb entry missing expiry: '%s'\n", data);
08678 return;
08679 }
08680 *expiry++ = '\0';
08681
08682 if (!ast_sockaddr_parse(&p->addr, data, PARSE_PORT_REQUIRE)) {
08683 ast_log(LOG_NOTICE, "IAX/Registry astdb host:port invalid - '%s'\n", data);
08684 return;
08685 }
08686
08687 p->expiry = atoi(expiry);
08688
08689 ast_verb(3, "Seeding '%s' at %s for %d\n", p->name,
08690 ast_sockaddr_stringify(&p->addr), p->expiry);
08691
08692 iax2_poke_peer(p, 0);
08693 if (p->expire > -1) {
08694 if (!ast_sched_thread_del(sched, p->expire)) {
08695 p->expire = -1;
08696 peer_unref(p);
08697 }
08698 }
08699
08700 ast_devstate_changed(AST_DEVICE_UNKNOWN, AST_DEVSTATE_CACHABLE, "IAX2/%s", p->name);
08701
08702 p->expire = iax2_sched_add(sched, (p->expiry + 10) * 1000, expire_registry, peer_ref(p));
08703 if (p->expire == -1) {
08704 peer_unref(p);
08705 }
08706
08707 if (iax2_regfunk) {
08708 iax2_regfunk(p->name, 1);
08709 }
08710
08711 register_peer_exten(p, 1);
08712 }
08713
08714
08715
08716
08717
08718
08719
08720 static int update_registry(struct sockaddr_in *sin, int callno, char *devtype, int fd, unsigned short refresh)
08721 {
08722
08723 struct iax_ie_data ied = {
08724 .pos = 0,
08725 };
08726 struct iax2_peer *p;
08727 int msgcount;
08728 char data[80];
08729 int version;
08730 const char *peer_name;
08731 int res = -1;
08732 struct ast_sockaddr sockaddr;
08733
08734 ast_sockaddr_from_sin(&sockaddr, sin);
08735
08736 peer_name = ast_strdupa(iaxs[callno]->peer);
08737
08738
08739 ast_mutex_unlock(&iaxsl[callno]);
08740 if (!(p = find_peer(peer_name, 1))) {
08741 ast_mutex_lock(&iaxsl[callno]);
08742 ast_log(LOG_WARNING, "No such peer '%s'\n", peer_name);
08743 return -1;
08744 }
08745 ast_mutex_lock(&iaxsl[callno]);
08746 if (!iaxs[callno])
08747 goto return_unref;
08748
08749 if (ast_test_flag64((&globalflags), IAX_RTUPDATE) && (ast_test_flag64(p, IAX_TEMPONLY|IAX_RTCACHEFRIENDS))) {
08750 if (sin->sin_addr.s_addr) {
08751 time_t nowtime;
08752 time(&nowtime);
08753 realtime_update_peer(peer_name, &sockaddr, nowtime);
08754 } else {
08755 realtime_update_peer(peer_name, &sockaddr, 0);
08756 }
08757 }
08758
08759 if (ast_sockaddr_cmp(&p->addr, &sockaddr)) {
08760 if (iax2_regfunk) {
08761 iax2_regfunk(p->name, 1);
08762 }
08763
08764
08765 peercnt_modify(0, 0, &p->addr);
08766
08767
08768 ast_sockaddr_from_sin(&p->addr, sin);
08769
08770 snprintf(data, sizeof(data), "%s:%d:%d", ast_inet_ntoa(sin->sin_addr), ntohs(sin->sin_port), p->expiry);
08771 if (!ast_test_flag64(p, IAX_TEMPONLY) && sin->sin_addr.s_addr) {
08772 ast_db_put("IAX/Registry", p->name, data);
08773 ast_verb(3, "Registered IAX2 '%s' (%s) at %s:%d\n", p->name,
08774 ast_test_flag(&iaxs[callno]->state, IAX_STATE_AUTHENTICATED) ? "AUTHENTICATED" : "UNAUTHENTICATED", ast_inet_ntoa(sin->sin_addr), ntohs(sin->sin_port));
08775 manager_event(EVENT_FLAG_SYSTEM, "PeerStatus", "ChannelType: IAX2\r\nPeer: IAX2/%s\r\nPeerStatus: Registered\r\n", p->name);
08776 register_peer_exten(p, 1);
08777 ast_devstate_changed(AST_DEVICE_UNKNOWN, AST_DEVSTATE_CACHABLE, "IAX2/%s", p->name);
08778 } else if (!ast_test_flag64(p, IAX_TEMPONLY)) {
08779 ast_verb(3, "Unregistered IAX2 '%s' (%s)\n", p->name,
08780 ast_test_flag(&iaxs[callno]->state, IAX_STATE_AUTHENTICATED) ? "AUTHENTICATED" : "UNAUTHENTICATED");
08781 manager_event(EVENT_FLAG_SYSTEM, "PeerStatus", "ChannelType: IAX2\r\nPeer: IAX2/%s\r\nPeerStatus: Unregistered\r\n", p->name);
08782 register_peer_exten(p, 0);
08783 ast_db_del("IAX/Registry", p->name);
08784 ast_devstate_changed(AST_DEVICE_UNAVAILABLE, AST_DEVSTATE_CACHABLE, "IAX2/%s", p->name);
08785 }
08786
08787
08788 iax2_poke_peer(p, callno);
08789 }
08790
08791
08792 if (p->maxcallno) {
08793 peercnt_modify(1, p->maxcallno, &p->addr);
08794 }
08795
08796
08797 if (!iaxs[callno]) {
08798 res = -1;
08799 goto return_unref;
08800 }
08801
08802
08803 p->sockfd = fd;
08804
08805 if (p->expire > -1) {
08806 if (!ast_sched_thread_del(sched, p->expire)) {
08807 p->expire = -1;
08808 peer_unref(p);
08809 }
08810 }
08811
08812 if (!refresh)
08813 refresh = min_reg_expire;
08814 if (refresh > max_reg_expire) {
08815 ast_log(LOG_NOTICE, "Restricting registration for peer '%s' to %d seconds (requested %d)\n",
08816 p->name, max_reg_expire, refresh);
08817 p->expiry = max_reg_expire;
08818 } else if (refresh < min_reg_expire) {
08819 ast_log(LOG_NOTICE, "Restricting registration for peer '%s' to %d seconds (requested %d)\n",
08820 p->name, min_reg_expire, refresh);
08821 p->expiry = min_reg_expire;
08822 } else {
08823 p->expiry = refresh;
08824 }
08825 if (p->expiry && sin->sin_addr.s_addr) {
08826 p->expire = iax2_sched_add(sched, (p->expiry + 10) * 1000, expire_registry, peer_ref(p));
08827 if (p->expire == -1)
08828 peer_unref(p);
08829 }
08830 iax_ie_append_str(&ied, IAX_IE_USERNAME, p->name);
08831 iax_ie_append_int(&ied, IAX_IE_DATETIME, iax2_datetime(p->zonetag));
08832 if (sin->sin_addr.s_addr) {
08833 struct sockaddr_in peer_addr;
08834
08835 ast_sockaddr_to_sin(&p->addr, &peer_addr);
08836
08837 iax_ie_append_short(&ied, IAX_IE_REFRESH, p->expiry);
08838 iax_ie_append_addr(&ied, IAX_IE_APPARENT_ADDR, &peer_addr);
08839 if (!ast_strlen_zero(p->mailbox)) {
08840 struct ast_event *event;
08841 int new, old;
08842 char *mailbox, *context;
08843
08844 context = mailbox = ast_strdupa(p->mailbox);
08845 strsep(&context, "@");
08846 if (ast_strlen_zero(context))
08847 context = "default";
08848
08849 event = ast_event_get_cached(AST_EVENT_MWI,
08850 AST_EVENT_IE_MAILBOX, AST_EVENT_IE_PLTYPE_STR, mailbox,
08851 AST_EVENT_IE_CONTEXT, AST_EVENT_IE_PLTYPE_STR, context,
08852 AST_EVENT_IE_END);
08853 if (event) {
08854 new = ast_event_get_ie_uint(event, AST_EVENT_IE_NEWMSGS);
08855 old = ast_event_get_ie_uint(event, AST_EVENT_IE_OLDMSGS);
08856 ast_event_destroy(event);
08857 } else {
08858 ast_app_inboxcount(p->mailbox, &new, &old);
08859 }
08860
08861 if (new > 255) {
08862 new = 255;
08863 }
08864 if (old > 255) {
08865 old = 255;
08866 }
08867 msgcount = (old << 8) | new;
08868
08869 iax_ie_append_short(&ied, IAX_IE_MSGCOUNT, msgcount);
08870 }
08871 if (ast_test_flag64(p, IAX_HASCALLERID)) {
08872 iax_ie_append_str(&ied, IAX_IE_CALLING_NUMBER, p->cid_num);
08873 iax_ie_append_str(&ied, IAX_IE_CALLING_NAME, p->cid_name);
08874 }
08875 }
08876 version = iax_check_version(devtype);
08877 if (version)
08878 iax_ie_append_short(&ied, IAX_IE_FIRMWAREVER, version);
08879
08880 res = 0;
08881
08882 return_unref:
08883 peer_unref(p);
08884
08885 return res ? res : send_command_final(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_REGACK, 0, ied.buf, ied.pos, -1);
08886 }
08887
08888 static int registry_authrequest(int callno)
08889 {
08890 struct iax_ie_data ied;
08891 struct iax2_peer *p;
08892 char challenge[10];
08893 const char *peer_name;
08894 int sentauthmethod;
08895
08896 peer_name = ast_strdupa(iaxs[callno]->peer);
08897
08898
08899 ast_mutex_unlock(&iaxsl[callno]);
08900 if ((p = find_peer(peer_name, 1))) {
08901 last_authmethod = p->authmethods;
08902 }
08903
08904 ast_mutex_lock(&iaxsl[callno]);
08905 if (!iaxs[callno])
08906 goto return_unref;
08907
08908 memset(&ied, 0, sizeof(ied));
08909
08910
08911
08912
08913
08914
08915 sentauthmethod = p ? p->authmethods : last_authmethod ? last_authmethod : (IAX_AUTH_MD5 | IAX_AUTH_PLAINTEXT);
08916 if (!p) {
08917 iaxs[callno]->authmethods = sentauthmethod;
08918 }
08919 iax_ie_append_short(&ied, IAX_IE_AUTHMETHODS, sentauthmethod);
08920 if (sentauthmethod & (IAX_AUTH_RSA | IAX_AUTH_MD5)) {
08921
08922 snprintf(challenge, sizeof(challenge), "%d", (int)ast_random());
08923 ast_string_field_set(iaxs[callno], challenge, challenge);
08924 iax_ie_append_str(&ied, IAX_IE_CHALLENGE, iaxs[callno]->challenge);
08925 }
08926 iax_ie_append_str(&ied, IAX_IE_USERNAME, peer_name);
08927
08928 return_unref:
08929 if (p) {
08930 peer_unref(p);
08931 }
08932
08933 return iaxs[callno] ? send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_REGAUTH, 0, ied.buf, ied.pos, -1) : -1;
08934 }
08935
08936 static int registry_rerequest(struct iax_ies *ies, int callno, struct sockaddr_in *sin)
08937 {
08938 struct iax2_registry *reg;
08939
08940 struct iax_ie_data ied;
08941 char peer[256] = "";
08942 char challenge[256] = "";
08943 int res;
08944 int authmethods = 0;
08945 if (ies->authmethods)
08946 authmethods = ies->authmethods;
08947 if (ies->username)
08948 ast_copy_string(peer, ies->username, sizeof(peer));
08949 if (ies->challenge)
08950 ast_copy_string(challenge, ies->challenge, sizeof(challenge));
08951 memset(&ied, 0, sizeof(ied));
08952 reg = iaxs[callno]->reg;
08953 if (reg) {
08954 struct sockaddr_in reg_addr;
08955
08956 ast_sockaddr_to_sin(®->addr, ®_addr);
08957
08958 if (inaddrcmp(®_addr, sin)) {
08959 ast_log(LOG_WARNING, "Received unsolicited registry authenticate request from '%s'\n", ast_inet_ntoa(sin->sin_addr));
08960 return -1;
08961 }
08962 if (ast_strlen_zero(reg->secret)) {
08963 ast_log(LOG_NOTICE, "No secret associated with peer '%s'\n", reg->username);
08964 reg->regstate = REG_STATE_NOAUTH;
08965 return -1;
08966 }
08967 iax_ie_append_str(&ied, IAX_IE_USERNAME, reg->username);
08968 iax_ie_append_short(&ied, IAX_IE_REFRESH, reg->refresh);
08969 if (reg->secret[0] == '[') {
08970 char tmpkey[256];
08971 ast_copy_string(tmpkey, reg->secret + 1, sizeof(tmpkey));
08972 tmpkey[strlen(tmpkey) - 1] = '\0';
08973 res = authenticate(challenge, NULL, tmpkey, authmethods, &ied, sin, NULL);
08974 } else
08975 res = authenticate(challenge, reg->secret, NULL, authmethods, &ied, sin, NULL);
08976 if (!res) {
08977 reg->regstate = REG_STATE_AUTHSENT;
08978 add_empty_calltoken_ie(iaxs[callno], &ied);
08979 return send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_REGREQ, 0, ied.buf, ied.pos, -1);
08980 } else
08981 return -1;
08982 ast_log(LOG_WARNING, "Registry acknowledge on unknown registery '%s'\n", peer);
08983 } else
08984 ast_log(LOG_NOTICE, "Can't reregister without a reg\n");
08985 return -1;
08986 }
08987
08988 static void stop_stuff(int callno)
08989 {
08990 iax2_destroy_helper(iaxs[callno]);
08991 }
08992
08993 static void __auth_reject(const void *nothing)
08994 {
08995
08996 int callno = (int)(long)(nothing);
08997 struct iax_ie_data ied;
08998 ast_mutex_lock(&iaxsl[callno]);
08999 if (iaxs[callno]) {
09000 memset(&ied, 0, sizeof(ied));
09001 if (iaxs[callno]->authfail == IAX_COMMAND_REGREJ) {
09002 iax_ie_append_str(&ied, IAX_IE_CAUSE, "Registration Refused");
09003 iax_ie_append_byte(&ied, IAX_IE_CAUSECODE, AST_CAUSE_FACILITY_REJECTED);
09004 } else if (iaxs[callno]->authfail == IAX_COMMAND_REJECT) {
09005 iax_ie_append_str(&ied, IAX_IE_CAUSE, "No authority found");
09006 iax_ie_append_byte(&ied, IAX_IE_CAUSECODE, AST_CAUSE_FACILITY_NOT_SUBSCRIBED);
09007 }
09008 send_command_final(iaxs[callno], AST_FRAME_IAX, iaxs[callno]->authfail, 0, ied.buf, ied.pos, -1);
09009 }
09010 ast_mutex_unlock(&iaxsl[callno]);
09011 }
09012
09013 static int auth_reject(const void *data)
09014 {
09015 int callno = (int)(long)(data);
09016 ast_mutex_lock(&iaxsl[callno]);
09017 if (iaxs[callno])
09018 iaxs[callno]->authid = -1;
09019 ast_mutex_unlock(&iaxsl[callno]);
09020 #ifdef SCHED_MULTITHREADED
09021 if (schedule_action(__auth_reject, data))
09022 #endif
09023 __auth_reject(data);
09024 return 0;
09025 }
09026
09027 static int auth_fail(int callno, int failcode)
09028 {
09029
09030
09031 if (iaxs[callno]) {
09032 iaxs[callno]->authfail = failcode;
09033 if (delayreject) {
09034 iaxs[callno]->authid = iax2_sched_replace(iaxs[callno]->authid,
09035 sched, 1000, auth_reject, (void *)(long)callno);
09036 } else
09037 auth_reject((void *)(long)callno);
09038 }
09039 return 0;
09040 }
09041
09042 static void __auto_hangup(const void *nothing)
09043 {
09044
09045 int callno = (int)(long)(nothing);
09046 struct iax_ie_data ied;
09047 ast_mutex_lock(&iaxsl[callno]);
09048 if (iaxs[callno]) {
09049 memset(&ied, 0, sizeof(ied));
09050 iax_ie_append_str(&ied, IAX_IE_CAUSE, "Timeout");
09051 iax_ie_append_byte(&ied, IAX_IE_CAUSECODE, AST_CAUSE_NO_USER_RESPONSE);
09052 send_command_final(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_HANGUP, 0, ied.buf, ied.pos, -1);
09053 }
09054 ast_mutex_unlock(&iaxsl[callno]);
09055 }
09056
09057 static int auto_hangup(const void *data)
09058 {
09059 int callno = (int)(long)(data);
09060 ast_mutex_lock(&iaxsl[callno]);
09061 if (iaxs[callno]) {
09062 iaxs[callno]->autoid = -1;
09063 }
09064 ast_mutex_unlock(&iaxsl[callno]);
09065 #ifdef SCHED_MULTITHREADED
09066 if (schedule_action(__auto_hangup, data))
09067 #endif
09068 __auto_hangup(data);
09069 return 0;
09070 }
09071
09072 static void iax2_dprequest(struct iax2_dpcache *dp, int callno)
09073 {
09074 struct iax_ie_data ied;
09075
09076 iaxs[callno]->autoid = iax2_sched_replace(iaxs[callno]->autoid,
09077 sched, 30000, auto_hangup, (void *)(long)callno);
09078 memset(&ied, 0, sizeof(ied));
09079 iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, dp->exten);
09080 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_DPREQ, 0, ied.buf, ied.pos, -1);
09081 dp->flags |= CACHE_FLAG_TRANSMITTED;
09082 }
09083
09084 static int iax2_vnak(int callno)
09085 {
09086 return send_command_immediate(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_VNAK, 0, NULL, 0, iaxs[callno]->iseqno);
09087 }
09088
09089 static void vnak_retransmit(int callno, int last)
09090 {
09091 struct iax_frame *f;
09092
09093 AST_LIST_TRAVERSE(&frame_queue[callno], f, list) {
09094
09095 if (((unsigned char) (f->oseqno - last) < 128) &&
09096 (f->retries >= 0)) {
09097 send_packet(f);
09098 }
09099 }
09100 }
09101
09102 static void __iax2_poke_peer_s(const void *data)
09103 {
09104 struct iax2_peer *peer = (struct iax2_peer *)data;
09105 iax2_poke_peer(peer, 0);
09106 peer_unref(peer);
09107 }
09108
09109 static int iax2_poke_peer_s(const void *data)
09110 {
09111 struct iax2_peer *peer = (struct iax2_peer *)data;
09112 peer->pokeexpire = -1;
09113 #ifdef SCHED_MULTITHREADED
09114 if (schedule_action(__iax2_poke_peer_s, data))
09115 #endif
09116 __iax2_poke_peer_s(data);
09117 return 0;
09118 }
09119
09120 static int send_trunk(struct iax2_trunk_peer *tpeer, struct timeval *now)
09121 {
09122 int res = 0;
09123 struct iax_frame *fr;
09124 struct ast_iax2_meta_hdr *meta;
09125 struct ast_iax2_meta_trunk_hdr *mth;
09126 int calls = 0;
09127
09128
09129 fr = (struct iax_frame *)tpeer->trunkdata;
09130
09131 meta = (struct ast_iax2_meta_hdr *)fr->afdata;
09132 mth = (struct ast_iax2_meta_trunk_hdr *)meta->data;
09133 if (tpeer->trunkdatalen) {
09134
09135 meta->zeros = 0;
09136 meta->metacmd = IAX_META_TRUNK;
09137 if (ast_test_flag64(&globalflags, IAX_TRUNKTIMESTAMPS))
09138 meta->cmddata = IAX_META_TRUNK_MINI;
09139 else
09140 meta->cmddata = IAX_META_TRUNK_SUPERMINI;
09141 mth->ts = htonl(calc_txpeerstamp(tpeer, trunkfreq, now));
09142
09143 fr->direction = DIRECTION_OUTGRESS;
09144 fr->retrans = -1;
09145 fr->transfer = 0;
09146
09147 fr->data = fr->afdata;
09148 fr->datalen = tpeer->trunkdatalen + sizeof(struct ast_iax2_meta_hdr) + sizeof(struct ast_iax2_meta_trunk_hdr);
09149 res = transmit_trunk(fr, &tpeer->addr, tpeer->sockfd);
09150 calls = tpeer->calls;
09151 #if 0
09152 ast_debug(1, "Trunking %d call chunks in %d bytes to %s:%d, ts=%d\n", calls, fr->datalen, ast_inet_ntoa(tpeer->addr.sin_addr), ntohs(tpeer->addr.sin_port), ntohl(mth->ts));
09153 #endif
09154
09155 tpeer->trunkdatalen = 0;
09156 tpeer->calls = 0;
09157 }
09158 if (res < 0)
09159 return res;
09160 return calls;
09161 }
09162
09163 static inline int iax2_trunk_expired(struct iax2_trunk_peer *tpeer, struct timeval *now)
09164 {
09165
09166 if (now->tv_sec > tpeer->trunkact.tv_sec + 5)
09167 return 1;
09168 return 0;
09169 }
09170
09171 static int timing_read(int *id, int fd, short events, void *cbdata)
09172 {
09173 int res, processed = 0, totalcalls = 0;
09174 struct iax2_trunk_peer *tpeer = NULL, *drop = NULL;
09175 struct timeval now = ast_tvnow();
09176
09177 if (iaxtrunkdebug)
09178 ast_verbose("Beginning trunk processing. Trunk queue ceiling is %d bytes per host\n", trunkmaxsize);
09179
09180 if (timer) {
09181 if (ast_timer_ack(timer, 1) < 0) {
09182 ast_log(LOG_ERROR, "Timer failed acknowledge\n");
09183 return 0;
09184 }
09185 }
09186
09187
09188 AST_LIST_LOCK(&tpeers);
09189 AST_LIST_TRAVERSE_SAFE_BEGIN(&tpeers, tpeer, list) {
09190 processed++;
09191 res = 0;
09192 ast_mutex_lock(&tpeer->lock);
09193
09194
09195 if (!drop && iax2_trunk_expired(tpeer, &now)) {
09196
09197
09198 AST_LIST_REMOVE_CURRENT(list);
09199 drop = tpeer;
09200 } else {
09201 res = send_trunk(tpeer, &now);
09202 trunk_timed++;
09203 if (iaxtrunkdebug)
09204 ast_verbose(" - Trunk peer (%s:%d) has %d call chunk%s in transit, %d bytes backloged and has hit a high water mark of %d bytes\n", ast_inet_ntoa(tpeer->addr.sin_addr), ntohs(tpeer->addr.sin_port), res, (res != 1) ? "s" : "", tpeer->trunkdatalen, tpeer->trunkdataalloc);
09205 }
09206 totalcalls += res;
09207 res = 0;
09208 ast_mutex_unlock(&tpeer->lock);
09209 }
09210 AST_LIST_TRAVERSE_SAFE_END;
09211 AST_LIST_UNLOCK(&tpeers);
09212
09213 if (drop) {
09214 ast_mutex_lock(&drop->lock);
09215
09216
09217 ast_debug(1, "Dropping unused iax2 trunk peer '%s:%d'\n", ast_inet_ntoa(drop->addr.sin_addr), ntohs(drop->addr.sin_port));
09218 if (drop->trunkdata) {
09219 ast_free(drop->trunkdata);
09220 drop->trunkdata = NULL;
09221 }
09222 ast_mutex_unlock(&drop->lock);
09223 ast_mutex_destroy(&drop->lock);
09224 ast_free(drop);
09225
09226 }
09227
09228 if (iaxtrunkdebug)
09229 ast_verbose("Ending trunk processing with %d peers and %d call chunks processed\n", processed, totalcalls);
09230 iaxtrunkdebug = 0;
09231
09232 return 1;
09233 }
09234
09235 struct dpreq_data {
09236 int callno;
09237 char context[AST_MAX_EXTENSION];
09238 char callednum[AST_MAX_EXTENSION];
09239 char *callerid;
09240 };
09241
09242 static void dp_lookup(int callno, const char *context, const char *callednum, const char *callerid, int skiplock)
09243 {
09244 unsigned short dpstatus = 0;
09245 struct iax_ie_data ied1;
09246 int mm;
09247
09248 memset(&ied1, 0, sizeof(ied1));
09249 mm = ast_matchmore_extension(NULL, context, callednum, 1, callerid);
09250
09251 if (ast_parking_ext_valid(callednum, NULL, context) || ast_exists_extension(NULL, context, callednum, 1, callerid)) {
09252 dpstatus = IAX_DPSTATUS_EXISTS;
09253 } else if (ast_canmatch_extension(NULL, context, callednum, 1, callerid)) {
09254 dpstatus = IAX_DPSTATUS_CANEXIST;
09255 } else {
09256 dpstatus = IAX_DPSTATUS_NONEXISTENT;
09257 }
09258 if (ast_ignore_pattern(context, callednum))
09259 dpstatus |= IAX_DPSTATUS_IGNOREPAT;
09260 if (mm)
09261 dpstatus |= IAX_DPSTATUS_MATCHMORE;
09262 if (!skiplock)
09263 ast_mutex_lock(&iaxsl[callno]);
09264 if (iaxs[callno]) {
09265 iax_ie_append_str(&ied1, IAX_IE_CALLED_NUMBER, callednum);
09266 iax_ie_append_short(&ied1, IAX_IE_DPSTATUS, dpstatus);
09267 iax_ie_append_short(&ied1, IAX_IE_REFRESH, iaxdefaultdpcache);
09268 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_DPREP, 0, ied1.buf, ied1.pos, -1);
09269 }
09270 if (!skiplock)
09271 ast_mutex_unlock(&iaxsl[callno]);
09272 }
09273
09274 static void *dp_lookup_thread(void *data)
09275 {
09276
09277 struct dpreq_data *dpr = data;
09278 dp_lookup(dpr->callno, dpr->context, dpr->callednum, dpr->callerid, 0);
09279 if (dpr->callerid)
09280 ast_free(dpr->callerid);
09281 ast_free(dpr);
09282 return NULL;
09283 }
09284
09285 static void spawn_dp_lookup(int callno, const char *context, const char *callednum, const char *callerid)
09286 {
09287 pthread_t newthread;
09288 struct dpreq_data *dpr;
09289
09290 if (!(dpr = ast_calloc(1, sizeof(*dpr))))
09291 return;
09292
09293 dpr->callno = callno;
09294 ast_copy_string(dpr->context, context, sizeof(dpr->context));
09295 ast_copy_string(dpr->callednum, callednum, sizeof(dpr->callednum));
09296 if (callerid)
09297 dpr->callerid = ast_strdup(callerid);
09298 if (ast_pthread_create_detached(&newthread, NULL, dp_lookup_thread, dpr)) {
09299 ast_log(LOG_WARNING, "Unable to start lookup thread!\n");
09300 }
09301 }
09302
09303 struct iax_dual {
09304 struct ast_channel *chan1;
09305 struct ast_channel *chan2;
09306 char *park_exten;
09307 char *park_context;
09308 };
09309
09310 static void *iax_park_thread(void *stuff)
09311 {
09312 struct iax_dual *d;
09313 int res;
09314 int ext = 0;
09315
09316 d = stuff;
09317
09318 ast_debug(4, "IAX Park: Transferer channel %s, Transferee %s\n",
09319 d->chan2->name, d->chan1->name);
09320
09321 res = ast_park_call_exten(d->chan1, d->chan2, d->park_exten, d->park_context, 0, &ext);
09322 if (res) {
09323
09324 ast_hangup(d->chan1);
09325 } else {
09326 ast_log(LOG_NOTICE, "Parked on extension '%d'\n", ext);
09327 }
09328 ast_hangup(d->chan2);
09329
09330 ast_free(d->park_exten);
09331 ast_free(d->park_context);
09332 ast_free(d);
09333 return NULL;
09334 }
09335
09336
09337 static int iax_park(struct ast_channel *chan1, struct ast_channel *chan2, const char *park_exten, const char *park_context)
09338 {
09339 struct iax_dual *d;
09340 struct ast_channel *chan1m, *chan2m;
09341 pthread_t th;
09342
09343 chan1m = ast_channel_alloc(0, AST_STATE_DOWN, 0, 0, chan2->accountcode, chan1->exten, chan1->context, chan1->linkedid, chan1->amaflags, "Parking/%s", chan1->name);
09344 chan2m = ast_channel_alloc(0, AST_STATE_DOWN, 0, 0, chan2->accountcode, chan2->exten, chan2->context, chan2->linkedid, chan2->amaflags, "IAXPeer/%s", chan2->name);
09345 d = ast_calloc(1, sizeof(*d));
09346 if (!chan1m || !chan2m || !d) {
09347 if (chan1m) {
09348 ast_hangup(chan1m);
09349 }
09350 if (chan2m) {
09351 ast_hangup(chan2m);
09352 }
09353 ast_free(d);
09354 return -1;
09355 }
09356 d->park_exten = ast_strdup(park_exten);
09357 d->park_context = ast_strdup(park_context);
09358 if (!d->park_exten || !d->park_context) {
09359 ast_hangup(chan1m);
09360 ast_hangup(chan2m);
09361 ast_free(d->park_exten);
09362 ast_free(d->park_context);
09363 ast_free(d);
09364 return -1;
09365 }
09366
09367
09368 chan1m->readformat = chan1->readformat;
09369 chan1m->writeformat = chan1->writeformat;
09370
09371
09372 if (ast_channel_masquerade(chan1m, chan1)) {
09373 ast_hangup(chan1m);
09374 ast_hangup(chan2m);
09375 ast_free(d->park_exten);
09376 ast_free(d->park_context);
09377 ast_free(d);
09378 return -1;
09379 }
09380
09381
09382 ast_copy_string(chan1m->context, chan1->context, sizeof(chan1m->context));
09383 ast_copy_string(chan1m->exten, chan1->exten, sizeof(chan1m->exten));
09384 chan1m->priority = chan1->priority;
09385
09386 ast_do_masquerade(chan1m);
09387
09388
09389
09390
09391
09392 chan2m->readformat = chan2->readformat;
09393 chan2m->writeformat = chan2->writeformat;
09394 ast_string_field_set(chan2m, parkinglot, chan2->parkinglot);
09395
09396
09397 if (ast_channel_masquerade(chan2m, chan2)) {
09398 ast_hangup(chan1m);
09399 ast_hangup(chan2m);
09400 ast_free(d->park_exten);
09401 ast_free(d->park_context);
09402 ast_free(d);
09403 return -1;
09404 }
09405
09406
09407 ast_copy_string(chan2m->context, chan2->context, sizeof(chan2m->context));
09408 ast_copy_string(chan2m->exten, chan2->exten, sizeof(chan2m->exten));
09409 chan2m->priority = chan2->priority;
09410
09411 ast_do_masquerade(chan2m);
09412
09413 d->chan1 = chan1m;
09414 d->chan2 = chan2m;
09415 if (ast_pthread_create_detached_background(&th, NULL, iax_park_thread, d) < 0) {
09416
09417 ast_hangup(chan1m);
09418 ast_hangup(chan2m);
09419 ast_free(d->park_exten);
09420 ast_free(d->park_context);
09421 ast_free(d);
09422 return -1;
09423 }
09424 return 0;
09425 }
09426
09427 static int check_provisioning(struct sockaddr_in *sin, int sockfd, char *si, unsigned int ver)
09428 {
09429 unsigned int ourver;
09430 char rsi[80];
09431 snprintf(rsi, sizeof(rsi), "si-%s", si);
09432 if (iax_provision_version(&ourver, rsi, 1))
09433 return 0;
09434 ast_debug(1, "Service identifier '%s', we think '%08x', they think '%08x'\n", si, ourver, ver);
09435 if (ourver != ver)
09436 iax2_provision(sin, sockfd, NULL, rsi, 1);
09437 return 0;
09438 }
09439
09440 static void construct_rr(struct chan_iax2_pvt *pvt, struct iax_ie_data *iep)
09441 {
09442 jb_info stats;
09443 jb_getinfo(pvt->jb, &stats);
09444
09445 memset(iep, 0, sizeof(*iep));
09446
09447 iax_ie_append_int(iep,IAX_IE_RR_JITTER, stats.jitter);
09448 if(stats.frames_in == 0) stats.frames_in = 1;
09449 iax_ie_append_int(iep,IAX_IE_RR_LOSS, ((0xff & (stats.losspct/1000)) << 24 | (stats.frames_lost & 0x00ffffff)));
09450 iax_ie_append_int(iep,IAX_IE_RR_PKTS, stats.frames_in);
09451 iax_ie_append_short(iep,IAX_IE_RR_DELAY, stats.current - stats.min);
09452 iax_ie_append_int(iep,IAX_IE_RR_DROPPED, stats.frames_dropped);
09453 iax_ie_append_int(iep,IAX_IE_RR_OOO, stats.frames_ooo);
09454 }
09455
09456 static void save_rr(struct iax_frame *fr, struct iax_ies *ies)
09457 {
09458 iaxs[fr->callno]->remote_rr.jitter = ies->rr_jitter;
09459 iaxs[fr->callno]->remote_rr.losspct = ies->rr_loss >> 24;
09460 iaxs[fr->callno]->remote_rr.losscnt = ies->rr_loss & 0xffffff;
09461 iaxs[fr->callno]->remote_rr.packets = ies->rr_pkts;
09462 iaxs[fr->callno]->remote_rr.delay = ies->rr_delay;
09463 iaxs[fr->callno]->remote_rr.dropped = ies->rr_dropped;
09464 iaxs[fr->callno]->remote_rr.ooo = ies->rr_ooo;
09465 }
09466
09467 static void save_osptoken(struct iax_frame *fr, struct iax_ies *ies)
09468 {
09469 int i;
09470 unsigned int length, offset = 0;
09471 char full_osptoken[IAX_MAX_OSPBUFF_SIZE];
09472
09473 for (i = 0; i < IAX_MAX_OSPBLOCK_NUM; i++) {
09474 length = ies->ospblocklength[i];
09475 if (length != 0) {
09476 if (length > IAX_MAX_OSPBLOCK_SIZE) {
09477
09478 offset = 0;
09479 break;
09480 } else {
09481 memcpy(full_osptoken + offset, ies->osptokenblock[i], length);
09482 offset += length;
09483 }
09484 } else {
09485 break;
09486 }
09487 }
09488 *(full_osptoken + offset) = '\0';
09489 if (strlen(full_osptoken) != offset) {
09490
09491 *full_osptoken = '\0';
09492 }
09493
09494 ast_string_field_set(iaxs[fr->callno], osptoken, full_osptoken);
09495 }
09496
09497 static void log_jitterstats(unsigned short callno)
09498 {
09499 int localjitter = -1, localdelay = 0, locallost = -1, locallosspct = -1, localdropped = 0, localooo = -1, localpackets = -1;
09500 jb_info jbinfo;
09501
09502 ast_mutex_lock(&iaxsl[callno]);
09503 if (iaxs[callno] && iaxs[callno]->owner && iaxs[callno]->owner->name) {
09504 if(ast_test_flag64(iaxs[callno], IAX_USEJITTERBUF)) {
09505 jb_getinfo(iaxs[callno]->jb, &jbinfo);
09506 localjitter = jbinfo.jitter;
09507 localdelay = jbinfo.current - jbinfo.min;
09508 locallost = jbinfo.frames_lost;
09509 locallosspct = jbinfo.losspct/1000;
09510 localdropped = jbinfo.frames_dropped;
09511 localooo = jbinfo.frames_ooo;
09512 localpackets = jbinfo.frames_in;
09513 }
09514 ast_debug(3, "JB STATS:%s ping=%d ljitterms=%d ljbdelayms=%d ltotlost=%d lrecentlosspct=%d ldropped=%d looo=%d lrecvd=%d rjitterms=%d rjbdelayms=%d rtotlost=%d rrecentlosspct=%d rdropped=%d rooo=%d rrecvd=%d\n",
09515 iaxs[callno]->owner->name,
09516 iaxs[callno]->pingtime,
09517 localjitter,
09518 localdelay,
09519 locallost,
09520 locallosspct,
09521 localdropped,
09522 localooo,
09523 localpackets,
09524 iaxs[callno]->remote_rr.jitter,
09525 iaxs[callno]->remote_rr.delay,
09526 iaxs[callno]->remote_rr.losscnt,
09527 iaxs[callno]->remote_rr.losspct/1000,
09528 iaxs[callno]->remote_rr.dropped,
09529 iaxs[callno]->remote_rr.ooo,
09530 iaxs[callno]->remote_rr.packets);
09531 manager_event(EVENT_FLAG_REPORTING, "JitterBufStats", "Owner: %s\r\nPing: %d\r\nLocalJitter: %d\r\nLocalJBDelay: %d\r\nLocalTotalLost: %d\r\nLocalLossPercent: %d\r\nLocalDropped: %d\r\nLocalooo: %d\r\nLocalReceived: %d\r\nRemoteJitter: %d\r\nRemoteJBDelay: %d\r\nRemoteTotalLost: %d\r\nRemoteLossPercent: %d\r\nRemoteDropped: %d\r\nRemoteooo: %d\r\nRemoteReceived: %d\r\n",
09532 iaxs[callno]->owner->name,
09533 iaxs[callno]->pingtime,
09534 localjitter,
09535 localdelay,
09536 locallost,
09537 locallosspct,
09538 localdropped,
09539 localooo,
09540 localpackets,
09541 iaxs[callno]->remote_rr.jitter,
09542 iaxs[callno]->remote_rr.delay,
09543 iaxs[callno]->remote_rr.losscnt,
09544 iaxs[callno]->remote_rr.losspct/1000,
09545 iaxs[callno]->remote_rr.dropped,
09546 iaxs[callno]->remote_rr.ooo,
09547 iaxs[callno]->remote_rr.packets);
09548 }
09549 ast_mutex_unlock(&iaxsl[callno]);
09550 }
09551
09552 static int socket_process(struct iax2_thread *thread);
09553
09554
09555
09556
09557 static void handle_deferred_full_frames(struct iax2_thread *thread)
09558 {
09559 struct iax2_pkt_buf *pkt_buf;
09560
09561 ast_mutex_lock(&thread->lock);
09562
09563 while ((pkt_buf = AST_LIST_REMOVE_HEAD(&thread->full_frames, entry))) {
09564 ast_mutex_unlock(&thread->lock);
09565
09566 thread->buf = pkt_buf->buf;
09567 thread->buf_len = pkt_buf->len;
09568 thread->buf_size = pkt_buf->len + 1;
09569
09570 socket_process(thread);
09571
09572 thread->buf = NULL;
09573 ast_free(pkt_buf);
09574
09575 ast_mutex_lock(&thread->lock);
09576 }
09577
09578 ast_mutex_unlock(&thread->lock);
09579 }
09580
09581
09582
09583
09584
09585
09586
09587 static void defer_full_frame(struct iax2_thread *from_here, struct iax2_thread *to_here)
09588 {
09589 struct iax2_pkt_buf *pkt_buf, *cur_pkt_buf;
09590 struct ast_iax2_full_hdr *fh, *cur_fh;
09591
09592 if (!(pkt_buf = ast_calloc(1, sizeof(*pkt_buf) + from_here->buf_len)))
09593 return;
09594
09595 pkt_buf->len = from_here->buf_len;
09596 memcpy(pkt_buf->buf, from_here->buf, pkt_buf->len);
09597
09598 fh = (struct ast_iax2_full_hdr *) pkt_buf->buf;
09599 ast_mutex_lock(&to_here->lock);
09600 AST_LIST_TRAVERSE_SAFE_BEGIN(&to_here->full_frames, cur_pkt_buf, entry) {
09601 cur_fh = (struct ast_iax2_full_hdr *) cur_pkt_buf->buf;
09602 if (fh->oseqno < cur_fh->oseqno) {
09603 AST_LIST_INSERT_BEFORE_CURRENT(pkt_buf, entry);
09604 break;
09605 }
09606 }
09607 AST_LIST_TRAVERSE_SAFE_END
09608
09609 if (!cur_pkt_buf)
09610 AST_LIST_INSERT_TAIL(&to_here->full_frames, pkt_buf, entry);
09611
09612 ast_mutex_unlock(&to_here->lock);
09613 }
09614
09615 static int socket_read(int *id, int fd, short events, void *cbdata)
09616 {
09617 struct iax2_thread *thread;
09618 socklen_t len;
09619 time_t t;
09620 static time_t last_errtime = 0;
09621 struct ast_iax2_full_hdr *fh;
09622
09623 if (!(thread = find_idle_thread())) {
09624 time(&t);
09625 if (t != last_errtime)
09626 ast_debug(1, "Out of idle IAX2 threads for I/O, pausing!\n");
09627 last_errtime = t;
09628 usleep(1);
09629 return 1;
09630 }
09631
09632 len = sizeof(thread->iosin);
09633 thread->iofd = fd;
09634 thread->buf_len = recvfrom(fd, thread->readbuf, sizeof(thread->readbuf), 0, (struct sockaddr *) &thread->iosin, &len);
09635 thread->buf_size = sizeof(thread->readbuf);
09636 thread->buf = thread->readbuf;
09637 if (thread->buf_len < 0) {
09638 if (errno != ECONNREFUSED && errno != EAGAIN)
09639 ast_log(LOG_WARNING, "Error: %s\n", strerror(errno));
09640 handle_error();
09641 thread->iostate = IAX_IOSTATE_IDLE;
09642 signal_condition(&thread->lock, &thread->cond);
09643 return 1;
09644 }
09645 if (test_losspct && ((100.0 * ast_random() / (RAND_MAX + 1.0)) < test_losspct)) {
09646 thread->iostate = IAX_IOSTATE_IDLE;
09647 signal_condition(&thread->lock, &thread->cond);
09648 return 1;
09649 }
09650
09651
09652
09653
09654 fh = (struct ast_iax2_full_hdr *) thread->buf;
09655 if (ntohs(fh->scallno) & IAX_FLAG_FULL) {
09656 struct iax2_thread *cur = NULL;
09657 uint16_t callno = ntohs(fh->scallno) & ~IAX_FLAG_FULL;
09658
09659 AST_LIST_LOCK(&active_list);
09660 AST_LIST_TRAVERSE(&active_list, cur, list) {
09661 if ((cur->ffinfo.callno == callno) &&
09662 !inaddrcmp(&cur->ffinfo.sin, &thread->iosin))
09663 break;
09664 }
09665 if (cur) {
09666
09667
09668 defer_full_frame(thread, cur);
09669 AST_LIST_UNLOCK(&active_list);
09670 thread->iostate = IAX_IOSTATE_IDLE;
09671 signal_condition(&thread->lock, &thread->cond);
09672 return 1;
09673 } else {
09674
09675 thread->ffinfo.callno = callno;
09676 memcpy(&thread->ffinfo.sin, &thread->iosin, sizeof(thread->ffinfo.sin));
09677 thread->ffinfo.type = fh->type;
09678 thread->ffinfo.csub = fh->csub;
09679 AST_LIST_INSERT_HEAD(&active_list, thread, list);
09680 }
09681 AST_LIST_UNLOCK(&active_list);
09682 }
09683
09684
09685 thread->iostate = IAX_IOSTATE_READY;
09686 #ifdef DEBUG_SCHED_MULTITHREAD
09687 ast_copy_string(thread->curfunc, "socket_process", sizeof(thread->curfunc));
09688 #endif
09689 signal_condition(&thread->lock, &thread->cond);
09690
09691 return 1;
09692 }
09693
09694 static int socket_process_meta(int packet_len, struct ast_iax2_meta_hdr *meta, struct sockaddr_in *sin, int sockfd,
09695 struct iax_frame *fr)
09696 {
09697 unsigned char metatype;
09698 struct ast_iax2_meta_trunk_mini *mtm;
09699 struct ast_iax2_meta_trunk_hdr *mth;
09700 struct ast_iax2_meta_trunk_entry *mte;
09701 struct iax2_trunk_peer *tpeer;
09702 unsigned int ts;
09703 void *ptr;
09704 struct timeval rxtrunktime;
09705 struct ast_frame f = { 0, };
09706
09707 if (packet_len < sizeof(*meta)) {
09708 ast_log(LOG_WARNING, "Rejecting packet from '%s.%d' that is flagged as a meta frame but is too short\n",
09709 ast_inet_ntoa(sin->sin_addr), ntohs(sin->sin_port));
09710 return 1;
09711 }
09712
09713 if (meta->metacmd != IAX_META_TRUNK)
09714 return 1;
09715
09716 if (packet_len < (sizeof(*meta) + sizeof(*mth))) {
09717 ast_log(LOG_WARNING, "midget meta trunk packet received (%d of %d min)\n", packet_len,
09718 (int) (sizeof(*meta) + sizeof(*mth)));
09719 return 1;
09720 }
09721 mth = (struct ast_iax2_meta_trunk_hdr *)(meta->data);
09722 ts = ntohl(mth->ts);
09723 metatype = meta->cmddata;
09724 packet_len -= (sizeof(*meta) + sizeof(*mth));
09725 ptr = mth->data;
09726 tpeer = find_tpeer(sin, sockfd);
09727 if (!tpeer) {
09728 ast_log(LOG_WARNING, "Unable to accept trunked packet from '%s:%d': No matching peer\n",
09729 ast_inet_ntoa(sin->sin_addr), ntohs(sin->sin_port));
09730 return 1;
09731 }
09732 tpeer->trunkact = ast_tvnow();
09733 if (!ts || ast_tvzero(tpeer->rxtrunktime))
09734 tpeer->rxtrunktime = tpeer->trunkact;
09735 rxtrunktime = tpeer->rxtrunktime;
09736 ast_mutex_unlock(&tpeer->lock);
09737 while (packet_len >= sizeof(*mte)) {
09738
09739 unsigned short callno, trunked_ts, len;
09740
09741 if (metatype == IAX_META_TRUNK_MINI) {
09742 mtm = (struct ast_iax2_meta_trunk_mini *) ptr;
09743 ptr += sizeof(*mtm);
09744 packet_len -= sizeof(*mtm);
09745 len = ntohs(mtm->len);
09746 callno = ntohs(mtm->mini.callno);
09747 trunked_ts = ntohs(mtm->mini.ts);
09748 } else if (metatype == IAX_META_TRUNK_SUPERMINI) {
09749 mte = (struct ast_iax2_meta_trunk_entry *)ptr;
09750 ptr += sizeof(*mte);
09751 packet_len -= sizeof(*mte);
09752 len = ntohs(mte->len);
09753 callno = ntohs(mte->callno);
09754 trunked_ts = 0;
09755 } else {
09756 ast_log(LOG_WARNING, "Unknown meta trunk cmd from '%s:%d': dropping\n", ast_inet_ntoa(sin->sin_addr), ntohs(sin->sin_port));
09757 break;
09758 }
09759
09760 if (len > packet_len)
09761 break;
09762 fr->callno = find_callno_locked(callno & ~IAX_FLAG_FULL, 0, sin, NEW_PREVENT, sockfd, 0);
09763 if (!fr->callno)
09764 continue;
09765
09766
09767
09768
09769 memset(&f, 0, sizeof(f));
09770 f.frametype = AST_FRAME_VOICE;
09771 if (!iaxs[fr->callno]) {
09772
09773 } else if (iaxs[fr->callno]->voiceformat == 0) {
09774 ast_log(LOG_WARNING, "Received trunked frame before first full voice frame\n");
09775 iax2_vnak(fr->callno);
09776 } else {
09777 f.subclass.codec = iaxs[fr->callno]->voiceformat;
09778 f.datalen = len;
09779 if (f.datalen >= 0) {
09780 if (f.datalen)
09781 f.data.ptr = ptr;
09782 else
09783 f.data.ptr = NULL;
09784 if (trunked_ts)
09785 fr->ts = (iaxs[fr->callno]->last & 0xFFFF0000L) | (trunked_ts & 0xffff);
09786 else
09787 fr->ts = fix_peerts(&rxtrunktime, fr->callno, ts);
09788
09789 if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED)) {
09790 struct iax_frame *duped_fr;
09791
09792
09793 f.src = "IAX2";
09794 f.mallocd = 0;
09795 f.offset = 0;
09796 if (f.datalen && (f.frametype == AST_FRAME_VOICE))
09797 f.samples = ast_codec_get_samples(&f);
09798 else
09799 f.samples = 0;
09800 fr->outoforder = 0;
09801 iax_frame_wrap(fr, &f);
09802 duped_fr = iaxfrdup2(fr);
09803 if (duped_fr)
09804 schedule_delivery(duped_fr, 1, 1, &fr->ts);
09805 if (iaxs[fr->callno] && iaxs[fr->callno]->last < fr->ts)
09806 iaxs[fr->callno]->last = fr->ts;
09807 }
09808 } else {
09809 ast_log(LOG_WARNING, "Datalen < 0?\n");
09810 }
09811 }
09812 ast_mutex_unlock(&iaxsl[fr->callno]);
09813 ptr += len;
09814 packet_len -= len;
09815 }
09816
09817 return 1;
09818 }
09819
09820 static int acf_iaxvar_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
09821 {
09822 struct ast_datastore *variablestore = ast_channel_datastore_find(chan, &iax2_variable_datastore_info, NULL);
09823 AST_LIST_HEAD(, ast_var_t) *varlist;
09824 struct ast_var_t *var;
09825
09826 if (!variablestore) {
09827 *buf = '\0';
09828 return 0;
09829 }
09830 varlist = variablestore->data;
09831
09832 AST_LIST_LOCK(varlist);
09833 AST_LIST_TRAVERSE(varlist, var, entries) {
09834 if (strcmp(var->name, data) == 0) {
09835 ast_copy_string(buf, var->value, len);
09836 break;
09837 }
09838 }
09839 AST_LIST_UNLOCK(varlist);
09840 return 0;
09841 }
09842
09843 static int acf_iaxvar_write(struct ast_channel *chan, const char *cmd, char *data, const char *value)
09844 {
09845 struct ast_datastore *variablestore = ast_channel_datastore_find(chan, &iax2_variable_datastore_info, NULL);
09846 AST_LIST_HEAD(, ast_var_t) *varlist;
09847 struct ast_var_t *var;
09848
09849 if (!variablestore) {
09850 variablestore = ast_datastore_alloc(&iax2_variable_datastore_info, NULL);
09851 if (!variablestore) {
09852 ast_log(LOG_ERROR, "Memory allocation error\n");
09853 return -1;
09854 }
09855 varlist = ast_calloc(1, sizeof(*varlist));
09856 if (!varlist) {
09857 ast_datastore_free(variablestore);
09858 ast_log(LOG_ERROR, "Unable to assign new variable '%s'\n", data);
09859 return -1;
09860 }
09861
09862 AST_LIST_HEAD_INIT(varlist);
09863 variablestore->data = varlist;
09864 variablestore->inheritance = DATASTORE_INHERIT_FOREVER;
09865 ast_channel_datastore_add(chan, variablestore);
09866 } else
09867 varlist = variablestore->data;
09868
09869 AST_LIST_LOCK(varlist);
09870 AST_LIST_TRAVERSE_SAFE_BEGIN(varlist, var, entries) {
09871 if (strcmp(var->name, data) == 0) {
09872 AST_LIST_REMOVE_CURRENT(entries);
09873 ast_var_delete(var);
09874 break;
09875 }
09876 }
09877 AST_LIST_TRAVERSE_SAFE_END;
09878 var = ast_var_assign(data, value);
09879 if (var)
09880 AST_LIST_INSERT_TAIL(varlist, var, entries);
09881 else
09882 ast_log(LOG_ERROR, "Unable to assign new variable '%s'\n", data);
09883 AST_LIST_UNLOCK(varlist);
09884 return 0;
09885 }
09886
09887 static struct ast_custom_function iaxvar_function = {
09888 .name = "IAXVAR",
09889 .read = acf_iaxvar_read,
09890 .write = acf_iaxvar_write,
09891 };
09892
09893 static void set_hangup_source_and_cause(int callno, unsigned char causecode)
09894 {
09895 iax2_lock_owner(callno);
09896 if (iaxs[callno] && iaxs[callno]->owner) {
09897 struct ast_channel *owner;
09898 const char *name;
09899
09900 owner = iaxs[callno]->owner;
09901 if (causecode) {
09902 owner->hangupcause = causecode;
09903 }
09904 name = ast_strdupa(owner->name);
09905 ast_channel_ref(owner);
09906 ast_channel_unlock(owner);
09907 ast_mutex_unlock(&iaxsl[callno]);
09908 ast_set_hangupsource(owner, name, 0);
09909 ast_channel_unref(owner);
09910 ast_mutex_lock(&iaxsl[callno]);
09911 }
09912 }
09913
09914 static int socket_process(struct iax2_thread *thread)
09915 {
09916 struct sockaddr_in sin;
09917 int res;
09918 int updatehistory=1;
09919 int new = NEW_PREVENT;
09920 int dcallno = 0;
09921 char decrypted = 0;
09922 struct ast_iax2_full_hdr *fh = (struct ast_iax2_full_hdr *)thread->buf;
09923 struct ast_iax2_mini_hdr *mh = (struct ast_iax2_mini_hdr *)thread->buf;
09924 struct ast_iax2_meta_hdr *meta = (struct ast_iax2_meta_hdr *)thread->buf;
09925 struct ast_iax2_video_hdr *vh = (struct ast_iax2_video_hdr *)thread->buf;
09926 struct iax_frame *fr;
09927 struct iax_frame *cur;
09928 struct ast_frame f = { 0, };
09929 struct ast_channel *c = NULL;
09930 struct iax2_dpcache *dp;
09931 struct iax2_peer *peer;
09932 struct iax_ies ies;
09933 struct iax_ie_data ied0, ied1;
09934 format_t format;
09935 int fd;
09936 int exists;
09937 int minivid = 0;
09938 char empty[32]="";
09939 struct iax_frame *duped_fr;
09940 char host_pref_buf[128];
09941 char caller_pref_buf[128];
09942 struct ast_codec_pref pref;
09943 char *using_prefs = "mine";
09944
09945
09946 fr = ast_alloca(sizeof(*fr) + 4096);
09947 memset(fr, 0, sizeof(*fr));
09948 fr->afdatalen = 4096;
09949
09950
09951 res = thread->buf_len;
09952 fd = thread->iofd;
09953 memcpy(&sin, &thread->iosin, sizeof(sin));
09954
09955 if (res < sizeof(*mh)) {
09956 ast_log(LOG_WARNING, "midget packet received (%d of %d min)\n", res, (int) sizeof(*mh));
09957 return 1;
09958 }
09959 if ((vh->zeros == 0) && (ntohs(vh->callno) & 0x8000)) {
09960 if (res < sizeof(*vh)) {
09961 ast_log(LOG_WARNING, "Rejecting packet from '%s.%d' that is flagged as a video frame but is too short\n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
09962 return 1;
09963 }
09964
09965
09966 fr->callno = find_callno(ntohs(vh->callno) & ~0x8000, dcallno, &sin, new, fd, 0);
09967 minivid = 1;
09968 } else if ((meta->zeros == 0) && !(ntohs(meta->metacmd) & 0x8000))
09969 return socket_process_meta(res, meta, &sin, fd, fr);
09970
09971 #ifdef DEBUG_SUPPORT
09972 if (res >= sizeof(*fh))
09973 iax_outputframe(NULL, fh, 1, &sin, res - sizeof(*fh));
09974 #endif
09975 if (ntohs(mh->callno) & IAX_FLAG_FULL) {
09976 if (res < sizeof(*fh)) {
09977 ast_log(LOG_WARNING, "Rejecting packet from '%s.%d' that is flagged as a full frame but is too short\n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
09978 return 1;
09979 }
09980
09981
09982 dcallno = ntohs(fh->dcallno) & ~IAX_FLAG_RETRANS;
09983
09984
09985
09986
09987
09988
09989 if ((dcallno != 1) && (fr->callno = find_callno(ntohs(mh->callno) & ~IAX_FLAG_FULL, dcallno, &sin, NEW_PREVENT, fd, 1))) {
09990 ast_mutex_lock(&iaxsl[fr->callno]);
09991 if (iaxs[fr->callno] && ast_test_flag64(iaxs[fr->callno], IAX_ENCRYPTED)) {
09992 if (decrypt_frame(fr->callno, fh, &f, &res)) {
09993 ast_log(LOG_NOTICE, "Packet Decrypt Failed!\n");
09994 ast_mutex_unlock(&iaxsl[fr->callno]);
09995 return 1;
09996 }
09997 decrypted = 1;
09998 }
09999 ast_mutex_unlock(&iaxsl[fr->callno]);
10000 }
10001
10002
10003 f.frametype = fh->type;
10004 if (f.frametype == AST_FRAME_VIDEO) {
10005 f.subclass.codec = uncompress_subclass(fh->csub & ~0x40) | ((fh->csub >> 6) & 0x1);
10006 } else if (f.frametype == AST_FRAME_VOICE) {
10007 f.subclass.codec = uncompress_subclass(fh->csub);
10008 } else {
10009 f.subclass.integer = uncompress_subclass(fh->csub);
10010 }
10011
10012
10013 if (f.frametype == AST_FRAME_IAX && f.subclass.integer == IAX_COMMAND_POKE) {
10014
10015 send_apathetic_reply(1, ntohs(fh->scallno), &sin, IAX_COMMAND_PONG, ntohl(fh->ts), fh->iseqno + 1, fd, NULL);
10016 return 1;
10017 } else if (f.frametype == AST_FRAME_IAX && f.subclass.integer == IAX_COMMAND_ACK && dcallno == 1) {
10018
10019 return 1;
10020 }
10021
10022 f.datalen = res - sizeof(*fh);
10023 if (f.datalen) {
10024 if (f.frametype == AST_FRAME_IAX) {
10025 if (iax_parse_ies(&ies, thread->buf + sizeof(struct ast_iax2_full_hdr), f.datalen)) {
10026 ast_log(LOG_WARNING, "Undecodable frame received from '%s'\n", ast_inet_ntoa(sin.sin_addr));
10027 ast_variables_destroy(ies.vars);
10028 return 1;
10029 }
10030 f.data.ptr = NULL;
10031 f.datalen = 0;
10032 } else {
10033 f.data.ptr = thread->buf + sizeof(struct ast_iax2_full_hdr);
10034 memset(&ies, 0, sizeof(ies));
10035 }
10036 } else {
10037 if (f.frametype == AST_FRAME_IAX)
10038 f.data.ptr = NULL;
10039 else
10040 f.data.ptr = empty;
10041 memset(&ies, 0, sizeof(ies));
10042 }
10043
10044 if (!dcallno && iax2_allow_new(f.frametype, f.subclass.integer, 1)) {
10045
10046 if (handle_call_token(fh, &ies, &sin, fd)) {
10047 ast_variables_destroy(ies.vars);
10048 return 1;
10049 }
10050
10051 if (ies.calltoken && ies.calltokendata) {
10052
10053
10054
10055
10056 new = NEW_ALLOW_CALLTOKEN_VALIDATED;
10057 } else {
10058 new = NEW_ALLOW;
10059 }
10060 }
10061 } else {
10062
10063 f.frametype = AST_FRAME_NULL;
10064 f.subclass.integer = 0;
10065 memset(&ies, 0, sizeof(ies));
10066 }
10067
10068 if (!fr->callno) {
10069 int check_dcallno = 0;
10070
10071
10072
10073
10074
10075
10076
10077
10078
10079 if ((ntohs(mh->callno) & IAX_FLAG_FULL) && ((f.frametype == AST_FRAME_IAX) && (f.subclass.integer == IAX_COMMAND_ACK))) {
10080 check_dcallno = 1;
10081 }
10082
10083 if (!(fr->callno = find_callno(ntohs(mh->callno) & ~IAX_FLAG_FULL, dcallno, &sin, new, fd, check_dcallno))) {
10084 if (f.frametype == AST_FRAME_IAX && f.subclass.integer == IAX_COMMAND_NEW) {
10085 send_apathetic_reply(1, ntohs(fh->scallno), &sin, IAX_COMMAND_REJECT, ntohl(fh->ts), fh->iseqno + 1, fd, NULL);
10086 } else if (f.frametype == AST_FRAME_IAX && (f.subclass.integer == IAX_COMMAND_REGREQ || f.subclass.integer == IAX_COMMAND_REGREL)) {
10087 send_apathetic_reply(1, ntohs(fh->scallno), &sin, IAX_COMMAND_REGREJ, ntohl(fh->ts), fh->iseqno + 1, fd, NULL);
10088 }
10089 ast_variables_destroy(ies.vars);
10090 return 1;
10091 }
10092 }
10093
10094 if (fr->callno > 0)
10095 ast_mutex_lock(&iaxsl[fr->callno]);
10096
10097 if (!fr->callno || !iaxs[fr->callno]) {
10098
10099
10100 if (ntohs(mh->callno) & IAX_FLAG_FULL) {
10101
10102 if (((f.subclass.integer != IAX_COMMAND_INVAL) &&
10103 (f.subclass.integer != IAX_COMMAND_TXCNT) &&
10104 (f.subclass.integer != IAX_COMMAND_TXACC) &&
10105 (f.subclass.integer != IAX_COMMAND_FWDOWNL))||
10106 (f.frametype != AST_FRAME_IAX))
10107 raw_hangup(&sin, ntohs(fh->dcallno) & ~IAX_FLAG_RETRANS, ntohs(mh->callno) & ~IAX_FLAG_FULL,
10108 fd);
10109 }
10110 if (fr->callno > 0)
10111 ast_mutex_unlock(&iaxsl[fr->callno]);
10112 ast_variables_destroy(ies.vars);
10113 return 1;
10114 }
10115 if (ast_test_flag64(iaxs[fr->callno], IAX_ENCRYPTED) && !decrypted) {
10116 if (decrypt_frame(fr->callno, fh, &f, &res)) {
10117 ast_log(LOG_NOTICE, "Packet Decrypt Failed!\n");
10118 ast_variables_destroy(ies.vars);
10119 ast_mutex_unlock(&iaxsl[fr->callno]);
10120 return 1;
10121 }
10122 decrypted = 1;
10123 }
10124
10125 #ifdef DEBUG_SUPPORT
10126 if (decrypted) {
10127 iax_outputframe(NULL, fh, 3, &sin, res - sizeof(*fh));
10128 }
10129 #endif
10130
10131
10132
10133 iaxs[fr->callno]->frames_received++;
10134
10135 if (!inaddrcmp(&sin, &iaxs[fr->callno]->addr) && !minivid &&
10136 f.subclass.integer != IAX_COMMAND_TXCNT &&
10137 f.subclass.integer != IAX_COMMAND_TXACC) {
10138 unsigned short new_peercallno;
10139
10140 new_peercallno = (unsigned short) (ntohs(mh->callno) & ~IAX_FLAG_FULL);
10141 if (new_peercallno && new_peercallno != iaxs[fr->callno]->peercallno) {
10142 if (iaxs[fr->callno]->peercallno) {
10143 remove_by_peercallno(iaxs[fr->callno]);
10144 }
10145 iaxs[fr->callno]->peercallno = new_peercallno;
10146 store_by_peercallno(iaxs[fr->callno]);
10147 }
10148 }
10149 if (ntohs(mh->callno) & IAX_FLAG_FULL) {
10150 if (iaxdebug)
10151 ast_debug(1, "Received packet %d, (%d, %u)\n", fh->oseqno, f.frametype, f.subclass.integer);
10152
10153 fr->oseqno = fh->oseqno;
10154 fr->iseqno = fh->iseqno;
10155 fr->ts = ntohl(fh->ts);
10156 #ifdef IAXTESTS
10157 if (test_resync) {
10158 ast_debug(1, "Simulating frame ts resync, was %u now %u\n", fr->ts, fr->ts + test_resync);
10159 fr->ts += test_resync;
10160 }
10161 #endif
10162 #if 0
10163 if ( (ntohs(fh->dcallno) & IAX_FLAG_RETRANS) ||
10164 ( (f.frametype != AST_FRAME_VOICE) && ! (f.frametype == AST_FRAME_IAX &&
10165 (f.subclass == IAX_COMMAND_NEW ||
10166 f.subclass == IAX_COMMAND_AUTHREQ ||
10167 f.subclass == IAX_COMMAND_ACCEPT ||
10168 f.subclass == IAX_COMMAND_REJECT)) ) )
10169 #endif
10170 if ((ntohs(fh->dcallno) & IAX_FLAG_RETRANS) || (f.frametype != AST_FRAME_VOICE))
10171 updatehistory = 0;
10172 if ((iaxs[fr->callno]->iseqno != fr->oseqno) &&
10173 (iaxs[fr->callno]->iseqno ||
10174 ((f.subclass.integer != IAX_COMMAND_TXCNT) &&
10175 (f.subclass.integer != IAX_COMMAND_TXREADY) &&
10176 (f.subclass.integer != IAX_COMMAND_TXREL) &&
10177 (f.subclass.integer != IAX_COMMAND_UNQUELCH ) &&
10178 (f.subclass.integer != IAX_COMMAND_TXACC)) ||
10179 (f.frametype != AST_FRAME_IAX))) {
10180 if (
10181 ((f.subclass.integer != IAX_COMMAND_ACK) &&
10182 (f.subclass.integer != IAX_COMMAND_INVAL) &&
10183 (f.subclass.integer != IAX_COMMAND_TXCNT) &&
10184 (f.subclass.integer != IAX_COMMAND_TXREADY) &&
10185 (f.subclass.integer != IAX_COMMAND_TXREL) &&
10186 (f.subclass.integer != IAX_COMMAND_UNQUELCH ) &&
10187 (f.subclass.integer != IAX_COMMAND_TXACC) &&
10188 (f.subclass.integer != IAX_COMMAND_VNAK)) ||
10189 (f.frametype != AST_FRAME_IAX)) {
10190
10191 ast_debug(1, "Packet arrived out of order (expecting %d, got %d) (frametype = %d, subclass = %d)\n",
10192 iaxs[fr->callno]->iseqno, fr->oseqno, f.frametype, f.subclass.integer);
10193
10194
10195 if ((unsigned char) (iaxs[fr->callno]->iseqno - fr->oseqno) < 128) {
10196
10197 if ((f.frametype != AST_FRAME_IAX) ||
10198 ((f.subclass.integer != IAX_COMMAND_ACK) && (f.subclass.integer != IAX_COMMAND_INVAL))) {
10199 ast_debug(1, "Acking anyway\n");
10200
10201
10202 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
10203 }
10204 } else {
10205
10206 iax2_vnak(fr->callno);
10207 }
10208 ast_variables_destroy(ies.vars);
10209 ast_mutex_unlock(&iaxsl[fr->callno]);
10210 return 1;
10211 }
10212 } else {
10213
10214 if (((f.subclass.integer != IAX_COMMAND_ACK) &&
10215 (f.subclass.integer != IAX_COMMAND_INVAL) &&
10216 (f.subclass.integer != IAX_COMMAND_TXCNT) &&
10217 (f.subclass.integer != IAX_COMMAND_TXACC) &&
10218 (f.subclass.integer != IAX_COMMAND_VNAK)) ||
10219 (f.frametype != AST_FRAME_IAX))
10220 iaxs[fr->callno]->iseqno++;
10221 }
10222
10223 if (f.frametype == AST_FRAME_TEXT && thread->buf[res - 1] != '\0') {
10224 if (res < thread->buf_size)
10225 thread->buf[res++] = '\0';
10226 else
10227 thread->buf[res - 1] = '\0';
10228 }
10229
10230
10231
10232 if (!inaddrcmp(&sin, &iaxs[fr->callno]->addr) &&
10233 ((f.subclass.integer != IAX_COMMAND_INVAL) ||
10234 (f.frametype != AST_FRAME_IAX))) {
10235 unsigned char x;
10236 int call_to_destroy;
10237
10238 if (iaxs[fr->callno]->rseqno >= iaxs[fr->callno]->oseqno || (fr->iseqno >= iaxs[fr->callno]->rseqno && fr->iseqno < iaxs[fr->callno]->oseqno))
10239 x = fr->iseqno;
10240 else
10241 x = iaxs[fr->callno]->oseqno;
10242 if ((x != iaxs[fr->callno]->oseqno) || (iaxs[fr->callno]->oseqno == fr->iseqno)) {
10243
10244
10245 for (x=iaxs[fr->callno]->rseqno; x != fr->iseqno; x++) {
10246
10247 if (iaxdebug)
10248 ast_debug(1, "Cancelling transmission of packet %d\n", x);
10249 call_to_destroy = 0;
10250 AST_LIST_TRAVERSE(&frame_queue[fr->callno], cur, list) {
10251
10252 if (x == cur->oseqno) {
10253 cur->retries = -1;
10254
10255 if (cur->final)
10256 call_to_destroy = fr->callno;
10257 }
10258 }
10259 if (call_to_destroy) {
10260 if (iaxdebug)
10261 ast_debug(1, "Really destroying %d, having been acked on final message\n", call_to_destroy);
10262 ast_mutex_lock(&iaxsl[call_to_destroy]);
10263 iax2_destroy(call_to_destroy);
10264 ast_mutex_unlock(&iaxsl[call_to_destroy]);
10265 }
10266 }
10267
10268 if (iaxs[fr->callno])
10269 iaxs[fr->callno]->rseqno = fr->iseqno;
10270 else {
10271
10272 ast_variables_destroy(ies.vars);
10273 ast_mutex_unlock(&iaxsl[fr->callno]);
10274 return 1;
10275 }
10276 } else {
10277 ast_debug(1, "Received iseqno %d not within window %d->%d\n", fr->iseqno, iaxs[fr->callno]->rseqno, iaxs[fr->callno]->oseqno);
10278 }
10279 }
10280 if (inaddrcmp(&sin, &iaxs[fr->callno]->addr) &&
10281 ((f.frametype != AST_FRAME_IAX) ||
10282 ((f.subclass.integer != IAX_COMMAND_TXACC) &&
10283 (f.subclass.integer != IAX_COMMAND_TXCNT)))) {
10284
10285 ast_variables_destroy(ies.vars);
10286 ast_mutex_unlock(&iaxsl[fr->callno]);
10287 return 1;
10288 }
10289
10290
10291
10292
10293 if ((f.frametype == AST_FRAME_VOICE) ||
10294 (f.frametype == AST_FRAME_VIDEO) ||
10295 (f.frametype == AST_FRAME_IAX)) {
10296 if (ast_test_flag64(iaxs[fr->callno], IAX_DELAYPBXSTART)) {
10297 ast_clear_flag64(iaxs[fr->callno], IAX_DELAYPBXSTART);
10298 if (!ast_iax2_new(fr->callno, AST_STATE_RING, iaxs[fr->callno]->chosenformat, NULL,
10299 ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_AUTHENTICATED))) {
10300 ast_variables_destroy(ies.vars);
10301 ast_mutex_unlock(&iaxsl[fr->callno]);
10302 return 1;
10303 }
10304 }
10305
10306 if (ies.vars) {
10307 struct ast_datastore *variablestore = NULL;
10308 struct ast_variable *var, *prev = NULL;
10309 AST_LIST_HEAD(, ast_var_t) *varlist;
10310
10311 iax2_lock_owner(fr->callno);
10312 if (!iaxs[fr->callno]) {
10313 ast_variables_destroy(ies.vars);
10314 ast_mutex_unlock(&iaxsl[fr->callno]);
10315 return 1;
10316 }
10317 if ((c = iaxs[fr->callno]->owner)) {
10318 varlist = ast_calloc(1, sizeof(*varlist));
10319 variablestore = ast_datastore_alloc(&iax2_variable_datastore_info, NULL);
10320
10321 if (variablestore && varlist) {
10322 variablestore->data = varlist;
10323 variablestore->inheritance = DATASTORE_INHERIT_FOREVER;
10324 AST_LIST_HEAD_INIT(varlist);
10325 ast_debug(1, "I can haz IAX vars?\n");
10326 for (var = ies.vars; var; var = var->next) {
10327 struct ast_var_t *newvar = ast_var_assign(var->name, var->value);
10328 if (prev) {
10329 ast_free(prev);
10330 }
10331 prev = var;
10332 if (!newvar) {
10333
10334 ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
10335 } else {
10336 AST_LIST_INSERT_TAIL(varlist, newvar, entries);
10337 }
10338 }
10339 if (prev) {
10340 ast_free(prev);
10341 }
10342 ies.vars = NULL;
10343 ast_channel_datastore_add(c, variablestore);
10344 } else {
10345 ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
10346 if (variablestore) {
10347 ast_datastore_free(variablestore);
10348 }
10349 if (varlist) {
10350 ast_free(varlist);
10351 }
10352 }
10353 ast_channel_unlock(c);
10354 } else {
10355
10356
10357 ast_debug(1, "No channel, so populating IAXVARs to the pvt, as an intermediate step.\n");
10358 for (var = ies.vars; var && var->next; var = var->next);
10359 if (var) {
10360 var->next = iaxs[fr->callno]->iaxvars;
10361 iaxs[fr->callno]->iaxvars = ies.vars;
10362 ies.vars = NULL;
10363 }
10364 }
10365 }
10366
10367 if (ies.vars) {
10368 ast_debug(1, "I have IAX variables, but they were not processed\n");
10369 }
10370 }
10371
10372
10373
10374 if ((f.frametype == AST_FRAME_IAX) && (f.subclass.integer != IAX_COMMAND_CALLTOKEN) && iaxs[fr->callno]->hold_signaling) {
10375 send_signaling(iaxs[fr->callno]);
10376 }
10377
10378 if (f.frametype == AST_FRAME_VOICE) {
10379 if (f.subclass.codec != iaxs[fr->callno]->voiceformat) {
10380 iaxs[fr->callno]->voiceformat = f.subclass.codec;
10381 ast_debug(1, "Ooh, voice format changed to '%s'\n", ast_getformatname(f.subclass.codec));
10382 if (iaxs[fr->callno]->owner) {
10383 iax2_lock_owner(fr->callno);
10384 if (iaxs[fr->callno]) {
10385 if (iaxs[fr->callno]->owner) {
10386 format_t orignative;
10387
10388 orignative = iaxs[fr->callno]->owner->nativeformats;
10389 iaxs[fr->callno]->owner->nativeformats = f.subclass.codec;
10390 if (iaxs[fr->callno]->owner->readformat)
10391 ast_set_read_format(iaxs[fr->callno]->owner, iaxs[fr->callno]->owner->readformat);
10392 iaxs[fr->callno]->owner->nativeformats = orignative;
10393 ast_channel_unlock(iaxs[fr->callno]->owner);
10394 }
10395 } else {
10396 ast_debug(1, "Neat, somebody took away the channel at a magical time but i found it!\n");
10397
10398 if (ies.vars) {
10399 ast_variables_destroy(ies.vars);
10400 ast_debug(1, "I can haz iaxvars, but they is no good. :-(\n");
10401 ies.vars = NULL;
10402 }
10403 ast_mutex_unlock(&iaxsl[fr->callno]);
10404 return 1;
10405 }
10406 }
10407 }
10408 }
10409 if (f.frametype == AST_FRAME_VIDEO) {
10410 if (f.subclass.codec != iaxs[fr->callno]->videoformat) {
10411 ast_debug(1, "Ooh, video format changed to %s\n", ast_getformatname(f.subclass.codec & ~0x1LL));
10412 iaxs[fr->callno]->videoformat = f.subclass.codec & ~0x1LL;
10413 }
10414 }
10415 if (f.frametype == AST_FRAME_CONTROL && iaxs[fr->callno]->owner) {
10416 if (f.subclass.integer == AST_CONTROL_BUSY) {
10417 iaxs[fr->callno]->owner->hangupcause = AST_CAUSE_BUSY;
10418 } else if (f.subclass.integer == AST_CONTROL_CONGESTION) {
10419 iaxs[fr->callno]->owner->hangupcause = AST_CAUSE_CONGESTION;
10420 }
10421 }
10422 if (f.frametype == AST_FRAME_IAX) {
10423 ast_sched_thread_del(sched, iaxs[fr->callno]->initid);
10424
10425 if (iaxdebug)
10426 ast_debug(1, "IAX subclass %d received\n", f.subclass.integer);
10427
10428
10429 if (iaxs[fr->callno]->last < fr->ts &&
10430 f.subclass.integer != IAX_COMMAND_ACK &&
10431 f.subclass.integer != IAX_COMMAND_PONG &&
10432 f.subclass.integer != IAX_COMMAND_LAGRP) {
10433 iaxs[fr->callno]->last = fr->ts;
10434 if (iaxdebug)
10435 ast_debug(1, "For call=%d, set last=%d\n", fr->callno, fr->ts);
10436 }
10437 iaxs[fr->callno]->last_iax_message = f.subclass.integer;
10438 if (!iaxs[fr->callno]->first_iax_message) {
10439 iaxs[fr->callno]->first_iax_message = f.subclass.integer;
10440 }
10441 switch(f.subclass.integer) {
10442 case IAX_COMMAND_ACK:
10443
10444 break;
10445 case IAX_COMMAND_QUELCH:
10446 if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED)) {
10447
10448 if (iaxs[fr->callno]->owner) {
10449 ast_manager_event(iaxs[fr->callno]->owner, EVENT_FLAG_CALL, "Hold",
10450 "Status: On\r\n"
10451 "Channel: %s\r\n"
10452 "Uniqueid: %s\r\n",
10453 iaxs[fr->callno]->owner->name,
10454 iaxs[fr->callno]->owner->uniqueid);
10455 }
10456
10457 ast_set_flag64(iaxs[fr->callno], IAX_QUELCH);
10458 if (ies.musiconhold) {
10459 iax2_lock_owner(fr->callno);
10460 if (!iaxs[fr->callno] || !iaxs[fr->callno]->owner) {
10461 break;
10462 }
10463 if (ast_bridged_channel(iaxs[fr->callno]->owner)) {
10464 const char *moh_suggest = iaxs[fr->callno]->mohsuggest;
10465
10466
10467
10468
10469
10470 iax2_queue_control_data(fr->callno, AST_CONTROL_HOLD,
10471 S_OR(moh_suggest, NULL),
10472 !ast_strlen_zero(moh_suggest) ? strlen(moh_suggest) + 1 : 0);
10473 }
10474 ast_channel_unlock(iaxs[fr->callno]->owner);
10475 }
10476 }
10477 break;
10478 case IAX_COMMAND_UNQUELCH:
10479 if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED)) {
10480 iax2_lock_owner(fr->callno);
10481 if (!iaxs[fr->callno]) {
10482 break;
10483 }
10484
10485 if (iaxs[fr->callno]->owner && ast_test_flag64(iaxs[fr->callno], IAX_QUELCH)) {
10486 ast_manager_event(iaxs[fr->callno]->owner, EVENT_FLAG_CALL, "Hold",
10487 "Status: Off\r\n"
10488 "Channel: %s\r\n"
10489 "Uniqueid: %s\r\n",
10490 iaxs[fr->callno]->owner->name,
10491 iaxs[fr->callno]->owner->uniqueid);
10492 }
10493
10494 ast_clear_flag64(iaxs[fr->callno], IAX_QUELCH);
10495 if (!iaxs[fr->callno]->owner) {
10496 break;
10497 }
10498 if (ast_bridged_channel(iaxs[fr->callno]->owner)) {
10499
10500
10501
10502
10503 iax2_queue_control_data(fr->callno, AST_CONTROL_UNHOLD, NULL, 0);
10504 }
10505 ast_channel_unlock(iaxs[fr->callno]->owner);
10506 }
10507 break;
10508 case IAX_COMMAND_TXACC:
10509 if (iaxs[fr->callno]->transferring == TRANSFER_BEGIN) {
10510
10511 AST_LIST_TRAVERSE(&frame_queue[fr->callno], cur, list) {
10512
10513 if (cur->transfer) {
10514 cur->retries = -1;
10515 }
10516 }
10517 memset(&ied1, 0, sizeof(ied1));
10518 iax_ie_append_short(&ied1, IAX_IE_CALLNO, iaxs[fr->callno]->callno);
10519 send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_TXREADY, 0, ied1.buf, ied1.pos, -1);
10520 iaxs[fr->callno]->transferring = TRANSFER_READY;
10521 }
10522 break;
10523 case IAX_COMMAND_NEW:
10524
10525 if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED | IAX_STATE_TBD))
10526 break;
10527 if (ies.provverpres && ies.serviceident && sin.sin_addr.s_addr) {
10528 ast_mutex_unlock(&iaxsl[fr->callno]);
10529 check_provisioning(&sin, fd, ies.serviceident, ies.provver);
10530 ast_mutex_lock(&iaxsl[fr->callno]);
10531 if (!iaxs[fr->callno]) {
10532 break;
10533 }
10534 }
10535
10536 if (ast_test_flag64(iaxs[fr->callno], IAX_TRUNK)) {
10537 int new_callno;
10538 if ((new_callno = make_trunk(fr->callno, 1)) != -1)
10539 fr->callno = new_callno;
10540 }
10541
10542 if (delayreject)
10543 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
10544 if (check_access(fr->callno, &sin, &ies)) {
10545
10546 auth_fail(fr->callno, IAX_COMMAND_REJECT);
10547 if (authdebug)
10548 ast_log(LOG_NOTICE, "Rejected connect attempt from %s, who was trying to reach '%s@%s'\n", ast_inet_ntoa(sin.sin_addr), iaxs[fr->callno]->exten, iaxs[fr->callno]->context);
10549 break;
10550 }
10551 if (ast_strlen_zero(iaxs[fr->callno]->secret) && ast_test_flag64(iaxs[fr->callno], IAX_FORCE_ENCRYPT)) {
10552 auth_fail(fr->callno, IAX_COMMAND_REJECT);
10553 ast_log(LOG_WARNING, "Rejected connect attempt. No secret present while force encrypt enabled.\n");
10554 break;
10555 }
10556 if (strcasecmp(iaxs[fr->callno]->exten, "TBD")) {
10557 const char *context, *exten, *cid_num;
10558
10559 context = ast_strdupa(iaxs[fr->callno]->context);
10560 exten = ast_strdupa(iaxs[fr->callno]->exten);
10561 cid_num = ast_strdupa(iaxs[fr->callno]->cid_num);
10562
10563
10564 ast_mutex_unlock(&iaxsl[fr->callno]);
10565 exists = ast_exists_extension(NULL, context, exten, 1, cid_num);
10566 ast_mutex_lock(&iaxsl[fr->callno]);
10567
10568 if (!iaxs[fr->callno]) {
10569 break;
10570 }
10571 } else
10572 exists = 0;
10573
10574 save_osptoken(fr, &ies);
10575 if (ast_strlen_zero(iaxs[fr->callno]->secret) && ast_strlen_zero(iaxs[fr->callno]->inkeys)) {
10576 if (strcmp(iaxs[fr->callno]->exten, "TBD") && !exists) {
10577 memset(&ied0, 0, sizeof(ied0));
10578 iax_ie_append_str(&ied0, IAX_IE_CAUSE, "No such context/extension");
10579 iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_NO_ROUTE_DESTINATION);
10580 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
10581 if (!iaxs[fr->callno]) {
10582 break;
10583 }
10584 if (authdebug)
10585 ast_log(LOG_NOTICE, "Rejected connect attempt from %s, request '%s@%s' does not exist\n", ast_inet_ntoa(sin.sin_addr), iaxs[fr->callno]->exten, iaxs[fr->callno]->context);
10586 } else {
10587
10588
10589 if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOPREFS)) {
10590 if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)) {
10591 using_prefs = "reqonly";
10592 } else {
10593 using_prefs = "disabled";
10594 }
10595 format = iaxs[fr->callno]->peerformat & iaxs[fr->callno]->capability;
10596 memset(&pref, 0, sizeof(pref));
10597 strcpy(caller_pref_buf, "disabled");
10598 strcpy(host_pref_buf, "disabled");
10599 } else {
10600 using_prefs = "mine";
10601
10602 if (ies.codec_prefs)
10603 ast_codec_pref_convert(&iaxs[fr->callno]->rprefs, ies.codec_prefs, 32, 0);
10604 if (ast_codec_pref_index(&iaxs[fr->callno]->rprefs, 0)) {
10605
10606 if (ast_test_flag64(iaxs[fr->callno], IAX_CODEC_USER_FIRST)) {
10607 pref = iaxs[fr->callno]->rprefs;
10608 using_prefs = "caller";
10609 } else {
10610 pref = iaxs[fr->callno]->prefs;
10611 }
10612 } else
10613 pref = iaxs[fr->callno]->prefs;
10614
10615 format = ast_codec_choose(&pref, iaxs[fr->callno]->capability & iaxs[fr->callno]->peercapability, 0);
10616 ast_codec_pref_string(&iaxs[fr->callno]->rprefs, caller_pref_buf, sizeof(caller_pref_buf) - 1);
10617 ast_codec_pref_string(&iaxs[fr->callno]->prefs, host_pref_buf, sizeof(host_pref_buf) - 1);
10618 }
10619 if (!format) {
10620 if(!ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP))
10621 format = iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability;
10622 if (!format) {
10623 memset(&ied0, 0, sizeof(ied0));
10624 iax_ie_append_str(&ied0, IAX_IE_CAUSE, "Unable to negotiate codec");
10625 iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
10626 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
10627 if (!iaxs[fr->callno]) {
10628 break;
10629 }
10630 if (authdebug) {
10631 char tmp[256], tmp2[256], tmp3[256];
10632 if (ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)) {
10633 ast_log(LOG_NOTICE, "Rejected connect attempt from %s, requested '%s' incompatible with our capability '%s'.\n",
10634 ast_inet_ntoa(sin.sin_addr),
10635 ast_getformatname_multiple(tmp, sizeof(tmp), iaxs[fr->callno]->peerformat),
10636 ast_getformatname_multiple(tmp2, sizeof(tmp2), iaxs[fr->callno]->capability));
10637 } else {
10638 ast_log(LOG_NOTICE, "Rejected connect attempt from %s, requested/capability '%s'/'%s' incompatible with our capability '%s'.\n",
10639 ast_inet_ntoa(sin.sin_addr),
10640 ast_getformatname_multiple(tmp, sizeof(tmp), iaxs[fr->callno]->peerformat),
10641 ast_getformatname_multiple(tmp2, sizeof(tmp2), iaxs[fr->callno]->peercapability),
10642 ast_getformatname_multiple(tmp3, sizeof(tmp3), iaxs[fr->callno]->capability));
10643 }
10644 }
10645 } else {
10646
10647 if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)) {
10648 if(!(iaxs[fr->callno]->peerformat & iaxs[fr->callno]->capability))
10649 format = 0;
10650 } else {
10651 if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOPREFS)) {
10652 using_prefs = ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP) ? "reqonly" : "disabled";
10653 memset(&pref, 0, sizeof(pref));
10654 format = ast_best_codec(iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability);
10655 strcpy(caller_pref_buf,"disabled");
10656 strcpy(host_pref_buf,"disabled");
10657 } else {
10658 using_prefs = "mine";
10659 if (ast_codec_pref_index(&iaxs[fr->callno]->rprefs, 0)) {
10660
10661 if (ast_test_flag64(iaxs[fr->callno], IAX_CODEC_USER_FIRST)) {
10662 pref = iaxs[fr->callno]->prefs;
10663 } else {
10664 pref = iaxs[fr->callno]->rprefs;
10665 using_prefs = "caller";
10666 }
10667 format = ast_codec_choose(&pref, iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability, 1);
10668 } else
10669 format = ast_best_codec(iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability);
10670 }
10671 }
10672
10673 if (!format) {
10674 char tmp[256], tmp2[256], tmp3[256];
10675 memset(&ied0, 0, sizeof(ied0));
10676 iax_ie_append_str(&ied0, IAX_IE_CAUSE, "Unable to negotiate codec");
10677 iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
10678 ast_log(LOG_ERROR, "No best format in '%s'???\n", ast_getformatname_multiple(tmp, sizeof(tmp), iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability));
10679 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
10680 if (!iaxs[fr->callno]) {
10681 break;
10682 }
10683 if (authdebug) {
10684 ast_log(LOG_NOTICE, "Rejected connect attempt from %s, requested/capability '%s'/'%s' incompatible with our capability '%s'.\n",
10685 ast_inet_ntoa(sin.sin_addr),
10686 ast_getformatname_multiple(tmp, sizeof(tmp), iaxs[fr->callno]->peerformat),
10687 ast_getformatname_multiple(tmp2, sizeof(tmp2), iaxs[fr->callno]->peercapability),
10688 ast_getformatname_multiple(tmp3, sizeof(tmp3), iaxs[fr->callno]->capability));
10689 }
10690 ast_set_flag64(iaxs[fr->callno], IAX_ALREADYGONE);
10691 break;
10692 }
10693 }
10694 }
10695 if (format) {
10696
10697 memset(&ied1, 0, sizeof(ied1));
10698 iax_ie_append_int(&ied1, IAX_IE_FORMAT, format);
10699 iax_ie_append_versioned_uint64(&ied1, IAX_IE_FORMAT2, 0, format);
10700 send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACCEPT, 0, ied1.buf, ied1.pos, -1);
10701 if (strcmp(iaxs[fr->callno]->exten, "TBD")) {
10702 ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED);
10703 ast_verb(3, "Accepting UNAUTHENTICATED call from %s:\n"
10704 "%srequested format = %s,\n"
10705 "%srequested prefs = %s,\n"
10706 "%sactual format = %s,\n"
10707 "%shost prefs = %s,\n"
10708 "%spriority = %s\n",
10709 ast_inet_ntoa(sin.sin_addr),
10710 VERBOSE_PREFIX_4,
10711 ast_getformatname(iaxs[fr->callno]->peerformat),
10712 VERBOSE_PREFIX_4,
10713 caller_pref_buf,
10714 VERBOSE_PREFIX_4,
10715 ast_getformatname(format),
10716 VERBOSE_PREFIX_4,
10717 host_pref_buf,
10718 VERBOSE_PREFIX_4,
10719 using_prefs);
10720
10721 iaxs[fr->callno]->chosenformat = format;
10722 ast_set_flag64(iaxs[fr->callno], IAX_DELAYPBXSTART);
10723 } else {
10724 ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_TBD);
10725
10726 ast_verb(3, "Accepted unauthenticated TBD call from %s\n", ast_inet_ntoa(sin.sin_addr));
10727 }
10728 }
10729 }
10730 break;
10731 }
10732 if (iaxs[fr->callno]->authmethods & IAX_AUTH_MD5)
10733 merge_encryption(iaxs[fr->callno],ies.encmethods);
10734 else
10735 iaxs[fr->callno]->encmethods = 0;
10736 if (!authenticate_request(fr->callno) && iaxs[fr->callno])
10737 ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_AUTHENTICATED);
10738 break;
10739 case IAX_COMMAND_DPREQ:
10740
10741 if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_TBD) &&
10742 !ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED) && ies.called_number) {
10743 if (iaxcompat) {
10744
10745 spawn_dp_lookup(fr->callno, iaxs[fr->callno]->context, ies.called_number, iaxs[fr->callno]->cid_num);
10746 } else {
10747
10748 dp_lookup(fr->callno, iaxs[fr->callno]->context, ies.called_number, iaxs[fr->callno]->cid_num, 1);
10749 }
10750 }
10751 break;
10752 case IAX_COMMAND_HANGUP:
10753 ast_set_flag64(iaxs[fr->callno], IAX_ALREADYGONE);
10754 ast_debug(1, "Immediately destroying %d, having received hangup\n", fr->callno);
10755
10756 if (iaxs[fr->callno]->owner) {
10757 set_hangup_source_and_cause(fr->callno, ies.causecode);
10758 if (!iaxs[fr->callno]) {
10759 break;
10760 }
10761 }
10762
10763
10764 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
10765 iax2_destroy(fr->callno);
10766 break;
10767 case IAX_COMMAND_REJECT:
10768
10769 if (iaxs[fr->callno]->owner) {
10770 set_hangup_source_and_cause(fr->callno, ies.causecode);
10771 if (!iaxs[fr->callno]) {
10772 break;
10773 }
10774 }
10775
10776 if (!ast_test_flag64(iaxs[fr->callno], IAX_PROVISION)) {
10777 if (iaxs[fr->callno]->owner && authdebug)
10778 ast_log(LOG_WARNING, "Call rejected by %s: %s\n",
10779 ast_inet_ntoa(iaxs[fr->callno]->addr.sin_addr),
10780 ies.cause ? ies.cause : "<Unknown>");
10781 ast_debug(1, "Immediately destroying %d, having received reject\n",
10782 fr->callno);
10783 }
10784
10785 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK,
10786 fr->ts, NULL, 0, fr->iseqno);
10787 if (!ast_test_flag64(iaxs[fr->callno], IAX_PROVISION))
10788 iaxs[fr->callno]->error = EPERM;
10789 iax2_destroy(fr->callno);
10790 break;
10791 case IAX_COMMAND_TRANSFER:
10792 {
10793 struct ast_channel *bridged_chan;
10794 struct ast_channel *owner;
10795
10796 iax2_lock_owner(fr->callno);
10797 if (!iaxs[fr->callno]) {
10798
10799 break;
10800 }
10801 owner = iaxs[fr->callno]->owner;
10802 bridged_chan = owner ? ast_bridged_channel(owner) : NULL;
10803 if (bridged_chan && ies.called_number) {
10804 const char *context;
10805
10806 context = ast_strdupa(iaxs[fr->callno]->context);
10807
10808 ast_channel_ref(owner);
10809 ast_channel_ref(bridged_chan);
10810 ast_channel_unlock(owner);
10811 ast_mutex_unlock(&iaxsl[fr->callno]);
10812
10813
10814 pbx_builtin_setvar_helper(owner, "BLINDTRANSFER", bridged_chan->name);
10815 pbx_builtin_setvar_helper(bridged_chan, "BLINDTRANSFER", owner->name);
10816
10817
10818 if (ast_parking_ext_valid(ies.called_number, owner, context)) {
10819 ast_debug(1, "Parking call '%s'\n", bridged_chan->name);
10820 if (iax_park(bridged_chan, owner, ies.called_number, context)) {
10821 ast_log(LOG_WARNING, "Failed to park call '%s'\n",
10822 bridged_chan->name);
10823 }
10824 } else {
10825 if (ast_async_goto(bridged_chan, context, ies.called_number, 1)) {
10826 ast_log(LOG_WARNING,
10827 "Async goto of '%s' to '%s@%s' failed\n",
10828 bridged_chan->name, ies.called_number, context);
10829 } else {
10830 ast_debug(1, "Async goto of '%s' to '%s@%s' started\n",
10831 bridged_chan->name, ies.called_number, context);
10832 }
10833 }
10834 ast_channel_unref(owner);
10835 ast_channel_unref(bridged_chan);
10836
10837 ast_mutex_lock(&iaxsl[fr->callno]);
10838 } else {
10839 ast_debug(1, "Async goto not applicable on call %d\n", fr->callno);
10840 if (owner) {
10841 ast_channel_unlock(owner);
10842 }
10843 }
10844
10845 break;
10846 }
10847 case IAX_COMMAND_ACCEPT:
10848
10849 if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED | IAX_STATE_TBD | IAX_STATE_AUTHENTICATED))
10850 break;
10851 if (ast_test_flag64(iaxs[fr->callno], IAX_PROVISION)) {
10852
10853 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
10854 iax2_destroy(fr->callno);
10855 break;
10856 }
10857 if (ies.format) {
10858 iaxs[fr->callno]->peerformat = ies.format;
10859 } else {
10860 if (iaxs[fr->callno]->owner)
10861 iaxs[fr->callno]->peerformat = iaxs[fr->callno]->owner->nativeformats;
10862 else
10863 iaxs[fr->callno]->peerformat = iaxs[fr->callno]->capability;
10864 }
10865 ast_verb(3, "Call accepted by %s (format %s)\n", ast_inet_ntoa(iaxs[fr->callno]->addr.sin_addr), ast_getformatname(iaxs[fr->callno]->peerformat));
10866 if (!(iaxs[fr->callno]->peerformat & iaxs[fr->callno]->capability)) {
10867 memset(&ied0, 0, sizeof(ied0));
10868 iax_ie_append_str(&ied0, IAX_IE_CAUSE, "Unable to negotiate codec");
10869 iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
10870 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
10871 if (!iaxs[fr->callno]) {
10872 break;
10873 }
10874 if (authdebug) {
10875 char tmp1[256], tmp2[256];
10876 ast_log(LOG_NOTICE, "Rejected call to %s, format %s incompatible with our capability %s.\n",
10877 ast_inet_ntoa(sin.sin_addr),
10878 ast_getformatname_multiple(tmp1, sizeof(tmp1), iaxs[fr->callno]->peerformat),
10879 ast_getformatname_multiple(tmp2, sizeof(tmp2), iaxs[fr->callno]->capability));
10880 }
10881 } else {
10882 ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED);
10883 iax2_lock_owner(fr->callno);
10884 if (iaxs[fr->callno] && iaxs[fr->callno]->owner) {
10885
10886 iaxs[fr->callno]->owner->nativeformats = iaxs[fr->callno]->peerformat;
10887 ast_verb(3, "Format for call is %s\n", ast_getformatname(iaxs[fr->callno]->owner->nativeformats));
10888
10889
10890 if (iaxs[fr->callno]->owner->writeformat)
10891 ast_set_write_format(iaxs[fr->callno]->owner, iaxs[fr->callno]->owner->writeformat);
10892 if (iaxs[fr->callno]->owner->readformat)
10893 ast_set_read_format(iaxs[fr->callno]->owner, iaxs[fr->callno]->owner->readformat);
10894 ast_channel_unlock(iaxs[fr->callno]->owner);
10895 }
10896 }
10897 if (iaxs[fr->callno]) {
10898 AST_LIST_LOCK(&dpcache);
10899 AST_LIST_TRAVERSE(&iaxs[fr->callno]->dpentries, dp, peer_list)
10900 if (!(dp->flags & CACHE_FLAG_TRANSMITTED))
10901 iax2_dprequest(dp, fr->callno);
10902 AST_LIST_UNLOCK(&dpcache);
10903 }
10904 break;
10905 case IAX_COMMAND_POKE:
10906
10907 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_PONG, fr->ts, NULL, 0, -1);
10908 break;
10909 case IAX_COMMAND_PING:
10910 {
10911 struct iax_ie_data pingied;
10912 construct_rr(iaxs[fr->callno], &pingied);
10913
10914 send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_PONG, fr->ts, pingied.buf, pingied.pos, -1);
10915 }
10916 break;
10917 case IAX_COMMAND_PONG:
10918
10919 iaxs[fr->callno]->pingtime = calc_timestamp(iaxs[fr->callno], 0, &f) - fr->ts;
10920
10921 save_rr(fr, &ies);
10922
10923
10924 log_jitterstats(fr->callno);
10925
10926 if (iaxs[fr->callno]->peerpoke) {
10927 peer = iaxs[fr->callno]->peerpoke;
10928 if ((peer->lastms < 0) || (peer->historicms > peer->maxms)) {
10929 if (iaxs[fr->callno]->pingtime <= peer->maxms) {
10930 ast_log(LOG_NOTICE, "Peer '%s' is now REACHABLE! Time: %d\n", peer->name, iaxs[fr->callno]->pingtime);
10931 manager_event(EVENT_FLAG_SYSTEM, "PeerStatus", "ChannelType: IAX2\r\nPeer: IAX2/%s\r\nPeerStatus: Reachable\r\nTime: %d\r\n", peer->name, iaxs[fr->callno]->pingtime);
10932 ast_devstate_changed(AST_DEVICE_NOT_INUSE, AST_DEVSTATE_CACHABLE, "IAX2/%s", peer->name);
10933 }
10934 } else if ((peer->historicms > 0) && (peer->historicms <= peer->maxms)) {
10935 if (iaxs[fr->callno]->pingtime > peer->maxms) {
10936 ast_log(LOG_NOTICE, "Peer '%s' is now TOO LAGGED (%d ms)!\n", peer->name, iaxs[fr->callno]->pingtime);
10937 manager_event(EVENT_FLAG_SYSTEM, "PeerStatus", "ChannelType: IAX2\r\nPeer: IAX2/%s\r\nPeerStatus: Lagged\r\nTime: %d\r\n", peer->name, iaxs[fr->callno]->pingtime);
10938 ast_devstate_changed(AST_DEVICE_UNAVAILABLE, AST_DEVSTATE_CACHABLE, "IAX2/%s", peer->name);
10939 }
10940 }
10941 peer->lastms = iaxs[fr->callno]->pingtime;
10942 if (peer->smoothing && (peer->lastms > -1))
10943 peer->historicms = (iaxs[fr->callno]->pingtime + peer->historicms) / 2;
10944 else if (peer->smoothing && peer->lastms < 0)
10945 peer->historicms = (0 + peer->historicms) / 2;
10946 else
10947 peer->historicms = iaxs[fr->callno]->pingtime;
10948
10949
10950 if (peer->pokeexpire > -1) {
10951 if (!ast_sched_thread_del(sched, peer->pokeexpire)) {
10952 peer_unref(peer);
10953 peer->pokeexpire = -1;
10954 }
10955 }
10956
10957 if ((peer->lastms < 0) || (peer->historicms > peer->maxms))
10958 peer->pokeexpire = iax2_sched_add(sched, peer->pokefreqnotok, iax2_poke_peer_s, peer_ref(peer));
10959 else
10960 peer->pokeexpire = iax2_sched_add(sched, peer->pokefreqok, iax2_poke_peer_s, peer_ref(peer));
10961 if (peer->pokeexpire == -1)
10962 peer_unref(peer);
10963
10964 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
10965
10966 iax2_destroy(fr->callno);
10967 peer->callno = 0;
10968 ast_debug(1, "Peer %s: got pong, lastms %d, historicms %d, maxms %d\n", peer->name, peer->lastms, peer->historicms, peer->maxms);
10969 }
10970 break;
10971 case IAX_COMMAND_LAGRQ:
10972 case IAX_COMMAND_LAGRP:
10973 f.src = "LAGRQ";
10974 f.mallocd = 0;
10975 f.offset = 0;
10976 f.samples = 0;
10977 iax_frame_wrap(fr, &f);
10978 if (f.subclass.integer == IAX_COMMAND_LAGRQ) {
10979
10980 fr->af.subclass.integer = IAX_COMMAND_LAGRP;
10981 iax2_send(iaxs[fr->callno], &fr->af, fr->ts, -1, 0, 0, 0);
10982 } else {
10983
10984 unsigned int ts;
10985
10986 ts = calc_timestamp(iaxs[fr->callno], 0, &fr->af);
10987 iaxs[fr->callno]->lag = ts - fr->ts;
10988 if (iaxdebug)
10989 ast_debug(1, "Peer %s lag measured as %dms\n",
10990 ast_inet_ntoa(iaxs[fr->callno]->addr.sin_addr), iaxs[fr->callno]->lag);
10991 }
10992 break;
10993 case IAX_COMMAND_AUTHREQ:
10994 if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED | IAX_STATE_TBD)) {
10995 ast_log(LOG_WARNING, "Call on %s is already up, can't start on it\n", iaxs[fr->callno]->owner ? iaxs[fr->callno]->owner->name : "<Unknown>");
10996 break;
10997 }
10998 if (authenticate_reply(iaxs[fr->callno], &iaxs[fr->callno]->addr, &ies, iaxs[fr->callno]->secret, iaxs[fr->callno]->outkey)) {
10999 struct ast_frame hangup_fr = { .frametype = AST_FRAME_CONTROL,
11000 .subclass.integer = AST_CONTROL_HANGUP,
11001 };
11002 ast_log(LOG_WARNING,
11003 "I don't know how to authenticate %s to %s\n",
11004 ies.username ? ies.username : "<unknown>", ast_inet_ntoa(iaxs[fr->callno]->addr.sin_addr));
11005 iax2_queue_frame(fr->callno, &hangup_fr);
11006 }
11007 break;
11008 case IAX_COMMAND_AUTHREP:
11009
11010 if (delayreject)
11011 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
11012
11013 if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED | IAX_STATE_TBD)) {
11014 ast_log(LOG_WARNING, "Call on %s is already up, can't start on it\n", iaxs[fr->callno]->owner ? iaxs[fr->callno]->owner->name : "<Unknown>");
11015 break;
11016 }
11017 if (authenticate_verify(iaxs[fr->callno], &ies)) {
11018 if (authdebug)
11019 ast_log(LOG_NOTICE, "Host %s failed to authenticate as %s\n", ast_inet_ntoa(iaxs[fr->callno]->addr.sin_addr), iaxs[fr->callno]->username);
11020 memset(&ied0, 0, sizeof(ied0));
11021 auth_fail(fr->callno, IAX_COMMAND_REJECT);
11022 break;
11023 }
11024 if (strcasecmp(iaxs[fr->callno]->exten, "TBD")) {
11025
11026 exists = ast_exists_extension(NULL, iaxs[fr->callno]->context, iaxs[fr->callno]->exten, 1, iaxs[fr->callno]->cid_num);
11027 } else
11028 exists = 0;
11029 if (strcmp(iaxs[fr->callno]->exten, "TBD") && !exists) {
11030 if (authdebug)
11031 ast_log(LOG_NOTICE, "Rejected connect attempt from %s, request '%s@%s' does not exist\n", ast_inet_ntoa(sin.sin_addr), iaxs[fr->callno]->exten, iaxs[fr->callno]->context);
11032 memset(&ied0, 0, sizeof(ied0));
11033 iax_ie_append_str(&ied0, IAX_IE_CAUSE, "No such context/extension");
11034 iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_NO_ROUTE_DESTINATION);
11035 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
11036 if (!iaxs[fr->callno]) {
11037 break;
11038 }
11039 } else {
11040
11041 if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOPREFS)) {
11042 if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)) {
11043 using_prefs = "reqonly";
11044 } else {
11045 using_prefs = "disabled";
11046 }
11047 format = iaxs[fr->callno]->peerformat & iaxs[fr->callno]->capability;
11048 memset(&pref, 0, sizeof(pref));
11049 strcpy(caller_pref_buf, "disabled");
11050 strcpy(host_pref_buf, "disabled");
11051 } else {
11052 using_prefs = "mine";
11053 if (ies.codec_prefs)
11054 ast_codec_pref_convert(&iaxs[fr->callno]->rprefs, ies.codec_prefs, 32, 0);
11055 if (ast_codec_pref_index(&iaxs[fr->callno]->rprefs, 0)) {
11056 if (ast_test_flag64(iaxs[fr->callno], IAX_CODEC_USER_FIRST)) {
11057 pref = iaxs[fr->callno]->rprefs;
11058 using_prefs = "caller";
11059 } else {
11060 pref = iaxs[fr->callno]->prefs;
11061 }
11062 } else
11063 pref = iaxs[fr->callno]->prefs;
11064 format = ast_codec_choose(&pref, iaxs[fr->callno]->capability & iaxs[fr->callno]->peercapability, 0);
11065 ast_codec_pref_string(&iaxs[fr->callno]->rprefs, caller_pref_buf, sizeof(caller_pref_buf) - 1);
11066 ast_codec_pref_string(&iaxs[fr->callno]->prefs, host_pref_buf, sizeof(host_pref_buf) - 1);
11067 }
11068 if (!format) {
11069 char tmp1[256], tmp2[256], tmp3[256];
11070 if(!ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)) {
11071 ast_debug(1, "We don't do requested format %s, falling back to peer capability '%s'\n",
11072 ast_getformatname(iaxs[fr->callno]->peerformat),
11073 ast_getformatname_multiple(tmp1, sizeof(tmp1), iaxs[fr->callno]->peercapability));
11074 format = iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability;
11075 }
11076 if (!format) {
11077 if (authdebug) {
11078 if (ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)) {
11079 ast_log(LOG_NOTICE, "Rejected connect attempt from %s, requested '%s' incompatible with our capability '%s'.\n", ast_inet_ntoa(sin.sin_addr),
11080 ast_getformatname_multiple(tmp1, sizeof(tmp1), iaxs[fr->callno]->peerformat),
11081 ast_getformatname_multiple(tmp2, sizeof(tmp2), iaxs[fr->callno]->capability));
11082 } else {
11083 ast_log(LOG_NOTICE, "Rejected connect attempt from %s, requested/capability '%s'/'%s' incompatible with our capability '%s'.\n",
11084 ast_inet_ntoa(sin.sin_addr),
11085 ast_getformatname_multiple(tmp1, sizeof(tmp1), iaxs[fr->callno]->peerformat),
11086 ast_getformatname_multiple(tmp2, sizeof(tmp2), iaxs[fr->callno]->peercapability),
11087 ast_getformatname_multiple(tmp3, sizeof(tmp3), iaxs[fr->callno]->capability));
11088 }
11089 }
11090 memset(&ied0, 0, sizeof(ied0));
11091 iax_ie_append_str(&ied0, IAX_IE_CAUSE, "Unable to negotiate codec");
11092 iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
11093 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
11094 if (!iaxs[fr->callno]) {
11095 break;
11096 }
11097 } else {
11098
11099 if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)) {
11100 if(!(iaxs[fr->callno]->peerformat & iaxs[fr->callno]->capability))
11101 format = 0;
11102 } else {
11103 if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOPREFS)) {
11104 using_prefs = ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP) ? "reqonly" : "disabled";
11105 memset(&pref, 0, sizeof(pref));
11106 format = ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP) ?
11107 iaxs[fr->callno]->peerformat : ast_best_codec(iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability);
11108 strcpy(caller_pref_buf,"disabled");
11109 strcpy(host_pref_buf,"disabled");
11110 } else {
11111 using_prefs = "mine";
11112 if (ast_codec_pref_index(&iaxs[fr->callno]->rprefs, 0)) {
11113
11114 if (ast_test_flag64(iaxs[fr->callno], IAX_CODEC_USER_FIRST)) {
11115 pref = iaxs[fr->callno]->prefs;
11116 } else {
11117 pref = iaxs[fr->callno]->rprefs;
11118 using_prefs = "caller";
11119 }
11120 format = ast_codec_choose(&pref, iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability, 1);
11121 } else
11122 format = ast_best_codec(iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability);
11123 }
11124 }
11125 if (!format) {
11126 char tmp1[256], tmp2[256], tmp3[256];
11127 ast_log(LOG_ERROR, "No best format in %s???\n",
11128 ast_getformatname_multiple(tmp1, sizeof(tmp1), iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability));
11129 if (authdebug) {
11130 if (ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)) {
11131 ast_log(LOG_NOTICE, "Rejected connect attempt from %s, requested '%s' incompatible with our capability '%s'.\n",
11132 ast_inet_ntoa(sin.sin_addr),
11133 ast_getformatname_multiple(tmp1, sizeof(tmp1), iaxs[fr->callno]->peerformat),
11134 ast_getformatname_multiple(tmp2, sizeof(tmp2), iaxs[fr->callno]->capability));
11135 } else {
11136 ast_log(LOG_NOTICE, "Rejected connect attempt from %s, requested/capability '%s'/'%s' incompatible with our capability '%s'.\n",
11137 ast_inet_ntoa(sin.sin_addr),
11138 ast_getformatname_multiple(tmp1, sizeof(tmp1), iaxs[fr->callno]->peerformat),
11139 ast_getformatname_multiple(tmp2, sizeof(tmp2), iaxs[fr->callno]->peercapability),
11140 ast_getformatname_multiple(tmp3, sizeof(tmp3), iaxs[fr->callno]->capability));
11141 }
11142 }
11143 memset(&ied0, 0, sizeof(ied0));
11144 iax_ie_append_str(&ied0, IAX_IE_CAUSE, "Unable to negotiate codec");
11145 iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
11146 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
11147 if (!iaxs[fr->callno]) {
11148 break;
11149 }
11150 }
11151 }
11152 }
11153 if (format) {
11154
11155 memset(&ied1, 0, sizeof(ied1));
11156 iax_ie_append_int(&ied1, IAX_IE_FORMAT, format);
11157 iax_ie_append_versioned_uint64(&ied1, IAX_IE_FORMAT2, 0, format);
11158 send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACCEPT, 0, ied1.buf, ied1.pos, -1);
11159 if (strcmp(iaxs[fr->callno]->exten, "TBD")) {
11160 ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED);
11161 ast_verb(3, "Accepting AUTHENTICATED call from %s:\n"
11162 "%srequested format = %s,\n"
11163 "%srequested prefs = %s,\n"
11164 "%sactual format = %s,\n"
11165 "%shost prefs = %s,\n"
11166 "%spriority = %s\n",
11167 ast_inet_ntoa(sin.sin_addr),
11168 VERBOSE_PREFIX_4,
11169 ast_getformatname(iaxs[fr->callno]->peerformat),
11170 VERBOSE_PREFIX_4,
11171 caller_pref_buf,
11172 VERBOSE_PREFIX_4,
11173 ast_getformatname(format),
11174 VERBOSE_PREFIX_4,
11175 host_pref_buf,
11176 VERBOSE_PREFIX_4,
11177 using_prefs);
11178
11179 ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED);
11180 if (!(c = ast_iax2_new(fr->callno, AST_STATE_RING, format, NULL, 1)))
11181 iax2_destroy(fr->callno);
11182 else if (ies.vars) {
11183 struct ast_datastore *variablestore;
11184 struct ast_variable *var, *prev = NULL;
11185 AST_LIST_HEAD(, ast_var_t) *varlist;
11186 varlist = ast_calloc(1, sizeof(*varlist));
11187 variablestore = ast_datastore_alloc(&iax2_variable_datastore_info, NULL);
11188 if (variablestore && varlist) {
11189 variablestore->data = varlist;
11190 variablestore->inheritance = DATASTORE_INHERIT_FOREVER;
11191 AST_LIST_HEAD_INIT(varlist);
11192 ast_debug(1, "I can haz IAX vars? w00t\n");
11193 for (var = ies.vars; var; var = var->next) {
11194 struct ast_var_t *newvar = ast_var_assign(var->name, var->value);
11195 if (prev)
11196 ast_free(prev);
11197 prev = var;
11198 if (!newvar) {
11199
11200 ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
11201 } else {
11202 AST_LIST_INSERT_TAIL(varlist, newvar, entries);
11203 }
11204 }
11205 if (prev)
11206 ast_free(prev);
11207 ies.vars = NULL;
11208 ast_channel_datastore_add(c, variablestore);
11209 } else {
11210 ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
11211 if (variablestore)
11212 ast_datastore_free(variablestore);
11213 if (varlist)
11214 ast_free(varlist);
11215 }
11216 }
11217 } else {
11218 ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_TBD);
11219
11220 ast_verb(3, "Accepted AUTHENTICATED TBD call from %s\n", ast_inet_ntoa(sin.sin_addr));
11221 if (ast_test_flag64(iaxs[fr->callno], IAX_IMMEDIATE)) {
11222 goto immediatedial;
11223 }
11224 }
11225 }
11226 }
11227 break;
11228 case IAX_COMMAND_DIAL:
11229 immediatedial:
11230 if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_TBD)) {
11231 ast_clear_flag(&iaxs[fr->callno]->state, IAX_STATE_TBD);
11232 ast_string_field_set(iaxs[fr->callno], exten, ies.called_number ? ies.called_number : "s");
11233 if (!ast_exists_extension(NULL, iaxs[fr->callno]->context, iaxs[fr->callno]->exten, 1, iaxs[fr->callno]->cid_num)) {
11234 if (authdebug)
11235 ast_log(LOG_NOTICE, "Rejected dial attempt from %s, request '%s@%s' does not exist\n", ast_inet_ntoa(sin.sin_addr), iaxs[fr->callno]->exten, iaxs[fr->callno]->context);
11236 memset(&ied0, 0, sizeof(ied0));
11237 iax_ie_append_str(&ied0, IAX_IE_CAUSE, "No such context/extension");
11238 iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_NO_ROUTE_DESTINATION);
11239 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
11240 if (!iaxs[fr->callno]) {
11241 break;
11242 }
11243 } else {
11244 char tmp[256];
11245 ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED);
11246 ast_verb(3, "Accepting DIAL from %s, formats = %s\n",
11247 ast_inet_ntoa(sin.sin_addr),
11248 ast_getformatname_multiple(tmp, sizeof(tmp), iaxs[fr->callno]->peerformat));
11249 ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED);
11250 send_command(iaxs[fr->callno], AST_FRAME_CONTROL, AST_CONTROL_PROGRESS, 0, NULL, 0, -1);
11251 if (!(c = ast_iax2_new(fr->callno, AST_STATE_RING, iaxs[fr->callno]->peerformat, NULL, 1)))
11252 iax2_destroy(fr->callno);
11253 else if (ies.vars) {
11254 struct ast_datastore *variablestore;
11255 struct ast_variable *var, *prev = NULL;
11256 AST_LIST_HEAD(, ast_var_t) *varlist;
11257 varlist = ast_calloc(1, sizeof(*varlist));
11258 variablestore = ast_datastore_alloc(&iax2_variable_datastore_info, NULL);
11259 ast_debug(1, "I can haz IAX vars? w00t\n");
11260 if (variablestore && varlist) {
11261 variablestore->data = varlist;
11262 variablestore->inheritance = DATASTORE_INHERIT_FOREVER;
11263 AST_LIST_HEAD_INIT(varlist);
11264 for (var = ies.vars; var; var = var->next) {
11265 struct ast_var_t *newvar = ast_var_assign(var->name, var->value);
11266 if (prev)
11267 ast_free(prev);
11268 prev = var;
11269 if (!newvar) {
11270
11271 ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
11272 } else {
11273 AST_LIST_INSERT_TAIL(varlist, newvar, entries);
11274 }
11275 }
11276 if (prev)
11277 ast_free(prev);
11278 ies.vars = NULL;
11279 ast_channel_datastore_add(c, variablestore);
11280 } else {
11281 ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
11282 if (variablestore)
11283 ast_datastore_free(variablestore);
11284 if (varlist)
11285 ast_free(varlist);
11286 }
11287 }
11288 }
11289 }
11290 break;
11291 case IAX_COMMAND_INVAL:
11292 iaxs[fr->callno]->error = ENOTCONN;
11293 ast_debug(1, "Immediately destroying %d, having received INVAL\n", fr->callno);
11294 iax2_destroy(fr->callno);
11295 ast_debug(1, "Destroying call %d\n", fr->callno);
11296 break;
11297 case IAX_COMMAND_VNAK:
11298 ast_debug(1, "Received VNAK: resending outstanding frames\n");
11299
11300 vnak_retransmit(fr->callno, fr->iseqno);
11301 break;
11302 case IAX_COMMAND_REGREQ:
11303 case IAX_COMMAND_REGREL:
11304
11305 if (delayreject)
11306 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
11307 if (register_verify(fr->callno, &sin, &ies)) {
11308 if (!iaxs[fr->callno]) {
11309 break;
11310 }
11311
11312 auth_fail(fr->callno, IAX_COMMAND_REGREJ);
11313 break;
11314 }
11315 if (!iaxs[fr->callno]) {
11316 break;
11317 }
11318 if ((ast_strlen_zero(iaxs[fr->callno]->secret) && ast_strlen_zero(iaxs[fr->callno]->inkeys)) ||
11319 ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_AUTHENTICATED)) {
11320
11321 if (f.subclass.integer == IAX_COMMAND_REGREL) {
11322 memset(&sin, 0, sizeof(sin));
11323 sin.sin_family = AF_INET;
11324 }
11325 if (update_registry(&sin, fr->callno, ies.devicetype, fd, ies.refresh)) {
11326 ast_log(LOG_WARNING, "Registry error\n");
11327 }
11328 if (!iaxs[fr->callno]) {
11329 break;
11330 }
11331 if (ies.provverpres && ies.serviceident && sin.sin_addr.s_addr) {
11332 ast_mutex_unlock(&iaxsl[fr->callno]);
11333 check_provisioning(&sin, fd, ies.serviceident, ies.provver);
11334 ast_mutex_lock(&iaxsl[fr->callno]);
11335 }
11336 break;
11337 }
11338 registry_authrequest(fr->callno);
11339 break;
11340 case IAX_COMMAND_REGACK:
11341 if (iax2_ack_registry(&ies, &sin, fr->callno))
11342 ast_log(LOG_WARNING, "Registration failure\n");
11343
11344 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
11345 iax2_destroy(fr->callno);
11346 break;
11347 case IAX_COMMAND_REGREJ:
11348 if (iaxs[fr->callno]->reg) {
11349 if (authdebug) {
11350 ast_log(LOG_NOTICE, "Registration of '%s' rejected: '%s' from: '%s'\n", iaxs[fr->callno]->reg->username, ies.cause ? ies.cause : "<unknown>", ast_inet_ntoa(sin.sin_addr));
11351 manager_event(EVENT_FLAG_SYSTEM, "Registry", "ChannelType: IAX2\r\nUsername: %s\r\nStatus: Rejected\r\nCause: %s\r\n", iaxs[fr->callno]->reg->username, ies.cause ? ies.cause : "<unknown>");
11352 }
11353 iaxs[fr->callno]->reg->regstate = REG_STATE_REJECTED;
11354 }
11355
11356 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
11357 iax2_destroy(fr->callno);
11358 break;
11359 case IAX_COMMAND_REGAUTH:
11360
11361 if (registry_rerequest(&ies, fr->callno, &sin)) {
11362 memset(&ied0, 0, sizeof(ied0));
11363 iax_ie_append_str(&ied0, IAX_IE_CAUSE, "No authority found");
11364 iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_FACILITY_NOT_SUBSCRIBED);
11365 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
11366 }
11367 break;
11368 case IAX_COMMAND_TXREJ:
11369 iaxs[fr->callno]->transferring = 0;
11370 ast_verb(3, "Channel '%s' unable to transfer\n", iaxs[fr->callno]->owner ? iaxs[fr->callno]->owner->name : "<Unknown>");
11371 memset(&iaxs[fr->callno]->transfer, 0, sizeof(iaxs[fr->callno]->transfer));
11372 if (iaxs[fr->callno]->bridgecallno) {
11373 if (iaxs[iaxs[fr->callno]->bridgecallno]->transferring) {
11374 iaxs[iaxs[fr->callno]->bridgecallno]->transferring = 0;
11375 send_command(iaxs[iaxs[fr->callno]->bridgecallno], AST_FRAME_IAX, IAX_COMMAND_TXREJ, 0, NULL, 0, -1);
11376 }
11377 }
11378 break;
11379 case IAX_COMMAND_TXREADY:
11380 if ((iaxs[fr->callno]->transferring == TRANSFER_BEGIN) ||
11381 (iaxs[fr->callno]->transferring == TRANSFER_MBEGIN)) {
11382 if (iaxs[fr->callno]->transferring == TRANSFER_MBEGIN)
11383 iaxs[fr->callno]->transferring = TRANSFER_MREADY;
11384 else
11385 iaxs[fr->callno]->transferring = TRANSFER_READY;
11386 ast_verb(3, "Channel '%s' ready to transfer\n", iaxs[fr->callno]->owner ? iaxs[fr->callno]->owner->name : "<Unknown>");
11387 if (iaxs[fr->callno]->bridgecallno) {
11388 if ((iaxs[iaxs[fr->callno]->bridgecallno]->transferring == TRANSFER_READY) ||
11389 (iaxs[iaxs[fr->callno]->bridgecallno]->transferring == TRANSFER_MREADY)) {
11390
11391 if (iaxs[fr->callno]->transferring == TRANSFER_MREADY) {
11392 ast_verb(3, "Attempting media bridge of %s and %s\n", iaxs[fr->callno]->owner ? iaxs[fr->callno]->owner->name : "<Unknown>",
11393 iaxs[iaxs[fr->callno]->bridgecallno]->owner ? iaxs[iaxs[fr->callno]->bridgecallno]->owner->name : "<Unknown>");
11394
11395 iaxs[iaxs[fr->callno]->bridgecallno]->transferring = TRANSFER_MEDIA;
11396 iaxs[fr->callno]->transferring = TRANSFER_MEDIA;
11397
11398 memset(&ied0, 0, sizeof(ied0));
11399 memset(&ied1, 0, sizeof(ied1));
11400 iax_ie_append_short(&ied0, IAX_IE_CALLNO, iaxs[iaxs[fr->callno]->bridgecallno]->peercallno);
11401 iax_ie_append_short(&ied1, IAX_IE_CALLNO, iaxs[fr->callno]->peercallno);
11402 send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_TXMEDIA, 0, ied0.buf, ied0.pos, -1);
11403 send_command(iaxs[iaxs[fr->callno]->bridgecallno], AST_FRAME_IAX, IAX_COMMAND_TXMEDIA, 0, ied1.buf, ied1.pos, -1);
11404 } else {
11405 ast_verb(3, "Releasing %s and %s\n", iaxs[fr->callno]->owner ? iaxs[fr->callno]->owner->name : "<Unknown>",
11406 iaxs[iaxs[fr->callno]->bridgecallno]->owner ? iaxs[iaxs[fr->callno]->bridgecallno]->owner->name : "<Unknown>");
11407
11408 iaxs[iaxs[fr->callno]->bridgecallno]->transferring = TRANSFER_RELEASED;
11409 iaxs[fr->callno]->transferring = TRANSFER_RELEASED;
11410 ast_set_flag64(iaxs[iaxs[fr->callno]->bridgecallno], IAX_ALREADYGONE);
11411 ast_set_flag64(iaxs[fr->callno], IAX_ALREADYGONE);
11412
11413
11414 stop_stuff(fr->callno);
11415 stop_stuff(iaxs[fr->callno]->bridgecallno);
11416
11417 memset(&ied0, 0, sizeof(ied0));
11418 memset(&ied1, 0, sizeof(ied1));
11419 iax_ie_append_short(&ied0, IAX_IE_CALLNO, iaxs[iaxs[fr->callno]->bridgecallno]->peercallno);
11420 iax_ie_append_short(&ied1, IAX_IE_CALLNO, iaxs[fr->callno]->peercallno);
11421 send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_TXREL, 0, ied0.buf, ied0.pos, -1);
11422 send_command(iaxs[iaxs[fr->callno]->bridgecallno], AST_FRAME_IAX, IAX_COMMAND_TXREL, 0, ied1.buf, ied1.pos, -1);
11423 }
11424
11425 }
11426 }
11427 }
11428 break;
11429 case IAX_COMMAND_TXREQ:
11430 try_transfer(iaxs[fr->callno], &ies);
11431 break;
11432 case IAX_COMMAND_TXCNT:
11433 if (iaxs[fr->callno]->transferring)
11434 send_command_transfer(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_TXACC, 0, NULL, 0);
11435 break;
11436 case IAX_COMMAND_TXREL:
11437
11438 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
11439 complete_transfer(fr->callno, &ies);
11440 stop_stuff(fr->callno);
11441 break;
11442 case IAX_COMMAND_TXMEDIA:
11443 if (iaxs[fr->callno]->transferring == TRANSFER_READY) {
11444 AST_LIST_TRAVERSE(&frame_queue[fr->callno], cur, list) {
11445
11446 if (cur->transfer) {
11447 cur->retries = -1;
11448 }
11449 }
11450
11451 iaxs[fr->callno]->transferring = TRANSFER_MEDIAPASS;
11452 }
11453 break;
11454 case IAX_COMMAND_RTKEY:
11455 if (!IAX_CALLENCRYPTED(iaxs[fr->callno])) {
11456 ast_log(LOG_WARNING,
11457 "we've been told to rotate our encryption key, "
11458 "but this isn't an encrypted call. bad things will happen.\n"
11459 );
11460 break;
11461 }
11462
11463 IAX_DEBUGDIGEST("Receiving", ies.challenge);
11464
11465 ast_aes_set_decrypt_key((unsigned char *) ies.challenge, &iaxs[fr->callno]->dcx);
11466 break;
11467 case IAX_COMMAND_DPREP:
11468 complete_dpreply(iaxs[fr->callno], &ies);
11469 break;
11470 case IAX_COMMAND_UNSUPPORT:
11471 ast_log(LOG_NOTICE, "Peer did not understand our iax command '%d'\n", ies.iax_unknown);
11472 break;
11473 case IAX_COMMAND_FWDOWNL:
11474
11475 if (!ast_test_flag64(&globalflags, IAX_ALLOWFWDOWNLOAD)) {
11476 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_UNSUPPORT, 0, NULL, 0, -1);
11477 break;
11478 }
11479 memset(&ied0, 0, sizeof(ied0));
11480 res = iax_firmware_append(&ied0, (unsigned char *)ies.devicetype, ies.fwdesc);
11481 if (res < 0)
11482 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
11483 else if (res > 0)
11484 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_FWDATA, 0, ied0.buf, ied0.pos, -1);
11485 else
11486 send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_FWDATA, 0, ied0.buf, ied0.pos, -1);
11487 break;
11488 case IAX_COMMAND_CALLTOKEN:
11489 {
11490 struct iax_frame *cur;
11491
11492 if ((cur = AST_LIST_LAST(&frame_queue[fr->callno])) && ies.calltoken && ies.calltokendata) {
11493 resend_with_token(fr->callno, cur, (char *) ies.calltokendata);
11494 }
11495 break;
11496 }
11497 default:
11498 ast_debug(1, "Unknown IAX command %d on %d/%d\n", f.subclass.integer, fr->callno, iaxs[fr->callno]->peercallno);
11499 memset(&ied0, 0, sizeof(ied0));
11500 iax_ie_append_byte(&ied0, IAX_IE_IAX_UNKNOWN, f.subclass.integer);
11501 send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_UNSUPPORT, 0, ied0.buf, ied0.pos, -1);
11502 }
11503
11504 if (ies.vars) {
11505 ast_variables_destroy(ies.vars);
11506 ast_debug(1, "I can haz IAX vars, but they is no good :-(\n");
11507 ies.vars = NULL;
11508 }
11509
11510
11511 if ((f.subclass.integer != IAX_COMMAND_ACK) &&
11512 (f.subclass.integer != IAX_COMMAND_TXCNT) &&
11513 (f.subclass.integer != IAX_COMMAND_TXACC) &&
11514 (f.subclass.integer != IAX_COMMAND_INVAL) &&
11515 (f.subclass.integer != IAX_COMMAND_VNAK)) {
11516 if (iaxs[fr->callno] && iaxs[fr->callno]->aseqno != iaxs[fr->callno]->iseqno)
11517 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
11518 }
11519 ast_mutex_unlock(&iaxsl[fr->callno]);
11520 return 1;
11521 }
11522
11523 if (iaxs[fr->callno] && iaxs[fr->callno]->aseqno != iaxs[fr->callno]->iseqno)
11524 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
11525 } else if (minivid) {
11526 f.frametype = AST_FRAME_VIDEO;
11527 if (iaxs[fr->callno]->videoformat > 0)
11528 f.subclass.codec = iaxs[fr->callno]->videoformat | (ntohs(vh->ts) & 0x8000LL ? 1 : 0);
11529 else {
11530 ast_log(LOG_WARNING, "Received mini frame before first full video frame\n");
11531 iax2_vnak(fr->callno);
11532 ast_variables_destroy(ies.vars);
11533 ast_mutex_unlock(&iaxsl[fr->callno]);
11534 return 1;
11535 }
11536 f.datalen = res - sizeof(*vh);
11537 if (f.datalen)
11538 f.data.ptr = thread->buf + sizeof(*vh);
11539 else
11540 f.data.ptr = NULL;
11541 #ifdef IAXTESTS
11542 if (test_resync) {
11543 fr->ts = (iaxs[fr->callno]->last & 0xFFFF8000L) | ((ntohs(vh->ts) + test_resync) & 0x7fff);
11544 } else
11545 #endif
11546 fr->ts = (iaxs[fr->callno]->last & 0xFFFF8000L) | (ntohs(vh->ts) & 0x7fff);
11547 } else {
11548
11549 f.frametype = AST_FRAME_VOICE;
11550 if (iaxs[fr->callno]->voiceformat > 0)
11551 f.subclass.codec = iaxs[fr->callno]->voiceformat;
11552 else {
11553 ast_debug(1, "Received mini frame before first full voice frame\n");
11554 iax2_vnak(fr->callno);
11555 ast_variables_destroy(ies.vars);
11556 ast_mutex_unlock(&iaxsl[fr->callno]);
11557 return 1;
11558 }
11559 f.datalen = res - sizeof(struct ast_iax2_mini_hdr);
11560 if (f.datalen < 0) {
11561 ast_log(LOG_WARNING, "Datalen < 0?\n");
11562 ast_variables_destroy(ies.vars);
11563 ast_mutex_unlock(&iaxsl[fr->callno]);
11564 return 1;
11565 }
11566 if (f.datalen)
11567 f.data.ptr = thread->buf + sizeof(*mh);
11568 else
11569 f.data.ptr = NULL;
11570 #ifdef IAXTESTS
11571 if (test_resync) {
11572 fr->ts = (iaxs[fr->callno]->last & 0xFFFF0000L) | ((ntohs(mh->ts) + test_resync) & 0xffff);
11573 } else
11574 #endif
11575 fr->ts = (iaxs[fr->callno]->last & 0xFFFF0000L) | ntohs(mh->ts);
11576
11577 }
11578
11579 if (!ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED)) {
11580 ast_variables_destroy(ies.vars);
11581 ast_mutex_unlock(&iaxsl[fr->callno]);
11582 return 1;
11583 }
11584
11585 if (f.frametype == AST_FRAME_CONTROL && f.subclass.integer == AST_CONTROL_CONNECTED_LINE) {
11586 struct ast_party_connected_line connected;
11587
11588 if (!ast_test_flag64(iaxs[fr->callno], IAX_RECVCONNECTEDLINE)) {
11589 ast_variables_destroy(ies.vars);
11590 ast_mutex_unlock(&iaxsl[fr->callno]);
11591 return 1;
11592 }
11593
11594
11595 ast_party_connected_line_init(&connected);
11596 connected.id.number.presentation = iaxs[fr->callno]->calling_pres;
11597 connected.id.name.presentation = iaxs[fr->callno]->calling_pres;
11598
11599 if (!ast_connected_line_parse_data(f.data.ptr, f.datalen, &connected)) {
11600 ast_string_field_set(iaxs[fr->callno], cid_num, connected.id.number.str);
11601 ast_string_field_set(iaxs[fr->callno], cid_name, connected.id.name.str);
11602 iaxs[fr->callno]->calling_pres = ast_party_id_presentation(&connected.id);
11603
11604 iax2_lock_owner(fr->callno);
11605 if (iaxs[fr->callno] && iaxs[fr->callno]->owner) {
11606 ast_set_callerid(iaxs[fr->callno]->owner,
11607 S_COR(connected.id.number.valid, connected.id.number.str, ""),
11608 S_COR(connected.id.name.valid, connected.id.name.str, ""),
11609 NULL);
11610 iaxs[fr->callno]->owner->caller.id.number.presentation = connected.id.number.presentation;
11611 iaxs[fr->callno]->owner->caller.id.name.presentation = connected.id.name.presentation;
11612 ast_channel_unlock(iaxs[fr->callno]->owner);
11613 }
11614 }
11615 ast_party_connected_line_free(&connected);
11616 }
11617
11618 f.src = "IAX2";
11619 f.mallocd = 0;
11620 f.offset = 0;
11621 f.len = 0;
11622 if (f.datalen && (f.frametype == AST_FRAME_VOICE)) {
11623 f.samples = ast_codec_get_samples(&f);
11624
11625 if (f.subclass.codec == AST_FORMAT_SLINEAR)
11626 ast_frame_byteswap_be(&f);
11627 } else
11628 f.samples = 0;
11629 iax_frame_wrap(fr, &f);
11630
11631
11632 if (iaxs[fr->callno] && iaxs[fr->callno]->last < fr->ts) {
11633
11634 fr->outoforder = 0;
11635 } else {
11636 if (iaxdebug && iaxs[fr->callno])
11637 ast_debug(1, "Received out of order packet... (type=%d, subclass %d, ts = %d, last = %d)\n", f.frametype, f.subclass.integer, fr->ts, iaxs[fr->callno]->last);
11638 fr->outoforder = -1;
11639 }
11640 fr->cacheable = ((f.frametype == AST_FRAME_VOICE) || (f.frametype == AST_FRAME_VIDEO));
11641 duped_fr = iaxfrdup2(fr);
11642 if (duped_fr) {
11643 schedule_delivery(duped_fr, updatehistory, 0, &fr->ts);
11644 }
11645 if (iaxs[fr->callno] && iaxs[fr->callno]->last < fr->ts) {
11646 iaxs[fr->callno]->last = fr->ts;
11647 #if 1
11648 if (iaxdebug)
11649 ast_debug(1, "For call=%d, set last=%d\n", fr->callno, fr->ts);
11650 #endif
11651 }
11652
11653
11654 ast_variables_destroy(ies.vars);
11655 ast_mutex_unlock(&iaxsl[fr->callno]);
11656 return 1;
11657 }
11658
11659
11660 static void iax2_process_thread_cleanup(void *data)
11661 {
11662 struct iax2_thread *thread = data;
11663 ast_mutex_destroy(&thread->lock);
11664 ast_cond_destroy(&thread->cond);
11665 ast_mutex_destroy(&thread->init_lock);
11666 ast_cond_destroy(&thread->init_cond);
11667 ast_free(thread);
11668
11669 ast_atomic_dec_and_test(&iaxactivethreadcount);
11670 }
11671
11672 static void *iax2_process_thread(void *data)
11673 {
11674 struct iax2_thread *thread = data;
11675 struct timeval wait;
11676 struct timespec ts;
11677 int put_into_idle = 0;
11678 int first_time = 1;
11679 int old_state;
11680
11681 ast_atomic_fetchadd_int(&iaxactivethreadcount, 1);
11682
11683 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old_state);
11684 pthread_cleanup_push(iax2_process_thread_cleanup, data);
11685
11686 for (;;) {
11687
11688 ast_mutex_lock(&thread->lock);
11689
11690 if (thread->stop) {
11691 ast_mutex_unlock(&thread->lock);
11692 break;
11693 }
11694
11695
11696 if (first_time) {
11697 signal_condition(&thread->init_lock, &thread->init_cond);
11698 first_time = 0;
11699 }
11700
11701
11702 if (put_into_idle) {
11703 insert_idle_thread(thread);
11704 }
11705
11706 if (thread->type == IAX_THREAD_TYPE_DYNAMIC) {
11707 struct iax2_thread *t = NULL;
11708
11709 wait = ast_tvadd(ast_tvnow(), ast_samp2tv(30000, 1000));
11710 ts.tv_sec = wait.tv_sec;
11711 ts.tv_nsec = wait.tv_usec * 1000;
11712 if (ast_cond_timedwait(&thread->cond, &thread->lock, &ts) == ETIMEDOUT) {
11713
11714
11715 if (!put_into_idle || thread->stop) {
11716 ast_mutex_unlock(&thread->lock);
11717 break;
11718 }
11719 AST_LIST_LOCK(&dynamic_list);
11720
11721 if ((t = AST_LIST_REMOVE(&dynamic_list, thread, list)))
11722 ast_atomic_fetchadd_int(&iaxdynamicthreadcount, -1);
11723 AST_LIST_UNLOCK(&dynamic_list);
11724 if (t) {
11725
11726
11727
11728 ast_mutex_unlock(&thread->lock);
11729 break;
11730 }
11731
11732
11733
11734 wait = ast_tvadd(ast_tvnow(), ast_samp2tv(30000, 1000));
11735 ts.tv_sec = wait.tv_sec;
11736 ts.tv_nsec = wait.tv_usec * 1000;
11737 if (ast_cond_timedwait(&thread->cond, &thread->lock, &ts) == ETIMEDOUT) {
11738 ast_mutex_unlock(&thread->lock);
11739 break;
11740 }
11741 }
11742 } else {
11743 ast_cond_wait(&thread->cond, &thread->lock);
11744 }
11745
11746
11747 put_into_idle = 1;
11748
11749 ast_mutex_unlock(&thread->lock);
11750
11751 if (thread->stop) {
11752 break;
11753 }
11754
11755 if (thread->iostate == IAX_IOSTATE_IDLE)
11756 continue;
11757
11758
11759 switch (thread->iostate) {
11760 case IAX_IOSTATE_READY:
11761 thread->actions++;
11762 thread->iostate = IAX_IOSTATE_PROCESSING;
11763 socket_process(thread);
11764 handle_deferred_full_frames(thread);
11765 break;
11766 case IAX_IOSTATE_SCHEDREADY:
11767 thread->actions++;
11768 thread->iostate = IAX_IOSTATE_PROCESSING;
11769 #ifdef SCHED_MULTITHREADED
11770 thread->schedfunc(thread->scheddata);
11771 #endif
11772 default:
11773 break;
11774 }
11775 time(&thread->checktime);
11776 thread->iostate = IAX_IOSTATE_IDLE;
11777 #ifdef DEBUG_SCHED_MULTITHREAD
11778 thread->curfunc[0]='\0';
11779 #endif
11780
11781
11782
11783
11784 AST_LIST_LOCK(&active_list);
11785 AST_LIST_REMOVE(&active_list, thread, list);
11786 AST_LIST_UNLOCK(&active_list);
11787
11788
11789 handle_deferred_full_frames(thread);
11790 }
11791
11792
11793
11794
11795
11796
11797 AST_LIST_LOCK(&idle_list);
11798 AST_LIST_REMOVE(&idle_list, thread, list);
11799 AST_LIST_UNLOCK(&idle_list);
11800
11801 AST_LIST_LOCK(&dynamic_list);
11802 AST_LIST_REMOVE(&dynamic_list, thread, list);
11803 AST_LIST_UNLOCK(&dynamic_list);
11804
11805 if (!thread->stop) {
11806
11807 pthread_detach(pthread_self());
11808 }
11809
11810
11811
11812
11813 pthread_cleanup_pop(1);
11814 return NULL;
11815 }
11816
11817 static int iax2_do_register(struct iax2_registry *reg)
11818 {
11819 struct iax_ie_data ied;
11820 if (iaxdebug)
11821 ast_debug(1, "Sending registration request for '%s'\n", reg->username);
11822
11823 if (reg->dnsmgr &&
11824 ((reg->regstate == REG_STATE_TIMEOUT) || !ast_sockaddr_ipv4(®->addr))) {
11825
11826 ast_dnsmgr_refresh(reg->dnsmgr);
11827 }
11828
11829
11830
11831
11832
11833 if (reg->dnsmgr && ast_dnsmgr_changed(reg->dnsmgr) && (reg->callno > 0)) {
11834 int callno = reg->callno;
11835 ast_mutex_lock(&iaxsl[callno]);
11836 iax2_destroy(callno);
11837 ast_mutex_unlock(&iaxsl[callno]);
11838 reg->callno = 0;
11839 }
11840 if (!ast_sockaddr_ipv4(®->addr)) {
11841 if (iaxdebug)
11842 ast_debug(1, "Unable to send registration request for '%s' without IP address\n", reg->username);
11843
11844 reg->expire = iax2_sched_replace(reg->expire, sched,
11845 (5 * reg->refresh / 6) * 1000, iax2_do_register_s, reg);
11846 return -1;
11847 }
11848
11849 if (!reg->callno) {
11850 struct sockaddr_in reg_addr;
11851
11852 ast_debug(3, "Allocate call number\n");
11853
11854 ast_sockaddr_to_sin(®->addr, ®_addr);
11855
11856 reg->callno = find_callno_locked(0, 0, ®_addr, NEW_FORCE, defaultsockfd, 0);
11857 if (reg->callno < 1) {
11858 ast_log(LOG_WARNING, "Unable to create call for registration\n");
11859 return -1;
11860 } else
11861 ast_debug(3, "Registration created on call %d\n", reg->callno);
11862 iaxs[reg->callno]->reg = reg;
11863 ast_mutex_unlock(&iaxsl[reg->callno]);
11864 }
11865
11866 reg->expire = iax2_sched_replace(reg->expire, sched,
11867 (5 * reg->refresh / 6) * 1000, iax2_do_register_s, reg);
11868
11869 memset(&ied, 0, sizeof(ied));
11870 iax_ie_append_str(&ied, IAX_IE_USERNAME, reg->username);
11871 iax_ie_append_short(&ied, IAX_IE_REFRESH, reg->refresh);
11872 add_empty_calltoken_ie(iaxs[reg->callno], &ied);
11873 send_command(iaxs[reg->callno],AST_FRAME_IAX, IAX_COMMAND_REGREQ, 0, ied.buf, ied.pos, -1);
11874 reg->regstate = REG_STATE_REGSENT;
11875 return 0;
11876 }
11877
11878 static int iax2_provision(struct sockaddr_in *end, int sockfd, const char *dest, const char *template, int force)
11879 {
11880
11881
11882 struct iax_ie_data provdata;
11883 struct iax_ie_data ied;
11884 unsigned int sig;
11885 struct sockaddr_in sin;
11886 int callno;
11887 struct create_addr_info cai;
11888
11889 memset(&cai, 0, sizeof(cai));
11890
11891 ast_debug(1, "Provisioning '%s' from template '%s'\n", dest, template);
11892
11893 if (iax_provision_build(&provdata, &sig, template, force)) {
11894 ast_debug(1, "No provisioning found for template '%s'\n", template);
11895 return 0;
11896 }
11897
11898 if (end) {
11899 memcpy(&sin, end, sizeof(sin));
11900 cai.sockfd = sockfd;
11901 } else if (create_addr(dest, NULL, &sin, &cai))
11902 return -1;
11903
11904
11905 memset(&ied, 0, sizeof(ied));
11906 iax_ie_append_raw(&ied, IAX_IE_PROVISIONING, provdata.buf, provdata.pos);
11907
11908 callno = find_callno_locked(0, 0, &sin, NEW_FORCE, cai.sockfd, 0);
11909 if (!callno)
11910 return -1;
11911
11912 if (iaxs[callno]) {
11913
11914 iaxs[callno]->autoid = iax2_sched_replace(iaxs[callno]->autoid,
11915 sched, 15000, auto_hangup, (void *)(long)callno);
11916 ast_set_flag64(iaxs[callno], IAX_PROVISION);
11917
11918 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_PROVISION, 0, ied.buf, ied.pos, -1);
11919 }
11920 ast_mutex_unlock(&iaxsl[callno]);
11921
11922 return 1;
11923 }
11924
11925 static char *papp = "IAX2Provision";
11926
11927
11928
11929
11930 static int iax2_prov_app(struct ast_channel *chan, const char *data)
11931 {
11932 int res;
11933 char *sdata;
11934 char *opts;
11935 int force =0;
11936 unsigned short callno = PTR_TO_CALLNO(chan->tech_pvt);
11937 if (ast_strlen_zero(data))
11938 data = "default";
11939 sdata = ast_strdupa(data);
11940 opts = strchr(sdata, '|');
11941 if (opts)
11942 *opts='\0';
11943
11944 if (chan->tech != &iax2_tech) {
11945 ast_log(LOG_NOTICE, "Can't provision a non-IAX device!\n");
11946 return -1;
11947 }
11948 if (!callno || !iaxs[callno] || !iaxs[callno]->addr.sin_addr.s_addr) {
11949 ast_log(LOG_NOTICE, "Can't provision something with no IP?\n");
11950 return -1;
11951 }
11952 res = iax2_provision(&iaxs[callno]->addr, iaxs[callno]->sockfd, NULL, sdata, force);
11953 ast_verb(3, "Provisioned IAXY at '%s' with '%s'= %d\n",
11954 ast_inet_ntoa(iaxs[callno]->addr.sin_addr),
11955 sdata, res);
11956 return res;
11957 }
11958
11959 static char *handle_cli_iax2_provision(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
11960 {
11961 int force = 0;
11962 int res;
11963
11964 switch (cmd) {
11965 case CLI_INIT:
11966 e->command = "iax2 provision";
11967 e->usage =
11968 "Usage: iax2 provision <host> <template> [forced]\n"
11969 " Provisions the given peer or IP address using a template\n"
11970 " matching either 'template' or '*' if the template is not\n"
11971 " found. If 'forced' is specified, even empty provisioning\n"
11972 " fields will be provisioned as empty fields.\n";
11973 return NULL;
11974 case CLI_GENERATE:
11975 if (a->pos == 3)
11976 return iax_prov_complete_template(a->line, a->word, a->pos, a->n);
11977 return NULL;
11978 }
11979
11980 if (a->argc < 4)
11981 return CLI_SHOWUSAGE;
11982 if (a->argc > 4) {
11983 if (!strcasecmp(a->argv[4], "forced"))
11984 force = 1;
11985 else
11986 return CLI_SHOWUSAGE;
11987 }
11988 res = iax2_provision(NULL, -1, a->argv[2], a->argv[3], force);
11989 if (res < 0)
11990 ast_cli(a->fd, "Unable to find peer/address '%s'\n", a->argv[2]);
11991 else if (res < 1)
11992 ast_cli(a->fd, "No template (including wildcard) matching '%s'\n", a->argv[3]);
11993 else
11994 ast_cli(a->fd, "Provisioning '%s' with template '%s'%s\n", a->argv[2], a->argv[3], force ? ", forced" : "");
11995 return CLI_SUCCESS;
11996 }
11997
11998 static void __iax2_poke_noanswer(const void *data)
11999 {
12000 struct iax2_peer *peer = (struct iax2_peer *)data;
12001 int callno;
12002
12003 if (peer->lastms > -1) {
12004 ast_log(LOG_NOTICE, "Peer '%s' is now UNREACHABLE! Time: %d\n", peer->name, peer->lastms);
12005 manager_event(EVENT_FLAG_SYSTEM, "PeerStatus", "ChannelType: IAX2\r\nPeer: IAX2/%s\r\nPeerStatus: Unreachable\r\nTime: %d\r\n", peer->name, peer->lastms);
12006 ast_devstate_changed(AST_DEVICE_UNAVAILABLE, AST_DEVSTATE_CACHABLE, "IAX2/%s", peer->name);
12007 }
12008 if ((callno = peer->callno) > 0) {
12009 ast_mutex_lock(&iaxsl[callno]);
12010 iax2_destroy(callno);
12011 ast_mutex_unlock(&iaxsl[callno]);
12012 }
12013 peer->callno = 0;
12014 peer->lastms = -1;
12015
12016 peer->pokeexpire = iax2_sched_add(sched, peer->pokefreqnotok, iax2_poke_peer_s, peer_ref(peer));
12017 if (peer->pokeexpire == -1)
12018 peer_unref(peer);
12019 }
12020
12021 static int iax2_poke_noanswer(const void *data)
12022 {
12023 struct iax2_peer *peer = (struct iax2_peer *)data;
12024 peer->pokeexpire = -1;
12025 #ifdef SCHED_MULTITHREADED
12026 if (schedule_action(__iax2_poke_noanswer, data))
12027 #endif
12028 __iax2_poke_noanswer(data);
12029 peer_unref(peer);
12030 return 0;
12031 }
12032
12033 static int iax2_poke_peer_cb(void *obj, void *arg, int flags)
12034 {
12035 struct iax2_peer *peer = obj;
12036
12037 iax2_poke_peer(peer, 0);
12038
12039 return 0;
12040 }
12041
12042 static int iax2_poke_peer(struct iax2_peer *peer, int heldcall)
12043 {
12044 int callno;
12045 struct sockaddr_in peer_addr;
12046
12047 if (!peer->maxms || (!ast_sockaddr_ipv4(&peer->addr) && !peer->dnsmgr)) {
12048
12049
12050 peer->lastms = 0;
12051 peer->historicms = 0;
12052 peer->pokeexpire = -1;
12053 peer->callno = 0;
12054 return 0;
12055 }
12056
12057 ast_sockaddr_to_sin(&peer->addr, &peer_addr);
12058
12059
12060 if ((callno = peer->callno) > 0) {
12061 ast_log(LOG_NOTICE, "Still have a callno...\n");
12062 ast_mutex_lock(&iaxsl[callno]);
12063 iax2_destroy(callno);
12064 ast_mutex_unlock(&iaxsl[callno]);
12065 }
12066 if (heldcall)
12067 ast_mutex_unlock(&iaxsl[heldcall]);
12068 callno = peer->callno = find_callno(0, 0, &peer_addr, NEW_FORCE, peer->sockfd, 0);
12069 if (heldcall)
12070 ast_mutex_lock(&iaxsl[heldcall]);
12071 if (peer->callno < 1) {
12072 ast_log(LOG_WARNING, "Unable to allocate call for poking peer '%s'\n", peer->name);
12073 return -1;
12074 }
12075
12076
12077 iaxs[peer->callno]->pingtime = peer->maxms / 4 + 1;
12078 iaxs[peer->callno]->peerpoke = peer;
12079
12080 if (peer->pokeexpire > -1) {
12081 if (!ast_sched_thread_del(sched, peer->pokeexpire)) {
12082 peer->pokeexpire = -1;
12083 peer_unref(peer);
12084 }
12085 }
12086
12087
12088
12089 if (peer->lastms < 0)
12090 peer->pokeexpire = iax2_sched_add(sched, peer->pokefreqnotok, iax2_poke_noanswer, peer_ref(peer));
12091 else
12092 peer->pokeexpire = iax2_sched_add(sched, DEFAULT_MAXMS * 2, iax2_poke_noanswer, peer_ref(peer));
12093
12094 if (peer->pokeexpire == -1)
12095 peer_unref(peer);
12096
12097
12098 ast_mutex_lock(&iaxsl[callno]);
12099 if (iaxs[callno]) {
12100 struct iax_ie_data ied = {
12101 .buf = { 0 },
12102 .pos = 0,
12103 };
12104 add_empty_calltoken_ie(iaxs[callno], &ied);
12105 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_POKE, 0, ied.buf, ied.pos, -1);
12106 }
12107 ast_mutex_unlock(&iaxsl[callno]);
12108
12109 return 0;
12110 }
12111
12112 static void free_context(struct iax2_context *con)
12113 {
12114 struct iax2_context *conl;
12115 while(con) {
12116 conl = con;
12117 con = con->next;
12118 ast_free(conl);
12119 }
12120 }
12121
12122 static struct ast_channel *iax2_request(const char *type, format_t format, const struct ast_channel *requestor, void *data, int *cause)
12123 {
12124 int callno;
12125 int res;
12126 format_t fmt, native;
12127 struct sockaddr_in sin;
12128 struct ast_channel *c;
12129 struct parsed_dial_string pds;
12130 struct create_addr_info cai;
12131 char *tmpstr;
12132
12133 memset(&pds, 0, sizeof(pds));
12134 tmpstr = ast_strdupa(data);
12135 parse_dial_string(tmpstr, &pds);
12136
12137 if (ast_strlen_zero(pds.peer)) {
12138 ast_log(LOG_WARNING, "No peer provided in the IAX2 dial string '%s'\n", (char *) data);
12139 return NULL;
12140 }
12141
12142 memset(&cai, 0, sizeof(cai));
12143 cai.capability = iax2_capability;
12144
12145 ast_copy_flags64(&cai, &globalflags, IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_FORCEJITTERBUF | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
12146
12147
12148 if (create_addr(pds.peer, NULL, &sin, &cai)) {
12149 *cause = AST_CAUSE_UNREGISTERED;
12150 return NULL;
12151 }
12152
12153 if (pds.port)
12154 sin.sin_port = htons(atoi(pds.port));
12155
12156 callno = find_callno_locked(0, 0, &sin, NEW_FORCE, cai.sockfd, 0);
12157 if (callno < 1) {
12158 ast_log(LOG_WARNING, "Unable to create call\n");
12159 *cause = AST_CAUSE_CONGESTION;
12160 return NULL;
12161 }
12162
12163
12164 ast_copy_flags64(iaxs[callno], &cai, IAX_TRUNK | IAX_SENDANI | IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_FORCEJITTERBUF | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
12165 if (ast_test_flag64(&cai, IAX_TRUNK)) {
12166 int new_callno;
12167 if ((new_callno = make_trunk(callno, 1)) != -1)
12168 callno = new_callno;
12169 }
12170 iaxs[callno]->maxtime = cai.maxtime;
12171 if (cai.found)
12172 ast_string_field_set(iaxs[callno], host, pds.peer);
12173
12174 c = ast_iax2_new(callno, AST_STATE_DOWN, cai.capability, requestor ? requestor->linkedid : NULL, cai.found);
12175
12176 ast_mutex_unlock(&iaxsl[callno]);
12177
12178 if (c) {
12179
12180 if (c->nativeformats & format)
12181 c->nativeformats &= format;
12182 else {
12183 native = c->nativeformats;
12184 fmt = format;
12185 res = ast_translator_best_choice(&fmt, &native);
12186 if (res < 0) {
12187 ast_log(LOG_WARNING, "Unable to create translator path for %s to %s on %s\n",
12188 ast_getformatname(c->nativeformats), ast_getformatname(fmt), c->name);
12189 ast_hangup(c);
12190 return NULL;
12191 }
12192 c->nativeformats = native;
12193 }
12194 c->readformat = ast_best_codec(c->nativeformats);
12195 c->writeformat = c->readformat;
12196 }
12197
12198 return c;
12199 }
12200
12201 static void *network_thread(void *ignore)
12202 {
12203 if (timer) {
12204 ast_io_add(io, ast_timer_fd(timer), timing_read, AST_IO_IN | AST_IO_PRI, NULL);
12205 }
12206
12207 for (;;) {
12208 pthread_testcancel();
12209
12210
12211
12212 if (ast_io_wait(io, 1000) <= 0) {
12213 break;
12214 }
12215 }
12216
12217 return NULL;
12218 }
12219
12220 static int start_network_thread(void)
12221 {
12222 struct iax2_thread *thread;
12223 int threadcount = 0;
12224 int x;
12225 for (x = 0; x < iaxthreadcount; x++) {
12226 thread = ast_calloc(1, sizeof(*thread));
12227 if (thread) {
12228 thread->type = IAX_THREAD_TYPE_POOL;
12229 thread->threadnum = ++threadcount;
12230 ast_mutex_init(&thread->lock);
12231 ast_cond_init(&thread->cond, NULL);
12232 ast_mutex_init(&thread->init_lock);
12233 ast_cond_init(&thread->init_cond, NULL);
12234 if (ast_pthread_create_background(&thread->threadid, NULL, iax2_process_thread, thread)) {
12235 ast_log(LOG_WARNING, "Failed to create new thread!\n");
12236 ast_mutex_destroy(&thread->lock);
12237 ast_cond_destroy(&thread->cond);
12238 ast_mutex_destroy(&thread->init_lock);
12239 ast_cond_destroy(&thread->init_cond);
12240 ast_free(thread);
12241 thread = NULL;
12242 continue;
12243 }
12244 AST_LIST_LOCK(&idle_list);
12245 AST_LIST_INSERT_TAIL(&idle_list, thread, list);
12246 AST_LIST_UNLOCK(&idle_list);
12247 }
12248 }
12249 if (ast_pthread_create_background(&netthreadid, NULL, network_thread, NULL)) {
12250 ast_log(LOG_ERROR, "Failed to create new thread!\n");
12251 return -1;
12252 }
12253 ast_verb(2, "%d helper threads started\n", threadcount);
12254 return 0;
12255 }
12256
12257 static struct iax2_context *build_context(const char *context)
12258 {
12259 struct iax2_context *con;
12260
12261 if ((con = ast_calloc(1, sizeof(*con))))
12262 ast_copy_string(con->context, context, sizeof(con->context));
12263
12264 return con;
12265 }
12266
12267 static int get_auth_methods(const char *value)
12268 {
12269 int methods = 0;
12270 if (strstr(value, "rsa"))
12271 methods |= IAX_AUTH_RSA;
12272 if (strstr(value, "md5"))
12273 methods |= IAX_AUTH_MD5;
12274 if (strstr(value, "plaintext"))
12275 methods |= IAX_AUTH_PLAINTEXT;
12276 return methods;
12277 }
12278
12279
12280
12281
12282
12283 static int check_srcaddr(struct sockaddr *sa, socklen_t salen)
12284 {
12285 int sd;
12286 int res;
12287
12288 sd = socket(AF_INET, SOCK_DGRAM, 0);
12289 if (sd < 0) {
12290 ast_log(LOG_ERROR, "Socket: %s\n", strerror(errno));
12291 return -1;
12292 }
12293
12294 res = bind(sd, sa, salen);
12295 if (res < 0) {
12296 ast_debug(1, "Can't bind: %s\n", strerror(errno));
12297 close(sd);
12298 return 1;
12299 }
12300
12301 close(sd);
12302 return 0;
12303 }
12304
12305
12306
12307
12308 static int peer_set_srcaddr(struct iax2_peer *peer, const char *srcaddr)
12309 {
12310 struct sockaddr_in sin;
12311 struct ast_sockaddr sin_tmp;
12312 int nonlocal = 1;
12313 int port = IAX_DEFAULT_PORTNO;
12314 int sockfd = defaultsockfd;
12315 char *tmp;
12316 char *addr;
12317 char *portstr;
12318
12319 tmp = ast_strdupa(srcaddr);
12320 addr = strsep(&tmp, ":");
12321 portstr = tmp;
12322
12323 if (portstr) {
12324 port = atoi(portstr);
12325 if (port < 1)
12326 port = IAX_DEFAULT_PORTNO;
12327 }
12328
12329 sin_tmp.ss.ss_family = AF_INET;
12330 if (!ast_get_ip(&sin_tmp, addr)) {
12331 struct ast_netsock *sock;
12332 int res;
12333
12334 ast_sockaddr_to_sin(&sin_tmp, &sin);
12335 sin.sin_port = 0;
12336 sin.sin_family = AF_INET;
12337 res = check_srcaddr((struct sockaddr *) &sin, sizeof(sin));
12338 if (res == 0) {
12339
12340 sin.sin_port = htons(port);
12341 if (!(sock = ast_netsock_find(netsock, &sin)))
12342 sock = ast_netsock_find(outsock, &sin);
12343 if (sock) {
12344 sockfd = ast_netsock_sockfd(sock);
12345 nonlocal = 0;
12346 } else {
12347 unsigned int orig_saddr = sin.sin_addr.s_addr;
12348
12349 sin.sin_addr.s_addr = INADDR_ANY;
12350 if (ast_netsock_find(netsock, &sin)) {
12351 sin.sin_addr.s_addr = orig_saddr;
12352 sock = ast_netsock_bind(outsock, io, srcaddr, port, qos.tos, qos.cos, socket_read, NULL);
12353 if (sock) {
12354 sockfd = ast_netsock_sockfd(sock);
12355 ast_netsock_unref(sock);
12356 nonlocal = 0;
12357 } else {
12358 nonlocal = 2;
12359 }
12360 }
12361 }
12362 }
12363 }
12364
12365 peer->sockfd = sockfd;
12366
12367 if (nonlocal == 1) {
12368 ast_log(LOG_WARNING, "Non-local or unbound address specified (%s) in sourceaddress for '%s', reverting to default\n",
12369 srcaddr, peer->name);
12370 return -1;
12371 } else if (nonlocal == 2) {
12372 ast_log(LOG_WARNING, "Unable to bind to sourceaddress '%s' for '%s', reverting to default\n",
12373 srcaddr, peer->name);
12374 return -1;
12375 } else {
12376 ast_debug(1, "Using sourceaddress %s for '%s'\n", srcaddr, peer->name);
12377 return 0;
12378 }
12379 }
12380
12381 static void peer_destructor(void *obj)
12382 {
12383 struct iax2_peer *peer = obj;
12384 int callno = peer->callno;
12385
12386 ast_free_ha(peer->ha);
12387
12388 if (callno > 0) {
12389 ast_mutex_lock(&iaxsl[callno]);
12390 iax2_destroy(callno);
12391 ast_mutex_unlock(&iaxsl[callno]);
12392 }
12393
12394 register_peer_exten(peer, 0);
12395
12396 if (peer->dnsmgr)
12397 ast_dnsmgr_release(peer->dnsmgr);
12398
12399 if (peer->mwi_event_sub)
12400 ast_event_unsubscribe(peer->mwi_event_sub);
12401
12402 ast_string_field_free_memory(peer);
12403 }
12404
12405
12406 static struct iax2_peer *build_peer(const char *name, struct ast_variable *v, struct ast_variable *alt, int temponly)
12407 {
12408 struct iax2_peer *peer = NULL;
12409 struct ast_ha *oldha = NULL;
12410 int maskfound = 0;
12411 int found = 0;
12412 int firstpass = 1;
12413 struct iax2_peer tmp_peer = {
12414 .name = name,
12415 };
12416
12417 if (!temponly) {
12418 peer = ao2_find(peers, &tmp_peer, OBJ_POINTER);
12419 if (peer && !ast_test_flag64(peer, IAX_DELME))
12420 firstpass = 0;
12421 }
12422
12423 if (peer) {
12424 found++;
12425 if (firstpass) {
12426 oldha = peer->ha;
12427 peer->ha = NULL;
12428 }
12429 unlink_peer(peer);
12430 } else if ((peer = ao2_alloc(sizeof(*peer), peer_destructor))) {
12431 peer->expire = -1;
12432 peer->pokeexpire = -1;
12433 peer->sockfd = defaultsockfd;
12434 peer->addr.ss.ss_family = AF_INET;
12435 peer->addr.len = sizeof(struct sockaddr_in);
12436 if (ast_string_field_init(peer, 32))
12437 peer = peer_unref(peer);
12438 }
12439
12440 if (peer) {
12441 if (firstpass) {
12442 ast_copy_flags64(peer, &globalflags, IAX_USEJITTERBUF | IAX_FORCEJITTERBUF | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE | IAX_FORCE_ENCRYPT);
12443 peer->encmethods = iax2_encryption;
12444 peer->adsi = adsi;
12445 ast_string_field_set(peer,secret,"");
12446 if (!found) {
12447 ast_string_field_set(peer, name, name);
12448 ast_sockaddr_set_port(&peer->addr, IAX_DEFAULT_PORTNO);
12449 peer->expiry = min_reg_expire;
12450 }
12451 peer->prefs = prefs;
12452 peer->capability = iax2_capability;
12453 peer->smoothing = 0;
12454 peer->pokefreqok = DEFAULT_FREQ_OK;
12455 peer->pokefreqnotok = DEFAULT_FREQ_NOTOK;
12456 peer->maxcallno = 0;
12457 peercnt_modify(0, 0, &peer->addr);
12458 peer->calltoken_required = CALLTOKEN_DEFAULT;
12459 ast_string_field_set(peer,context,"");
12460 ast_string_field_set(peer,peercontext,"");
12461 ast_clear_flag64(peer, IAX_HASCALLERID);
12462 ast_string_field_set(peer, cid_name, "");
12463 ast_string_field_set(peer, cid_num, "");
12464 ast_string_field_set(peer, mohinterpret, mohinterpret);
12465 ast_string_field_set(peer, mohsuggest, mohsuggest);
12466 }
12467
12468 if (!v) {
12469 v = alt;
12470 alt = NULL;
12471 }
12472 while(v) {
12473 if (!strcasecmp(v->name, "secret")) {
12474 ast_string_field_set(peer, secret, v->value);
12475 } else if (!strcasecmp(v->name, "mailbox")) {
12476 ast_string_field_set(peer, mailbox, v->value);
12477 } else if (!strcasecmp(v->name, "hasvoicemail")) {
12478 if (ast_true(v->value) && ast_strlen_zero(peer->mailbox)) {
12479 ast_string_field_set(peer, mailbox, name);
12480 }
12481 } else if (!strcasecmp(v->name, "mohinterpret")) {
12482 ast_string_field_set(peer, mohinterpret, v->value);
12483 } else if (!strcasecmp(v->name, "mohsuggest")) {
12484 ast_string_field_set(peer, mohsuggest, v->value);
12485 } else if (!strcasecmp(v->name, "dbsecret")) {
12486 ast_string_field_set(peer, dbsecret, v->value);
12487 } else if (!strcasecmp(v->name, "trunk")) {
12488 ast_set2_flag64(peer, ast_true(v->value), IAX_TRUNK);
12489 if (ast_test_flag64(peer, IAX_TRUNK) && !timer) {
12490 ast_log(LOG_WARNING, "Unable to support trunking on peer '%s' without a timing interface\n", peer->name);
12491 ast_clear_flag64(peer, IAX_TRUNK);
12492 }
12493 } else if (!strcasecmp(v->name, "auth")) {
12494 peer->authmethods = get_auth_methods(v->value);
12495 } else if (!strcasecmp(v->name, "encryption")) {
12496 peer->encmethods |= get_encrypt_methods(v->value);
12497 if (!peer->encmethods) {
12498 ast_clear_flag64(peer, IAX_FORCE_ENCRYPT);
12499 }
12500 } else if (!strcasecmp(v->name, "forceencryption")) {
12501 if (ast_false(v->value)) {
12502 ast_clear_flag64(peer, IAX_FORCE_ENCRYPT);
12503 } else {
12504 peer->encmethods |= get_encrypt_methods(v->value);
12505 if (peer->encmethods) {
12506 ast_set_flag64(peer, IAX_FORCE_ENCRYPT);
12507 }
12508 }
12509 } else if (!strcasecmp(v->name, "transfer")) {
12510 if (!strcasecmp(v->value, "mediaonly")) {
12511 ast_set_flags_to64(peer, IAX_NOTRANSFER|IAX_TRANSFERMEDIA, IAX_TRANSFERMEDIA);
12512 } else if (ast_true(v->value)) {
12513 ast_set_flags_to64(peer, IAX_NOTRANSFER|IAX_TRANSFERMEDIA, 0);
12514 } else
12515 ast_set_flags_to64(peer, IAX_NOTRANSFER|IAX_TRANSFERMEDIA, IAX_NOTRANSFER);
12516 } else if (!strcasecmp(v->name, "jitterbuffer")) {
12517 ast_set2_flag64(peer, ast_true(v->value), IAX_USEJITTERBUF);
12518 } else if (!strcasecmp(v->name, "forcejitterbuffer")) {
12519 ast_set2_flag64(peer, ast_true(v->value), IAX_FORCEJITTERBUF);
12520 } else if (!strcasecmp(v->name, "host")) {
12521 if (!strcasecmp(v->value, "dynamic")) {
12522
12523 ast_set_flag64(peer, IAX_DYNAMIC);
12524 if (!found) {
12525
12526
12527 if (ast_sockaddr_port(&peer->addr)) {
12528 peer->defaddr.sin_port = htons(ast_sockaddr_port(&peer->addr));
12529 }
12530 ast_sockaddr_setnull(&peer->addr);
12531 }
12532 } else {
12533
12534 ast_sched_thread_del(sched, peer->expire);
12535 ast_clear_flag64(peer, IAX_DYNAMIC);
12536 if (ast_dnsmgr_lookup(v->value, &peer->addr, &peer->dnsmgr, srvlookup ? "_iax._udp" : NULL))
12537 return peer_unref(peer);
12538 if (!ast_sockaddr_port(&peer->addr)) {
12539 ast_sockaddr_set_port(&peer->addr, IAX_DEFAULT_PORTNO);
12540 }
12541 }
12542 if (!maskfound)
12543 inet_aton("255.255.255.255", &peer->mask);
12544 } else if (!strcasecmp(v->name, "defaultip")) {
12545 struct ast_sockaddr peer_defaddr_tmp;
12546
12547 peer_defaddr_tmp.ss.ss_family = AF_INET;
12548 if (ast_get_ip(&peer_defaddr_tmp, v->value)) {
12549 return peer_unref(peer);
12550 }
12551 ast_sockaddr_to_sin(&peer_defaddr_tmp,
12552 &peer->defaddr);
12553 } else if (!strcasecmp(v->name, "sourceaddress")) {
12554 peer_set_srcaddr(peer, v->value);
12555 } else if (!strcasecmp(v->name, "permit") ||
12556 !strcasecmp(v->name, "deny")) {
12557 peer->ha = ast_append_ha(v->name, v->value, peer->ha, NULL);
12558 } else if (!strcasecmp(v->name, "mask")) {
12559 maskfound++;
12560 inet_aton(v->value, &peer->mask);
12561 } else if (!strcasecmp(v->name, "context")) {
12562 ast_string_field_set(peer, context, v->value);
12563 } else if (!strcasecmp(v->name, "regexten")) {
12564 ast_string_field_set(peer, regexten, v->value);
12565 } else if (!strcasecmp(v->name, "peercontext")) {
12566 ast_string_field_set(peer, peercontext, v->value);
12567 } else if (!strcasecmp(v->name, "port")) {
12568 if (ast_test_flag64(peer, IAX_DYNAMIC)) {
12569 peer->defaddr.sin_port = htons(atoi(v->value));
12570 } else {
12571 ast_sockaddr_set_port(&peer->addr, atoi(v->value));
12572 }
12573 } else if (!strcasecmp(v->name, "username")) {
12574 ast_string_field_set(peer, username, v->value);
12575 } else if (!strcasecmp(v->name, "allow")) {
12576 ast_parse_allow_disallow(&peer->prefs, &peer->capability, v->value, 1);
12577 } else if (!strcasecmp(v->name, "disallow")) {
12578 ast_parse_allow_disallow(&peer->prefs, &peer->capability, v->value, 0);
12579 } else if (!strcasecmp(v->name, "callerid")) {
12580 if (!ast_strlen_zero(v->value)) {
12581 char name2[80];
12582 char num2[80];
12583 ast_callerid_split(v->value, name2, sizeof(name2), num2, sizeof(num2));
12584 ast_string_field_set(peer, cid_name, name2);
12585 ast_string_field_set(peer, cid_num, num2);
12586 } else {
12587 ast_string_field_set(peer, cid_name, "");
12588 ast_string_field_set(peer, cid_num, "");
12589 }
12590 ast_set_flag64(peer, IAX_HASCALLERID);
12591 } else if (!strcasecmp(v->name, "fullname")) {
12592 ast_string_field_set(peer, cid_name, S_OR(v->value, ""));
12593 ast_set_flag64(peer, IAX_HASCALLERID);
12594 } else if (!strcasecmp(v->name, "cid_number")) {
12595 ast_string_field_set(peer, cid_num, S_OR(v->value, ""));
12596 ast_set_flag64(peer, IAX_HASCALLERID);
12597 } else if (!strcasecmp(v->name, "sendani")) {
12598 ast_set2_flag64(peer, ast_true(v->value), IAX_SENDANI);
12599 } else if (!strcasecmp(v->name, "inkeys")) {
12600 ast_string_field_set(peer, inkeys, v->value);
12601 } else if (!strcasecmp(v->name, "outkey")) {
12602 ast_string_field_set(peer, outkey, v->value);
12603 } else if (!strcasecmp(v->name, "qualify")) {
12604 if (!strcasecmp(v->value, "no")) {
12605 peer->maxms = 0;
12606 } else if (!strcasecmp(v->value, "yes")) {
12607 peer->maxms = DEFAULT_MAXMS;
12608 } else if (sscanf(v->value, "%30d", &peer->maxms) != 1) {
12609 ast_log(LOG_WARNING, "Qualification of peer '%s' should be 'yes', 'no', or a number of milliseconds at line %d of iax.conf\n", peer->name, v->lineno);
12610 peer->maxms = 0;
12611 }
12612 } else if (!strcasecmp(v->name, "qualifysmoothing")) {
12613 peer->smoothing = ast_true(v->value);
12614 } else if (!strcasecmp(v->name, "qualifyfreqok")) {
12615 if (sscanf(v->value, "%30d", &peer->pokefreqok) != 1) {
12616 ast_log(LOG_WARNING, "Qualification testing frequency of peer '%s' when OK should a number of milliseconds at line %d of iax.conf\n", peer->name, v->lineno);
12617 }
12618 } else if (!strcasecmp(v->name, "qualifyfreqnotok")) {
12619 if (sscanf(v->value, "%30d", &peer->pokefreqnotok) != 1) {
12620 ast_log(LOG_WARNING, "Qualification testing frequency of peer '%s' when NOT OK should be a number of milliseconds at line %d of iax.conf\n", peer->name, v->lineno);
12621 }
12622 } else if (!strcasecmp(v->name, "timezone")) {
12623 ast_string_field_set(peer, zonetag, v->value);
12624 } else if (!strcasecmp(v->name, "adsi")) {
12625 peer->adsi = ast_true(v->value);
12626 } else if (!strcasecmp(v->name, "connectedline")) {
12627 if (ast_true(v->value)) {
12628 ast_set_flag64(peer, IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
12629 } else if (!strcasecmp(v->value, "send")) {
12630 ast_clear_flag64(peer, IAX_RECVCONNECTEDLINE);
12631 ast_set_flag64(peer, IAX_SENDCONNECTEDLINE);
12632 } else if (!strcasecmp(v->value, "receive")) {
12633 ast_clear_flag64(peer, IAX_SENDCONNECTEDLINE);
12634 ast_set_flag64(peer, IAX_RECVCONNECTEDLINE);
12635 } else {
12636 ast_clear_flag64(peer, IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
12637 }
12638 } else if (!strcasecmp(v->name, "maxcallnumbers")) {
12639 if (sscanf(v->value, "%10hu", &peer->maxcallno) != 1) {
12640 ast_log(LOG_WARNING, "maxcallnumbers must be set to a valid number. %s is not valid at line %d.\n", v->value, v->lineno);
12641 } else {
12642 peercnt_modify(1, peer->maxcallno, &peer->addr);
12643 }
12644 } else if (!strcasecmp(v->name, "requirecalltoken")) {
12645
12646 if (ast_false(v->value)) {
12647 peer->calltoken_required = CALLTOKEN_NO;
12648 } else if (!strcasecmp(v->value, "auto")) {
12649 peer->calltoken_required = CALLTOKEN_AUTO;
12650 } else if (ast_true(v->value)) {
12651 peer->calltoken_required = CALLTOKEN_YES;
12652 } else {
12653 ast_log(LOG_WARNING, "requirecalltoken must be set to a valid value. at line %d\n", v->lineno);
12654 }
12655 }
12656
12657 v = v->next;
12658 if (!v) {
12659 v = alt;
12660 alt = NULL;
12661 }
12662 }
12663 if (!peer->authmethods)
12664 peer->authmethods = IAX_AUTH_MD5 | IAX_AUTH_PLAINTEXT;
12665 ast_clear_flag64(peer, IAX_DELME);
12666 }
12667
12668 if (oldha)
12669 ast_free_ha(oldha);
12670
12671 if (!ast_strlen_zero(peer->mailbox)) {
12672 char *mailbox, *context;
12673 context = mailbox = ast_strdupa(peer->mailbox);
12674 strsep(&context, "@");
12675 if (ast_strlen_zero(context))
12676 context = "default";
12677 peer->mwi_event_sub = ast_event_subscribe(AST_EVENT_MWI, mwi_event_cb, "IAX MWI subscription", NULL,
12678 AST_EVENT_IE_MAILBOX, AST_EVENT_IE_PLTYPE_STR, mailbox,
12679 AST_EVENT_IE_CONTEXT, AST_EVENT_IE_PLTYPE_STR, context,
12680 AST_EVENT_IE_END);
12681 }
12682
12683 return peer;
12684 }
12685
12686 static void user_destructor(void *obj)
12687 {
12688 struct iax2_user *user = obj;
12689
12690 ast_free_ha(user->ha);
12691 free_context(user->contexts);
12692 if(user->vars) {
12693 ast_variables_destroy(user->vars);
12694 user->vars = NULL;
12695 }
12696 ast_string_field_free_memory(user);
12697 }
12698
12699
12700 static struct iax2_user *build_user(const char *name, struct ast_variable *v, struct ast_variable *alt, int temponly)
12701 {
12702 struct iax2_user *user = NULL;
12703 struct iax2_context *con, *conl = NULL;
12704 struct ast_ha *oldha = NULL;
12705 struct iax2_context *oldcon = NULL;
12706 int format;
12707 int firstpass=1;
12708 int oldcurauthreq = 0;
12709 char *varname = NULL, *varval = NULL;
12710 struct ast_variable *tmpvar = NULL;
12711 struct iax2_user tmp_user = {
12712 .name = name,
12713 };
12714
12715 if (!temponly) {
12716 user = ao2_find(users, &tmp_user, OBJ_POINTER);
12717 if (user && !ast_test_flag64(user, IAX_DELME))
12718 firstpass = 0;
12719 }
12720
12721 if (user) {
12722 if (firstpass) {
12723 oldcurauthreq = user->curauthreq;
12724 oldha = user->ha;
12725 oldcon = user->contexts;
12726 user->ha = NULL;
12727 user->contexts = NULL;
12728 }
12729
12730 ao2_unlink(users, user);
12731 } else {
12732 user = ao2_alloc(sizeof(*user), user_destructor);
12733 }
12734
12735 if (user) {
12736 if (firstpass) {
12737 ast_string_field_free_memory(user);
12738 memset(user, 0, sizeof(struct iax2_user));
12739 if (ast_string_field_init(user, 32)) {
12740 user = user_unref(user);
12741 goto cleanup;
12742 }
12743 user->maxauthreq = maxauthreq;
12744 user->curauthreq = oldcurauthreq;
12745 user->prefs = prefs;
12746 user->capability = iax2_capability;
12747 user->encmethods = iax2_encryption;
12748 user->adsi = adsi;
12749 user->calltoken_required = CALLTOKEN_DEFAULT;
12750 ast_string_field_set(user, name, name);
12751 ast_string_field_set(user, language, language);
12752 ast_copy_flags64(user, &globalflags, IAX_USEJITTERBUF | IAX_FORCEJITTERBUF | IAX_CODEC_USER_FIRST | IAX_CODEC_NOPREFS | IAX_CODEC_NOCAP | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE | IAX_FORCE_ENCRYPT);
12753 ast_clear_flag64(user, IAX_HASCALLERID);
12754 ast_string_field_set(user, cid_name, "");
12755 ast_string_field_set(user, cid_num, "");
12756 ast_string_field_set(user, accountcode, accountcode);
12757 ast_string_field_set(user, mohinterpret, mohinterpret);
12758 ast_string_field_set(user, mohsuggest, mohsuggest);
12759 }
12760 if (!v) {
12761 v = alt;
12762 alt = NULL;
12763 }
12764 while(v) {
12765 if (!strcasecmp(v->name, "context")) {
12766 con = build_context(v->value);
12767 if (con) {
12768 if (conl)
12769 conl->next = con;
12770 else
12771 user->contexts = con;
12772 conl = con;
12773 }
12774 } else if (!strcasecmp(v->name, "permit") ||
12775 !strcasecmp(v->name, "deny")) {
12776 user->ha = ast_append_ha(v->name, v->value, user->ha, NULL);
12777 } else if (!strcasecmp(v->name, "setvar")) {
12778 varname = ast_strdupa(v->value);
12779 if ((varval = strchr(varname, '='))) {
12780 *varval = '\0';
12781 varval++;
12782 if((tmpvar = ast_variable_new(varname, varval, ""))) {
12783 tmpvar->next = user->vars;
12784 user->vars = tmpvar;
12785 }
12786 }
12787 } else if (!strcasecmp(v->name, "allow")) {
12788 ast_parse_allow_disallow(&user->prefs, &user->capability, v->value, 1);
12789 } else if (!strcasecmp(v->name, "disallow")) {
12790 ast_parse_allow_disallow(&user->prefs, &user->capability,v->value, 0);
12791 } else if (!strcasecmp(v->name, "trunk")) {
12792 ast_set2_flag64(user, ast_true(v->value), IAX_TRUNK);
12793 if (ast_test_flag64(user, IAX_TRUNK) && !timer) {
12794 ast_log(LOG_WARNING, "Unable to support trunking on user '%s' without a timing interface\n", user->name);
12795 ast_clear_flag64(user, IAX_TRUNK);
12796 }
12797 } else if (!strcasecmp(v->name, "auth")) {
12798 user->authmethods = get_auth_methods(v->value);
12799 } else if (!strcasecmp(v->name, "encryption")) {
12800 user->encmethods |= get_encrypt_methods(v->value);
12801 if (!user->encmethods) {
12802 ast_clear_flag64(user, IAX_FORCE_ENCRYPT);
12803 }
12804 } else if (!strcasecmp(v->name, "forceencryption")) {
12805 if (ast_false(v->value)) {
12806 ast_clear_flag64(user, IAX_FORCE_ENCRYPT);
12807 } else {
12808 user->encmethods |= get_encrypt_methods(v->value);
12809 if (user->encmethods) {
12810 ast_set_flag64(user, IAX_FORCE_ENCRYPT);
12811 }
12812 }
12813 } else if (!strcasecmp(v->name, "transfer")) {
12814 if (!strcasecmp(v->value, "mediaonly")) {
12815 ast_set_flags_to64(user, IAX_NOTRANSFER|IAX_TRANSFERMEDIA, IAX_TRANSFERMEDIA);
12816 } else if (ast_true(v->value)) {
12817 ast_set_flags_to64(user, IAX_NOTRANSFER|IAX_TRANSFERMEDIA, 0);
12818 } else
12819 ast_set_flags_to64(user, IAX_NOTRANSFER|IAX_TRANSFERMEDIA, IAX_NOTRANSFER);
12820 } else if (!strcasecmp(v->name, "codecpriority")) {
12821 if(!strcasecmp(v->value, "caller"))
12822 ast_set_flag64(user, IAX_CODEC_USER_FIRST);
12823 else if(!strcasecmp(v->value, "disabled"))
12824 ast_set_flag64(user, IAX_CODEC_NOPREFS);
12825 else if(!strcasecmp(v->value, "reqonly")) {
12826 ast_set_flag64(user, IAX_CODEC_NOCAP);
12827 ast_set_flag64(user, IAX_CODEC_NOPREFS);
12828 }
12829 } else if (!strcasecmp(v->name, "immediate")) {
12830 ast_set2_flag64(user, ast_true(v->value), IAX_IMMEDIATE);
12831 } else if (!strcasecmp(v->name, "jitterbuffer")) {
12832 ast_set2_flag64(user, ast_true(v->value), IAX_USEJITTERBUF);
12833 } else if (!strcasecmp(v->name, "forcejitterbuffer")) {
12834 ast_set2_flag64(user, ast_true(v->value), IAX_FORCEJITTERBUF);
12835 } else if (!strcasecmp(v->name, "dbsecret")) {
12836 ast_string_field_set(user, dbsecret, v->value);
12837 } else if (!strcasecmp(v->name, "secret")) {
12838 if (!ast_strlen_zero(user->secret)) {
12839 char *old = ast_strdupa(user->secret);
12840
12841 ast_string_field_build(user, secret, "%s;%s", old, v->value);
12842 } else
12843 ast_string_field_set(user, secret, v->value);
12844 } else if (!strcasecmp(v->name, "callerid")) {
12845 if (!ast_strlen_zero(v->value) && strcasecmp(v->value, "asreceived")) {
12846 char name2[80];
12847 char num2[80];
12848 ast_callerid_split(v->value, name2, sizeof(name2), num2, sizeof(num2));
12849 ast_string_field_set(user, cid_name, name2);
12850 ast_string_field_set(user, cid_num, num2);
12851 ast_set_flag64(user, IAX_HASCALLERID);
12852 } else {
12853 ast_clear_flag64(user, IAX_HASCALLERID);
12854 ast_string_field_set(user, cid_name, "");
12855 ast_string_field_set(user, cid_num, "");
12856 }
12857 } else if (!strcasecmp(v->name, "fullname")) {
12858 if (!ast_strlen_zero(v->value)) {
12859 ast_string_field_set(user, cid_name, v->value);
12860 ast_set_flag64(user, IAX_HASCALLERID);
12861 } else {
12862 ast_string_field_set(user, cid_name, "");
12863 if (ast_strlen_zero(user->cid_num))
12864 ast_clear_flag64(user, IAX_HASCALLERID);
12865 }
12866 } else if (!strcasecmp(v->name, "cid_number")) {
12867 if (!ast_strlen_zero(v->value)) {
12868 ast_string_field_set(user, cid_num, v->value);
12869 ast_set_flag64(user, IAX_HASCALLERID);
12870 } else {
12871 ast_string_field_set(user, cid_num, "");
12872 if (ast_strlen_zero(user->cid_name))
12873 ast_clear_flag64(user, IAX_HASCALLERID);
12874 }
12875 } else if (!strcasecmp(v->name, "accountcode")) {
12876 ast_string_field_set(user, accountcode, v->value);
12877 } else if (!strcasecmp(v->name, "mohinterpret")) {
12878 ast_string_field_set(user, mohinterpret, v->value);
12879 } else if (!strcasecmp(v->name, "mohsuggest")) {
12880 ast_string_field_set(user, mohsuggest, v->value);
12881 } else if (!strcasecmp(v->name, "parkinglot")) {
12882 ast_string_field_set(user, parkinglot, v->value);
12883 } else if (!strcasecmp(v->name, "language")) {
12884 ast_string_field_set(user, language, v->value);
12885 } else if (!strcasecmp(v->name, "amaflags")) {
12886 format = ast_cdr_amaflags2int(v->value);
12887 if (format < 0) {
12888 ast_log(LOG_WARNING, "Invalid AMA Flags: %s at line %d\n", v->value, v->lineno);
12889 } else {
12890 user->amaflags = format;
12891 }
12892 } else if (!strcasecmp(v->name, "inkeys")) {
12893 ast_string_field_set(user, inkeys, v->value);
12894 } else if (!strcasecmp(v->name, "maxauthreq")) {
12895 user->maxauthreq = atoi(v->value);
12896 if (user->maxauthreq < 0)
12897 user->maxauthreq = 0;
12898 } else if (!strcasecmp(v->name, "adsi")) {
12899 user->adsi = ast_true(v->value);
12900 } else if (!strcasecmp(v->name, "connectedline")) {
12901 if (ast_true(v->value)) {
12902 ast_set_flag64(user, IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
12903 } else if (!strcasecmp(v->value, "send")) {
12904 ast_clear_flag64(user, IAX_RECVCONNECTEDLINE);
12905 ast_set_flag64(user, IAX_SENDCONNECTEDLINE);
12906 } else if (!strcasecmp(v->value, "receive")) {
12907 ast_clear_flag64(user, IAX_SENDCONNECTEDLINE);
12908 ast_set_flag64(user, IAX_RECVCONNECTEDLINE);
12909 } else {
12910 ast_clear_flag64(user, IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
12911 }
12912 } else if (!strcasecmp(v->name, "requirecalltoken")) {
12913
12914 if (ast_false(v->value)) {
12915 user->calltoken_required = CALLTOKEN_NO;
12916 } else if (!strcasecmp(v->value, "auto")) {
12917 user->calltoken_required = CALLTOKEN_AUTO;
12918 } else if (ast_true(v->value)) {
12919 user->calltoken_required = CALLTOKEN_YES;
12920 } else {
12921 ast_log(LOG_WARNING, "requirecalltoken must be set to a valid value. at line %d\n", v->lineno);
12922 }
12923 }
12924
12925 v = v->next;
12926 if (!v) {
12927 v = alt;
12928 alt = NULL;
12929 }
12930 }
12931 if (!user->authmethods) {
12932 if (!ast_strlen_zero(user->secret)) {
12933 user->authmethods = IAX_AUTH_MD5 | IAX_AUTH_PLAINTEXT;
12934 if (!ast_strlen_zero(user->inkeys))
12935 user->authmethods |= IAX_AUTH_RSA;
12936 } else if (!ast_strlen_zero(user->inkeys)) {
12937 user->authmethods = IAX_AUTH_RSA;
12938 } else {
12939 user->authmethods = IAX_AUTH_MD5 | IAX_AUTH_PLAINTEXT;
12940 }
12941 }
12942 ast_clear_flag64(user, IAX_DELME);
12943 }
12944 cleanup:
12945 if (oldha)
12946 ast_free_ha(oldha);
12947 if (oldcon)
12948 free_context(oldcon);
12949 return user;
12950 }
12951
12952 static int peer_delme_cb(void *obj, void *arg, int flags)
12953 {
12954 struct iax2_peer *peer = obj;
12955
12956 ast_set_flag64(peer, IAX_DELME);
12957
12958 return 0;
12959 }
12960
12961 static int user_delme_cb(void *obj, void *arg, int flags)
12962 {
12963 struct iax2_user *user = obj;
12964
12965 ast_set_flag64(user, IAX_DELME);
12966
12967 return 0;
12968 }
12969
12970 static void delete_users(void)
12971 {
12972 struct iax2_registry *reg;
12973
12974 ao2_callback(users, 0, user_delme_cb, NULL);
12975
12976 AST_LIST_LOCK(®istrations);
12977 while ((reg = AST_LIST_REMOVE_HEAD(®istrations, entry))) {
12978 if (sched) {
12979 ast_sched_thread_del(sched, reg->expire);
12980 }
12981 if (reg->callno) {
12982 int callno = reg->callno;
12983 ast_mutex_lock(&iaxsl[callno]);
12984 if (iaxs[callno]) {
12985 iaxs[callno]->reg = NULL;
12986 iax2_destroy(callno);
12987 }
12988 ast_mutex_unlock(&iaxsl[callno]);
12989 }
12990 if (reg->dnsmgr)
12991 ast_dnsmgr_release(reg->dnsmgr);
12992 ast_free(reg);
12993 }
12994 AST_LIST_UNLOCK(®istrations);
12995
12996 ao2_callback(peers, 0, peer_delme_cb, NULL);
12997 }
12998
12999 static void prune_users(void)
13000 {
13001 struct iax2_user *user;
13002 struct ao2_iterator i;
13003
13004 i = ao2_iterator_init(users, 0);
13005 while ((user = ao2_iterator_next(&i))) {
13006 if (ast_test_flag64(user, IAX_DELME) || ast_test_flag64(user, IAX_RTCACHEFRIENDS)) {
13007 ao2_unlink(users, user);
13008 }
13009 user_unref(user);
13010 }
13011 ao2_iterator_destroy(&i);
13012 }
13013
13014
13015 static void prune_peers(void)
13016 {
13017 struct iax2_peer *peer;
13018 struct ao2_iterator i;
13019
13020 i = ao2_iterator_init(peers, 0);
13021 while ((peer = ao2_iterator_next(&i))) {
13022 if (ast_test_flag64(peer, IAX_DELME) || ast_test_flag64(peer, IAX_RTCACHEFRIENDS)) {
13023 unlink_peer(peer);
13024 }
13025 peer_unref(peer);
13026 }
13027 ao2_iterator_destroy(&i);
13028 }
13029
13030 static void set_config_destroy(void)
13031 {
13032 strcpy(accountcode, "");
13033 strcpy(language, "");
13034 strcpy(mohinterpret, "");
13035 strcpy(mohsuggest, "");
13036 trunkmaxsize = MAX_TRUNKDATA;
13037 amaflags = 0;
13038 delayreject = 0;
13039 ast_clear_flag64((&globalflags), IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF |
13040 IAX_FORCEJITTERBUF | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
13041 delete_users();
13042 ao2_callback(callno_limits, OBJ_NODATA, addr_range_delme_cb, NULL);
13043 ao2_callback(calltoken_ignores, OBJ_NODATA, addr_range_delme_cb, NULL);
13044 }
13045
13046
13047 static int set_config(const char *config_file, int reload)
13048 {
13049 struct ast_config *cfg, *ucfg;
13050 format_t capability = iax2_capability;
13051 struct ast_variable *v;
13052 char *cat;
13053 const char *utype;
13054 const char *tosval;
13055 int format;
13056 int portno = IAX_DEFAULT_PORTNO;
13057 int x;
13058 int mtuv;
13059 int subscribe_network_change = 1;
13060 struct iax2_user *user;
13061 struct iax2_peer *peer;
13062 struct ast_netsock *ns;
13063 struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
13064 #if 0
13065 static unsigned short int last_port=0;
13066 #endif
13067
13068 cfg = ast_config_load(config_file, config_flags);
13069
13070 if (!cfg) {
13071 ast_log(LOG_ERROR, "Unable to load config %s\n", config_file);
13072 return -1;
13073 } else if (cfg == CONFIG_STATUS_FILEUNCHANGED) {
13074 ucfg = ast_config_load("users.conf", config_flags);
13075 if (ucfg == CONFIG_STATUS_FILEUNCHANGED)
13076 return 0;
13077
13078 ast_clear_flag(&config_flags, CONFIG_FLAG_FILEUNCHANGED);
13079 if ((cfg = ast_config_load(config_file, config_flags)) == CONFIG_STATUS_FILEINVALID) {
13080 ast_log(LOG_ERROR, "Config file %s is in an invalid format. Aborting.\n", config_file);
13081 ast_config_destroy(ucfg);
13082 return 0;
13083 }
13084 if (!cfg) {
13085
13086 ast_log(LOG_ERROR, "Unable to load config %s again\n", config_file);
13087 return -1;
13088 }
13089 } else if (cfg == CONFIG_STATUS_FILEINVALID) {
13090 ast_log(LOG_ERROR, "Config file %s is in an invalid format. Aborting.\n", config_file);
13091 return 0;
13092 } else {
13093 ast_clear_flag(&config_flags, CONFIG_FLAG_FILEUNCHANGED);
13094 if ((ucfg = ast_config_load("users.conf", config_flags)) == CONFIG_STATUS_FILEINVALID) {
13095 ast_log(LOG_ERROR, "Config file users.conf is in an invalid format. Aborting.\n");
13096 ast_config_destroy(cfg);
13097 return 0;
13098 }
13099 }
13100
13101 if (reload) {
13102 set_config_destroy();
13103 }
13104
13105
13106 memset(&prefs, 0 , sizeof(struct ast_codec_pref));
13107
13108
13109 memset(&globalflags, 0, sizeof(globalflags));
13110 ast_set_flag64(&globalflags, IAX_RTUPDATE);
13111 ast_set_flag64((&globalflags), IAX_SHRINKCALLERID);
13112
13113 #ifdef SO_NO_CHECK
13114 nochecksums = 0;
13115 #endif
13116
13117 default_parkinglot[0] = '\0';
13118
13119 min_reg_expire = IAX_DEFAULT_REG_EXPIRE;
13120 max_reg_expire = IAX_DEFAULT_REG_EXPIRE;
13121 global_max_trunk_mtu = MAX_TRUNK_MTU;
13122 global_maxcallno = DEFAULT_MAXCALLNO_LIMIT;
13123 global_maxcallno_nonval = DEFAULT_MAXCALLNO_LIMIT_NONVAL;
13124
13125 maxauthreq = 3;
13126
13127 srvlookup = 0;
13128
13129 v = ast_variable_browse(cfg, "general");
13130
13131
13132 tosval = ast_variable_retrieve(cfg, "general", "tos");
13133 if (tosval) {
13134 if (ast_str2tos(tosval, &qos.tos))
13135 ast_log(LOG_WARNING, "Invalid tos value, refer to QoS documentation\n");
13136 }
13137
13138 tosval = ast_variable_retrieve(cfg, "general", "cos");
13139 if (tosval) {
13140 if (ast_str2cos(tosval, &qos.cos))
13141 ast_log(LOG_WARNING, "Invalid cos value, refer to QoS documentation\n");
13142 }
13143 while(v) {
13144 if (!strcasecmp(v->name, "bindport")){
13145 if (reload)
13146 ast_log(LOG_NOTICE, "Ignoring bindport on reload\n");
13147 else
13148 portno = atoi(v->value);
13149 } else if (!strcasecmp(v->name, "pingtime"))
13150 ping_time = atoi(v->value);
13151 else if (!strcasecmp(v->name, "iaxthreadcount")) {
13152 if (reload) {
13153 if (atoi(v->value) != iaxthreadcount)
13154 ast_log(LOG_NOTICE, "Ignoring any changes to iaxthreadcount during reload\n");
13155 } else {
13156 iaxthreadcount = atoi(v->value);
13157 if (iaxthreadcount < 1) {
13158 ast_log(LOG_NOTICE, "iaxthreadcount must be at least 1.\n");
13159 iaxthreadcount = 1;
13160 } else if (iaxthreadcount > 256) {
13161 ast_log(LOG_NOTICE, "limiting iaxthreadcount to 256\n");
13162 iaxthreadcount = 256;
13163 }
13164 }
13165 } else if (!strcasecmp(v->name, "iaxmaxthreadcount")) {
13166 if (reload) {
13167 AST_LIST_LOCK(&dynamic_list);
13168 iaxmaxthreadcount = atoi(v->value);
13169 AST_LIST_UNLOCK(&dynamic_list);
13170 } else {
13171 iaxmaxthreadcount = atoi(v->value);
13172 if (iaxmaxthreadcount < 0) {
13173 ast_log(LOG_NOTICE, "iaxmaxthreadcount must be at least 0.\n");
13174 iaxmaxthreadcount = 0;
13175 } else if (iaxmaxthreadcount > 256) {
13176 ast_log(LOG_NOTICE, "Limiting iaxmaxthreadcount to 256\n");
13177 iaxmaxthreadcount = 256;
13178 }
13179 }
13180 } else if (!strcasecmp(v->name, "nochecksums")) {
13181 #ifdef SO_NO_CHECK
13182 if (ast_true(v->value))
13183 nochecksums = 1;
13184 else
13185 nochecksums = 0;
13186 #else
13187 if (ast_true(v->value))
13188 ast_log(LOG_WARNING, "Disabling RTP checksums is not supported on this operating system!\n");
13189 #endif
13190 }
13191 else if (!strcasecmp(v->name, "maxjitterbuffer"))
13192 maxjitterbuffer = atoi(v->value);
13193 else if (!strcasecmp(v->name, "resyncthreshold"))
13194 resyncthreshold = atoi(v->value);
13195 else if (!strcasecmp(v->name, "maxjitterinterps"))
13196 maxjitterinterps = atoi(v->value);
13197 else if (!strcasecmp(v->name, "jittertargetextra"))
13198 jittertargetextra = atoi(v->value);
13199 else if (!strcasecmp(v->name, "lagrqtime"))
13200 lagrq_time = atoi(v->value);
13201 else if (!strcasecmp(v->name, "maxregexpire"))
13202 max_reg_expire = atoi(v->value);
13203 else if (!strcasecmp(v->name, "minregexpire"))
13204 min_reg_expire = atoi(v->value);
13205 else if (!strcasecmp(v->name, "bindaddr")) {
13206 if (reload) {
13207 ast_log(LOG_NOTICE, "Ignoring bindaddr on reload\n");
13208 } else {
13209 if (!(ns = ast_netsock_bind(netsock, io, v->value, portno, qos.tos, qos.cos, socket_read, NULL))) {
13210 ast_log(LOG_WARNING, "Unable apply binding to '%s' at line %d\n", v->value, v->lineno);
13211 } else {
13212 if (strchr(v->value, ':'))
13213 ast_verb(2, "Binding IAX2 to '%s'\n", v->value);
13214 else
13215 ast_verb(2, "Binding IAX2 to '%s:%d'\n", v->value, portno);
13216 if (defaultsockfd < 0)
13217 defaultsockfd = ast_netsock_sockfd(ns);
13218 ast_netsock_unref(ns);
13219 }
13220 }
13221 } else if (!strcasecmp(v->name, "authdebug")) {
13222 authdebug = ast_true(v->value);
13223 } else if (!strcasecmp(v->name, "encryption")) {
13224 iax2_encryption |= get_encrypt_methods(v->value);
13225 if (!iax2_encryption) {
13226 ast_clear_flag64((&globalflags), IAX_FORCE_ENCRYPT);
13227 }
13228 } else if (!strcasecmp(v->name, "forceencryption")) {
13229 if (ast_false(v->value)) {
13230 ast_clear_flag64((&globalflags), IAX_FORCE_ENCRYPT);
13231 } else {
13232 iax2_encryption |= get_encrypt_methods(v->value);
13233 if (iax2_encryption) {
13234 ast_set_flag64((&globalflags), IAX_FORCE_ENCRYPT);
13235 }
13236 }
13237 } else if (!strcasecmp(v->name, "transfer")) {
13238 if (!strcasecmp(v->value, "mediaonly")) {
13239 ast_set_flags_to64((&globalflags), IAX_NOTRANSFER|IAX_TRANSFERMEDIA, IAX_TRANSFERMEDIA);
13240 } else if (ast_true(v->value)) {
13241 ast_set_flags_to64((&globalflags), IAX_NOTRANSFER|IAX_TRANSFERMEDIA, 0);
13242 } else
13243 ast_set_flags_to64((&globalflags), IAX_NOTRANSFER|IAX_TRANSFERMEDIA, IAX_NOTRANSFER);
13244 } else if (!strcasecmp(v->name, "codecpriority")) {
13245 if(!strcasecmp(v->value, "caller"))
13246 ast_set_flag64((&globalflags), IAX_CODEC_USER_FIRST);
13247 else if(!strcasecmp(v->value, "disabled"))
13248 ast_set_flag64((&globalflags), IAX_CODEC_NOPREFS);
13249 else if(!strcasecmp(v->value, "reqonly")) {
13250 ast_set_flag64((&globalflags), IAX_CODEC_NOCAP);
13251 ast_set_flag64((&globalflags), IAX_CODEC_NOPREFS);
13252 }
13253 } else if (!strcasecmp(v->name, "jitterbuffer"))
13254 ast_set2_flag64((&globalflags), ast_true(v->value), IAX_USEJITTERBUF);
13255 else if (!strcasecmp(v->name, "forcejitterbuffer"))
13256 ast_set2_flag64((&globalflags), ast_true(v->value), IAX_FORCEJITTERBUF);
13257 else if (!strcasecmp(v->name, "delayreject"))
13258 delayreject = ast_true(v->value);
13259 else if (!strcasecmp(v->name, "allowfwdownload"))
13260 ast_set2_flag64((&globalflags), ast_true(v->value), IAX_ALLOWFWDOWNLOAD);
13261 else if (!strcasecmp(v->name, "rtcachefriends"))
13262 ast_set2_flag64((&globalflags), ast_true(v->value), IAX_RTCACHEFRIENDS);
13263 else if (!strcasecmp(v->name, "rtignoreregexpire"))
13264 ast_set2_flag64((&globalflags), ast_true(v->value), IAX_RTIGNOREREGEXPIRE);
13265 else if (!strcasecmp(v->name, "rtupdate"))
13266 ast_set2_flag64((&globalflags), ast_true(v->value), IAX_RTUPDATE);
13267 else if (!strcasecmp(v->name, "rtsavesysname"))
13268 ast_set2_flag64((&globalflags), ast_true(v->value), IAX_RTSAVE_SYSNAME);
13269 else if (!strcasecmp(v->name, "trunktimestamps"))
13270 ast_set2_flag64(&globalflags, ast_true(v->value), IAX_TRUNKTIMESTAMPS);
13271 else if (!strcasecmp(v->name, "rtautoclear")) {
13272 int i = atoi(v->value);
13273 if(i > 0)
13274 global_rtautoclear = i;
13275 else
13276 i = 0;
13277 ast_set2_flag64((&globalflags), i || ast_true(v->value), IAX_RTAUTOCLEAR);
13278 } else if (!strcasecmp(v->name, "trunkfreq")) {
13279 trunkfreq = atoi(v->value);
13280 if (trunkfreq < 10) {
13281 ast_log(LOG_NOTICE, "trunkfreq must be between 10ms and 1000ms, using 10ms instead.\n");
13282 trunkfreq = 10;
13283 } else if (trunkfreq > 1000) {
13284 ast_log(LOG_NOTICE, "trunkfreq must be between 10ms and 1000ms, using 1000ms instead.\n");
13285 trunkfreq = 1000;
13286 }
13287 if (timer) {
13288 ast_timer_set_rate(timer, 1000 / trunkfreq);
13289 }
13290 } else if (!strcasecmp(v->name, "trunkmtu")) {
13291 mtuv = atoi(v->value);
13292 if (mtuv == 0 )
13293 global_max_trunk_mtu = 0;
13294 else if (mtuv >= 172 && mtuv < 4000)
13295 global_max_trunk_mtu = mtuv;
13296 else
13297 ast_log(LOG_NOTICE, "trunkmtu value out of bounds (%d) at line %d\n",
13298 mtuv, v->lineno);
13299 } else if (!strcasecmp(v->name, "trunkmaxsize")) {
13300 trunkmaxsize = atoi(v->value);
13301 if (trunkmaxsize == 0)
13302 trunkmaxsize = MAX_TRUNKDATA;
13303 } else if (!strcasecmp(v->name, "autokill")) {
13304 if (sscanf(v->value, "%30d", &x) == 1) {
13305 if (x >= 0)
13306 autokill = x;
13307 else
13308 ast_log(LOG_NOTICE, "Nice try, but autokill has to be >0 or 'yes' or 'no' at line %d\n", v->lineno);
13309 } else if (ast_true(v->value)) {
13310 autokill = DEFAULT_MAXMS;
13311 } else {
13312 autokill = 0;
13313 }
13314 } else if (!strcasecmp(v->name, "bandwidth")) {
13315 if (!strcasecmp(v->value, "low")) {
13316 capability = IAX_CAPABILITY_LOWBANDWIDTH;
13317 } else if (!strcasecmp(v->value, "medium")) {
13318 capability = IAX_CAPABILITY_MEDBANDWIDTH;
13319 } else if (!strcasecmp(v->value, "high")) {
13320 capability = IAX_CAPABILITY_FULLBANDWIDTH;
13321 } else
13322 ast_log(LOG_WARNING, "bandwidth must be either low, medium, or high\n");
13323 } else if (!strcasecmp(v->name, "allow")) {
13324 ast_parse_allow_disallow(&prefs, &capability, v->value, 1);
13325 } else if (!strcasecmp(v->name, "disallow")) {
13326 ast_parse_allow_disallow(&prefs, &capability, v->value, 0);
13327 } else if (!strcasecmp(v->name, "register")) {
13328 iax2_register(v->value, v->lineno);
13329 } else if (!strcasecmp(v->name, "iaxcompat")) {
13330 iaxcompat = ast_true(v->value);
13331 } else if (!strcasecmp(v->name, "regcontext")) {
13332 ast_copy_string(regcontext, v->value, sizeof(regcontext));
13333
13334 ast_context_find_or_create(NULL, NULL, regcontext, "IAX2");
13335 } else if (!strcasecmp(v->name, "tos")) {
13336 if (ast_str2tos(v->value, &qos.tos))
13337 ast_log(LOG_WARNING, "Invalid tos value at line %d, refer to QoS documentation\n", v->lineno);
13338 } else if (!strcasecmp(v->name, "cos")) {
13339 if (ast_str2cos(v->value, &qos.cos))
13340 ast_log(LOG_WARNING, "Invalid cos value at line %d, refer to QoS documentation\n", v->lineno);
13341 } else if (!strcasecmp(v->name, "parkinglot")) {
13342 ast_copy_string(default_parkinglot, v->value, sizeof(default_parkinglot));
13343 } else if (!strcasecmp(v->name, "accountcode")) {
13344 ast_copy_string(accountcode, v->value, sizeof(accountcode));
13345 } else if (!strcasecmp(v->name, "mohinterpret")) {
13346 ast_copy_string(mohinterpret, v->value, sizeof(mohinterpret));
13347 } else if (!strcasecmp(v->name, "mohsuggest")) {
13348 ast_copy_string(mohsuggest, v->value, sizeof(mohsuggest));
13349 } else if (!strcasecmp(v->name, "amaflags")) {
13350 format = ast_cdr_amaflags2int(v->value);
13351 if (format < 0) {
13352 ast_log(LOG_WARNING, "Invalid AMA Flags: %s at line %d\n", v->value, v->lineno);
13353 } else {
13354 amaflags = format;
13355 }
13356 } else if (!strcasecmp(v->name, "language")) {
13357 ast_copy_string(language, v->value, sizeof(language));
13358 } else if (!strcasecmp(v->name, "maxauthreq")) {
13359 maxauthreq = atoi(v->value);
13360 if (maxauthreq < 0)
13361 maxauthreq = 0;
13362 } else if (!strcasecmp(v->name, "adsi")) {
13363 adsi = ast_true(v->value);
13364 } else if (!strcasecmp(v->name, "srvlookup")) {
13365 srvlookup = ast_true(v->value);
13366 } else if (!strcasecmp(v->name, "connectedline")) {
13367 if (ast_true(v->value)) {
13368 ast_set_flag64((&globalflags), IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
13369 } else if (!strcasecmp(v->value, "send")) {
13370 ast_clear_flag64((&globalflags), IAX_RECVCONNECTEDLINE);
13371 ast_set_flag64((&globalflags), IAX_SENDCONNECTEDLINE);
13372 } else if (!strcasecmp(v->value, "receive")) {
13373 ast_clear_flag64((&globalflags), IAX_SENDCONNECTEDLINE);
13374 ast_set_flag64((&globalflags), IAX_RECVCONNECTEDLINE);
13375 } else {
13376 ast_clear_flag64((&globalflags), IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
13377 }
13378 } else if (!strcasecmp(v->name, "maxcallnumbers")) {
13379 if (sscanf(v->value, "%10hu", &global_maxcallno) != 1) {
13380 ast_log(LOG_WARNING, "maxcallnumbers must be set to a valid number. %s is not valid at line %d\n", v->value, v->lineno);
13381 }
13382 } else if (!strcasecmp(v->name, "maxcallnumbers_nonvalidated")) {
13383 if (sscanf(v->value, "%10hu", &global_maxcallno_nonval) != 1) {
13384 ast_log(LOG_WARNING, "maxcallnumbers_nonvalidated must be set to a valid number. %s is not valid at line %d.\n", v->value, v->lineno);
13385 }
13386 } else if (!strcasecmp(v->name, "calltokenoptional")) {
13387 if (add_calltoken_ignore(v->value)) {
13388 ast_log(LOG_WARNING, "Invalid calltokenoptional address range - '%s' line %d\n", v->value, v->lineno);
13389 }
13390 } else if (!strcasecmp(v->name, "subscribe_network_change_event")) {
13391 if (ast_true(v->value)) {
13392 subscribe_network_change = 1;
13393 } else if (ast_false(v->value)) {
13394 subscribe_network_change = 0;
13395 } else {
13396 ast_log(LOG_WARNING, "subscribe_network_change_event value %s is not valid at line %d.\n", v->value, v->lineno);
13397 }
13398 } else if (!strcasecmp(v->name, "shrinkcallerid")) {
13399 if (ast_true(v->value)) {
13400 ast_set_flag64((&globalflags), IAX_SHRINKCALLERID);
13401 } else if (ast_false(v->value)) {
13402 ast_clear_flag64((&globalflags), IAX_SHRINKCALLERID);
13403 } else {
13404 ast_log(LOG_WARNING, "shrinkcallerid value %s is not valid at line %d.\n", v->value, v->lineno);
13405 }
13406 }
13407
13408 v = v->next;
13409 }
13410
13411 if (subscribe_network_change) {
13412 network_change_event_subscribe();
13413 } else {
13414 network_change_event_unsubscribe();
13415 }
13416
13417 if (defaultsockfd < 0) {
13418 if (!(ns = ast_netsock_bind(netsock, io, "0.0.0.0", portno, qos.tos, qos.cos, socket_read, NULL))) {
13419 ast_log(LOG_ERROR, "Unable to create network socket: %s\n", strerror(errno));
13420 } else {
13421 ast_verb(2, "Binding IAX2 to default address 0.0.0.0:%d\n", portno);
13422 defaultsockfd = ast_netsock_sockfd(ns);
13423 ast_netsock_unref(ns);
13424 }
13425 }
13426 if (reload) {
13427 ast_netsock_release(outsock);
13428 outsock = ast_netsock_list_alloc();
13429 if (!outsock) {
13430 ast_log(LOG_ERROR, "Could not allocate outsock list.\n");
13431 return -1;
13432 }
13433 ast_netsock_init(outsock);
13434 }
13435
13436 if (min_reg_expire > max_reg_expire) {
13437 ast_log(LOG_WARNING, "Minimum registration interval of %d is more than maximum of %d, resetting minimum to %d\n",
13438 min_reg_expire, max_reg_expire, max_reg_expire);
13439 min_reg_expire = max_reg_expire;
13440 }
13441 iax2_capability = capability;
13442
13443 if (ucfg) {
13444 struct ast_variable *gen;
13445 int genhasiax;
13446 int genregisteriax;
13447 const char *hasiax, *registeriax;
13448
13449 genhasiax = ast_true(ast_variable_retrieve(ucfg, "general", "hasiax"));
13450 genregisteriax = ast_true(ast_variable_retrieve(ucfg, "general", "registeriax"));
13451 gen = ast_variable_browse(ucfg, "general");
13452 cat = ast_category_browse(ucfg, NULL);
13453 while (cat) {
13454 if (strcasecmp(cat, "general")) {
13455 hasiax = ast_variable_retrieve(ucfg, cat, "hasiax");
13456 registeriax = ast_variable_retrieve(ucfg, cat, "registeriax");
13457 if (ast_true(hasiax) || (!hasiax && genhasiax)) {
13458
13459 user = build_user(cat, gen, ast_variable_browse(ucfg, cat), 0);
13460 if (user) {
13461 ao2_link(users, user);
13462 user = user_unref(user);
13463 }
13464 peer = build_peer(cat, gen, ast_variable_browse(ucfg, cat), 0);
13465 if (peer) {
13466 if (ast_test_flag64(peer, IAX_DYNAMIC))
13467 reg_source_db(peer);
13468 ao2_link(peers, peer);
13469 peer = peer_unref(peer);
13470 }
13471 }
13472 if (ast_true(registeriax) || (!registeriax && genregisteriax)) {
13473 char tmp[256];
13474 const char *host = ast_variable_retrieve(ucfg, cat, "host");
13475 const char *username = ast_variable_retrieve(ucfg, cat, "username");
13476 const char *secret = ast_variable_retrieve(ucfg, cat, "secret");
13477 if (!host)
13478 host = ast_variable_retrieve(ucfg, "general", "host");
13479 if (!username)
13480 username = ast_variable_retrieve(ucfg, "general", "username");
13481 if (!secret)
13482 secret = ast_variable_retrieve(ucfg, "general", "secret");
13483 if (!ast_strlen_zero(username) && !ast_strlen_zero(host)) {
13484 if (!ast_strlen_zero(secret))
13485 snprintf(tmp, sizeof(tmp), "%s:%s@%s", username, secret, host);
13486 else
13487 snprintf(tmp, sizeof(tmp), "%s@%s", username, host);
13488 iax2_register(tmp, 0);
13489 }
13490 }
13491 }
13492 cat = ast_category_browse(ucfg, cat);
13493 }
13494 ast_config_destroy(ucfg);
13495 }
13496
13497 cat = ast_category_browse(cfg, NULL);
13498 while(cat) {
13499 if (strcasecmp(cat, "general")) {
13500 utype = ast_variable_retrieve(cfg, cat, "type");
13501 if (!strcasecmp(cat, "callnumberlimits")) {
13502 build_callno_limits(ast_variable_browse(cfg, cat));
13503 } else if (utype) {
13504 if (!strcasecmp(utype, "user") || !strcasecmp(utype, "friend")) {
13505 user = build_user(cat, ast_variable_browse(cfg, cat), NULL, 0);
13506 if (user) {
13507 ao2_link(users, user);
13508 user = user_unref(user);
13509 }
13510 }
13511 if (!strcasecmp(utype, "peer") || !strcasecmp(utype, "friend")) {
13512 peer = build_peer(cat, ast_variable_browse(cfg, cat), NULL, 0);
13513 if (peer) {
13514 if (ast_test_flag64(peer, IAX_DYNAMIC))
13515 reg_source_db(peer);
13516 ao2_link(peers, peer);
13517 peer = peer_unref(peer);
13518 }
13519 } else if (strcasecmp(utype, "user")) {
13520 ast_log(LOG_WARNING, "Unknown type '%s' for '%s' in %s\n", utype, cat, config_file);
13521 }
13522 } else
13523 ast_log(LOG_WARNING, "Section '%s' lacks type\n", cat);
13524 }
13525 cat = ast_category_browse(cfg, cat);
13526 }
13527 ast_config_destroy(cfg);
13528 return 1;
13529 }
13530
13531 static void poke_all_peers(void)
13532 {
13533 struct ao2_iterator i;
13534 struct iax2_peer *peer;
13535
13536 i = ao2_iterator_init(peers, 0);
13537 while ((peer = ao2_iterator_next(&i))) {
13538 iax2_poke_peer(peer, 0);
13539 peer_unref(peer);
13540 }
13541 ao2_iterator_destroy(&i);
13542 }
13543 static int reload_config(void)
13544 {
13545 static const char config[] = "iax.conf";
13546 struct iax2_registry *reg;
13547
13548 if (set_config(config, 1) > 0) {
13549 prune_peers();
13550 prune_users();
13551 ao2_callback(callno_limits, OBJ_NODATA | OBJ_UNLINK | OBJ_MULTIPLE, prune_addr_range_cb, NULL);
13552 ao2_callback(calltoken_ignores, OBJ_NODATA | OBJ_UNLINK | OBJ_MULTIPLE, prune_addr_range_cb, NULL);
13553 ao2_callback(peercnts, OBJ_NODATA, set_peercnt_limit_all_cb, NULL);
13554 trunk_timed = trunk_untimed = 0;
13555 trunk_nmaxmtu = trunk_maxmtu = 0;
13556 memset(&debugaddr, '\0', sizeof(debugaddr));
13557
13558 AST_LIST_LOCK(®istrations);
13559 AST_LIST_TRAVERSE(®istrations, reg, entry)
13560 iax2_do_register(reg);
13561 AST_LIST_UNLOCK(®istrations);
13562
13563
13564 poke_all_peers();
13565 }
13566
13567 reload_firmware(0);
13568 iax_provision_reload(1);
13569 ast_unload_realtime("iaxpeers");
13570
13571 return 0;
13572 }
13573
13574 static char *handle_cli_iax2_reload(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
13575 {
13576 switch (cmd) {
13577 case CLI_INIT:
13578 e->command = "iax2 reload";
13579 e->usage =
13580 "Usage: iax2 reload\n"
13581 " Reloads IAX configuration from iax.conf\n";
13582 return NULL;
13583 case CLI_GENERATE:
13584 return NULL;
13585 }
13586
13587 reload_config();
13588
13589 return CLI_SUCCESS;
13590 }
13591
13592 static int reload(void)
13593 {
13594 return reload_config();
13595 }
13596
13597 static int cache_get_callno_locked(const char *data)
13598 {
13599 struct sockaddr_in sin;
13600 int x;
13601 int callno;
13602 struct iax_ie_data ied;
13603 struct create_addr_info cai;
13604 struct parsed_dial_string pds;
13605 char *tmpstr;
13606
13607 for (x = 0; x < ARRAY_LEN(iaxs); x++) {
13608
13609
13610 if (!ast_mutex_trylock(&iaxsl[x])) {
13611 if (iaxs[x] && !strcasecmp(data, iaxs[x]->dproot))
13612 return x;
13613 ast_mutex_unlock(&iaxsl[x]);
13614 }
13615 }
13616
13617
13618
13619 memset(&cai, 0, sizeof(cai));
13620 memset(&ied, 0, sizeof(ied));
13621 memset(&pds, 0, sizeof(pds));
13622
13623 tmpstr = ast_strdupa(data);
13624 parse_dial_string(tmpstr, &pds);
13625
13626 if (ast_strlen_zero(pds.peer)) {
13627 ast_log(LOG_WARNING, "No peer provided in the IAX2 dial string '%s'\n", data);
13628 return -1;
13629 }
13630
13631
13632 if (create_addr(pds.peer, NULL, &sin, &cai))
13633 return -1;
13634
13635 ast_debug(1, "peer: %s, username: %s, password: %s, context: %s\n",
13636 pds.peer, pds.username, pds.password, pds.context);
13637
13638 callno = find_callno_locked(0, 0, &sin, NEW_FORCE, cai.sockfd, 0);
13639 if (callno < 1) {
13640 ast_log(LOG_WARNING, "Unable to create call\n");
13641 return -1;
13642 }
13643
13644 ast_string_field_set(iaxs[callno], dproot, data);
13645 iaxs[callno]->capability = IAX_CAPABILITY_FULLBANDWIDTH;
13646
13647 iax_ie_append_short(&ied, IAX_IE_VERSION, IAX_PROTO_VERSION);
13648 iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, "TBD");
13649
13650
13651
13652 if (pds.exten)
13653 iax_ie_append_str(&ied, IAX_IE_CALLED_CONTEXT, pds.exten);
13654 if (pds.username)
13655 iax_ie_append_str(&ied, IAX_IE_USERNAME, pds.username);
13656 iax_ie_append_int(&ied, IAX_IE_FORMAT, IAX_CAPABILITY_FULLBANDWIDTH);
13657 iax_ie_append_int(&ied, IAX_IE_CAPABILITY, IAX_CAPABILITY_FULLBANDWIDTH);
13658
13659 if (pds.password)
13660 ast_string_field_set(iaxs[callno], secret, pds.password);
13661 if (pds.key)
13662 ast_string_field_set(iaxs[callno], outkey, pds.key);
13663
13664 add_empty_calltoken_ie(iaxs[callno], &ied);
13665 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_NEW, 0, ied.buf, ied.pos, -1);
13666
13667 return callno;
13668 }
13669
13670 static struct iax2_dpcache *find_cache(struct ast_channel *chan, const char *data, const char *context, const char *exten, int priority)
13671 {
13672 struct iax2_dpcache *dp = NULL;
13673 struct timeval now = ast_tvnow();
13674 int x, com[2], timeout, old = 0, outfd, doabort, callno;
13675 struct ast_channel *c = NULL;
13676 struct ast_frame *f = NULL;
13677
13678 AST_LIST_TRAVERSE_SAFE_BEGIN(&dpcache, dp, cache_list) {
13679 if (ast_tvcmp(now, dp->expiry) > 0) {
13680 AST_LIST_REMOVE_CURRENT(cache_list);
13681 if ((dp->flags & CACHE_FLAG_PENDING) || dp->callno)
13682 ast_log(LOG_WARNING, "DP still has peer field or pending or callno (flags = %d, peer = blah, callno = %d)\n", dp->flags, dp->callno);
13683 else
13684 ast_free(dp);
13685 continue;
13686 }
13687 if (!strcmp(dp->peercontext, data) && !strcmp(dp->exten, exten))
13688 break;
13689 }
13690 AST_LIST_TRAVERSE_SAFE_END;
13691
13692 if (!dp) {
13693
13694
13695 if ((callno = cache_get_callno_locked(data)) < 0) {
13696 ast_log(LOG_WARNING, "Unable to generate call for '%s'\n", data);
13697 return NULL;
13698 }
13699 if (!(dp = ast_calloc(1, sizeof(*dp)))) {
13700 ast_mutex_unlock(&iaxsl[callno]);
13701 return NULL;
13702 }
13703 ast_copy_string(dp->peercontext, data, sizeof(dp->peercontext));
13704 ast_copy_string(dp->exten, exten, sizeof(dp->exten));
13705 dp->expiry = ast_tvnow();
13706 dp->orig = dp->expiry;
13707
13708 dp->expiry.tv_sec += iaxdefaultdpcache;
13709 dp->flags = CACHE_FLAG_PENDING;
13710 for (x = 0; x < ARRAY_LEN(dp->waiters); x++)
13711 dp->waiters[x] = -1;
13712
13713 AST_LIST_INSERT_TAIL(&dpcache, dp, cache_list);
13714 AST_LIST_INSERT_TAIL(&iaxs[callno]->dpentries, dp, peer_list);
13715
13716 if (ast_test_flag(&iaxs[callno]->state, IAX_STATE_STARTED))
13717 iax2_dprequest(dp, callno);
13718 ast_mutex_unlock(&iaxsl[callno]);
13719 }
13720
13721
13722 if (dp->flags & CACHE_FLAG_PENDING) {
13723 struct timeval start;
13724 int ms;
13725
13726
13727 for (x = 0; x < ARRAY_LEN(dp->waiters); x++) {
13728
13729 if (dp->waiters[x] < 0)
13730 break;
13731 }
13732 if (x >= ARRAY_LEN(dp->waiters)) {
13733 ast_log(LOG_WARNING, "No more waiter positions available\n");
13734 return NULL;
13735 }
13736 if (pipe(com)) {
13737 ast_log(LOG_WARNING, "Unable to create pipe for comm\n");
13738 return NULL;
13739 }
13740 dp->waiters[x] = com[1];
13741
13742 timeout = iaxdefaulttimeout * 1000;
13743
13744 AST_LIST_UNLOCK(&dpcache);
13745
13746 if (chan)
13747 old = ast_channel_defer_dtmf(chan);
13748 doabort = 0;
13749 start = ast_tvnow();
13750 while ((ms = ast_remaining_ms(start, timeout))) {
13751 c = ast_waitfor_nandfds(&chan, chan ? 1 : 0, &com[0], 1, NULL, &outfd, &ms);
13752 if (outfd > -1)
13753 break;
13754 if (!c)
13755 continue;
13756 if (!(f = ast_read(c))) {
13757 doabort = 1;
13758 break;
13759 }
13760 ast_frfree(f);
13761 }
13762 if (!ms) {
13763 ast_log(LOG_WARNING, "Timeout waiting for %s exten %s\n", data, exten);
13764 }
13765 AST_LIST_LOCK(&dpcache);
13766 dp->waiters[x] = -1;
13767 close(com[1]);
13768 close(com[0]);
13769 if (doabort) {
13770
13771
13772 if (!old && chan)
13773 ast_channel_undefer_dtmf(chan);
13774 return NULL;
13775 }
13776 if (!(dp->flags & CACHE_FLAG_TIMEOUT)) {
13777
13778 if (dp->flags & CACHE_FLAG_PENDING) {
13779
13780
13781 dp->flags &= ~CACHE_FLAG_PENDING;
13782 dp->flags |= CACHE_FLAG_TIMEOUT;
13783
13784
13785 dp->expiry.tv_sec = dp->orig.tv_sec + 60;
13786 for (x = 0; x < ARRAY_LEN(dp->waiters); x++) {
13787 if (dp->waiters[x] > -1) {
13788 if (write(dp->waiters[x], "asdf", 4) < 0) {
13789 ast_log(LOG_WARNING, "write() failed: %s\n", strerror(errno));
13790 }
13791 }
13792 }
13793 }
13794 }
13795
13796 if (!old && chan)
13797 ast_channel_undefer_dtmf(chan);
13798 }
13799 return dp;
13800 }
13801
13802
13803 static int iax2_exists(struct ast_channel *chan, const char *context, const char *exten, int priority, const char *callerid, const char *data)
13804 {
13805 int res = 0;
13806 struct iax2_dpcache *dp = NULL;
13807 #if 0
13808 ast_log(LOG_NOTICE, "iax2_exists: con: %s, exten: %s, pri: %d, cid: %s, data: %s\n", context, exten, priority, callerid ? callerid : "<unknown>", data);
13809 #endif
13810 if ((priority != 1) && (priority != 2))
13811 return 0;
13812
13813 AST_LIST_LOCK(&dpcache);
13814 if ((dp = find_cache(chan, data, context, exten, priority))) {
13815 if (dp->flags & CACHE_FLAG_EXISTS)
13816 res = 1;
13817 } else {
13818 ast_log(LOG_WARNING, "Unable to make DP cache\n");
13819 }
13820 AST_LIST_UNLOCK(&dpcache);
13821
13822 return res;
13823 }
13824
13825
13826 static int iax2_canmatch(struct ast_channel *chan, const char *context, const char *exten, int priority, const char *callerid, const char *data)
13827 {
13828 int res = 0;
13829 struct iax2_dpcache *dp = NULL;
13830 #if 0
13831 ast_log(LOG_NOTICE, "iax2_canmatch: con: %s, exten: %s, pri: %d, cid: %s, data: %s\n", context, exten, priority, callerid ? callerid : "<unknown>", data);
13832 #endif
13833 if ((priority != 1) && (priority != 2))
13834 return 0;
13835
13836 AST_LIST_LOCK(&dpcache);
13837 if ((dp = find_cache(chan, data, context, exten, priority))) {
13838 if (dp->flags & CACHE_FLAG_CANEXIST)
13839 res = 1;
13840 } else {
13841 ast_log(LOG_WARNING, "Unable to make DP cache\n");
13842 }
13843 AST_LIST_UNLOCK(&dpcache);
13844
13845 return res;
13846 }
13847
13848
13849 static int iax2_matchmore(struct ast_channel *chan, const char *context, const char *exten, int priority, const char *callerid, const char *data)
13850 {
13851 int res = 0;
13852 struct iax2_dpcache *dp = NULL;
13853 #if 0
13854 ast_log(LOG_NOTICE, "iax2_matchmore: con: %s, exten: %s, pri: %d, cid: %s, data: %s\n", context, exten, priority, callerid ? callerid : "<unknown>", data);
13855 #endif
13856 if ((priority != 1) && (priority != 2))
13857 return 0;
13858
13859 AST_LIST_LOCK(&dpcache);
13860 if ((dp = find_cache(chan, data, context, exten, priority))) {
13861 if (dp->flags & CACHE_FLAG_MATCHMORE)
13862 res = 1;
13863 } else {
13864 ast_log(LOG_WARNING, "Unable to make DP cache\n");
13865 }
13866 AST_LIST_UNLOCK(&dpcache);
13867
13868 return res;
13869 }
13870
13871
13872 static int iax2_exec(struct ast_channel *chan, const char *context, const char *exten, int priority, const char *callerid, const char *data)
13873 {
13874 char odata[256];
13875 char req[256];
13876 char *ncontext;
13877 struct iax2_dpcache *dp = NULL;
13878 struct ast_app *dial = NULL;
13879 #if 0
13880 ast_log(LOG_NOTICE, "iax2_exec: con: %s, exten: %s, pri: %d, cid: %s, data: %s, newstack: %d\n", context, exten, priority, callerid ? callerid : "<unknown>", data, newstack);
13881 #endif
13882 if (priority == 2) {
13883
13884 const char *dialstatus = pbx_builtin_getvar_helper(chan, "DIALSTATUS");
13885 if (dialstatus) {
13886 dial = pbx_findapp(dialstatus);
13887 if (dial)
13888 pbx_exec(chan, dial, "");
13889 }
13890 return -1;
13891 } else if (priority != 1)
13892 return -1;
13893
13894 AST_LIST_LOCK(&dpcache);
13895 if ((dp = find_cache(chan, data, context, exten, priority))) {
13896 if (dp->flags & CACHE_FLAG_EXISTS) {
13897 ast_copy_string(odata, data, sizeof(odata));
13898 ncontext = strchr(odata, '/');
13899 if (ncontext) {
13900 *ncontext = '\0';
13901 ncontext++;
13902 snprintf(req, sizeof(req), "IAX2/%s/%s@%s", odata, exten, ncontext);
13903 } else {
13904 snprintf(req, sizeof(req), "IAX2/%s/%s", odata, exten);
13905 }
13906 ast_verb(3, "Executing Dial('%s')\n", req);
13907 } else {
13908 AST_LIST_UNLOCK(&dpcache);
13909 ast_log(LOG_WARNING, "Can't execute nonexistent extension '%s[@%s]' in data '%s'\n", exten, context, data);
13910 return -1;
13911 }
13912 }
13913 AST_LIST_UNLOCK(&dpcache);
13914
13915 if ((dial = pbx_findapp("Dial")))
13916 return pbx_exec(chan, dial, req);
13917 else
13918 ast_log(LOG_WARNING, "No dial application registered\n");
13919
13920 return -1;
13921 }
13922
13923 static int function_iaxpeer(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
13924 {
13925 struct iax2_peer *peer;
13926 char *peername, *colname;
13927
13928 peername = ast_strdupa(data);
13929
13930
13931 if (!strcmp(peername,"CURRENTCHANNEL")) {
13932 unsigned short callno;
13933 if (chan->tech != &iax2_tech)
13934 return -1;
13935 callno = PTR_TO_CALLNO(chan->tech_pvt);
13936 ast_copy_string(buf, iaxs[callno]->addr.sin_addr.s_addr ? ast_inet_ntoa(iaxs[callno]->addr.sin_addr) : "", len);
13937 return 0;
13938 }
13939
13940 if ((colname = strchr(peername, ',')))
13941 *colname++ = '\0';
13942 else
13943 colname = "ip";
13944
13945 if (!(peer = find_peer(peername, 1)))
13946 return -1;
13947
13948 if (!strcasecmp(colname, "ip")) {
13949 ast_copy_string(buf, ast_sockaddr_stringify_addr(&peer->addr), len);
13950 } else if (!strcasecmp(colname, "status")) {
13951 peer_status(peer, buf, len);
13952 } else if (!strcasecmp(colname, "mailbox")) {
13953 ast_copy_string(buf, peer->mailbox, len);
13954 } else if (!strcasecmp(colname, "context")) {
13955 ast_copy_string(buf, peer->context, len);
13956 } else if (!strcasecmp(colname, "expire")) {
13957 snprintf(buf, len, "%d", peer->expire);
13958 } else if (!strcasecmp(colname, "dynamic")) {
13959 ast_copy_string(buf, (ast_test_flag64(peer, IAX_DYNAMIC) ? "yes" : "no"), len);
13960 } else if (!strcasecmp(colname, "callerid_name")) {
13961 ast_copy_string(buf, peer->cid_name, len);
13962 } else if (!strcasecmp(colname, "callerid_num")) {
13963 ast_copy_string(buf, peer->cid_num, len);
13964 } else if (!strcasecmp(colname, "codecs")) {
13965 ast_getformatname_multiple(buf, len -1, peer->capability);
13966 } else if (!strncasecmp(colname, "codec[", 6)) {
13967 char *codecnum, *ptr;
13968 int codec = 0;
13969
13970
13971 codecnum = colname + 5;
13972 *codecnum = '\0';
13973 codecnum++;
13974 if ((ptr = strchr(codecnum, ']'))) {
13975 *ptr = '\0';
13976 }
13977 if((codec = ast_codec_pref_index(&peer->prefs, atoi(codecnum)))) {
13978 ast_copy_string(buf, ast_getformatname(codec), len);
13979 } else {
13980 buf[0] = '\0';
13981 }
13982 } else {
13983 buf[0] = '\0';
13984 }
13985
13986 peer_unref(peer);
13987
13988 return 0;
13989 }
13990
13991 static struct ast_custom_function iaxpeer_function = {
13992 .name = "IAXPEER",
13993 .read = function_iaxpeer,
13994 };
13995
13996 static int acf_channel_read(struct ast_channel *chan, const char *funcname, char *args, char *buf, size_t buflen)
13997 {
13998 struct chan_iax2_pvt *pvt;
13999 unsigned int callno;
14000 int res = 0;
14001
14002 if (!chan || chan->tech != &iax2_tech) {
14003 ast_log(LOG_ERROR, "This function requires a valid IAX2 channel\n");
14004 return -1;
14005 }
14006
14007 callno = PTR_TO_CALLNO(chan->tech_pvt);
14008 ast_mutex_lock(&iaxsl[callno]);
14009 if (!(pvt = iaxs[callno])) {
14010 ast_mutex_unlock(&iaxsl[callno]);
14011 return -1;
14012 }
14013
14014 if (!strcasecmp(args, "osptoken")) {
14015 ast_copy_string(buf, pvt->osptoken, buflen);
14016 } else if (!strcasecmp(args, "peerip")) {
14017 ast_copy_string(buf, pvt->addr.sin_addr.s_addr ? ast_inet_ntoa(pvt->addr.sin_addr) : "", buflen);
14018 } else if (!strcasecmp(args, "peername")) {
14019 ast_copy_string(buf, pvt->username, buflen);
14020 } else if (!strcasecmp(args, "secure_signaling") || !strcasecmp(args, "secure_media")) {
14021 snprintf(buf, buflen, "%s", IAX_CALLENCRYPTED(pvt) ? "1" : "");
14022 } else {
14023 res = -1;
14024 }
14025
14026 ast_mutex_unlock(&iaxsl[callno]);
14027
14028 return res;
14029 }
14030
14031
14032 static int iax2_devicestate(void *data)
14033 {
14034 struct parsed_dial_string pds;
14035 char *tmp = ast_strdupa(data);
14036 struct iax2_peer *p;
14037 int res = AST_DEVICE_INVALID;
14038
14039 memset(&pds, 0, sizeof(pds));
14040 parse_dial_string(tmp, &pds);
14041
14042 if (ast_strlen_zero(pds.peer)) {
14043 ast_log(LOG_WARNING, "No peer provided in the IAX2 dial string '%s'\n", (char *) data);
14044 return res;
14045 }
14046
14047 ast_debug(3, "Checking device state for device %s\n", pds.peer);
14048
14049
14050 if (!(p = find_peer(pds.peer, 1)))
14051 return res;
14052
14053 res = AST_DEVICE_UNAVAILABLE;
14054 ast_debug(3, "iax2_devicestate: Found peer. What's device state of %s? addr=%d, defaddr=%d maxms=%d, lastms=%d\n",
14055 pds.peer, ast_sockaddr_ipv4(&p->addr), p->defaddr.sin_addr.s_addr, p->maxms, p->lastms);
14056
14057 if ((ast_sockaddr_ipv4(&p->addr) || p->defaddr.sin_addr.s_addr) &&
14058 (!p->maxms || ((p->lastms > -1) && (p->historicms <= p->maxms)))) {
14059
14060
14061 if (p->historicms == 0 || p->historicms <= p->maxms)
14062
14063 res = AST_DEVICE_UNKNOWN;
14064 }
14065
14066 peer_unref(p);
14067
14068 return res;
14069 }
14070
14071 static struct ast_switch iax2_switch =
14072 {
14073 .name = "IAX2",
14074 .description = "IAX Remote Dialplan Switch",
14075 .exists = iax2_exists,
14076 .canmatch = iax2_canmatch,
14077 .exec = iax2_exec,
14078 .matchmore = iax2_matchmore,
14079 };
14080
14081
14082
14083
14084
14085
14086
14087
14088
14089
14090
14091
14092
14093
14094
14095
14096
14097
14098
14099
14100
14101
14102
14103
14104
14105
14106
14107
14108
14109
14110
14111
14112
14113
14114
14115
14116
14117
14118
14119
14120
14121
14122
14123
14124
14125
14126
14127
14128
14129
14130
14131
14132
14133
14134
14135
14136
14137
14138
14139
14140
14141
14142
14143
14144
14145
14146
14147
14148
14149
14150
14151
14152
14153
14154
14155
14156
14157
14158
14159
14160
14161
14162
14163
14164
14165
14166
14167
14168
14169
14170
14171
14172
14173
14174
14175
14176
14177
14178
14179
14180
14181
14182
14183
14184
14185 static struct ast_cli_entry cli_iax2[] = {
14186 AST_CLI_DEFINE(handle_cli_iax2_provision, "Provision an IAX device"),
14187 AST_CLI_DEFINE(handle_cli_iax2_prune_realtime, "Prune a cached realtime lookup"),
14188 AST_CLI_DEFINE(handle_cli_iax2_reload, "Reload IAX configuration"),
14189 AST_CLI_DEFINE(handle_cli_iax2_set_mtu, "Set the IAX systemwide trunking MTU"),
14190 AST_CLI_DEFINE(handle_cli_iax2_set_debug, "Enable/Disable IAX debugging"),
14191 AST_CLI_DEFINE(handle_cli_iax2_set_debug_trunk, "Enable/Disable IAX trunk debugging"),
14192 AST_CLI_DEFINE(handle_cli_iax2_set_debug_jb, "Enable/Disable IAX jitterbuffer debugging"),
14193 AST_CLI_DEFINE(handle_cli_iax2_show_cache, "Display IAX cached dialplan"),
14194 AST_CLI_DEFINE(handle_cli_iax2_show_channels, "List active IAX channels"),
14195 AST_CLI_DEFINE(handle_cli_iax2_show_firmware, "List available IAX firmware"),
14196 AST_CLI_DEFINE(handle_cli_iax2_show_netstats, "List active IAX channel netstats"),
14197 AST_CLI_DEFINE(handle_cli_iax2_show_peer, "Show details on specific IAX peer"),
14198 AST_CLI_DEFINE(handle_cli_iax2_show_peers, "List defined IAX peers"),
14199 AST_CLI_DEFINE(handle_cli_iax2_show_registry, "Display IAX registration status"),
14200 AST_CLI_DEFINE(handle_cli_iax2_show_stats, "Display IAX statistics"),
14201 AST_CLI_DEFINE(handle_cli_iax2_show_threads, "Display IAX helper thread info"),
14202 AST_CLI_DEFINE(handle_cli_iax2_show_users, "List defined IAX users"),
14203 AST_CLI_DEFINE(handle_cli_iax2_test_losspct, "Set IAX2 incoming frame loss percentage"),
14204 AST_CLI_DEFINE(handle_cli_iax2_unregister, "Unregister (force expiration) an IAX2 peer from the registry"),
14205 AST_CLI_DEFINE(handle_cli_iax2_show_callno_limits, "Show current entries in IP call number limit table"),
14206 #ifdef IAXTESTS
14207 AST_CLI_DEFINE(handle_cli_iax2_test_jitter, "Simulates jitter for testing"),
14208 AST_CLI_DEFINE(handle_cli_iax2_test_late, "Test the receipt of a late frame"),
14209 AST_CLI_DEFINE(handle_cli_iax2_test_resync, "Test a resync in received timestamps"),
14210 #endif
14211 };
14212
14213 #ifdef TEST_FRAMEWORK
14214 AST_TEST_DEFINE(test_iax2_peers_get)
14215 {
14216 struct ast_data_query query = {
14217 .path = "/asterisk/channel/iax2/peers",
14218 .search = "peers/peer/name=test_peer_data_provider"
14219 };
14220 struct ast_data *node;
14221 struct iax2_peer *peer;
14222
14223 switch (cmd) {
14224 case TEST_INIT:
14225 info->name = "iax2_peers_get_data_test";
14226 info->category = "/main/data/iax2/peers/";
14227 info->summary = "IAX2 peers data providers unit test";
14228 info->description =
14229 "Tests whether the IAX2 peers data provider implementation works as expected.";
14230 return AST_TEST_NOT_RUN;
14231 case TEST_EXECUTE:
14232 break;
14233 }
14234
14235
14236 peer = build_peer("test_peer_data_provider", NULL, NULL, 0);
14237 if (!peer) {
14238 return AST_TEST_FAIL;
14239 }
14240 peer->expiry= 1010;
14241 ao2_link(peers, peer);
14242
14243 node = ast_data_get(&query);
14244 if (!node) {
14245 ao2_unlink(peers, peer);
14246 peer_unref(peer);
14247 return AST_TEST_FAIL;
14248 }
14249
14250
14251 if (strcmp(ast_data_retrieve_string(node, "peer/name"), "test_peer_data_provider")) {
14252 ao2_unlink(peers, peer);
14253 peer_unref(peer);
14254 ast_data_free(node);
14255 return AST_TEST_FAIL;
14256 }
14257
14258 if (ast_data_retrieve_int(node, "peer/expiry") != 1010) {
14259 ao2_unlink(peers, peer);
14260 peer_unref(peer);
14261 ast_data_free(node);
14262 return AST_TEST_FAIL;
14263 }
14264
14265
14266 ast_data_free(node);
14267
14268 ao2_unlink(peers, peer);
14269 peer_unref(peer);
14270
14271 return AST_TEST_PASS;
14272 }
14273
14274 AST_TEST_DEFINE(test_iax2_users_get)
14275 {
14276 struct ast_data_query query = {
14277 .path = "/asterisk/channel/iax2/users",
14278 .search = "users/user/name=test_user_data_provider"
14279 };
14280 struct ast_data *node;
14281 struct iax2_user *user;
14282
14283 switch (cmd) {
14284 case TEST_INIT:
14285 info->name = "iax2_users_get_data_test";
14286 info->category = "/main/data/iax2/users/";
14287 info->summary = "IAX2 users data providers unit test";
14288 info->description =
14289 "Tests whether the IAX2 users data provider implementation works as expected.";
14290 return AST_TEST_NOT_RUN;
14291 case TEST_EXECUTE:
14292 break;
14293 }
14294
14295 user = build_user("test_user_data_provider", NULL, NULL, 0);
14296 if (!user) {
14297 ast_test_status_update(test, "Failed to build a test user\n");
14298 return AST_TEST_FAIL;
14299 }
14300 user->amaflags = 1010;
14301 ao2_link(users, user);
14302
14303 node = ast_data_get(&query);
14304 if (!node) {
14305 ast_test_status_update(test, "The data query to find our test user failed\n");
14306 ao2_unlink(users, user);
14307 user_unref(user);
14308 return AST_TEST_FAIL;
14309 }
14310
14311 if (strcmp(ast_data_retrieve_string(node, "user/name"), "test_user_data_provider")) {
14312 ast_test_status_update(test, "Our data results did not return the test user created in the previous step.\n");
14313 ao2_unlink(users, user);
14314 user_unref(user);
14315 ast_data_free(node);
14316 return AST_TEST_FAIL;
14317 }
14318
14319 if (ast_data_retrieve_int(node, "user/amaflags/value") != 1010) {
14320 ast_test_status_update(test, "The amaflags field in our test user was '%d' not the expected value '1010'\n", ast_data_retrieve_int(node, "user/amaflags/value"));
14321 ao2_unlink(users, user);
14322 user_unref(user);
14323 ast_data_free(node);
14324 return AST_TEST_FAIL;
14325 }
14326
14327 ast_data_free(node);
14328
14329 ao2_unlink(users, user);
14330 user_unref(user);
14331
14332 return AST_TEST_PASS;
14333 }
14334 #endif
14335
14336 static void cleanup_thread_list(void *head)
14337 {
14338 AST_LIST_HEAD(iax2_thread_list, iax2_thread);
14339 struct iax2_thread_list *list_head = head;
14340 struct iax2_thread *thread;
14341
14342 AST_LIST_LOCK(list_head);
14343 while ((thread = AST_LIST_REMOVE_HEAD(&idle_list, list))) {
14344 pthread_t thread_id = thread->threadid;
14345
14346 thread->stop = 1;
14347 signal_condition(&thread->lock, &thread->cond);
14348
14349 AST_LIST_UNLOCK(list_head);
14350 pthread_join(thread_id, NULL);
14351 AST_LIST_LOCK(list_head);
14352 }
14353 AST_LIST_UNLOCK(list_head);
14354 }
14355
14356 static int __unload_module(void)
14357 {
14358 struct ast_context *con;
14359 int x;
14360
14361 network_change_event_unsubscribe();
14362
14363 ast_manager_unregister("IAXpeers");
14364 ast_manager_unregister("IAXpeerlist");
14365 ast_manager_unregister("IAXnetstats");
14366 ast_manager_unregister("IAXregistry");
14367 ast_unregister_application(papp);
14368 ast_cli_unregister_multiple(cli_iax2, ARRAY_LEN(cli_iax2));
14369 ast_unregister_switch(&iax2_switch);
14370 ast_channel_unregister(&iax2_tech);
14371
14372 if (netthreadid != AST_PTHREADT_NULL) {
14373 pthread_cancel(netthreadid);
14374 pthread_kill(netthreadid, SIGURG);
14375 pthread_join(netthreadid, NULL);
14376 }
14377
14378 for (x = 0; x < ARRAY_LEN(iaxs); x++) {
14379 if (iaxs[x]) {
14380 iax2_destroy(x);
14381 }
14382 }
14383
14384
14385 cleanup_thread_list(&idle_list);
14386 cleanup_thread_list(&active_list);
14387 cleanup_thread_list(&dynamic_list);
14388
14389 ast_netsock_release(netsock);
14390 ast_netsock_release(outsock);
14391 for (x = 0; x < ARRAY_LEN(iaxs); x++) {
14392 if (iaxs[x]) {
14393 iax2_destroy(x);
14394 }
14395 }
14396 ast_manager_unregister( "IAXpeers" );
14397 ast_manager_unregister( "IAXpeerlist" );
14398 ast_manager_unregister( "IAXnetstats" );
14399 ast_manager_unregister( "IAXregistry" );
14400 ast_unregister_application(papp);
14401 #ifdef TEST_FRAMEWORK
14402 AST_TEST_UNREGISTER(test_iax2_peers_get);
14403 AST_TEST_UNREGISTER(test_iax2_users_get);
14404 #endif
14405 ast_data_unregister(NULL);
14406 ast_cli_unregister_multiple(cli_iax2, ARRAY_LEN(cli_iax2));
14407 ast_unregister_switch(&iax2_switch);
14408 ast_channel_unregister(&iax2_tech);
14409 delete_users();
14410 iax_provision_unload();
14411 reload_firmware(1);
14412
14413 for (x = 0; x < ARRAY_LEN(iaxsl); x++) {
14414 ast_mutex_destroy(&iaxsl[x]);
14415 }
14416
14417 ao2_ref(peers, -1);
14418 ao2_ref(users, -1);
14419 ao2_ref(iax_peercallno_pvts, -1);
14420 ao2_ref(iax_transfercallno_pvts, -1);
14421 ao2_ref(peercnts, -1);
14422 ao2_ref(callno_limits, -1);
14423 ao2_ref(calltoken_ignores, -1);
14424 ao2_ref(callno_pool, -1);
14425 ao2_ref(callno_pool_trunk, -1);
14426 if (timer) {
14427 ast_timer_close(timer);
14428 timer = NULL;
14429 }
14430 transmit_processor = ast_taskprocessor_unreference(transmit_processor);
14431 sched = ast_sched_thread_destroy(sched);
14432
14433 con = ast_context_find(regcontext);
14434 if (con)
14435 ast_context_destroy(con, "IAX2");
14436 ast_unload_realtime("iaxpeers");
14437 return 0;
14438 }
14439
14440 static int unload_module(void)
14441 {
14442 ast_custom_function_unregister(&iaxpeer_function);
14443 ast_custom_function_unregister(&iaxvar_function);
14444 return __unload_module();
14445 }
14446
14447 static int peer_set_sock_cb(void *obj, void *arg, int flags)
14448 {
14449 struct iax2_peer *peer = obj;
14450
14451 if (peer->sockfd < 0)
14452 peer->sockfd = defaultsockfd;
14453
14454 return 0;
14455 }
14456
14457 static int pvt_hash_cb(const void *obj, const int flags)
14458 {
14459 const struct chan_iax2_pvt *pvt = obj;
14460
14461 return pvt->peercallno;
14462 }
14463
14464 static int pvt_cmp_cb(void *obj, void *arg, int flags)
14465 {
14466 struct chan_iax2_pvt *pvt = obj, *pvt2 = arg;
14467
14468
14469
14470
14471 return match(&pvt2->addr, pvt2->peercallno, pvt2->callno, pvt,
14472 pvt2->frames_received) ? CMP_MATCH | CMP_STOP : 0;
14473 }
14474
14475 static int transfercallno_pvt_hash_cb(const void *obj, const int flags)
14476 {
14477 const struct chan_iax2_pvt *pvt = obj;
14478
14479 return pvt->transfercallno;
14480 }
14481
14482 static int transfercallno_pvt_cmp_cb(void *obj, void *arg, int flags)
14483 {
14484 struct chan_iax2_pvt *pvt = obj, *pvt2 = arg;
14485
14486
14487
14488
14489 return match(&pvt2->transfer, pvt2->transfercallno, pvt2->callno, pvt,
14490 pvt2->frames_received) ? CMP_MATCH | CMP_STOP : 0;
14491 }
14492
14493 static int load_objects(void)
14494 {
14495 peers = users = iax_peercallno_pvts = iax_transfercallno_pvts = NULL;
14496 peercnts = callno_limits = calltoken_ignores = callno_pool = callno_pool_trunk = NULL;
14497
14498 if (!(peers = ao2_container_alloc(MAX_PEER_BUCKETS, peer_hash_cb, peer_cmp_cb))) {
14499 goto container_fail;
14500 } else if (!(users = ao2_container_alloc(MAX_USER_BUCKETS, user_hash_cb, user_cmp_cb))) {
14501 goto container_fail;
14502 } else if (!(iax_peercallno_pvts = ao2_container_alloc(IAX_MAX_CALLS, pvt_hash_cb, pvt_cmp_cb))) {
14503 goto container_fail;
14504 } else if (!(iax_transfercallno_pvts = ao2_container_alloc(IAX_MAX_CALLS, transfercallno_pvt_hash_cb, transfercallno_pvt_cmp_cb))) {
14505 goto container_fail;
14506 } else if (!(peercnts = ao2_container_alloc(MAX_PEER_BUCKETS, peercnt_hash_cb, peercnt_cmp_cb))) {
14507 goto container_fail;
14508 } else if (!(callno_limits = ao2_container_alloc(MAX_PEER_BUCKETS, addr_range_hash_cb, addr_range_cmp_cb))) {
14509 goto container_fail;
14510 } else if (!(calltoken_ignores = ao2_container_alloc(MAX_PEER_BUCKETS, addr_range_hash_cb, addr_range_cmp_cb))) {
14511 goto container_fail;
14512 } else if (create_callno_pools()) {
14513 goto container_fail;
14514 } else if (!(transmit_processor = ast_taskprocessor_get("iax2_transmit", TPS_REF_DEFAULT))) {
14515 goto container_fail;
14516 }
14517
14518 return 0;
14519
14520 container_fail:
14521 if (peers) {
14522 ao2_ref(peers, -1);
14523 }
14524 if (users) {
14525 ao2_ref(users, -1);
14526 }
14527 if (iax_peercallno_pvts) {
14528 ao2_ref(iax_peercallno_pvts, -1);
14529 }
14530 if (iax_transfercallno_pvts) {
14531 ao2_ref(iax_transfercallno_pvts, -1);
14532 }
14533 if (peercnts) {
14534 ao2_ref(peercnts, -1);
14535 }
14536 if (callno_limits) {
14537 ao2_ref(callno_limits, -1);
14538 }
14539 if (calltoken_ignores) {
14540 ao2_ref(calltoken_ignores, -1);
14541 }
14542 if (callno_pool) {
14543 ao2_ref(callno_pool, -1);
14544 }
14545 if (callno_pool_trunk) {
14546 ao2_ref(callno_pool_trunk, -1);
14547 }
14548 return AST_MODULE_LOAD_FAILURE;
14549 }
14550
14551
14552 #define DATA_EXPORT_IAX2_PEER(MEMBER) \
14553 MEMBER(iax2_peer, name, AST_DATA_STRING) \
14554 MEMBER(iax2_peer, username, AST_DATA_STRING) \
14555 MEMBER(iax2_peer, secret, AST_DATA_PASSWORD) \
14556 MEMBER(iax2_peer, dbsecret, AST_DATA_PASSWORD) \
14557 MEMBER(iax2_peer, outkey, AST_DATA_STRING) \
14558 MEMBER(iax2_peer, regexten, AST_DATA_STRING) \
14559 MEMBER(iax2_peer, context, AST_DATA_STRING) \
14560 MEMBER(iax2_peer, peercontext, AST_DATA_STRING) \
14561 MEMBER(iax2_peer, mailbox, AST_DATA_STRING) \
14562 MEMBER(iax2_peer, mohinterpret, AST_DATA_STRING) \
14563 MEMBER(iax2_peer, mohsuggest, AST_DATA_STRING) \
14564 MEMBER(iax2_peer, inkeys, AST_DATA_STRING) \
14565 MEMBER(iax2_peer, cid_num, AST_DATA_STRING) \
14566 MEMBER(iax2_peer, cid_name, AST_DATA_STRING) \
14567 MEMBER(iax2_peer, zonetag, AST_DATA_STRING) \
14568 MEMBER(iax2_peer, parkinglot, AST_DATA_STRING) \
14569 MEMBER(iax2_peer, expiry, AST_DATA_SECONDS) \
14570 MEMBER(iax2_peer, callno, AST_DATA_INTEGER) \
14571 MEMBER(iax2_peer, lastms, AST_DATA_MILLISECONDS) \
14572 MEMBER(iax2_peer, maxms, AST_DATA_MILLISECONDS) \
14573 MEMBER(iax2_peer, pokefreqok, AST_DATA_MILLISECONDS) \
14574 MEMBER(iax2_peer, pokefreqnotok, AST_DATA_MILLISECONDS) \
14575 MEMBER(iax2_peer, historicms, AST_DATA_INTEGER) \
14576 MEMBER(iax2_peer, smoothing, AST_DATA_BOOLEAN) \
14577 MEMBER(iax2_peer, maxcallno, AST_DATA_INTEGER)
14578
14579 AST_DATA_STRUCTURE(iax2_peer, DATA_EXPORT_IAX2_PEER);
14580
14581 static int peers_data_provider_get(const struct ast_data_search *search,
14582 struct ast_data *data_root)
14583 {
14584 struct ast_data *data_peer;
14585 struct iax2_peer *peer;
14586 struct ao2_iterator i;
14587 char status[20];
14588 struct ast_str *encmethods = ast_str_alloca(256);
14589
14590 i = ao2_iterator_init(peers, 0);
14591 while ((peer = ao2_iterator_next(&i))) {
14592 data_peer = ast_data_add_node(data_root, "peer");
14593 if (!data_peer) {
14594 peer_unref(peer);
14595 continue;
14596 }
14597
14598 ast_data_add_structure(iax2_peer, data_peer, peer);
14599
14600 ast_data_add_codecs(data_peer, "codecs", peer->capability);
14601
14602 peer_status(peer, status, sizeof(status));
14603 ast_data_add_str(data_peer, "status", status);
14604
14605 ast_data_add_str(data_peer, "host", ast_sockaddr_stringify_host(&peer->addr));
14606
14607 ast_data_add_str(data_peer, "mask", ast_inet_ntoa(peer->mask));
14608
14609 ast_data_add_int(data_peer, "port", ast_sockaddr_port(&peer->addr));
14610
14611 ast_data_add_bool(data_peer, "trunk", ast_test_flag64(peer, IAX_TRUNK));
14612
14613 ast_data_add_bool(data_peer, "dynamic", ast_test_flag64(peer, IAX_DYNAMIC));
14614
14615 encmethods_to_str(peer->encmethods, &encmethods);
14616 ast_data_add_str(data_peer, "encryption", peer->encmethods ? ast_str_buffer(encmethods) : "no");
14617
14618 peer_unref(peer);
14619
14620 if (!ast_data_search_match(search, data_peer)) {
14621 ast_data_remove_node(data_root, data_peer);
14622 }
14623 }
14624 ao2_iterator_destroy(&i);
14625
14626 return 0;
14627 }
14628
14629 #define DATA_EXPORT_IAX2_USER(MEMBER) \
14630 MEMBER(iax2_user, name, AST_DATA_STRING) \
14631 MEMBER(iax2_user, dbsecret, AST_DATA_PASSWORD) \
14632 MEMBER(iax2_user, accountcode, AST_DATA_STRING) \
14633 MEMBER(iax2_user, mohinterpret, AST_DATA_STRING) \
14634 MEMBER(iax2_user, mohsuggest, AST_DATA_STRING) \
14635 MEMBER(iax2_user, inkeys, AST_DATA_STRING) \
14636 MEMBER(iax2_user, language, AST_DATA_STRING) \
14637 MEMBER(iax2_user, cid_num, AST_DATA_STRING) \
14638 MEMBER(iax2_user, cid_name, AST_DATA_STRING) \
14639 MEMBER(iax2_user, parkinglot, AST_DATA_STRING) \
14640 MEMBER(iax2_user, maxauthreq, AST_DATA_INTEGER) \
14641 MEMBER(iax2_user, curauthreq, AST_DATA_INTEGER)
14642
14643 AST_DATA_STRUCTURE(iax2_user, DATA_EXPORT_IAX2_USER);
14644
14645 static int users_data_provider_get(const struct ast_data_search *search,
14646 struct ast_data *data_root)
14647 {
14648 struct ast_data *data_user, *data_authmethods, *data_enum_node;
14649 struct iax2_user *user;
14650 struct ao2_iterator i;
14651 char auth[90];
14652 char *pstr = "";
14653
14654 i = ao2_iterator_init(users, 0);
14655 for (; (user = ao2_iterator_next(&i)); user_unref(user)) {
14656 data_user = ast_data_add_node(data_root, "user");
14657 if (!data_user) {
14658 continue;
14659 }
14660
14661 ast_data_add_structure(iax2_user, data_user, user);
14662
14663 ast_data_add_codecs(data_user, "codecs", user->capability);
14664
14665 if (!ast_strlen_zero(user->secret)) {
14666 ast_copy_string(auth, user->secret, sizeof(auth));
14667 } else if (!ast_strlen_zero(user->inkeys)) {
14668 snprintf(auth, sizeof(auth), "Key: %s", user->inkeys);
14669 } else {
14670 ast_copy_string(auth, "no secret", sizeof(auth));
14671 }
14672 ast_data_add_password(data_user, "secret", auth);
14673
14674 ast_data_add_str(data_user, "context", user->contexts ? user->contexts->context : DEFAULT_CONTEXT);
14675
14676
14677 data_authmethods = ast_data_add_node(data_user, "authmethods");
14678 if (!data_authmethods) {
14679 ast_data_remove_node(data_root, data_user);
14680 continue;
14681 }
14682 ast_data_add_bool(data_authmethods, "rsa", user->authmethods & IAX_AUTH_RSA);
14683 ast_data_add_bool(data_authmethods, "md5", user->authmethods & IAX_AUTH_MD5);
14684 ast_data_add_bool(data_authmethods, "plaintext", user->authmethods & IAX_AUTH_PLAINTEXT);
14685
14686
14687 data_enum_node = ast_data_add_node(data_user, "amaflags");
14688 if (!data_enum_node) {
14689 ast_data_remove_node(data_root, data_user);
14690 continue;
14691 }
14692 ast_data_add_int(data_enum_node, "value", user->amaflags);
14693 ast_data_add_str(data_enum_node, "text", ast_cdr_flags2str(user->amaflags));
14694
14695 ast_data_add_bool(data_user, "access-control", user->ha ? 1 : 0);
14696
14697 if (ast_test_flag64(user, IAX_CODEC_NOCAP)) {
14698 pstr = "REQ only";
14699 } else if (ast_test_flag64(user, IAX_CODEC_NOPREFS)) {
14700 pstr = "disabled";
14701 } else {
14702 pstr = ast_test_flag64(user, IAX_CODEC_USER_FIRST) ? "caller" : "host";
14703 }
14704 ast_data_add_str(data_user, "codec-preferences", pstr);
14705
14706 if (!ast_data_search_match(search, data_user)) {
14707 ast_data_remove_node(data_root, data_user);
14708 }
14709 }
14710 ao2_iterator_destroy(&i);
14711
14712 return 0;
14713 }
14714
14715 static const struct ast_data_handler peers_data_provider = {
14716 .version = AST_DATA_HANDLER_VERSION,
14717 .get = peers_data_provider_get
14718 };
14719
14720 static const struct ast_data_handler users_data_provider = {
14721 .version = AST_DATA_HANDLER_VERSION,
14722 .get = users_data_provider_get
14723 };
14724
14725 static const struct ast_data_entry iax2_data_providers[] = {
14726 AST_DATA_ENTRY("asterisk/channel/iax2/peers", &peers_data_provider),
14727 AST_DATA_ENTRY("asterisk/channel/iax2/users", &users_data_provider),
14728 };
14729
14730
14731 static int load_module(void)
14732 {
14733 static const char config[] = "iax.conf";
14734 int x = 0;
14735 struct iax2_registry *reg = NULL;
14736
14737 if (load_objects()) {
14738 return AST_MODULE_LOAD_FAILURE;
14739 }
14740
14741 memset(iaxs, 0, sizeof(iaxs));
14742
14743 for (x = 0; x < ARRAY_LEN(iaxsl); x++) {
14744 ast_mutex_init(&iaxsl[x]);
14745 }
14746
14747 if (!(sched = ast_sched_thread_create())) {
14748 ast_log(LOG_ERROR, "Failed to create scheduler thread\n");
14749 return AST_MODULE_LOAD_FAILURE;
14750 }
14751
14752 if (!(io = io_context_create())) {
14753 ast_log(LOG_ERROR, "Failed to create I/O context\n");
14754 sched = ast_sched_thread_destroy(sched);
14755 return AST_MODULE_LOAD_FAILURE;
14756 }
14757
14758 if (!(netsock = ast_netsock_list_alloc())) {
14759 ast_log(LOG_ERROR, "Failed to create netsock list\n");
14760 io_context_destroy(io);
14761 sched = ast_sched_thread_destroy(sched);
14762 return AST_MODULE_LOAD_FAILURE;
14763 }
14764 ast_netsock_init(netsock);
14765
14766 outsock = ast_netsock_list_alloc();
14767 if (!outsock) {
14768 ast_log(LOG_ERROR, "Could not allocate outsock list.\n");
14769 io_context_destroy(io);
14770 sched = ast_sched_thread_destroy(sched);
14771 return AST_MODULE_LOAD_FAILURE;
14772 }
14773 ast_netsock_init(outsock);
14774
14775 randomcalltokendata = ast_random();
14776
14777 iax_set_output(iax_debug_output);
14778 iax_set_error(iax_error_output);
14779 jb_setoutput(jb_error_output, jb_warning_output, NULL);
14780
14781 if ((timer = ast_timer_open())) {
14782 ast_timer_set_rate(timer, 1000 / trunkfreq);
14783 }
14784
14785 if (set_config(config, 0) == -1) {
14786 if (timer) {
14787 ast_timer_close(timer);
14788 timer = NULL;
14789 }
14790 return AST_MODULE_LOAD_DECLINE;
14791 }
14792
14793 #ifdef TEST_FRAMEWORK
14794 AST_TEST_REGISTER(test_iax2_peers_get);
14795 AST_TEST_REGISTER(test_iax2_users_get);
14796 #endif
14797
14798
14799 ast_data_register_multiple(iax2_data_providers, ARRAY_LEN(iax2_data_providers));
14800 ast_cli_register_multiple(cli_iax2, ARRAY_LEN(cli_iax2));
14801
14802 ast_register_application_xml(papp, iax2_prov_app);
14803
14804 ast_custom_function_register(&iaxpeer_function);
14805 ast_custom_function_register(&iaxvar_function);
14806
14807 ast_manager_register_xml("IAXpeers", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, manager_iax2_show_peers);
14808 ast_manager_register_xml("IAXpeerlist", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, manager_iax2_show_peer_list);
14809 ast_manager_register_xml("IAXnetstats", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, manager_iax2_show_netstats);
14810 ast_manager_register_xml("IAXregistry", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, manager_iax2_show_registry);
14811
14812 if (ast_channel_register(&iax2_tech)) {
14813 ast_log(LOG_ERROR, "Unable to register channel class %s\n", "IAX2");
14814 __unload_module();
14815 return AST_MODULE_LOAD_FAILURE;
14816 }
14817
14818 if (ast_register_switch(&iax2_switch)) {
14819 ast_log(LOG_ERROR, "Unable to register IAX switch\n");
14820 }
14821
14822 if (start_network_thread()) {
14823 ast_log(LOG_ERROR, "Unable to start network thread\n");
14824 __unload_module();
14825 return AST_MODULE_LOAD_FAILURE;
14826 } else {
14827 ast_verb(2, "IAX Ready and Listening\n");
14828 }
14829
14830 AST_LIST_LOCK(®istrations);
14831 AST_LIST_TRAVERSE(®istrations, reg, entry)
14832 iax2_do_register(reg);
14833 AST_LIST_UNLOCK(®istrations);
14834
14835 ao2_callback(peers, 0, peer_set_sock_cb, NULL);
14836 ao2_callback(peers, 0, iax2_poke_peer_cb, NULL);
14837
14838
14839 reload_firmware(0);
14840 iax_provision_reload(0);
14841
14842 ast_realtime_require_field("iaxpeers", "name", RQ_CHAR, 10, "ipaddr", RQ_CHAR, 15, "port", RQ_UINTEGER2, 5, "regseconds", RQ_UINTEGER2, 6, SENTINEL);
14843
14844 network_change_event_subscribe();
14845
14846 return AST_MODULE_LOAD_SUCCESS;
14847 }
14848
14849 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "Inter Asterisk eXchange (Ver 2)",
14850 .load = load_module,
14851 .unload = unload_module,
14852 .reload = reload,
14853 .load_pri = AST_MODPRI_CHANNEL_DRIVER,
14854 .nonoptreq = "res_crypto",
14855 );