57#if defined(__NetBSD__) || defined(__FreeBSD__)
60#include <sys/sysmacros.h>
76#error "Upgrade your libpri"
82#if !defined(LIBSS7_ABI_COMPATIBILITY)
83#error "Upgrade your libss7"
84#elif LIBSS7_ABI_COMPATIBILITY != 2
85#error "Your installed libss7 is not compatible"
89#if defined(HAVE_OPENR2)
91#define SIG_MFCR2_MAX_CHANNELS 672
673#define SMDI_MD_WAIT_TIMEOUT 1500
676"0 db (CSU)/0-133 feet (DSX-1)",
677"133-266 feet (DSX-1)",
678"266-399 feet (DSX-1)",
679"399-533 feet (DSX-1)",
680"533-655 feet (DSX-1)",
692 .resync_threshold = 1000,
710#define DEFAULT_CIDRINGS 1
712#define AST_LAW(p) (((p)->law == DAHDI_LAW_ALAW) ? ast_format_alaw : ast_format_ulaw)
716#define NEED_MFDETECT(p) (((p)->sig == SIG_FEATDMF) || ((p)->sig == SIG_FEATDMF_TA) || ((p)->sig == SIG_E911) || ((p)->sig == SIG_FGC_CAMA) || ((p)->sig == SIG_FGC_CAMAMF) || ((p)->sig == SIG_FEATB))
718static const char tdesc[] =
"DAHDI Telephony"
719#if defined(HAVE_PRI) || defined(HAVE_SS7) || defined(HAVE_OPENR2)
721 #if defined(HAVE_PRI)
724 #if defined(HAVE_SS7)
725 #if defined(HAVE_PRI)
730 #if defined(HAVE_OPENR2)
731 #if defined(HAVE_PRI) || defined(HAVE_SS7)
739static const char config[] =
"chan_dahdi.conf";
742#define NUM_SPANS DAHDI_MAX_SPANS
747#define CHAN_PSEUDO -2
749#define CALLPROGRESS_PROGRESS 1
750#define CALLPROGRESS_FAX_OUTGOING 2
751#define CALLPROGRESS_FAX_INCOMING 4
752#define CALLPROGRESS_FAX (CALLPROGRESS_FAX_INCOMING | CALLPROGRESS_FAX_OUTGOING)
754#define NUM_CADENCE_MAX 25
761 { { 125, 125, 2000, 4000 } },
762 { { 250, 250, 500, 1000, 250, 250, 500, 4000 } },
763 { { 125, 125, 125, 125, 125, 4000 } },
764 { { 1000, 500, 2500, 5000 } },
781#define ISTRUNK(p) ((p->sig == SIG_FXSLS) || (p->sig == SIG_FXSKS) || \
782 (p->sig == SIG_FXSGS) || (p->sig == SIG_PRI))
784#define CANBUSYDETECT(p) (ISTRUNK(p) || (p->sig & (SIG_EM | SIG_EM_E1 | SIG_SF)) )
785#define CANPROGRESSDETECT(p) (ISTRUNK(p) || (p->sig & (SIG_EM | SIG_EM_E1 | SIG_SF)) )
792#ifndef HAVE_DAHDI_LINEREVERSE_VMWI
806#define REPORT_CHANNEL_ALARMS 1
807#define REPORT_SPAN_ALARMS 2
811static int pridebugfd = -1;
812static char pridebugfilename[1024] =
"";
846 if (ioctl(fd, DAHDI_GETEVENT, &j) == -1)
855 i = DAHDI_IOMUX_SIGEVENT;
856 if (ioctl(fd, DAHDI_IOMUX, &i) == -1)
858 if (ioctl(fd, DAHDI_GETEVENT, &j) == -1)
866#define MASK_AVAIL (1 << 0)
867#define MASK_INUSE (1 << 1)
869#define CALLWAITING_SILENT_SAMPLES ((300 * 8) / READ_SIZE)
870#define CALLWAITING_REPEAT_SAMPLES ((10000 * 8) / READ_SIZE)
871#define CALLWAITING_SUPPRESS_SAMPLES ((100 * 8) / READ_SIZE)
872#define CIDCW_EXPIRE_SAMPLES ((500 * 8) / READ_SIZE)
873#define MIN_MS_SINCE_FLASH ((2000) )
874#define DEFAULT_RINGT ((8000 * 8) / READ_SIZE)
875#define DEFAULT_DIALTONE_DETECT_TIMEOUT ((10000 * 8) / READ_SIZE)
889static struct dahdi_ss7 linksets[
NUM_SPANS];
891static int cur_ss7type = -1;
892static int cur_slc = -1;
893static int cur_linkset = -1;
894static int cur_pointcode = -1;
895static int cur_cicbeginswith = -1;
896static int cur_adjpointcode = -1;
897static int cur_networkindicator = -1;
898static int cur_defaultdpc = -1;
902struct dahdi_mfcr2_conf {
903 openr2_variant_t variant;
905 int metering_pulse_timeout;
908#if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 2
912#if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 3
913 int dtmf_end_timeout;
915 signed int get_ani_first:2;
916#if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 1
917 signed int skip_category_request:2;
919 unsigned int call_files:1;
920 unsigned int allow_collect_calls:1;
921 unsigned int charge_calls:1;
922 unsigned int accept_on_offer:1;
923 unsigned int forced_release:1;
924 unsigned int double_answer:1;
925 signed int immediate_accept:2;
926#if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 2
927 signed int dtmf_dialing:2;
928 signed int dtmf_detection:2;
930 char logdir[OR2_MAX_PATH];
931 char r2proto_file[OR2_MAX_PATH];
932 openr2_log_level_t loglevel;
933 openr2_calling_party_category_t category;
940 openr2_context_t *protocol_context;
945 struct dahdi_mfcr2_conf
conf;
949 struct dahdi_mfcr2 mfcr2;
957static int r2links_count = 0;
965 int mastertrunkgroup;
972#if defined(HAVE_PRI_CCSS)
974static const char dahdi_pri_cc_type[] =
"DAHDI/PRI";
983#define POLARITY_IDLE 0
984#define POLARITY_REV 1
1004static struct dahdi_parms_pseudo {
1009} dahdi_pseudo_parms;
1025 struct dahdi_pri pri;
1028#if defined(HAVE_SS7)
1029 struct dahdi_ss7 ss7;
1033 struct dahdi_mfcr2_conf mfcr2;
1068 .nsf = PRI_NSF_NONE,
1069 .switchtype = PRI_SWITCH_NI2,
1070 .dialplan = PRI_UNKNOWN + 1,
1071 .localdialplan = PRI_NATIONAL_ISDN + 1,
1072 .nodetype = PRI_CPE,
1075#if defined(HAVE_PRI_CCSS)
1076 .cc_ptmp_recall_mode = 1,
1077 .cc_qsig_signaling_link_req = 1,
1078 .cc_qsig_signaling_link_rsp = 1,
1084 .internationalprefix =
"",
1085 .nationalprefix =
"",
1087 .privateprefix =
"",
1088 .unknownprefix =
"",
1090 .resetinterval = -1,
1093#if defined(HAVE_SS7)
1095 .called_nai = SS7_NAI_NATIONAL,
1096 .calling_nai = SS7_NAI_NATIONAL,
1097 .internationalprefix =
"",
1098 .nationalprefix =
"",
1099 .subscriberprefix =
"",
1100 .unknownprefix =
"",
1101 .networkroutedprefix =
""
1106 .variant = OR2_VAR_ITU,
1107 .mfback_timeout = -1,
1108 .metering_pulse_timeout = -1,
1111 .get_ani_first = -1,
1112#if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 1
1113 .skip_category_request = -1,
1116 .allow_collect_calls = 0,
1118 .accept_on_offer = 1,
1119 .forced_release = 0,
1121 .immediate_accept = -1,
1122#if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 2
1124 .dtmf_detection = -1,
1125 .dtmf_time_on = OR2_DEFAULT_DTMF_ON,
1126 .dtmf_time_off = OR2_DEFAULT_DTMF_OFF,
1128#if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 3
1129 .dtmf_end_timeout = -1,
1133 .loglevel = OR2_LOG_ERROR | OR2_LOG_WARNING,
1134 .category = OR2_CALLING_PARTY_CATEGORY_NATIONAL_SUBSCRIBER
1138 .context =
"default",
1143 .mohinterpret =
"default",
1146 .transfertobusy = 1,
1149 .ani_info_digits = 2,
1150 .ani_wink_time = 1000,
1151 .ani_timeout = 10000,
1155 .dahditrcallerid = 0,
1164 .echocancel.head.tap_length = 1,
1172#ifdef HAVE_DAHDI_LINEREVERSE_VMWI
1175 .polarityonanswerdelay = 600,
1179 .buf_policy = DAHDI_POLICY_IMMEDIATE,
1198 .ignore_failed_channels = 1,
1199 .smdi_port =
"/dev/ttyS0",
1208 const char *
data,
int *cause);
1229 .description =
tdesc,
1250#define GET_CHANNEL(p) ((p)->channel)
1307 return DAHDI_TONE_RINGTONE;
1309 return DAHDI_TONE_STUTTER;
1311 return DAHDI_TONE_CONGESTION;
1313 return DAHDI_TONE_DIALTONE;
1315 return DAHDI_TONE_DIALRECALL;
1317 return DAHDI_TONE_INFO;
1327 switch (analogsub) {
1356 struct doomed_pri *entry;
1362 ast_debug(4,
"Destroying span %d from doomed queue.\n",
1364 pri_destroy_span(entry->pri);
1383static void pri_queue_for_destruction(
struct sig_pri_span *pri)
1385 struct doomed_pri *entry;
1389 if (entry->pri == pri) {
1394 entry =
ast_calloc(
sizeof(
struct doomed_pri), 1);
1402 ast_debug(4,
"Queue span %d for destruction.\n", pri->
span);
1425 struct dahdi_dialoperation zo = {
1431 for (offset = 0; offset <
sizeof(zo.dialstr) - 1; ++offset) {
1438 if (offset >=
sizeof(zo.dialstr) - 3) {
1442 zo.dialstr[offset] =
'w';
1444 zo.dialstr[offset] =
'w';
1447 zo.dialstr[offset] = *pos++;
1451 ast_debug(1,
"Channel %d: Dial str '%s' expanded to '%s' sent to DAHDI_DIAL.\n",
1452 pvt->
channel, dial_str, zo.dialstr);
1503 struct pollfd poller;
1507 unsigned char buf[256];
1512 poller.events = POLLPRI | POLLIN;
1515 res = poll(&poller, 1, timeout);
1517 if (poller.revents & POLLPRI) {
1522 if (poller.revents & POLLIN) {
1534 if (analog_p->
ringt > 0) {
1535 if (!(--analog_p->
ringt)) {
1598 unsigned char buf[256];
1606 int checkaftercid = 0;
1607 const char *matched_context;
1611 if (ringdata ==
NULL) {
1612 ringdata = curRingData;
1620 for (receivedRingT = 0; receivedRingT <
RING_PATTERNS; receivedRingT++)
1621 ringdata[receivedRingT] = 0;
1625 ast_verb(3,
"Detecting post-CID distinctive ring\n");
1629 i = DAHDI_IOMUX_READ | DAHDI_IOMUX_SIGEVENT;
1630 res = ioctl(p->
subs[idx].
dfd, DAHDI_IOMUX, &i);
1636 if (i & DAHDI_IOMUX_SIGEVENT) {
1639 if (res == DAHDI_EVENT_NOALARM) {
1642 }
else if (res == DAHDI_EVENT_RINGOFFHOOK) {
1644 ringdata[receivedRingT] = analog_p->
ringt;
1655 }
else if (i & DAHDI_IOMUX_READ) {
1658 if (
errno != ELAST) {
1665 if (analog_p->
ringt > 0) {
1666 if (!(--analog_p->
ringt)) {
1675 ast_verb(3,
"Detected ring pattern: %d,%d,%d\n", ringdata[0], ringdata[1], ringdata[2]);
1677 for (counter = 0; counter < 3; counter++) {
1681 ast_verb(3,
"Checking %d,%d,%d with +/- %d range\n",
1686 for (counter1 = 0; counter1 < 3; counter1++) {
1690 ast_verb(3,
"Pattern ignore (-1) detected, so matching pattern %d regardless.\n",
1691 ringdata[counter1]);
1693 }
else if (ring - range <= ringdata[counter1] && ringdata[counter1] <= ring + range) {
1694 ast_verb(3,
"Ring pattern %d is in range: %d to %d\n",
1695 ringdata[counter1], ring - range, ring + range);
1703 if (distMatches == 3) {
1706 ast_verb(3,
"Matched Distinctive Ring context %s\n", matched_context);
1712 if (strcmp(p->
context, matched_context) != 0) {
1800 ast_verb(3,
"CPE supports Call Waiting Caller*ID. Sending '%s/%s'\n",
1876 ast_log(
LOG_ERROR,
"We used a sub other than SUB_REAL (incorrect assumption sir)\n");
1893 ast_debug(1,
"%s DTMF digit: 0x%02X '%c' on %s\n",
1903 struct dahdi_bufferinfo bi = {
1910 if ((res = ioctl(p->
subs[idx].
dfd, DAHDI_SET_BUFINFO, &bi)) < 0) {
1948 ast_debug(1,
"Already in a fax extension, not redirecting\n");
1957 *dest = &p->
subs[idx].
f;
1987 if (!channel_string) {
1997 "DAHDIGroup: %llu\r\n"
1999 "DAHDIChannel: %s\r\n",
2020 "channel", dahdi_channel);
2044 snprintf(ch_name,
sizeof(ch_name),
"no-media (%d)", p->
channel);
2047 strcpy(ch_name,
"pseudo");
2050 snprintf(ch_name,
sizeof(ch_name),
"%d", p->
channel);
2064static void my_ami_channel_event(
void *pvt,
struct ast_channel *chan)
2124 return p->
subs[dahdi_sub].
dfd;
2167#if defined(HAVE_PRI) || defined(HAVE_SS7)
2168static void my_set_digital(
void *pvt,
int is_digital)
2176#if defined(HAVE_SS7)
2177static void my_set_inservice(
void *pvt,
int is_inservice)
2185#if defined(HAVE_SS7)
2186static void my_set_locallyblocked(
void *pvt,
int is_blocked)
2194#if defined(HAVE_SS7)
2195static void my_set_remotelyblocked(
void *pvt,
int is_blocked)
2308 p->
owner = new_owner;
2359 for (i = 0; i < 3; i++) {
2396 int needconf = needconference;
2503#if defined(HAVE_PRI) || defined(HAVE_SS7)
2504static int dahdi_setlaw(
int dfd,
int law)
2507 res = ioctl(dfd, DAHDI_SETLAW, &
law);
2514#if defined(HAVE_PRI)
2553 newlaw = DAHDI_LAW_ALAW;
2556 newlaw = DAHDI_LAW_MULAW;
2566#if defined(HAVE_PRI) || defined(HAVE_SS7)
2574static void my_pri_ss7_open_media(
void *p)
2585 res = ioctl(dfd, DAHDI_AUDIOMODE, &set_val);
2592 res = dahdi_setlaw(dfd, pvt->
law);
2614#if defined(HAVE_PRI)
2625static void my_pri_dial_digits(
void *p,
const char *dial_string)
2627 char dial_str[DAHDI_MAX_DTMF_BUF];
2631 snprintf(dial_str,
sizeof(dial_str),
"T%s", dial_string);
2681 case DAHDI_EVENT_ONHOOK:
2684 case DAHDI_EVENT_RINGOFFHOOK:
2687 case DAHDI_EVENT_WINKFLASH:
2690 case DAHDI_EVENT_ALARM:
2693 case DAHDI_EVENT_NOALARM:
2696 case DAHDI_EVENT_DIALCOMPLETE:
2699 case DAHDI_EVENT_RINGERON:
2702 case DAHDI_EVENT_RINGEROFF:
2705 case DAHDI_EVENT_HOOKCOMPLETE:
2708 case DAHDI_EVENT_PULSE_START:
2711 case DAHDI_EVENT_POLARITY:
2714 case DAHDI_EVENT_RINGBEGIN:
2717 case DAHDI_EVENT_EC_DISABLED:
2720 case DAHDI_EVENT_REMOVED:
2723 case DAHDI_EVENT_NEONMWI_ACTIVE:
2726 case DAHDI_EVENT_NEONMWI_INACTIVE:
2729#ifdef HAVE_DAHDI_ECHOCANCEL_FAX_MODE
2730 case DAHDI_EVENT_TX_CED_DETECTED:
2733 case DAHDI_EVENT_RX_CED_DETECTED:
2736 case DAHDI_EVENT_EC_NLP_DISABLED:
2739 case DAHDI_EVENT_EC_NLP_ENABLED:
2743 case DAHDI_EVENT_PULSEDIGIT:
2746 case DAHDI_EVENT_DTMFDOWN:
2749 case DAHDI_EVENT_DTMFUP:
2753 switch(
event & 0xFFFF0000) {
2754 case DAHDI_EVENT_PULSEDIGIT:
2755 case DAHDI_EVENT_DTMFDOWN:
2756 case DAHDI_EVENT_DTMFUP:
2798 struct dahdi_params par;
2800 memset(&par, 0,
sizeof(par));
2807 par.rxisoffhook = 0;
2817 return (par.rxbits > -1) || par.rxisoffhook;
2820 return par.rxisoffhook;
2847 int func = DAHDI_FLASH;
2915 struct dahdi_params dahdip;
2923 memset(&dahdip, 0,
sizeof(dahdip));
2930 if (!(dahdip.sigtype & __DAHDI_SIG_FXO)) {
2953 snprintf(buffer, buflen,
"%d", pvt->
polarity);
2968 if (!strcasecmp(
value,
"idle")) {
2970 }
else if (!strcasecmp(
value,
"reverse")) {
2994 int x = DAHDI_START;
3009 ast_log(
LOG_ERROR,
"Trying to dial_digits '%s' on channel %d subchannel %u\n",
3036 if (ioctl(p->
subs[index].
dfd, DAHDI_DIALING, &x)) {
3037 ast_debug(1,
"DAHDI_DIALING ioctl failed!\n");
3050#if defined(HAVE_PRI)
3051static void my_pri_fixup_chans(
void *chan_old,
void *chan_new)
3058 if (new_chan->
owner) {
3065 new_chan->
dsp = old_chan->
dsp;
3079 new_chan->
law = old_chan->
law;
3084#if defined(HAVE_PRI)
3085static int sig_pri_tone_to_dahditone(
enum sig_pri_tone tone)
3089 return DAHDI_TONE_RINGTONE;
3091 return DAHDI_TONE_STUTTER;
3093 return DAHDI_TONE_CONGESTION;
3095 return DAHDI_TONE_DIALTONE;
3097 return DAHDI_TONE_DIALRECALL;
3099 return DAHDI_TONE_INFO;
3101 return DAHDI_TONE_BUSY;
3108#if defined(HAVE_PRI)
3109static void my_handle_dchan_exception(
struct sig_pri_span *pri,
int index)
3113 ioctl(pri->
fds[index], DAHDI_GETEVENT, &x);
3115 case DAHDI_EVENT_NONE:
3117 case DAHDI_EVENT_ALARM:
3118 case DAHDI_EVENT_NOALARM:
3130 case DAHDI_EVENT_ALARM:
3133 case DAHDI_EVENT_NOALARM:
3136 case DAHDI_EVENT_REMOVED:
3137 pri_queue_for_destruction(pri);
3145#if defined(HAVE_PRI)
3146static int my_pri_play_tone(
void *pvt,
enum sig_pri_tone tone)
3150 return tone_zone_play_tone(p->
subs[
SUB_REAL].
dfd, sig_pri_tone_to_dahditone(tone));
3154#if defined(HAVE_PRI) || defined(HAVE_SS7)
3163static void my_set_callerid(
void *pvt,
const struct ast_party_caller *caller)
3178 if (caller->
id.
tag) {
3183 sizeof(p->cid_ani));
3188#if defined(HAVE_PRI) || defined(HAVE_SS7)
3197static void my_set_dnid(
void *pvt,
const char *
dnid)
3205#if defined(HAVE_PRI)
3214static void my_set_rdnis(
void *pvt,
const char *
rdnis)
3222#if defined(HAVE_PRI)
3249static void my_pri_make_cc_dialstring(
void *priv,
char *
buf,
size_t buf_size)
3270 snprintf(
buf, buf_size,
"%s/i%d-",
args.tech, pvt->pri->span);
3273 if (isdigit(
args.group[0]) ||
args.group[0] ==
'i' || strchr(
args.group,
'!')) {
3280 snprintf(
buf, buf_size,
"%s/i%d-%s",
args.tech, pvt->pri->span,
args.group);
3284#if defined(HAVE_PRI)
3294static void dahdi_pri_update_span_devstate(
struct sig_pri_span *pri)
3297 unsigned num_b_chans;
3306 for (idx = pri->
numchans; idx--;) {
3330#if defined(THRESHOLD_DEVSTATE_PLACEHOLDER)
3334 }
else if (!in_use) {
3336 }
else if (!pri->user_busy_threshold) {
3342 if (pri->threshold_devstate != new_state) {
3343 pri->threshold_devstate = new_state;
3350#if defined(HAVE_PRI)
3356static void my_module_ref(
void)
3362#if defined(HAVE_PRI)
3368static void my_module_unref(
void)
3374#if defined(HAVE_PRI)
3375#if defined(HAVE_PRI_CALL_WAITING)
3376static void my_pri_init_config(
void *priv,
struct sig_pri_span *pri);
3378static int dahdi_new_pri_nobch_channel(
struct sig_pri_span *pri);
3383 .play_tone = my_pri_play_tone,
3389 .new_ast_channel = my_new_pri_ast_channel,
3390 .fixup_chans = my_pri_fixup_chans,
3394 .set_digital = my_set_digital,
3395 .set_callerid = my_set_callerid,
3396 .set_dnid = my_set_dnid,
3397 .set_rdnis = my_set_rdnis,
3398 .new_nobch_intf = dahdi_new_pri_nobch_channel,
3399#if defined(HAVE_PRI_CALL_WAITING)
3400 .init_config = my_pri_init_config,
3403 .make_cc_dialstring = my_pri_make_cc_dialstring,
3404 .update_span_devstate = dahdi_pri_update_span_devstate,
3405 .module_ref = my_module_ref,
3406 .module_unref = my_module_unref,
3407 .dial_digits = my_pri_dial_digits,
3408 .open_media = my_pri_ss7_open_media,
3409 .ami_channel_event = my_ami_channel_event,
3410 .destroy_later = pri_queue_for_destruction,
3414#if defined(HAVE_SS7)
3423static void my_handle_link_exception(
struct sig_ss7_linkset *linkset,
int which)
3427 if (ioctl(linkset->
fds[which], DAHDI_GETEVENT, &
event)) {
3429 linkset->
span, which);
3433 case DAHDI_EVENT_NONE:
3435 case DAHDI_EVENT_ALARM:
3440 case DAHDI_EVENT_NOALARM:
3453#if defined(HAVE_SS7)
3454static void my_ss7_set_loopback(
void *pvt,
int enable)
3465#if defined(HAVE_SS7)
3485 if (linksets[idx].
ss7.ss7 ==
ss7) {
3486 return &linksets[idx].ss7;
3493#if defined(HAVE_SS7)
3536 newlaw = DAHDI_LAW_ALAW;
3539 newlaw = DAHDI_LAW_MULAW;
3546#if defined(HAVE_SS7)
3547static int sig_ss7_tone_to_dahditone(
enum sig_ss7_tone tone)
3551 return DAHDI_TONE_RINGTONE;
3553 return DAHDI_TONE_STUTTER;
3555 return DAHDI_TONE_CONGESTION;
3557 return DAHDI_TONE_DIALTONE;
3559 return DAHDI_TONE_DIALRECALL;
3561 return DAHDI_TONE_INFO;
3563 return DAHDI_TONE_BUSY;
3570#if defined(HAVE_SS7)
3571static int my_ss7_play_tone(
void *pvt,
enum sig_ss7_tone tone)
3575 return tone_zone_play_tone(p->
subs[
SUB_REAL].
dfd, sig_ss7_tone_to_dahditone(tone));
3579#if defined(HAVE_SS7)
3587 .set_loopback = my_ss7_set_loopback,
3589 .new_ast_channel = my_new_ss7_ast_channel,
3590 .play_tone = my_ss7_play_tone,
3592 .handle_link_exception = my_handle_link_exception,
3596 .set_digital = my_set_digital,
3597 .set_inservice = my_set_inservice,
3598 .set_locallyblocked = my_set_locallyblocked,
3599 .set_remotelyblocked = my_set_remotelyblocked,
3600 .set_callerid = my_set_callerid,
3601 .set_dnid = my_set_dnid,
3602 .open_media = my_pri_ss7_open_media,
3603 .find_linkset = my_ss7_find_linkset,
3673#define gen_pvt_field_callback(type, field) \
3674 static type my_get_##field(void *pvt) \
3676 struct dahdi_pvt *p = pvt; \
3684#undef gen_pvt_field_callback
3754 .get_firstdigit_timeout = my_get_firstdigit_timeout,
3755 .get_matchdigit_timeout = my_get_matchdigit_timeout,
3756 .get_interdigit_timeout = my_get_interdigit_timeout,
3775 "Unable to get index for '%s' on channel %d (%s(), line %lu)\n",
3868#if defined(HAVE_PRI)
3883static void mfcr2_queue_for_destruction(
const struct dahdi_pvt *p)
3885 const struct dahdi_mfcr2 *r2link = p->mfcr2;
3886 struct r2link_entry *cur;
3889 if (r2link == &cur->mfcr2) {
3899static int dahdi_r2_answer(
struct dahdi_pvt *p)
3905#if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 1
3907 int wants_double_answer =
ast_true(double_answer) ? 1 : 0;
3908 if (!double_answer) {
3911 res = openr2_chan_answer_call(p->r2chan);
3912 }
else if (wants_double_answer) {
3913 res = openr2_chan_answer_call_with_mode(p->r2chan, OR2_ANSWER_DOUBLE);
3915 res = openr2_chan_answer_call_with_mode(p->r2chan, OR2_ANSWER_SIMPLE);
3918 res = openr2_chan_answer_call(p->r2chan);
3926static openr2_calling_party_category_t dahdi_r2_get_channel_category(
struct ast_channel *
c)
3928 openr2_calling_party_category_t cat;
3932 ast_debug(1,
"No MFC/R2 category specified for chan %s, using default %s\n",
3934 return p->mfcr2_category;
3936 if ((cat = openr2_proto_get_category(catstr)) == OR2_CALLING_PARTY_CATEGORY_UNKNOWN) {
3937 ast_log(
LOG_WARNING,
"Invalid category specified '%s' for chan %s, using default %s\n",
3938 catstr,
ast_channel_name(
c), openr2_proto_get_category_string(p->mfcr2_category));
3939 return p->mfcr2_category;
3941 ast_debug(1,
"Using category %s\n", catstr);
3945static void dahdi_r2_on_call_init(openr2_chan_t *r2chan)
3947 struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
3956 ast_log(
LOG_ERROR,
"Collision of calls on chan %d detected!.\n", openr2_chan_get_number(r2chan));
3966 p->mfcr2_ani_index =
'\0';
3967 p->mfcr2_dnis_index =
'\0';
3968 p->mfcr2_dnis_matched = 0;
3969 p->mfcr2_answer_pending = 0;
3970 p->mfcr2_call_accepted = 0;
3972 ast_verbose(
"New MFC/R2 call detected on chan %d.\n", openr2_chan_get_number(r2chan));
3975static void dahdi_r2_on_hardware_alarm(openr2_chan_t *r2chan,
int alarm)
3978 struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
3983 if (res == DAHDI_ALARM_NOTOPEN) {
3984 mfcr2_queue_for_destruction(p);
3993static void dahdi_r2_on_os_error(openr2_chan_t *r2chan,
int errorcode)
3995 struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
3997 ast_log(
LOG_ERROR,
"OS error on chan %d: %s\n", openr2_chan_get_number(r2chan), strerror(errorcode));
4000 if (errorcode == ENODEV) {
4001 struct dahdi_mfcr2 *r2link = p->mfcr2;
4010static void dahdi_r2_on_protocol_error(openr2_chan_t *r2chan, openr2_protocol_error_t reason)
4012 struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
4013 ast_log(
LOG_ERROR,
"MFC/R2 protocol error on chan %d: %s\n", openr2_chan_get_number(r2chan), openr2_proto_get_error(reason));
4023static void dahdi_r2_disconnect_call(
struct dahdi_pvt *p, openr2_call_disconnect_cause_t cause)
4025 if (openr2_chan_disconnect_call(p->r2chan, cause)) {
4026 ast_log(
LOG_NOTICE,
"Bad! failed to disconnect call on channel %d with reason %s, hope for the best!\n",
4027 p->
channel, openr2_proto_get_disconnect_string(cause));
4029 openr2_chan_set_idle(p->r2chan);
4036static void dahdi_r2_on_call_offered(openr2_chan_t *r2chan,
const char *ani,
const char *dnis, openr2_calling_party_category_t category)
4042 ast_verbose(
"MFC/R2 call offered on chan %d. ANI = %s, DNIS = %s, Category = %s\n",
4043 openr2_chan_get_number(r2chan), ani ? ani :
"(restricted)", dnis,
4044 openr2_proto_get_category_string(category));
4045 p = openr2_chan_get_client_data(r2chan);
4047 if (!p->mfcr2_allow_collect_calls && category == OR2_CALLING_PARTY_CATEGORY_COLLECT_CALL) {
4049 dahdi_r2_disconnect_call(p, OR2_CAUSE_COLLECT_CALL_REJECTED);
4050 goto dahdi_r2_on_call_offered_cleanup;
4053 p->mfcr2_recvd_category = category;
4056 ast_debug(1,
"No CID allowed in configuration, CID is being cleared!\n");
4061 if (p->
immediate || !openr2_context_get_max_dnis(openr2_chan_get_context(r2chan))) {
4062 ast_debug(1,
"Setting exten => s because of immediate or 0 DNIS configured\n");
4068 ast_log(
LOG_NOTICE,
"MFC/R2 call on channel %d requested non-existent extension '%s' in context '%s'. Rejecting call.\n",
4070 dahdi_r2_disconnect_call(p, OR2_CAUSE_UNALLOCATED_NUMBER);
4071 goto dahdi_r2_on_call_offered_cleanup;
4073 if (!p->mfcr2_accept_on_offer) {
4080 goto dahdi_r2_on_call_offered_cleanup;
4083 dahdi_r2_disconnect_call(p, OR2_CAUSE_OUT_OF_ORDER);
4084 }
else if (p->mfcr2_charge_calls) {
4085 ast_debug(1,
"Accepting MFC/R2 call with charge on chan %d\n", p->
channel);
4086 openr2_chan_accept_call(r2chan, OR2_CALL_WITH_CHARGE);
4088 ast_debug(1,
"Accepting MFC/R2 call with no charge on chan %d\n", p->
channel);
4089 openr2_chan_accept_call(r2chan, OR2_CALL_NO_CHARGE);
4092dahdi_r2_on_call_offered_cleanup:
4096static void dahdi_r2_on_call_end(openr2_chan_t *r2chan)
4098 struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
4105static void dahdi_r2_on_call_accepted(openr2_chan_t *r2chan, openr2_call_mode_t mode)
4111 p = openr2_chan_get_client_data(r2chan);
4113 p->mfcr2_call_accepted = 1;
4115 if (OR2_DIR_BACKWARD == openr2_chan_get_direction(r2chan)) {
4116 ast_verbose(
"MFC/R2 call has been accepted on backward channel %d\n", openr2_chan_get_number(r2chan));
4121 if (!p->mfcr2_accept_on_offer) {
4122 openr2_chan_disable_read(r2chan);
4123 if (p->mfcr2_answer_pending) {
4124 ast_debug(1,
"Answering MFC/R2 call after accepting it on chan %d\n", openr2_chan_get_number(r2chan));
4127 goto dahdi_r2_on_call_accepted_cleanup;
4133 openr2_chan_disable_read(r2chan);
4134 goto dahdi_r2_on_call_accepted_cleanup;
4138 dahdi_r2_disconnect_call(p, OR2_CAUSE_OUT_OF_ORDER);
4139 goto dahdi_r2_on_call_accepted_cleanup;
4146 openr2_chan_disable_read(r2chan);
4148dahdi_r2_on_call_accepted_cleanup:
4152static void dahdi_r2_on_call_answered(openr2_chan_t *r2chan)
4154 struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
4155 ast_verbose(
"MFC/R2 call has been answered on channel %d\n", openr2_chan_get_number(r2chan));
4159static void dahdi_r2_on_call_read(openr2_chan_t *r2chan,
const unsigned char *
buf,
int buflen)
4164static int dahdi_r2_cause_to_ast_cause(openr2_call_disconnect_cause_t cause)
4167 case OR2_CAUSE_BUSY_NUMBER:
4169 case OR2_CAUSE_NETWORK_CONGESTION:
4171 case OR2_CAUSE_OUT_OF_ORDER:
4173 case OR2_CAUSE_UNALLOCATED_NUMBER:
4175 case OR2_CAUSE_NO_ANSWER:
4177 case OR2_CAUSE_NORMAL_CLEARING:
4179 case OR2_CAUSE_UNSPECIFIED:
4185static void dahdi_r2_on_call_disconnect(openr2_chan_t *r2chan, openr2_call_disconnect_cause_t cause)
4187 struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
4190 int datalen =
sizeof(*cause_code);
4192 ast_verbose(
"MFC/R2 call disconnected on channel %d\n", openr2_chan_get_number(r2chan));
4197 dahdi_r2_disconnect_call(p, OR2_CAUSE_NORMAL_CLEARING);
4201 snprintf(cause_str,
sizeof(cause_str),
"R2 DISCONNECT (%s)", openr2_proto_get_disconnect_string(cause));
4202 datalen += strlen(cause_str);
4204 memset(cause_code, 0, datalen);
4205 cause_code->
ast_cause = dahdi_r2_cause_to_ast_cause(cause);
4217 }
else if (openr2_chan_get_direction(r2chan) == OR2_DIR_FORWARD) {
4220 case OR2_CAUSE_BUSY_NUMBER:
4223 case OR2_CAUSE_NETWORK_CONGESTION:
4224 case OR2_CAUSE_OUT_OF_ORDER:
4225 case OR2_CAUSE_UNALLOCATED_NUMBER:
4226 case OR2_CAUSE_NO_ANSWER:
4227 case OR2_CAUSE_UNSPECIFIED:
4228 case OR2_CAUSE_NORMAL_CLEARING:
4243static void dahdi_r2_write_log(openr2_log_level_t level,
char *logmessage)
4246 case OR2_LOG_NOTICE:
4249 case OR2_LOG_WARNING:
4255 case OR2_LOG_STACK_TRACE:
4256 case OR2_LOG_MF_TRACE:
4257 case OR2_LOG_CAS_TRACE:
4259 case OR2_LOG_EX_DEBUG:
4269static void dahdi_r2_on_line_blocked(openr2_chan_t *r2chan)
4271 struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
4275 ast_log(
LOG_NOTICE,
"Far end blocked on chan %d\n", openr2_chan_get_number(r2chan));
4278static void dahdi_r2_on_line_idle(openr2_chan_t *r2chan)
4280 struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
4284 ast_log(
LOG_NOTICE,
"Far end unblocked on chan %d\n", openr2_chan_get_number(r2chan));
4287static void dahdi_r2_on_context_log(openr2_context_t *r2context, openr2_log_level_t level,
const char *fmt, va_list ap)
4288 __attribute__((format (printf, 3, 0)));
4289static void dahdi_r2_on_context_log(openr2_context_t *r2context, openr2_log_level_t level,
const char *fmt, va_list ap)
4291#define CONTEXT_TAG "Context - "
4293 char completemsg[
sizeof(
logmsg) * 2];
4295 snprintf(completemsg,
sizeof(completemsg), CONTEXT_TAG
"%s",
logmsg);
4296 dahdi_r2_write_log(level, completemsg);
4300static void dahdi_r2_on_chan_log(openr2_chan_t *r2chan, openr2_log_level_t level,
const char *fmt, va_list ap)
4301 __attribute__((format (printf, 3, 0)));
4302static void dahdi_r2_on_chan_log(openr2_chan_t *r2chan, openr2_log_level_t level,
const char *fmt, va_list ap)
4304#define CHAN_TAG "Chan "
4306 char completemsg[
sizeof(
logmsg) * 2];
4308 snprintf(completemsg,
sizeof(completemsg), CHAN_TAG
"%d - %s", openr2_chan_get_number(r2chan),
logmsg);
4309 dahdi_r2_write_log(level, completemsg);
4313static int dahdi_r2_on_dnis_digit_received(openr2_chan_t *r2chan,
char digit)
4315 struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
4322 p->mfcr2_dnis_index++;
4323 p->
exten[p->mfcr2_dnis_index] = 0;
4324 p->
rdnis[p->mfcr2_dnis_index] = 0;
4326 if ((p->mfcr2_dnis_matched ||
4335static void dahdi_r2_on_ani_digit_received(openr2_chan_t *r2chan,
char digit)
4337 struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
4340 p->mfcr2_ani_index++;
4341 p->
cid_num[p->mfcr2_ani_index] = 0;
4342 p->
cid_name[p->mfcr2_ani_index] = 0;
4345static void dahdi_r2_on_billing_pulse_received(openr2_chan_t *r2chan)
4347 ast_verbose(
"MFC/R2 billing pulse received on channel %d\n", openr2_chan_get_number(r2chan));
4350static openr2_event_interface_t dahdi_r2_event_iface = {
4351 .on_call_init = dahdi_r2_on_call_init,
4352 .on_call_offered = dahdi_r2_on_call_offered,
4353 .on_call_accepted = dahdi_r2_on_call_accepted,
4354 .on_call_answered = dahdi_r2_on_call_answered,
4355 .on_call_disconnect = dahdi_r2_on_call_disconnect,
4356 .on_call_end = dahdi_r2_on_call_end,
4357 .on_call_read = dahdi_r2_on_call_read,
4358 .on_hardware_alarm = dahdi_r2_on_hardware_alarm,
4359 .on_os_error = dahdi_r2_on_os_error,
4360 .on_protocol_error = dahdi_r2_on_protocol_error,
4361 .on_line_blocked = dahdi_r2_on_line_blocked,
4362 .on_line_idle = dahdi_r2_on_line_idle,
4364 .on_context_log = (openr2_handle_context_logging_func)dahdi_r2_on_context_log,
4365 .on_dnis_digit_received = dahdi_r2_on_dnis_digit_received,
4366 .on_ani_digit_received = dahdi_r2_on_ani_digit_received,
4368 .on_billing_pulse_received = dahdi_r2_on_billing_pulse_received
4371static inline int16_t dahdi_r2_alaw_to_linear(uint8_t sample)
4376static inline uint8_t dahdi_r2_linear_to_alaw(
int sample)
4381static openr2_transcoder_interface_t dahdi_r2_transcode_iface = {
4382 dahdi_r2_alaw_to_linear,
4383 dahdi_r2_linear_to_alaw
4424 for (
x = 0;
x < strlen(fn);
x++) {
4425 if (!isdigit(fn[
x])) {
4436 fn =
"/dev/dahdi/channel";
4438 fd = open(fn, O_RDWR | O_NONBLOCK);
4444 if (ioctl(fd, DAHDI_SPECIFY, &chan)) {
4453 if (ioctl(fd, DAHDI_SET_BLOCKSIZE, &
bs) == -1) {
4472 chan_pvt->
subs[sub_num].
dfd = -1;
4475#if defined(HAVE_PRI)
4476static void dahdi_close_pri_fd(
struct dahdi_pri *pri,
int fd_num)
4479 pri->pri.fds[fd_num] = -1;
4483#if defined(HAVE_SS7)
4484static void dahdi_close_ss7_fd(
struct dahdi_ss7 *ss7,
int fd_num)
4487 ss7->ss7.fds[fd_num] = -1;
4493 return ioctl(dfd, DAHDI_SETLINEAR, &linear);
4499 struct dahdi_bufferinfo bi;
4512 res = ioctl(p->
subs[x].
dfd, DAHDI_GET_BUFINFO, &bi);
4517 res = ioctl(p->
subs[x].
dfd, DAHDI_SET_BUFINFO, &bi);
4554 return DAHDI_TONE_DTMF_BASE + (
digit -
'0');
4556 return DAHDI_TONE_DTMF_A + (
digit -
'A');
4558 return DAHDI_TONE_DTMF_A + (
digit -
'a');
4559 else if (
digit ==
'*')
4560 return DAHDI_TONE_DTMF_s;
4561 else if (
digit ==
'#')
4562 return DAHDI_TONE_DTMF_p;
4601 char dial_str[] = {
'T',
digit,
'\0' };
4612 dtmf = DAHDI_FLUSH_WRITE;
4615 ast_log(
LOG_WARNING,
"Unable to flush the DAHDI write buffer to send DTMF on channel %d: %s\n",
4619 ast_debug(1,
"Channel %s started VLDTMF digit '%c'\n",
4654 ast_debug(1,
"Channel %s ending VLDTMF digit '%c'\n",
4680 "Hook Transition Complete",
4685 "Polarity Reversal",
4693 { DAHDI_ALARM_RED,
"Red Alarm" },
4694 { DAHDI_ALARM_YELLOW,
"Yellow Alarm" },
4695 { DAHDI_ALARM_BLUE,
"Blue Alarm" },
4696 { DAHDI_ALARM_RECOVER,
"Recovering" },
4697 { DAHDI_ALARM_LOOPBACK,
"Loopback" },
4698 { DAHDI_ALARM_NOTOPEN,
"Not Open" },
4699 { DAHDI_ALARM_NONE,
"None" },
4709 return alm ?
"Unknown Alarm" :
"No Alarm";
4714 static char buf[256];
4723 static char buf[256];
4726 return "E & M Immediate";
4728 return "E & M Wink";
4732 return "Feature Group D (DTMF)";
4734 return "Feature Group D (MF)";
4736 return "Feature Group D (MF) Tandem Access";
4738 return "Feature Group B (MF)";
4742 return "FGC/CAMA (Dialpulse)";
4744 return "FGC/CAMA (MF)";
4746 return "FXS Loopstart";
4748 return "FXS Groundstart";
4750 return "FXS Kewlstart";
4752 return "FXO Loopstart";
4754 return "FXO Groundstart";
4756 return "FXO Kewlstart";
4760 return "ISDN BRI Point to Point";
4762 return "ISDN BRI Point to MultiPoint";
4768 return "SF (Tone) Immediate";
4770 return "SF (Tone) Wink";
4772 return "SF (Tone) with Feature Group D (DTMF)";
4774 return "SF (Tone) with Feature Group D (MF)";
4776 return "SF (Tone) with Feature Group B (MF)";
4780 snprintf(
buf,
sizeof(
buf),
"Unknown signalling %d", sig);
4785#define sig2str dahdi_sig2str
4791 struct dahdi_confinfo zi;
4793 memset(&zi, 0,
sizeof(zi));
4796 if (slavechannel > 0) {
4798 zi.confmode = DAHDI_CONF_DIGITALMON;
4799 zi.confno = slavechannel;
4803 zi.confmode = DAHDI_CONF_REALANDPSEUDO | DAHDI_CONF_TALKER | DAHDI_CONF_LISTENER |
4804 DAHDI_CONF_PSEUDO_TALKER | DAHDI_CONF_PSEUDO_LISTENER;
4806 zi.confmode = DAHDI_CONF_CONF | DAHDI_CONF_TALKER | DAHDI_CONF_LISTENER;
4809 if ((zi.confno ==
c->curconf.confno) && (zi.confmode ==
c->curconf.confmode))
4813 if (ioctl(
c->dfd, DAHDI_SETCONF, &zi)) {
4814 ast_log(
LOG_WARNING,
"Failed to add %d to conference %d/%d: %s\n",
c->dfd, zi.confmode, zi.confno, strerror(
errno));
4817 if (slavechannel < 1) {
4821 ast_debug(1,
"Added %d to conference %d/%d\n",
c->dfd,
c->curconf.confmode,
c->curconf.confno);
4828 if ((p->
channel ==
c->curconf.confno) && (
c->curconf.confmode == DAHDI_CONF_DIGITALMON))
4831 if ((p->
confno > 0) && (p->
confno ==
c->curconf.confno) && (
c->curconf.confmode & DAHDI_CONF_TALKER))
4838 struct dahdi_confinfo zi;
4845 memset(&zi, 0,
sizeof(zi));
4846 if (ioctl(
c->dfd, DAHDI_SETCONF, &zi)) {
4847 ast_log(
LOG_WARNING,
"Failed to drop %d from conference %d/%d: %s\n",
c->dfd,
c->curconf.confmode,
c->curconf.confno, strerror(
errno));
4850 ast_debug(1,
"Removed %d from conference %d/%d\n",
c->dfd,
c->curconf.confmode,
c->curconf.confno);
4851 memcpy(&
c->curconf, &zi,
sizeof(
c->curconf));
4863 for (x = 0; x < 3; x++) {
4871 if (useslavenative) {
4890 else if (slave->
law != p->
law) {
4896 return useslavenative;
4904 struct dahdi_confinfo zi;
4906 memset(&zi, 0,
sizeof(zi));
4922 for (x = 0; x < 3; x++) {
4965 ast_debug(1,
"Updated conferencing on %d, with %d conference users\n", p->
channel, needconf);
4974 ast_debug(1,
"Echo cancellation already on\n");
4978 ast_debug(1,
"Echo cancellation isn't required on digital connection\n");
4982#if defined(HAVE_PRI) || defined(HAVE_SS7)
4984#if defined(HAVE_PRI)
4995#if defined(HAVE_SS7)
5004 "Unable to enable audio mode on channel %d (%s)\n",
5020 ast_debug(1,
"No echo cancellation requested\n");
5036 ast_debug(1,
"No echo training requested\n");
5045 struct dahdi_echocanparams ecp = { .tap_length = 0 };
5060 struct dahdi_hwgain hwgain;
5062 hwgain.newgain = gain * 10.0;
5063 hwgain.tx = tx_direction;
5064 return ioctl(fd, DAHDI_SET_HWGAIN, &hwgain) < 0;
5071 float shallow, steep;
5072 float max = SHRT_MAX;
5074 neg = (sample < 0 ? -1 : 1);
5076 shallow = neg*(
max-
max/drc)+(
float)sample/drc;
5077 if (fabsf(steep) < fabsf(shallow)) {
5088static void fill_txgain(
struct dahdi_gains *g,
float gain,
float drc,
int law)
5093 float linear_gain = pow(10.0, gain / 20.0);
5096 case DAHDI_LAW_ALAW:
5097 for (j = 0; j <
ARRAY_LEN(g->txgain); j++) {
5103 k = (float)k * linear_gain;
5106 }
else if (k < -32768) {
5115 case DAHDI_LAW_MULAW:
5116 for (j = 0; j <
ARRAY_LEN(g->txgain); j++) {
5122 k = (float)k * linear_gain;
5125 }
else if (k < -32768) {
5138static void fill_rxgain(
struct dahdi_gains *g,
float gain,
float drc,
int law)
5142 float linear_gain = pow(10.0, gain / 20.0);
5145 case DAHDI_LAW_ALAW:
5146 for (j = 0; j <
ARRAY_LEN(g->rxgain); j++) {
5152 k = (float)k * linear_gain;
5155 }
else if (k < -32768) {
5164 case DAHDI_LAW_MULAW:
5165 for (j = 0; j <
ARRAY_LEN(g->rxgain); j++) {
5171 k = (float)k * linear_gain;
5174 }
else if (k < -32768) {
5188 struct dahdi_gains g;
5191 memset(&g, 0,
sizeof(g));
5192 res = ioctl(fd, DAHDI_GETGAINS, &g);
5200 return ioctl(fd, DAHDI_SETGAINS, &g);
5205 struct dahdi_gains g;
5208 memset(&g, 0,
sizeof(g));
5209 res = ioctl(fd, DAHDI_GETGAINS, &g);
5217 return ioctl(fd, DAHDI_SETGAINS, &g);
5220static int set_actual_gain(
int fd,
float rxgain,
float txgain,
float rxdrc,
float txdrc,
int law)
5257 res = ioctl(fd, DAHDI_HOOK, &x);
5260 if (
errno == EINPROGRESS)
5274#if defined(HAVE_PRI) || defined(HAVE_SS7)
5276#if defined(HAVE_PRI)
5284#if defined(HAVE_SS7)
5308 struct dahdi_confinfo
c;
5321 memset(&
c, 0,
sizeof(
c));
5322 c.confmode = DAHDI_CONF_NORMAL;
5328 ast_debug(1,
"Disabled conferencing\n");
5342 ast_debug(1,
"Restored conferencing\n");
5375 ast_debug(6,
"MWI manual override active on channel %d: pretending that it should be %s\n",
5406 if (
errno == EAGAIN)
5485#if defined(HAVE_PRI)
5492 subaddr = strchr(p->
exten,
':');
5521 x = DAHDI_FLUSH_READ | DAHDI_FLUSH_WRITE;
5536 (p->
law == DAHDI_LAW_ALAW) ? PRI_LAYER_1_ALAW : PRI_LAYER_1_ULAW);
5542#if defined(HAVE_SS7)
5574 openr2_calling_party_category_t chancat;
5593 chancat = dahdi_r2_get_channel_category(ast);
5594 callres = openr2_chan_make_call(p->r2chan, l, (
c + p->
stripmsd), chancat);
5595 if (-1 == callres) {
5600 p->mfcr2_call_accepted = 0;
5601 p->mfcr2_progress_sent = 0;
5675 }
else if (
iflist == pvt) {
5683 }
else if (
ifend == pvt) {
5694#if defined(HAVE_PRI)
5747#if defined(HAVE_PRI)
5785#if defined(HAVE_PRI)
5793static void dahdi_unlink_pri_pvt(
struct dahdi_pvt *pvt)
5804 for (idx = 0; idx <
pri->numchans; ++idx) {
5815#if defined(HAVE_SS7)
5823static void dahdi_unlink_ss7_pvt(
struct dahdi_pvt *pvt)
5834 for (idx = 0; idx <
ss7->numchans; ++idx) {
5845#if defined(HAVE_OPENR2)
5852static void dahdi_unlink_mfcr2_pvt(
struct dahdi_pvt *pvt)
5855 struct dahdi_mfcr2 *mfcr2;
5856 int should_destroy_link = 0;
5861 openr2_chan_disable_read(pvt->r2chan);
5865 for (idx = 0; idx < mfcr2->numchans; ++idx) {
5866 if (mfcr2->pvts[idx] == pvt) {
5867 ast_debug(1,
"Removing MFC/R2 channel %d from the mfcr2 link\n", pvt->
channel);
5868 mfcr2->pvts[idx] =
NULL;
5869 mfcr2->live_chans--;
5873 if (!mfcr2->live_chans) {
5874 ast_debug(1,
"MFC/R2 link is now empty\n");
5875 should_destroy_link = 1;
5879 if (should_destroy_link) {
5880 ast_debug(1,
"MFC/R2 link is now empty\n");
5881 mfcr2_queue_for_destruction(pvt);
5909#if defined(HAVE_PRI)
5910 dahdi_unlink_pri_pvt(p);
5912#if defined(HAVE_SS7)
5913 dahdi_unlink_ss7_pvt(p);
5915#if defined(HAVE_OPENR2)
5916 dahdi_unlink_mfcr2_pvt(p);
5924#if defined(HAVE_PRI)
5925 case DAHDI_IFLIST_NO_B_CHAN:
5927 dahdi_nobch_extract(p->pri, p);
5938#if defined(HAVE_PRI)
5943#if defined(HAVE_SS7)
5986 for (i = 0; i < 3; i++) {
5998#if defined(HAVE_PRI)
6014#if defined(HAVE_PRI_SERVICE_MESSAGES)
6016 char db_chan_name[20];
6021 snprintf(db_chan_name,
sizeof(db_chan_name),
"%s/%d:%d", dahdi_db, p->
span, chan);
6022 if (!
ast_db_get(db_chan_name, SRVST_DBKEY, db_answer,
sizeof(db_answer))) {
6023 sscanf(db_answer,
"%1c:%30d", &
state, &why);
6033 ast_verb(3,
"Unregistered channel %d\n", chan);
6038#if defined(HAVE_PRI)
6041 if (!pris[
span].dchannels[0]) {
6057#if defined(HAVE_PRI)
6058static char *dahdi_send_keypad_facility_app =
"DAHDISendKeypadFacility";
6060static int dahdi_send_keypad_facility_exec(
struct ast_channel *chan,
const char *digits)
6066 ast_debug(1,
"No digit string sent to application!\n");
6073 ast_debug(1,
"Unable to find technology private\n");
6083#if defined(HAVE_PRI)
6084#if defined(HAVE_PRI_PROG_W_CAUSE)
6085static char *dahdi_send_callrerouting_facility_app =
"DAHDISendCallreroutingFacility";
6087static int dahdi_send_callrerouting_facility_exec(
struct ast_channel *chan,
const char *data)
6100 ast_debug(1,
"No data sent to application!\n");
6104 ast_debug(1,
"Only DAHDI technology accepted!\n");
6109 ast_debug(1,
"Unable to find technology private\n");
6116 ast_debug(1,
"callrerouting attempted on non-ISDN channel %s\n",
6125 ast_log(
LOG_WARNING,
"callrerouting facility requires at least destination number argument\n");
6130 ast_log(
LOG_WARNING,
"Callrerouting Facility without original called number argument\n");
6135 ast_log(
LOG_NOTICE,
"Callrerouting Facility without diversion reason argument, defaulting to unknown\n");
6154#if defined(HAVE_OPENR2)
6155static const char *
const dahdi_accept_r2_call_app =
"DAHDIAcceptR2Call";
6157static int dahdi_accept_r2_call_exec(
struct ast_channel *chan,
const char *data)
6160 openr2_call_mode_t accept_mode;
6161 int res, timeout, maxloops;
6170 ast_debug(1,
"No data sent to application!\n");
6175 ast_debug(1,
"Only DAHDI technology accepted!\n");
6181 ast_debug(1,
"Unable to find technology private!\n");
6189 ast_log(
LOG_WARNING,
"DAHDIAcceptR2Call requires 'yes' or 'no' for the charge parameter\n");
6194 if (!p->mfcr2 || !p->mfcr2call) {
6200 if (p->mfcr2_call_accepted) {
6205 accept_mode =
ast_true(
args.charge) ? OR2_CALL_WITH_CHARGE : OR2_CALL_NO_CHARGE;
6206 if (openr2_chan_accept_call(p->r2chan, accept_mode)) {
6217 while (maxloops > 0) {
6246 if (p->mfcr2_call_accepted) {
6248 ast_debug(1,
"Accepted MFC/R2 call!\n");
6259static openr2_call_disconnect_cause_t dahdi_ast_cause_to_r2_cause(
int cause)
6261 openr2_call_disconnect_cause_t r2cause = OR2_CAUSE_NORMAL_CLEARING;
6266 r2cause = OR2_CAUSE_BUSY_NUMBER;
6271 r2cause = OR2_CAUSE_NETWORK_CONGESTION;
6275 r2cause = OR2_CAUSE_UNALLOCATED_NUMBER;
6280 r2cause = OR2_CAUSE_OUT_OF_ORDER;
6285 r2cause = OR2_CAUSE_NO_ANSWER;
6289 r2cause = OR2_CAUSE_NORMAL_CLEARING;
6292 ast_debug(1,
"ast cause %d resulted in openr2 cause %d/%s\n",
6293 cause, r2cause, openr2_proto_get_disconnect_string(r2cause));
6302 struct dahdi_bufferinfo bi = {
6310 if ((bpres = ioctl(p->
subs[
SUB_REAL].
dfd, DAHDI_SET_BUFINFO, &bi)) < 0) {
6327 struct dahdi_params par;
6355#if defined(HAVE_PRI)
6418#if defined(HAVE_SS7)
6497 ast_debug(1,
"Hangup: channel: %d index = %d, normal = %d, callwait = %d, thirdcall = %d\n",
6514 ast_debug(1,
"Normal call hung up with both three way call and a call waiting call in place?\n");
6517 ast_debug(1,
"We were flipped over to the callwait, moving back and not owning.\n");
6524 ast_debug(1,
"We were in the threeway and have a callwait still. Ditching the threeway.\n");
6530 ast_debug(1,
"Call was complete, setting owner to former third call\n");
6534 ast_debug(1,
"Call was incomplete, setting owner to NULL\n");
6553 ast_debug(1,
"Call was complete, setting owner to former third call\n");
6557 ast_debug(1,
"Call was incomplete, setting owner to NULL\n");
6618 if (p->mfcr2 && p->mfcr2call && openr2_chan_get_direction(p->r2chan) != OR2_DIR_STOPPED) {
6621 if (openr2_chan_get_direction(p->r2chan) == OR2_DIR_BACKWARD && p->mfcr2_forced_release) {
6622 dahdi_r2_disconnect_call(p, OR2_CAUSE_FORCED_RELEASE);
6625 int r2cause_user = r2causestr ? atoi(r2causestr) : 0;
6626 openr2_call_disconnect_cause_t r2cause = r2cause_user ? dahdi_ast_cause_to_r2_cause(r2cause_user)
6628 dahdi_r2_disconnect_call(p, r2cause);
6630 }
else if (p->mfcr2call) {
6656 memset(&par, 0,
sizeof(par));
6661 ast_debug(1,
"Hanging up channel %d, offhook = %d\n", p->
channel, par.rxisoffhook);
6664 if ((par.rxisoffhook) && (!(p->
radio || (p->
oprmode < 0))))
6747 ast_debug(1,
"Channel %d is no longer eligible for reorigination (went back on hook or became in use)\n", p->
channel);
6792#if defined(HAVE_PRI)
6797#if defined(HAVE_SS7)
6804 if (!p->mfcr2_call_accepted) {
6807 p->mfcr2_answer_pending = 1;
6808 if (p->mfcr2_charge_calls) {
6809 ast_debug(1,
"Accepting MFC/R2 call with charge before answering on chan %d\n", p->
channel);
6810 openr2_chan_accept_call(p->r2chan, OR2_CALL_WITH_CHARGE);
6812 ast_debug(1,
"Accepting MFC/R2 call with no charge before answering on chan %d\n", p->
channel);
6813 openr2_chan_accept_call(p->r2chan, OR2_CALL_NO_CHARGE);
6849 int val = DAHDI_TONEDETECT_ON | DAHDI_TONEDETECT_MUTE;
6870 if (!p || !data || (*datalen < 1)) {
6881 *cp = p->
tdd ? 1 : 0;
6895#if defined(HAVE_PRI)
6896#if defined(HAVE_PRI_CCSS)
6924 if (!p || !data || (datalen < 1)) {
6931 scp = (
signed char *) data;
6940 scp = (
signed char *) data;
6978 ast_debug(1,
"Set option TDD MODE, value: %s(%d) on %s\n",
6983 unsigned char mybuf[41000];
6985 int size, res, fd,
len;
6986 struct pollfd fds[1];
6989 memset(
buf, 0x7f,
sizeof(mybuf));
7005 fds[0].events = POLLPRI | POLLOUT;
7007 res = poll(fds, 1, -1);
7013 if (fds[0].revents & POLLPRI)
7015 if (!(fds[0].revents & POLLOUT)) {
7019 res = write(fd,
buf, size);
7021 if (res == -1)
return -1;
7045 ast_debug(1,
"Set option RELAX DTMF, value: %s(%d) on %s\n",
7050#if defined(HAVE_PRI)
7090 ast_debug(1,
"Set Operator Services mode, value: %d on %s/%s\n",
7143 if (!strcasecmp(data,
"rxgain")) {
7147 }
else if (!strcasecmp(data,
"txgain")) {
7151 }
else if (!strcasecmp(data,
"dahdi_channel")) {
7155 }
else if (!strcasecmp(data,
"dahdi_span")) {
7159 }
else if (!strcasecmp(data,
"dahdi_group")) {
7163 }
else if (!strcasecmp(data,
"dahdi_type")) {
7166#if defined(HAVE_OPENR2)
7171#if defined(HAVE_PRI)
7179#if defined(HAVE_SS7)
7190#if defined(HAVE_PRI)
7191#if defined(HAVE_PRI_REVERSE_CHARGE)
7192 }
else if (!strcasecmp(data,
"reversecharge")) {
7205#if defined(HAVE_PRI_SETUP_KEYPAD)
7206 }
else if (!strcasecmp(data,
"keypad_digits")) {
7220 }
else if (!strcasecmp(data,
"no_media_path")) {
7237 }
else if (!strcasecmp(data,
"dialmode")) {
7275 char policy_str[21] =
"";
7277 if ((res = sscanf(parse,
"%30d,%20s", num_buffers, policy_str)) != 2) {
7281 if (*num_buffers < 0) {
7285 if (!strcasecmp(policy_str,
"full")) {
7286 *policy = DAHDI_POLICY_WHEN_FULL;
7287 }
else if (!strcasecmp(policy_str,
"immediate")) {
7288 *policy = DAHDI_POLICY_IMMEDIATE;
7289#if defined(HAVE_DAHDI_HALF_FULL)
7290 }
else if (!strcasecmp(policy_str,
"half")) {
7291 *policy = DAHDI_POLICY_HALF_FULL;
7311 if (!strcasecmp(data,
"buffers")) {
7312 int num_bufs, policy;
7315 struct dahdi_bufferinfo bi = {
7316 .txbufpolicy = policy,
7317 .rxbufpolicy = policy,
7319 .numbufs = num_bufs,
7323 if ((bpres = ioctl(p->
subs[
SUB_REAL].
dfd, DAHDI_SET_BUFINFO, &bi)) < 0) {
7331 }
else if (!strcasecmp(data,
"echocan_mode")) {
7332 if (!strcasecmp(
value,
"on")) {
7336 }
else if (!strcasecmp(
value,
"off")) {
7340#ifdef HAVE_DAHDI_ECHOCANCEL_FAX_MODE
7341 }
else if (!strcasecmp(
value,
"fax")) {
7352 }
else if (!strcasecmp(
value,
"voice")) {
7368 }
else if (!strcasecmp(data,
"dialmode")) {
7379 if (!strcasecmp(
value,
"pulse")) {
7381 }
else if (!strcasecmp(
value,
"dtmf") || !strcasecmp(
value,
"tone")) {
7383 }
else if (!strcasecmp(
value,
"none")) {
7385 }
else if (!strcasecmp(
value,
"both")) {
7392 }
else if (!strcasecmp(data,
"waitfordialtone")) {
7432 if (!slave || (master->
slaves[x] == slave)) {
7473 if (!slave || !master) {
7478 if (!master->
slaves[x]) {
7479 master->
slaves[x] = slave;
7502 if (p->
owner == oldchan) {
7505 for (x = 0; x < 3; x++) {
7515#if defined(HAVE_PRI)
7519#if defined(HAVE_SS7)
7588 ast_verb(3,
"TRANSFERRING %s to %s\n",
7613 struct dahdi_confinfo ci;
7617 memset(&ci, 0,
sizeof(ci));
7626 ast_verb(3,
"Avoiding 3-way call when in an external conference\n");
7640 struct dahdi_spaninfo zi;
7641 struct dahdi_params params;
7643 memset(&zi, 0,
sizeof(zi));
7644 zi.spanno = p->
span;
7647 if (zi.alarms != DAHDI_ALARM_NONE)
7655 memset(¶ms, 0,
sizeof(params));
7656 if ((res = ioctl(p->
subs[
SUB_REAL].
dfd, DAHDI_GET_PARAMS, ¶ms)) >= 0)
7657 return params.chan_alarms;
7661 return DAHDI_ALARM_NONE;
7669 ast_debug(1,
"%s DTMF digit: 0x%02X '%c' on %s\n",
7686 *dest = &p->
subs[idx].
f;
7690 ast_debug(1,
"Got some DTMF, but it's for the CAS\n");
7699 *dest = &p->
subs[idx].
f;
7706 struct dahdi_bufferinfo bi = {
7713 if ((res = ioctl(p->
subs[idx].
dfd, DAHDI_SET_BUFINFO, &bi)) < 0) {
7751 ast_debug(1,
"Already in a fax extension, not redirecting\n");
7760 *dest = &p->
subs[idx].
f;
7770 "Alarm", alarm_txt);
7789 "Alarm", alarm_txt);
7799 const char *alarm_str;
7801#if defined(HAVE_PRI)
7842 p->
subs[idx].
f.
src =
"dahdi_handle_event";
7844 f = &p->
subs[idx].
f;
7854 if (res & (DAHDI_EVENT_PULSEDIGIT | DAHDI_EVENT_DTMFUP)) {
7855 p->
pulsedial = (res & DAHDI_EVENT_PULSEDIGIT) ? 1 : 0;
7857#if defined(HAVE_PRI)
7875 if (res & DAHDI_EVENT_DTMFDOWN) {
7876 ast_debug(1,
"DTMF Down '%c'\n", res & 0xff);
7877#if defined(HAVE_PRI)
7892 return &p->
subs[idx].
f;
7896 case DAHDI_EVENT_EC_DISABLED:
7900#ifdef HAVE_DAHDI_ECHOCANCEL_FAX_MODE
7901 case DAHDI_EVENT_TX_CED_DETECTED:
7902 ast_verb(3,
"Channel %d detected a CED tone towards the network.\n", p->
channel);
7904 case DAHDI_EVENT_RX_CED_DETECTED:
7905 ast_verb(3,
"Channel %d detected a CED tone from the network.\n", p->
channel);
7907 case DAHDI_EVENT_EC_NLP_DISABLED:
7908 ast_verb(3,
"Channel %d echo canceler disabled its NLP.\n", p->
channel);
7910 case DAHDI_EVENT_EC_NLP_ENABLED:
7911 ast_verb(3,
"Channel %d echo canceler enabled its NLP.\n", p->
channel);
7914 case DAHDI_EVENT_BITSCHANGED:
7920 openr2_chan_handle_cas(p->r2chan);
7926 case DAHDI_EVENT_PULSE_START:
7929 tone_zone_play_tone(p->
subs[idx].
dfd, -1);
7931 case DAHDI_EVENT_DIALCOMPLETE:
7933#if defined(HAVE_PRI)
7938 if (ioctl(p->
subs[idx].
dfd, DAHDI_DIALING, &x) == -1) {
7939 ast_debug(1,
"DAHDI_DIALING ioctl failed on %s: %s\n",
7964 if (ioctl(p->
subs[idx].
dfd,DAHDI_DIALING,&x) == -1) {
7973 p->
dop.op = DAHDI_DIAL_OP_REPLACE;
7992 ast_debug(1,
"Done dialing, but waiting for progress detection before doing more...\n");
8017 case DAHDI_EVENT_ALARM:
8019#if defined(HAVE_PRI)
8024#if defined(HAVE_SS7)
8036 if (!p->pri || !p->pri->pri || pri_get_timer(p->pri->pri, PRI_TIMER_T309) < 0) {
8042#if defined(HAVE_SS7)
8050 case DAHDI_EVENT_ONHOOK:
8084 ast_verb(3,
"Channel %d still has (callwait) call, ringing phone\n", p->
channel);
8099 unsigned int mssinceflash;
8110 if (p->
owner != ast) {
8120 ast_debug(1,
"Last flash was %u ms ago\n", mssinceflash);
8127 ast_debug(1,
"Looks like a bounced flash, hanging up both calls on %d\n", p->
channel);
8173 case DAHDI_EVENT_RINGOFFHOOK:
8203 int numchars = snprintf(p->
dop.dialstr,
sizeof(p->
dop.dialstr),
"M*0%s#",
c);
8204 if (numchars >=
sizeof(p->
dop.dialstr)) {
8211 if (strlen(p->
dop.dialstr) > 4) {
8216 p->
dop.dialstr[strlen(p->
dop.dialstr)-2] =
'\0';
8225 return &p->
subs[idx].
f;
8257 p->
dop.dialstr[0] =
'\0';
8260 ast_debug(1,
"Sent FXO deferred digit string: %s\n", p->
dop.dialstr);
8265 p->
dop.dialstr[0] =
'\0';
8269 return &p->
subs[idx].
f;
8276 return &p->
subs[idx].
f;
8289 res = tone_zone_play_tone(p->
subs[
SUB_REAL].
dfd, DAHDI_TONE_DIALTONE);
8304 ast_debug(1,
"Setting IDLE polarity due "
8305 "to ring. Old polarity was %d\n",
8348 case DAHDI_EVENT_RINGBEGIN:
8359 case DAHDI_EVENT_RINGERON:
8361 case DAHDI_EVENT_NOALARM:
8363#if defined(HAVE_PRI)
8368#if defined(HAVE_SS7)
8379 case DAHDI_EVENT_WINKFLASH:
8381 if (p->
radio)
break;
8385 struct dahdi_params par;
8387 memset(&par, 0,
sizeof(par));
8390 if (!par.rxisoffhook)
8408 ast_debug(1,
"Winkflash, index: %d, normal: %d, callwait: %d, thirdcall: %d\n",
8472 ast_debug(1,
"Flash when call not up or ringing\n");
8503 res = tone_zone_play_tone(p->
subs[
SUB_REAL].
dfd, DAHDI_TONE_DIALRECALL);
8511 res = tone_zone_play_tone(p->
subs[
SUB_REAL].
dfd, DAHDI_TONE_CONGESTION);
8527 ast_debug(1,
"Got flash with three way call up, dropping last call on %d\n", p->
channel);
8545 ast_verb(3,
"Building conference call with %s and %s\n",
8595 snprintf(p->
dop.dialstr,
sizeof(p->
dop.dialstr),
"M*%d%s#",
8604 ast_log(
LOG_WARNING,
"Received unexpected wink on channel of type SIG_FEATDMF_TA\n");
8621 p->
dop.dialstr[0] =
'\0';
8624 ast_debug(1,
"Sent deferred digit string: %s\n", p->
dop.dialstr);
8626 p->
dop.dialstr[0] =
'\0';
8632 case DAHDI_EVENT_HOOKCOMPLETE:
8650 p->
dop.dialstr[0] =
'\0';
8653 ast_debug(1,
"Sent deferred digit string: %s\n", p->
dop.dialstr);
8655 p->
dop.dialstr[0] =
'\0';
8656 p->
dop.op = DAHDI_DIAL_OP_REPLACE;
8666 ast_debug(1,
"Got hook complete in MF FGD, waiting for wink now on channel %d\n",p->
channel);
8672 case DAHDI_EVENT_POLARITY:
8684 ast_debug(1,
"Answering on polarity switch!\n");
8699 ast_debug(1,
"Polarity Reversal event occurred - DEBUG 1: channel %d, state %u, pol= %d, aonp= %d, honp= %d, pdelay= %d, tv= %" PRIi64
"\n", p->
channel,
ast_channel_state(ast), p->
polarity, p->
answeronpolarityswitch, p->
hanguponpolarityswitch, p->
polarityonanswerdelay,
ast_tvdiff_ms(
ast_tvnow(), p->
polaritydelaytv) );
8702 ast_debug(1,
"Polarity Reversal detected and now Hanging up on channel %d\n", p->
channel);
8713 ast_debug(1,
"Polarity Reversal event occurred - DEBUG 2: channel %d, state %u, pol= %d, aonp= %d, honp= %d, pdelay= %d, tv= %" PRIi64
"\n", p->
channel,
ast_channel_state(ast), p->
polarity, p->
answeronpolarityswitch, p->
hanguponpolarityswitch, p->
polarityonanswerdelay,
ast_tvdiff_ms(
ast_tvnow(), p->
polaritydelaytv) );
8716 ast_debug(1,
"Dunno what to do with event %d on channel %d\n", res, p->
channel);
8718 return &p->
subs[idx].
f;
8740 p->
subs[idx].
f.
src =
"dahdi_exception";
8756 if ((res != DAHDI_EVENT_RINGEROFF) && (res != DAHDI_EVENT_RINGERON) &&
8757 (res != DAHDI_EVENT_HOOKCOMPLETE)) {
8758 ast_debug(1,
"Restoring owner of channel %d on event %d\n", p->
channel, res);
8766 case DAHDI_EVENT_ONHOOK:
8778 case DAHDI_EVENT_RINGOFFHOOK:
8786 case DAHDI_EVENT_HOOKCOMPLETE:
8787 case DAHDI_EVENT_RINGERON:
8788 case DAHDI_EVENT_RINGEROFF:
8791 case DAHDI_EVENT_WINKFLASH:
8798 if (usedindex > -1) {
8815 f = &p->
subs[idx].
f;
8821 if (ast != p->
owner) {
8825 f = &p->
subs[idx].
f;
8919 struct dahdi_params ps;
8921 memset(&ps, 0,
sizeof(ps));
8937 return &p->
subs[idx].
f;
8940 if (!(--p->
ringt)) {
8948 openr2_chan_process_event(p->r2chan);
8949 if (OR2_DIR_FORWARD == openr2_chan_get_direction(p->r2chan)) {
8953 if (p->mfcr2_call_accepted &&
8954 !p->mfcr2_progress_sent &&
8956 ast_debug(1,
"Enqueuing progress frame after R2 accept in chan %d\n", p->
channel);
8958 p->mfcr2_progress_sent = 1;
8971 return &p->
subs[idx].
f;
8980 return &p->
subs[idx].
f;
8989 return &p->
subs[idx].
f;
8998 return &p->
subs[idx].
f;
9001 if (p->mfcr2 && openr2_chan_get_read_enabled(p->r2chan)) {
9017 return &p->
subs[idx].
f;
9027 return &p->
subs[idx].
f;
9037 return &p->
subs[idx].
f;
9079 if (
errno == EAGAIN) {
9082 return &p->
subs[idx].
f;
9083 }
else if (
errno == ELAST) {
9125 return &p->
subs[idx].
f;
9133 ast_verb(3,
"CPE does not support Call Waiting Caller*ID.\n");
9190 ast_debug(1,
"Channel driver fax CNG detection timeout on %s\n",
9235 ast_debug(1,
"Absorbing inband %s DTMF digit: 0x%02X '%c' on %s\n",
9258 ast_debug(1,
"Got 10 samples of dialtone!\n");
9262 p->
dop.dialstr[0] =
'\0';
9267 ast_debug(1,
"Sent deferred digit string: %s\n", p->
dop.dialstr);
9269 p->
dop.dialstr[0] =
'\0';
9270 p->
dop.op = DAHDI_DIAL_OP_REPLACE;
9279 f = &p->
subs[idx].
f;
9330 res = write(fd,
buf, size);
9375 if (mssinceflash >= 1000) {
9393 ast_debug(5,
"Dropping frame since I'm still dialing on %s...\n",
9399 ast_debug(5,
"Dropping frame since there is no active owner on %s...\n",
9405 ast_debug(5,
"Dropping frame since I've still got a callerid spill on %s...\n",
9447 int func = DAHDI_FLASH;
9452#if defined(HAVE_PRI)
9458#if defined(HAVE_SS7)
9468 if (p->mfcr2 && !p->mfcr2_call_accepted) {
9477 switch (condition) {
9479 res = tone_zone_play_tone(p->
subs[idx].
dfd, DAHDI_TONE_BUSY);
9482 res = tone_zone_play_tone(p->
subs[idx].
dfd, DAHDI_TONE_RINGTONE);
9543 p->
dop.dialstr[0] =
'\0';
9556 res = tone_zone_play_tone(p->
subs[idx].
dfd, -1);
9566#if defined(HAVE_PRI)
9581#if defined(HAVE_PRI)
9582 }
else if (i->pri) {
9584 y = ++i->pri->new_chan_seq;
9602 for (x = 0; x < 3; ++x) {
9640#if defined(HAVE_PRI)
9659 tmp =
ast_channel_alloc(0,
state, i->
cid_num, i->
cid_name, i->
accountcode, i->
exten, i->
context, assignedids, requestor, i->
amaflags,
"DAHDI/%s",
ast_str_buffer(chan_name));
9673#if defined(HAVE_PRI)
9681 if (law == DAHDI_LAW_ALAW) {
9691 ? DAHDI_LAW_ALAW : DAHDI_LAW_MULAW;
9726 x = DAHDI_TONEDETECT_ON | DAHDI_TONEDETECT_MUTE;
9727 if (ioctl(i->
subs[idx].
dfd, DAHDI_TONEDETECT, &x)) {
9745#if defined(HAVE_PRI) || defined(HAVE_SS7)
9779 ast_channel_parkinglot_set(tmp, i->
parkinglot);
9781 ast_channel_language_set(tmp, i->
language);
9808#if defined(HAVE_PRI) || defined(HAVE_SS7)
9837 dashptr = strrchr(device_name,
'-');
9844 for (v = i->
vars ; v ; v = v->
next)
9884 if (strchr(term,
c))
9896 j = DAHDI_IOMUX_SIGEVENT;
9898 if (ioctl(p->
subs[idx].
dfd,DAHDI_IOMUX,&j) == -1)
return(-1);
9900 if (j & DAHDI_IOMUX_SIGEVENT)
break;
9903 if (ioctl(p->
subs[idx].
dfd,DAHDI_GETEVENT,&j) == -1)
return(-1);
9943 return dahdichan->
dnd;
9948 ast_verb(3,
"%s DND on channel %d\n",
9949 flag?
"Enabled" :
"Disabled",
9957 int extlen = strlen(exten);
9963 if (extlen < strlen(pickupexten) && !strncmp(pickupexten, exten, extlen)) {
9967 if (exten[0] ==
'*' && extlen < 3) {
9988 unsigned char buf[256];
10003 int getforward = 0;
10009 const char *pickupexten;
10033 ast_log(
LOG_ERROR,
"Unable to retrieve pickup configuration options. Unable to detect call pickup extension\n");
10036 pickupexten =
ast_strdupa(pickup_cfg->pickupexten);
10061 res = tone_zone_play_tone(p->
subs[idx].
dfd, -1);
10071 memset(dtmfbuf, 0,
sizeof(dtmfbuf));
10086 res =
my_getsigstr(chan, dtmfbuf + strlen(dtmfbuf),
"*", 3000);
10096 if (res <= 0)
break;
10105 if ((p->
sig ==
SIG_FEATDMF) && (dtmfbuf[1] !=
'0') && (strlen(dtmfbuf) != 14))
10111 if (res <= 0)
break;
10119 res =
my_getsigstr(chan, dtmfbuf + strlen(dtmfbuf),
"#", 3000);
10136 res =
my_getsigstr(chan, dtmfbuf + strlen(dtmfbuf),
"*", 3000);
10143 dtmfbuf[
len] =
'\0';
10152 ast_debug(1,
"waitfordigit returned < 0...\n");
10156 dtmfbuf[
len++] = res;
10157 dtmfbuf[
len] =
'\0';
10169 }
else if (res < 0) {
10170 ast_debug(1,
"Got hung up before digits finished\n");
10185 if ((res > 0) && (strlen(anibuf) > 2)) {
10186 if (anibuf[strlen(anibuf) - 1] ==
'#')
10187 anibuf[strlen(anibuf) - 1] = 0;
10198 if (exten[0] ==
'*') {
10199 char *stringp=
NULL;
10203 s1 =
strsep(&stringp,
"*");
10204 s2 =
strsep(&stringp,
"*");
10217 if (exten[0] ==
'*') {
10218 char *stringp=
NULL;
10222 s1 =
strsep(&stringp,
"#");
10223 s2 =
strsep(&stringp,
"#");
10237 if (exten[0] ==
'*') {
10238 char *stringp=
NULL;
10242 s1 =
strsep(&stringp,
"#");
10243 s2 =
strsep(&stringp,
"#");
10244 if (s2 && (*(s2 + 1) ==
'0')) {
10254 if (exten[0] ==
'*') {
10255 char *stringp=
NULL;
10259 s1 =
strsep(&stringp,
"#");
10293 res = tone_zone_play_tone(p->
subs[idx].
dfd, DAHDI_TONE_CONGESTION);
10299 res = tone_zone_play_tone(p->
subs[idx].
dfd, DAHDI_TONE_INFO);
10307 res = tone_zone_play_tone(p->
subs[idx].
dfd, DAHDI_TONE_CONGESTION);
10322 int is_exten_parking = 0;
10332 ast_debug(1,
"waitfordigit returned < 0...\n");
10333 res = tone_zone_play_tone(p->
subs[idx].
dfd, -1);
10337 ast_debug(1,
"waitfordigit returned '%c' (%d), timeout = %d\n", res, res, timeout);
10342 tone_zone_play_tone(p->
subs[idx].
dfd, -1);
10344 tone_zone_play_tone(p->
subs[idx].
dfd, DAHDI_TONE_DIALTONE);
10355 res = tone_zone_play_tone(p->
subs[idx].
dfd, DAHDI_TONE_DIALRECALL);
10359 res = tone_zone_play_tone(p->
subs[idx].
dfd, -1);
10361 memset(exten, 0,
sizeof(exten));
10362 res = tone_zone_play_tone(p->
subs[idx].
dfd, DAHDI_TONE_DIALTONE);
10366 res = tone_zone_play_tone(p->
subs[idx].
dfd, -1);
10385 res = tone_zone_play_tone(p->
subs[idx].
dfd, DAHDI_TONE_CONGESTION);
10394 }
else if (res == 0) {
10395 ast_debug(1,
"not enough digits (and no ambiguous match)...\n");
10396 res = tone_zone_play_tone(p->
subs[idx].
dfd, DAHDI_TONE_CONGESTION);
10400 }
else if (p->
callwaiting && !strcmp(exten,
"*70")) {
10404 res = tone_zone_play_tone(p->
subs[idx].
dfd, DAHDI_TONE_DIALRECALL);
10410 ioctl(p->
subs[idx].
dfd,DAHDI_CONFDIAG,&
len);
10411 memset(exten, 0,
sizeof(exten));
10414 }
else if (!strcmp(exten, pickupexten)) {
10430 ast_debug(1,
"No call pickup possible...\n");
10431 res = tone_zone_play_tone(p->
subs[idx].
dfd, DAHDI_TONE_CONGESTION);
10442 }
else if (!p->
hidecallerid && !strcmp(exten,
"*67")) {
10450 res = tone_zone_play_tone(p->
subs[idx].
dfd, DAHDI_TONE_DIALRECALL);
10456 memset(exten, 0,
sizeof(exten));
10458 }
else if (p->
callreturn && !strcmp(exten,
"*69")) {
10459 res = tone_zone_play_tone(p->
subs[idx].
dfd, DAHDI_TONE_DIALRECALL);
10461 }
else if (!strcmp(exten,
"*78")) {
10464 res = tone_zone_play_tone(p->
subs[idx].
dfd, DAHDI_TONE_DIALRECALL);
10466 memset(exten, 0,
sizeof(exten));
10468 }
else if (!strcmp(exten,
"*79")) {
10471 res = tone_zone_play_tone(p->
subs[idx].
dfd, DAHDI_TONE_DIALRECALL);
10473 memset(exten, 0,
sizeof(exten));
10476 res = tone_zone_play_tone(p->
subs[idx].
dfd, DAHDI_TONE_DIALRECALL);
10478 memset(exten, 0,
sizeof(exten));
10481 ast_verb(3,
"Cancelling call forwarding on channel %d\n", p->
channel);
10482 res = tone_zone_play_tone(p->
subs[idx].
dfd, DAHDI_TONE_DIALRECALL);
10485 memset(exten, 0,
sizeof(exten));
10498 if (bridge_channel) {
10517 }
else if (p->
hidecallerid && !strcmp(exten,
"*82")) {
10522 res = tone_zone_play_tone(p->
subs[idx].
dfd, DAHDI_TONE_DIALRECALL);
10528 memset(exten, 0,
sizeof(exten));
10530 }
else if (!strcmp(exten,
"*0")) {
10537 if (nbridge && bridged) {
10540 if (nbridge && pbridge &&
10544 int func = DAHDI_FLASH;
10546 p->
dop.dialstr[0] =
'\0';
10559 tone_zone_play_tone(p->
subs[idx].
dfd, DAHDI_TONE_CONGESTION);
10561 tone_zone_play_tone(p->
subs[idx].
dfd, -1);
10579 tone_zone_play_tone(p->
subs[idx].
dfd, -1);
10589 if (smdi_msg !=
NULL) {
10592 if (smdi_msg->
type ==
'B')
10594 else if (smdi_msg->
type ==
'N')
10642 "Exiting simple switch\n");
10667 ast_debug(1,
"CID got string '%s'\n", dtmfbuf);
10680 struct timeval start;
10691 i = DAHDI_IOMUX_READ | DAHDI_IOMUX_SIGEVENT;
10692 if ((res = ioctl(p->
subs[idx].
dfd, DAHDI_IOMUX, &i))) {
10698 if (i & DAHDI_IOMUX_SIGEVENT) {
10701 if (res == DAHDI_EVENT_NOALARM) {
10706 if (res == DAHDI_EVENT_RINGBEGIN) {
10714 }
else if (i & DAHDI_IOMUX_READ) {
10717 if (
errno != ELAST) {
10738 "Failed to decode CallerID on channel '%s'\n",
10743 else if (samples > (8000 * 10))
10767 "Exiting simple switch\n");
10788 for (receivedRingT = 0; receivedRingT <
ARRAY_LEN(curRingData); receivedRingT++)
10789 curRingData[receivedRingT] = 0;
10800 i = DAHDI_IOMUX_READ | DAHDI_IOMUX_SIGEVENT;
10801 if ((res = ioctl(p->
subs[idx].
dfd, DAHDI_IOMUX, &i))) {
10807 if (i & DAHDI_IOMUX_SIGEVENT) {
10810 if (res == DAHDI_EVENT_NOALARM) {
10816 curRingData[receivedRingT] = p->
ringt;
10822 if (++receivedRingT ==
ARRAY_LEN(curRingData))
10824 }
else if (i & DAHDI_IOMUX_READ) {
10827 if (
errno != ELAST) {
10835 if (p->
ringt > 0) {
10836 if (!(--p->
ringt)) {
10844 ast_verb(3,
"Detected ring pattern: %d,%d,%d\n",curRingData[0],curRingData[1],curRingData[2]);
10845 for (counter = 0; counter < 3; counter++) {
10849 for (counter1 = 0; counter1 < 3; counter1++) {
10852 ast_verb(3,
"Pattern ignore (-1) detected, so matching pattern %d regardless.\n",
10853 curRingData[counter1]);
10857 ast_verb(3,
"Ring pattern matched in range: %d to %d\n",
10864 if (distMatches == 3) {
10882 "state, but I have nothing to do. "
10883 "Terminating simple switch, should be "
10884 "restarted by the actual ring.\n",
10893 struct timeval start;
10906 "Exiting simple switch\n");
10930 ast_debug(1,
"CID is '%s', flags %d\n",
10949 for (receivedRingT = 0; receivedRingT <
ARRAY_LEN(curRingData); receivedRingT++)
10950 curRingData[receivedRingT] = 0;
10963 i = DAHDI_IOMUX_READ | DAHDI_IOMUX_SIGEVENT;
10964 if ((res = ioctl(p->
subs[idx].
dfd, DAHDI_IOMUX, &i))) {
10970 if (i & DAHDI_IOMUX_SIGEVENT) {
10973 if (res == DAHDI_EVENT_NOALARM) {
10978 ast_debug(1,
"Hanging up due to polarity reversal on channel %d while detecting callerid\n", p->
channel);
10987 curRingData[receivedRingT] = p->
ringt;
10993 if (++receivedRingT ==
ARRAY_LEN(curRingData))
10995 }
else if (i & DAHDI_IOMUX_READ) {
10998 if (
errno != ELAST) {
11006 if (p->
ringt > 0) {
11007 if (!(--p->
ringt)) {
11020 "Failed to decode CallerID on channel '%s'\n",
11025 else if (
samples > (8000 * 10))
11035 for (receivedRingT = 0; receivedRingT < 3; receivedRingT++) {
11036 curRingData[receivedRingT] = 0;
11039 ast_verb(3,
"Detecting post-CID distinctive ring\n");
11041 i = DAHDI_IOMUX_READ | DAHDI_IOMUX_SIGEVENT;
11042 if ((res = ioctl(p->
subs[idx].
dfd, DAHDI_IOMUX, &i))) {
11048 if (i & DAHDI_IOMUX_SIGEVENT) {
11051 if (res == DAHDI_EVENT_NOALARM) {
11057 curRingData[receivedRingT] = p->
ringt;
11063 if (++receivedRingT ==
ARRAY_LEN(curRingData))
11065 }
else if (i & DAHDI_IOMUX_READ) {
11068 if (
errno != ELAST) {
11076 if (p->
ringt > 0) {
11077 if (!(--p->
ringt)) {
11087 ast_verb(3,
"Detected ring pattern: %d,%d,%d\n",curRingData[0],curRingData[1],curRingData[2]);
11089 for (counter = 0; counter < 3; counter++) {
11093 ast_verb(3,
"Checking %d,%d,%d\n",
11098 for (counter1 = 0; counter1 < 3; counter1++) {
11101 ast_verb(3,
"Pattern ignore (-1) detected, so matching pattern %d regardless.\n",
11102 curRingData[counter1]);
11107 ast_verb(3,
"Ring pattern matched in range: %d to %d\n",
11113 if (distMatches == 3) {
11160 res = tone_zone_play_tone(p->
subs[idx].
dfd, DAHDI_TONE_CONGESTION);
11164 res = tone_zone_play_tone(p->
subs[idx].
dfd, DAHDI_TONE_CONGESTION);
11190 for (x = 0; x <
len; x++)
11200 pthread_t threadid;
11205 unsigned int spill_done = 0;
11206 int spill_result = -1;
11209 goto quit_no_clean;
11217 i = DAHDI_IOMUX_READ | DAHDI_IOMUX_SIGEVENT;
11223 if (i & DAHDI_IOMUX_SIGEVENT) {
11226 int callid_created;
11234 case DAHDI_EVENT_NEONMWI_ACTIVE:
11235 case DAHDI_EVENT_NEONMWI_INACTIVE:
11236 case DAHDI_EVENT_NONE:
11237 case DAHDI_EVENT_BITSCHANGED:
11239 case DAHDI_EVENT_NOALARM:
11248 case DAHDI_EVENT_ALARM:
11286 goto quit_no_clean;
11288 }
else if (i & DAHDI_IOMUX_READ) {
11290 if (
errno != ELAST) {
11305 }
else if (spill_result) {
11315 if (samples > (8000 * 4))
11320 if (spill_result == 1) {
11357#ifdef HAVE_DAHDI_LINEREVERSE_VMWI
11359 if (pvt->mwisend_rpas) {
11362 }
else if (pvt->mwisend_fsk) {
11390 x = DAHDI_FLUSH_BOTH;
11394#ifdef HAVE_DAHDI_LINEREVERSE_VMWI
11395 if (pvt->mwisend_fsk) {
11400#ifdef HAVE_DAHDI_LINEREVERSE_VMWI
11408 struct timeval now;
11432#ifdef HAVE_DAHDI_LINEREVERSE_VMWI
11433 if (pvt->mwisend_fsk) {
11435 gettimeofday(&now,
NULL);
11439#ifdef HAVE_DAHDI_LINEREVERSE_VMWI
11447 if (0 < num_read) {
11500 case DAHDI_EVENT_RINGEROFF:
11517 case DAHDI_EVENT_RINGOFFHOOK:
11527 case DAHDI_EVENT_RINGERON:
11528 case DAHDI_EVENT_HOOKCOMPLETE:
11542 int destroyed_first = 0;
11543 int destroyed_last = 0;
11550 int x = DAHDI_FLASH;
11552 if (cur->
channel > destroyed_last) {
11553 destroyed_last = cur->
channel;
11555 if (destroyed_first < 1 || cur->
channel < destroyed_first) {
11556 destroyed_first = cur->
channel;
11567 if (destroyed_first > start || destroyed_last <
end) {
11568 ast_debug(1,
"Asked to destroy %d-%d, destroyed %d-%d,\n",
11569 start,
end, destroyed_first, destroyed_last);
11574static void dahdi_r2_destroy_nodev(
void)
11576 struct r2link_entry *cur;
11580 struct dahdi_mfcr2 *r2 = &cur->mfcr2;
11581 ast_debug(3,
"About to destroy %d DAHDI channels of MFC/R2 link.\n", r2->numchans);
11582 for (i = 0; i < r2->numchans; i++) {
11595 pthread_cancel(r2->r2master);
11596 pthread_join(r2->r2master,
NULL);
11598 openr2_context_delete(r2->protocol_context);
11628 ast_debug(1,
"channel range caps: %d - %d\n", start,
end);
11633 "channel range %d-%d is occupied\n",
11642 struct dahdi_pri *pri = pris + x;
11644 if (!pris[x].pri.pvts[0]) {
11648 int channo = pri->dchannels[i];
11653 if (!pri->pri.fds[i]) {
11656 if (channo >= start && channo <=
end) {
11658 "channel range %d-%d is occupied by span %d\n",
11659 start,
end, x + 1);
11667 !
conf.chan.cc_params) {
11672 conf.wanted_channels_start = start;
11675 conf.wanted_channels_end =
end;
11691 pthread_t threadid;
11694 int callid_created;
11699 case DAHDI_EVENT_NONE:
11700 case DAHDI_EVENT_BITSCHANGED:
11702 case DAHDI_EVENT_WINKFLASH:
11703 case DAHDI_EVENT_RINGOFFHOOK:
11705 if (i->
radio)
break;
11712 if (res && (
errno == EBUSY)) {
11726 res = tone_zone_play_tone(i->
subs[
SUB_REAL].
dfd, DAHDI_TONE_RINGTONE);
11730 res = tone_zone_play_tone(i->
subs[
SUB_REAL].
dfd, DAHDI_TONE_CONGESTION);
11739 res = tone_zone_play_tone(i->
subs[
SUB_REAL].
dfd, DAHDI_TONE_STUTTER);
11741 res = tone_zone_play_tone(i->
subs[
SUB_REAL].
dfd, DAHDI_TONE_DIALTONE);
11743 ast_log(
LOG_WARNING,
"Unable to play dialtone on channel %d, do you have defaultzone and loadzone defined?\n", i->
channel);
11746 res = tone_zone_play_tone(i->
subs[
SUB_REAL].
dfd, DAHDI_TONE_CONGESTION);
11789 res = tone_zone_play_tone(i->
subs[
SUB_REAL].
dfd, DAHDI_TONE_CONGESTION);
11800 res = tone_zone_play_tone(i->
subs[
SUB_REAL].
dfd, DAHDI_TONE_CONGESTION);
11806 case DAHDI_EVENT_NOALARM:
11808#if defined(HAVE_PRI)
11815#if defined(HAVE_SS7)
11826 case DAHDI_EVENT_ALARM:
11828#if defined(HAVE_PRI)
11835#if defined(HAVE_SS7)
11847 case DAHDI_EVENT_ONHOOK:
11893 case DAHDI_EVENT_POLARITY:
11907 ast_verb(2,
"Starting post polarity "
11908 "CID detection on channel %d\n",
11922 "polarity reversal on non-FXO (SIG_FXS) "
11923 "interface %d\n", i->
channel);
11926 case DAHDI_EVENT_REMOVED:
11928 "Got DAHDI_EVENT_REMOVED. Destroying channel %d\n",
11931 case DAHDI_EVENT_NEONMWI_ACTIVE:
11937 case DAHDI_EVENT_NEONMWI_INACTIVE:
11948 struct pollfd **pfds = arg;
11954 int count, res, res2, spoint, pollres=0;
11958 time_t thispass = 0, lastpass = 0;
11961 struct pollfd *pfds=
NULL;
11962 int lastalloc = -1;
11967 if (pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,
NULL)) {
11973 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,
NULL);
11979 if (!pfds || (lastalloc !=
ifcount)) {
12006 pfds[count].events = POLLPRI;
12007 pfds[count].revents = 0;
12011 pfds[count].events |= POLLIN;
12019 pfds[count].events = POLLPRI;
12020 pfds[count].revents = 0;
12025 pfds[count].events |= POLLIN;
12036 pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,
NULL);
12037 pthread_testcancel();
12039 res = poll(pfds, count, 1000);
12040 pthread_testcancel();
12041 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,
NULL);
12054 lastpass = thispass;
12055 thispass = time(
NULL);
12066 if (thispass != lastpass) {
12073 && !
last->mwisendactive
12074 && (
last->sig & __DAHDI_SIG_FXO)
12087 res2 = ioctl(
last->subs[
SUB_REAL].dfd, DAHDI_VMWI, &res);
12090 ast_debug(3,
"Unable to control message waiting led on channel %d: %s\n",
last->channel, strerror(
errno));
12093 ast_debug(5,
"Initiating MWI FSK spill on channel %d\n",
last->channel);
12123 if (pollres & POLLIN) {
12139 pthread_attr_t attr;
12140 pthread_t threadid;
12143 pthread_attr_init(&attr);
12144 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
12149 memcpy(mtd->
buf,
buf, res);
12162 struct timeval now;
12170 gettimeofday(&now,
NULL);
12177 pthread_t threadid;
12212 if (pollres & POLLPRI) {
12239 ast_debug(1,
"Woah! Went back on hook before reoriginate could happen on channel %d\n", i->
channel);
12242 res = DAHDI_EVENT_RINGOFFHOOK;
12257 dahdi_r2_destroy_nodev();
12261 pthread_cleanup_pop(1);
12292#if defined(HAVE_PRI)
12293static int pri_resolve_span(
int *
span,
int channel,
int offset,
struct dahdi_spaninfo *si)
12298 trunkgroup = pris[*
span].mastertrunkgroup;
12313 }
else if (pris[*
span].mastertrunkgroup) {
12314 ast_log(
LOG_WARNING,
"Unable to use span %d implicitly since it is already part of trunk group %d\n", *
span, pris[*
span].mastertrunkgroup);
12317 if (si->totalchans == 31) {
12319 pris[*
span].dchannels[0] = 16 + offset;
12320 }
else if (si->totalchans == 24) {
12322 pris[*
span].dchannels[0] = 24 + offset;
12323 }
else if (si->totalchans == 3) {
12325 pris[*
span].dchannels[0] = 3 + offset;
12327 ast_log(
LOG_WARNING,
"Unable to use span %d, since the D-channel cannot be located (unexpected span size of %d channels)\n", *
span, si->totalchans);
12338#if defined(HAVE_PRI)
12339static int pri_create_trunkgroup(
int trunkgroup,
int *
channels)
12341 struct dahdi_spaninfo si;
12342 struct dahdi_params p;
12349 ast_log(
LOG_WARNING,
"Trunk group %d already exists on span %d, Primary d-channel %d\n", trunkgroup, x + 1, pris[x].dchannels[0]);
12356 memset(&si, 0,
sizeof(si));
12357 memset(&p, 0,
sizeof(p));
12358 fd = open(
"/dev/dahdi/channel", O_RDWR);
12364 if (ioctl(fd, DAHDI_SPECIFY, &x)) {
12369 if (ioctl(fd, DAHDI_GET_PARAMS, &p)) {
12374 if (ioctl(fd, DAHDI_SPANSTAT, &si)) {
12379 span = p.spanno - 1;
12385 if (pris[span].pri.
pvts[0]) {
12386 ast_log(
LOG_WARNING,
"Span %d is already provisioned with channels (implicit PRI maybe?)\n", span + 1);
12391 pris[span].pri.trunkgroup = trunkgroup;
12394 pris[ospan].dchannels[y] =
channels[y];
12395 pris[span].pri.span = span + 1;
12402#if defined(HAVE_PRI)
12403static int pri_create_spanmap(
int span,
int trunkgroup,
int logicalspan)
12405 if (pris[span].mastertrunkgroup) {
12406 ast_log(
LOG_WARNING,
"Span %d is already part of trunk group %d, cannot add to trunk group %d\n", span + 1, pris[span].mastertrunkgroup, trunkgroup);
12409 pris[span].mastertrunkgroup = trunkgroup;
12410 pris[span].prilogicalspan = logicalspan;
12415#if defined(HAVE_SS7)
12416static unsigned int parse_pointcode(
const char *pcstring)
12418 unsigned int code1, code2, code3;
12421 numvals = sscanf(pcstring,
"%30d-%30d-%30d", &code1, &code2, &code3);
12425 return (code1 << 16) | (code2 << 8) | code3;
12431#if defined(HAVE_SS7)
12432static struct dahdi_ss7 * ss7_resolve_linkset(
int linkset)
12434 if ((linkset < 0) || (linkset >=
NUM_SPANS))
12437 return &linksets[linkset - 1];
12442static void dahdi_r2_destroy_links(
void)
12444 struct r2link_entry *cur;
12449 ast_debug(3,
"MFC/R2 link #%d queued for destruction\n", cur->mfcr2.index);
12455 dahdi_r2_destroy_nodev();
12459#define R2_LINK_CAPACITY 30
12462 struct r2link_entry *cur =
NULL;
12470 if (memcmp(&
conf->mfcr2, &cur->mfcr2.conf,
sizeof(
conf->mfcr2))) {
12471 ast_debug(3,
"Need new R2 link because of: Configuration change\n");
12473 }
else if (cur->mfcr2.numchans == R2_LINK_CAPACITY) {
12474 ast_debug(3,
"Need new R2 link because of: Capacity (%d)\n", R2_LINK_CAPACITY);
12479 struct r2link_entry *tmp =
NULL;
12480 int new_idx = r2links_count + 1;
12482 for (i = 1; i <= r2links_count; i++) {
12485 if (i == tmp->mfcr2.index) {
12500 cur->mfcr2.index = new_idx;
12503 ast_debug(3,
"Created new R2 link #%d (now have %d)\n", new_idx, r2links_count);
12510static int dahdi_r2_set_context(
struct dahdi_mfcr2 *r2_link,
const struct dahdi_chan_conf *
conf)
12512 char tmplogdir[] =
"/tmp";
12513 char logdir[OR2_MAX_PATH];
12516 r2_link->protocol_context = openr2_context_new(
NULL, &dahdi_r2_event_iface,
12517 &dahdi_r2_transcode_iface,
conf->mfcr2.variant,
conf->mfcr2.max_ani,
12518 conf->mfcr2.max_dnis);
12519 if (!r2_link->protocol_context) {
12522 openr2_context_set_log_level(r2_link->protocol_context,
conf->mfcr2.loglevel);
12523 openr2_context_set_ani_first(r2_link->protocol_context,
conf->mfcr2.get_ani_first);
12524#if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 1
12525 openr2_context_set_skip_category_request(r2_link->protocol_context,
conf->mfcr2.skip_category_request);
12527 openr2_context_set_mf_threshold(r2_link->protocol_context,
threshold);
12528 openr2_context_set_mf_back_timeout(r2_link->protocol_context,
conf->mfcr2.mfback_timeout);
12529 openr2_context_set_metering_pulse_timeout(r2_link->protocol_context,
conf->mfcr2.metering_pulse_timeout);
12530 openr2_context_set_double_answer(r2_link->protocol_context,
conf->mfcr2.double_answer);
12531 openr2_context_set_immediate_accept(r2_link->protocol_context,
conf->mfcr2.immediate_accept);
12532#if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 2
12533 openr2_context_set_dtmf_dialing(r2_link->protocol_context,
conf->mfcr2.dtmf_dialing,
conf->mfcr2.dtmf_time_on,
conf->mfcr2.dtmf_time_off);
12534 openr2_context_set_dtmf_detection(r2_link->protocol_context,
conf->mfcr2.dtmf_detection);
12536#if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 3
12537 openr2_context_set_dtmf_detection_end_timeout(r2_link->protocol_context,
conf->mfcr2.dtmf_end_timeout);
12540 if (openr2_context_set_log_directory(r2_link->protocol_context, tmplogdir)) {
12541 ast_log(
LOG_ERROR,
"Failed setting default MFC/R2 log directory %s\n", tmplogdir);
12545 if (snres >=
sizeof(logdir)) {
12546 ast_log(
LOG_ERROR,
"MFC/R2 logging directory truncated, using %s\n", tmplogdir);
12547 if (openr2_context_set_log_directory(r2_link->protocol_context, tmplogdir)) {
12548 ast_log(
LOG_ERROR,
"Failed setting default MFC/R2 log directory %s\n", tmplogdir);
12551 if (openr2_context_set_log_directory(r2_link->protocol_context, logdir)) {
12557 if (openr2_context_configure_from_advanced_file(r2_link->protocol_context,
conf->mfcr2.r2proto_file)) {
12558 ast_log(
LOG_ERROR,
"Failed to configure r2context from advanced configuration file %s\n",
conf->mfcr2.r2proto_file);
12562 memcpy(&r2_link->conf, &
conf->mfcr2,
sizeof(r2_link->conf));
12596 struct dahdi_bufferinfo bi;
12599#if defined(HAVE_PRI)
12605 struct dahdi_params p;
12606#if defined(HAVE_PRI)
12607 struct dahdi_spaninfo si;
12610#if defined(HAVE_SS7)
12630 if (!here && reloading != 1) {
12642 for (x = 0; x < 3; x++)
12649 int chan_sig =
conf->chan.sig;
12652 if (reloading && tmp->
vars) {
12662 snprintf(fn,
sizeof(fn),
"%d",
channel);
12677 memset(&p, 0,
sizeof(p));
12684 if (
conf->is_sig_auto)
12686 if (p.sigtype != (chan_sig & 0x3ffff)) {
12692 tmp->
law = p.curlaw;
12693 tmp->
span = p.spanno;
12694#if defined(HAVE_PRI)
12695 span = p.spanno - 1;
12700 tmp->
sig = chan_sig;
12711#if defined(HAVE_SS7)
12713 struct dahdi_ss7 *ss7;
12717 ast_log(
LOG_ERROR,
"Unable to set clear mode on clear channel %d of span %d: %s\n", channel, p.spanno, strerror(
errno));
12722 ss7 = ss7_resolve_linkset(cur_linkset);
12728 ss7->ss7.span = cur_linkset;
12729 if (cur_cicbeginswith < 0) {
12740 tmp->ss7 = &ss7->ss7;
12743 ss7_chan->
cic = cur_cicbeginswith++;
12746 ss7_chan->
dpc = cur_defaultdpc;
12748 ss7->ss7.pvts[ss7->ss7.numchans++] = ss7_chan;
12750 ast_copy_string(ss7->ss7.internationalprefix,
conf->ss7.ss7.internationalprefix,
sizeof(ss7->ss7.internationalprefix));
12751 ast_copy_string(ss7->ss7.nationalprefix,
conf->ss7.ss7.nationalprefix,
sizeof(ss7->ss7.nationalprefix));
12752 ast_copy_string(ss7->ss7.subscriberprefix,
conf->ss7.ss7.subscriberprefix,
sizeof(ss7->ss7.subscriberprefix));
12753 ast_copy_string(ss7->ss7.unknownprefix,
conf->ss7.ss7.unknownprefix,
sizeof(ss7->ss7.unknownprefix));
12754 ast_copy_string(ss7->ss7.networkroutedprefix,
conf->ss7.ss7.networkroutedprefix,
sizeof(ss7->ss7.networkroutedprefix));
12756 ss7->ss7.called_nai =
conf->ss7.ss7.called_nai;
12757 ss7->ss7.calling_nai =
conf->ss7.ss7.calling_nai;
12762 struct dahdi_mfcr2 *r2_link;
12763 struct r2link_entry *r2_le = dahdi_r2_get_link(
conf);
12764 r2_link = &r2_le->mfcr2;
12770 if (!r2_link->protocol_context && dahdi_r2_set_context(r2_link,
conf)) {
12775 if (r2_link->numchans ==
ARRAY_LEN(r2_link->pvts)) {
12780 r2_link->pvts[r2_link->numchans++] = tmp;
12781 tmp->r2chan = openr2_chan_new_from_fd(r2_link->protocol_context,
12784 if (!tmp->r2chan) {
12785 openr2_liberr_t err = openr2_context_get_last_error(r2_link->protocol_context);
12786 ast_log(
LOG_ERROR,
"Cannot create OpenR2 channel: %s\n", openr2_context_error_string(err));
12790 r2_link->live_chans++;
12791 tmp->mfcr2 = r2_link;
12792 if (
conf->mfcr2.call_files) {
12793 openr2_chan_enable_call_files(tmp->r2chan);
12795 openr2_chan_set_client_data(tmp->r2chan, tmp);
12797 openr2_chan_set_logging_func(tmp->r2chan, (openr2_logging_func_t)dahdi_r2_on_chan_log);
12798 openr2_chan_set_log_level(tmp->r2chan,
conf->mfcr2.loglevel);
12799 tmp->mfcr2_category =
conf->mfcr2.category;
12800 tmp->mfcr2_charge_calls =
conf->mfcr2.charge_calls;
12801 tmp->mfcr2_allow_collect_calls =
conf->mfcr2.allow_collect_calls;
12802 tmp->mfcr2_forced_release =
conf->mfcr2.forced_release;
12803 tmp->mfcr2_accept_on_offer =
conf->mfcr2.accept_on_offer;
12804 tmp->mfcr2call = 0;
12805 tmp->mfcr2_dnis_index = 0;
12806 tmp->mfcr2_ani_index = 0;
12814 int myswitchtype = 0;
12818 ast_log(
LOG_ERROR,
"Unable to set clear mode on clear channel %d of span %d: %s\n", channel, p.spanno, strerror(
errno));
12823 ast_log(
LOG_ERROR,
"Channel %d does not lie on a span I know of (%d)\n", channel, span);
12834 tmp->logicalspan = pris[span].prilogicalspan;
12835 pri_resolve_span(&span, channel, (channel - p.chanpos), &si);
12837 ast_log(
LOG_WARNING,
"Channel %d: Unable to find locate channel/trunk group!\n", channel);
12841 myswitchtype =
conf->pri.pri.switchtype;
12846 if (pris[x].dchannels[y] == tmp->
channel) {
12852 if (!matchesdchan) {
12853 if (pris[span].pri.
nodetype && (pris[span].pri.nodetype !=
conf->pri.pri.nodetype)) {
12858 if (pris[span].pri.
switchtype && (pris[span].pri.switchtype != myswitchtype)) {
12863 if ((pris[span].pri.
dialplan) && (pris[span].pri.dialplan !=
conf->pri.pri.dialplan)) {
12864 ast_log(
LOG_ERROR,
"Span %d is already a %s dialing plan\n", span + 1, pris[span].pri.
dialplan == -1 ?
"Dynamically set dialplan in ISDN" : pri_plan2str(pris[span].pri.
dialplan));
12878 if (pris[span].pri.
minunused && (pris[span].pri.minunused !=
conf->pri.pri.minunused)) {
12879 ast_log(
LOG_ERROR,
"Span %d already has minunused of %d.\n", span + 1,
conf->pri.pri.minunused);
12883 if (pris[span].pri.
minidle && (pris[span].pri.minidle !=
conf->pri.pri.minidle)) {
12889 ast_log(
LOG_ERROR,
"Unable to add channel %d: Too many channels in trunk group %d!\n", channel,
12895 pri_chan =
sig_pri_chan_new(tmp, &pris[span].pri, tmp->logicalspan, p.chanpos, pris[span].mastertrunkgroup);
12901 tmp->pri = &pris[span].pri;
12913 conf->chan.cc_params);
12915 pris[span].pri.sig = chan_sig;
12916 pris[span].pri.nodetype =
conf->pri.pri.nodetype;
12917 pris[span].pri.switchtype = myswitchtype;
12918 pris[span].pri.nsf =
conf->pri.pri.nsf;
12919 pris[span].pri.dialplan =
conf->pri.pri.dialplan;
12920 pris[span].pri.localdialplan =
conf->pri.pri.localdialplan;
12921 pris[span].pri.cpndialplan =
conf->pri.pri.cpndialplan;
12922 pris[span].pri.pvts[pris[span].pri.numchans++] = tmp->
sig_pvt;
12923 pris[span].pri.minunused =
conf->pri.pri.minunused;
12924 pris[span].pri.minidle =
conf->pri.pri.minidle;
12925 pris[span].pri.overlapdial =
conf->pri.pri.overlapdial;
12926 pris[span].pri.qsigchannelmapping =
conf->pri.pri.qsigchannelmapping;
12927 pris[span].pri.discardremoteholdretrieval =
conf->pri.pri.discardremoteholdretrieval;
12928#if defined(HAVE_PRI_SERVICE_MESSAGES)
12929 pris[span].pri.enable_service_message_support =
conf->pri.pri.enable_service_message_support;
12931#ifdef HAVE_PRI_INBANDDISCONNECT
12932 pris[span].pri.inbanddisconnect =
conf->pri.pri.inbanddisconnect;
12934#if defined(HAVE_PRI_CALL_HOLD)
12935 pris[span].pri.hold_disconnect_transfer =
12936 conf->pri.pri.hold_disconnect_transfer;
12938#if defined(HAVE_PRI_CCSS)
12939 pris[span].pri.cc_ptmp_recall_mode =
12940 conf->pri.pri.cc_ptmp_recall_mode;
12941 pris[span].pri.cc_qsig_signaling_link_req =
12942 conf->pri.pri.cc_qsig_signaling_link_req;
12943 pris[span].pri.cc_qsig_signaling_link_rsp =
12944 conf->pri.pri.cc_qsig_signaling_link_rsp;
12946#if defined(HAVE_PRI_CALL_WAITING)
12947 pris[span].pri.max_call_waiting_calls =
12948 conf->pri.pri.max_call_waiting_calls;
12949 pris[span].pri.allow_call_waiting_calls =
12950 conf->pri.pri.allow_call_waiting_calls;
12952 pris[span].pri.transfer =
conf->chan.transfer;
12953 pris[span].pri.facilityenable =
conf->pri.pri.facilityenable;
12954#if defined(HAVE_PRI_L2_PERSISTENCE)
12955 pris[span].pri.l2_persistence =
conf->pri.pri.l2_persistence;
12957 pris[span].pri.colp_send =
conf->pri.pri.colp_send;
12958#if defined(HAVE_PRI_AOC_EVENTS)
12959 pris[span].pri.aoc_passthrough_flag =
conf->pri.pri.aoc_passthrough_flag;
12960 pris[span].pri.aoce_delayhangup =
conf->pri.pri.aoce_delayhangup;
12963 pris[span].pri.layer1_ignored =
conf->pri.pri.layer1_ignored;
12966 pris[span].pri.layer1_ignored = 0;
12968 pris[span].pri.append_msn_to_user_tag =
conf->pri.pri.append_msn_to_user_tag;
12969 pris[span].pri.inband_on_setup_ack =
conf->pri.pri.inband_on_setup_ack;
12970 pris[span].pri.inband_on_proceeding =
conf->pri.pri.inband_on_proceeding;
12971 ast_copy_string(pris[span].pri.initial_user_tag,
conf->chan.cid_tag,
sizeof(pris[span].pri.initial_user_tag));
12972 ast_copy_string(pris[span].pri.msn_list,
conf->pri.pri.msn_list,
sizeof(pris[span].pri.msn_list));
12973#if defined(HAVE_PRI_MWI)
12975 conf->pri.pri.mwi_mailboxes,
12976 sizeof(pris[span].pri.mwi_mailboxes));
12978 conf->pri.pri.mwi_vm_boxes,
12979 sizeof(pris[span].pri.mwi_vm_boxes));
12981 conf->pri.pri.mwi_vm_numbers,
12982 sizeof(pris[span].pri.mwi_vm_numbers));
12984 ast_copy_string(pris[span].pri.idledial,
conf->pri.pri.idledial,
sizeof(pris[span].pri.idledial));
12985 ast_copy_string(pris[span].pri.idleext,
conf->pri.pri.idleext,
sizeof(pris[span].pri.idleext));
12986 ast_copy_string(pris[span].pri.internationalprefix,
conf->pri.pri.internationalprefix,
sizeof(pris[span].pri.internationalprefix));
12987 ast_copy_string(pris[span].pri.nationalprefix,
conf->pri.pri.nationalprefix,
sizeof(pris[span].pri.nationalprefix));
12988 ast_copy_string(pris[span].pri.localprefix,
conf->pri.pri.localprefix,
sizeof(pris[span].pri.localprefix));
12989 ast_copy_string(pris[span].pri.privateprefix,
conf->pri.pri.privateprefix,
sizeof(pris[span].pri.privateprefix));
12990 ast_copy_string(pris[span].pri.unknownprefix,
conf->pri.pri.unknownprefix,
sizeof(pris[span].pri.unknownprefix));
12991 pris[span].pri.moh_signaling =
conf->pri.pri.moh_signaling;
12992 pris[span].pri.resetinterval =
conf->pri.pri.resetinterval;
12993#if defined(HAVE_PRI_DISPLAY_TEXT)
12994 pris[span].pri.display_flags_send =
conf->pri.pri.display_flags_send;
12995 pris[span].pri.display_flags_receive =
conf->pri.pri.display_flags_receive;
12997#if defined(HAVE_PRI_MCID)
12998 pris[span].pri.mcid_send =
conf->pri.pri.mcid_send;
13000 pris[span].pri.force_restart_unavailable_chans =
conf->pri.pri.force_restart_unavailable_chans;
13001#if defined(HAVE_PRI_DATETIME_SEND)
13002 pris[span].pri.datetime_send =
conf->pri.pri.datetime_send;
13005 for (x = 0; x < PRI_MAX_TIMERS; x++) {
13006 pris[span].pri.pritimers[x] =
conf->pri.pri.pritimers[x];
13009#if defined(HAVE_PRI_CALL_WAITING)
13011 pris[span].pri.ch_cfg.stripmsd =
conf->chan.stripmsd;
13012 pris[span].pri.ch_cfg.hidecallerid =
conf->chan.hidecallerid;
13013 pris[span].pri.ch_cfg.hidecalleridname =
conf->chan.hidecalleridname;
13014 pris[span].pri.ch_cfg.immediate =
conf->chan.immediate;
13015 pris[span].pri.ch_cfg.priexclusive =
conf->chan.priexclusive;
13016 pris[span].pri.ch_cfg.priindication_oob =
conf->chan.priindication_oob;
13017 pris[span].pri.ch_cfg.use_callerid =
conf->chan.use_callerid;
13018 pris[span].pri.ch_cfg.use_callingpres =
conf->chan.use_callingpres;
13019 ast_copy_string(pris[span].pri.ch_cfg.context,
conf->chan.context,
sizeof(pris[span].pri.ch_cfg.context));
13020 ast_copy_string(pris[span].pri.ch_cfg.mohinterpret,
conf->chan.mohinterpret,
sizeof(pris[span].pri.ch_cfg.mohinterpret));
13033 chan_sig = tmp->
sig;
13035 memset(&p, 0,
sizeof(p));
13040 switch (chan_sig) {
13064 p.channo = channel;
13068 p.debouncetime = 5;
13070 p.channo = channel;
13072 if (
conf->timing.prewinktime >= 0)
13073 p.prewinktime =
conf->timing.prewinktime;
13074 if (
conf->timing.preflashtime >= 0)
13075 p.preflashtime =
conf->timing.preflashtime;
13076 if (
conf->timing.winktime >= 0)
13077 p.winktime =
conf->timing.winktime;
13078 if (
conf->timing.flashtime >= 0)
13079 p.flashtime =
conf->timing.flashtime;
13080 if (
conf->timing.starttime >= 0)
13081 p.starttime =
conf->timing.starttime;
13082 if (
conf->timing.rxwinktime >= 0)
13083 p.rxwinktime =
conf->timing.rxwinktime;
13084 if (
conf->timing.rxflashtime >= 0)
13085 p.rxflashtime =
conf->timing.rxflashtime;
13086 if (
conf->timing.debouncetime >= 0)
13087 p.debouncetime =
conf->timing.debouncetime;
13102 memset(&bi, 0,
sizeof(bi));
13105 bi.txbufpolicy =
conf->chan.buf_policy;
13106 bi.rxbufpolicy =
conf->chan.buf_policy;
13107 bi.numbufs =
conf->chan.buf_no;
13131 if (chan_sig & __DAHDI_SIG_FXS) {
13172 if (
conf->chan.echocanbridged)
13173 ast_log(
LOG_NOTICE,
"echocancelwhenbridged requires echocancel to be enabled; ignoring\n");
13214 ast_log(
LOG_ERROR,
"Invalid SMDI port specified, disabling SMDI support\n");
13242#if defined(HAVE_PRI)
13259#ifdef HAVE_DAHDI_LINEREVERSE_VMWI
13260 tmp->mwisend_setting =
conf->chan.mwisend_setting;
13261 tmp->mwisend_fsk =
conf->chan.mwisend_fsk;
13262 tmp->mwisend_rpas =
conf->chan.mwisend_rpas;
13272 if (
conf->chan.vars) {
13274 for (v =
conf->chan.vars ; v ; v = v->
next) {
13278 tmp->
vars = tmpvar;
13305 switch (chan_sig) {
13317 if ((res =
get_alarms(tmp)) != DAHDI_ALARM_NONE) {
13319 switch (tmp->
sig) {
13325#if defined(HAVE_SS7)
13356 switch (tmp->
sig) {
13357#if defined(HAVE_PRI)
13360#if defined(HAVE_PRI_SERVICE_MESSAGES)
13363 char db_chan_name[20];
13370 snprintf(db_chan_name,
sizeof(db_chan_name),
"%s/%d:%d", dahdi_db, tmp->
span, tmp->
channel);
13371 if (!
ast_db_get(db_chan_name, SRVST_DBKEY, db_answer,
sizeof(db_answer))) {
13375 if (tmp->pri->enable_service_message_support) {
13378 sscanf(db_answer,
"%1c:%30u", &
state, why);
13381 *why &= (SRVST_NEAREND | SRVST_FAREND);
13391#if defined(HAVE_SS7)
13406 switch (tmp->
sig) {
13407#if defined(HAVE_PRI)
13427#if defined(HAVE_SS7)
13482 switch (
conf->chan.cid_start) {
13501 if (chan_sig & __DAHDI_SIG_FXO) {
13502 memset(&p, 0,
sizeof(p));
13507#ifdef HAVE_DAHDI_LINEREVERSE_VMWI
13508 res = ioctl(tmp->
subs[
SUB_REAL].
dfd, DAHDI_VMWI_CONFIG, &tmp->mwisend_setting);
13521#if defined(HAVE_PRI)
13527 dahdi_pseudo_parms.buf_no = tmp->
buf_no;
13528 dahdi_pseudo_parms.buf_policy = tmp->
buf_policy;
13529 dahdi_pseudo_parms.faxbuf_no = tmp->
faxbuf_no;
13534 if (tmp && !here) {
13543#if defined(HAVE_PRI)
13546 if (!p->pri || p->pri->
span != span) {
13549 if (!groupmatch && channelmatch == -1) {
13558 if ((p->
group & groupmatch) != groupmatch)
13564 if (channelmatch != -1) {
13565 if (p->
channel != channelmatch)
13568 *channelmatched = 1;
13585#if defined(HAVE_PRI)
13597#if defined(HAVE_SS7)
13614 if (p->mfcr2call) {
13627#if defined(HAVE_PRI)
13628#if defined(HAVE_PRI_CALL_WAITING)
13643 pvt->
stripmsd = pri->ch_cfg.stripmsd;
13646 pvt->
immediate = pri->ch_cfg.immediate;
13657#if defined(HAVE_PRI)
13670static int dahdi_new_pri_nobch_channel(
struct sig_pri_span *pri)
13677 struct dahdi_bufferinfo bi;
13682 for (pvt_idx = 0; pvt_idx < pri->
numchans; ++pvt_idx) {
13683 if (!pri->
pvts[pvt_idx]) {
13711 pvt->
buf_no = dahdi_pseudo_parms.buf_no;
13712 pvt->
buf_policy = dahdi_pseudo_parms.buf_policy;
13713 pvt->
faxbuf_no = dahdi_pseudo_parms.faxbuf_no;
13734 pri->
pvts[pvt_idx] = chan;
13738 ast_log(
LOG_ERROR,
"Unable to open no B channel interface pseudo channel: %s\n",
13743 memset(&bi, 0,
sizeof(bi));
13749 bi.numbufs = pvt->
buf_no;
13753 "Unable to set buffer policy on no B channel interface: %s\n",
13758 "Unable to check buffer policy on no B channel interface: %s\n",
13765 pvt->
channel = nobch_channel;
13769 dahdi_nobch_insert(pri, pvt);
13783 struct dahdi_bufferinfo bi;
13814 bi.numbufs = src->
buf_no;
13851 char *subdir =
NULL;
13895 memset(param, 0,
sizeof(*param));
13898 if (strchr(
args.group,
'!') !=
NULL) {
13900 while ((s = strchr(
prev,
'!')) !=
NULL) {
13904 *(
prev - 1) =
'\0';
13905 subdir =
args.group;
13907 }
else if (
args.group[0] ==
'i') {
13909 res = sscanf(
args.group + 1,
"%30d", &x);
13917 s = strchr(
args.group,
'-');
13922 args.group = s + 1;
13925 if (toupper(
args.group[0]) ==
'G' || toupper(
args.group[0])==
'R') {
13927 s =
args.group + 1;
13928 res = sscanf(s,
"%30d%1c%30d", &x, ¶m->
opt, ¶m->
cadence);
13935 if (toupper(
args.group[0]) ==
'G') {
13936 if (
args.group[0] ==
'G') {
13947 if (
args.group[0] ==
'R') {
13962 if (!strcasecmp(s,
"pseudo")) {
13967 res = sscanf(s,
"%30d%1c%30d", &x, ¶m->
opt, ¶m->
cadence);
13979 snprintf(path,
sizeof(path),
"/dev/dahdi/%s/%d",
13981 if (stat(path, &stbuf) < 0) {
13983 path, strerror(
errno));
13986 if (!S_ISCHR(stbuf.st_mode)) {
13997 if (param->
opt ==
'r' && res < 3) {
14007 const char *
data,
int *cause)
14013 int channelmatched = 0;
14014 int foundowner = 0;
14015 int groupmatched = 0;
14016#if defined(HAVE_PRI) || defined(HAVE_SS7)
14017 int transcapdigital = 0;
14034 while (p && !tmp) {
14050 if (p->mfcr2call) {
14052 ast_debug(1,
"Yay!, someone just beat us in the race for channel %d.\n", p->
channel);
14068 switch (start.
opt) {
14081#if defined(HAVE_PRI) || defined(HAVE_SS7)
14108#if defined(HAVE_SS7)
14117#if defined(HAVE_PRI)
14120#if defined(HAVE_PRI_CALL_WAITING)
14159 if (cause && !tmp) {
14160 if (callwait || (channelmatched && foundowner)) {
14162 }
else if (groupmatched) {
14188#if defined(HAVE_PRI)
14189 const char *device;
14195 if (*device !=
'I') {
14199 res = sscanf(device,
"I%30u", &span);
14200 if (res != 1 || !span ||
NUM_SPANS < span) {
14204 device = strchr(device,
'/');
14214#if defined(THRESHOLD_DEVSTATE_PLACEHOLDER)
14216 if (!strcmp(device,
"congestion"))
14219 return pris[span - 1].pri.congestion_devstate;
14221#if defined(THRESHOLD_DEVSTATE_PLACEHOLDER)
14222 else if (!strcmp(device,
"threshold")) {
14223 return pris[span - 1].pri.threshold_devstate;
14253 int groupmatched = 0;
14254 int channelmatched = 0;
14268 const char *monitor_type;
14278#if defined(HAVE_PRI)
14284 snprintf(full_device_name,
sizeof(full_device_name),
14285 "DAHDI/I%d/congestion", p->pri->
span);
14289#if defined(HAVE_PRI)
14294 snprintf(full_device_name,
sizeof(full_device_name),
"DAHDI/%s",
14302 dash = strrchr(full_device_name,
'-');
14307 snprintf(dialstring,
sizeof(dialstring),
"DAHDI/%s", dest);
14317#
if defined(HAVE_PRI)
14322 monitor_type, full_device_name, dialstring,
NULL);
14330 if (p == exitpvt) {
14338#if defined(HAVE_SS7)
14339static void dahdi_ss7_message(
struct ss7 *ss7,
char *s)
14345 if (linksets[i].ss7.ss7 == ss7) {
14355#if defined(HAVE_SS7)
14356static void dahdi_ss7_error(
struct ss7 *ss7,
char *s)
14362 if (linksets[i].ss7.ss7 == ss7) {
14372#if defined(HAVE_OPENR2)
14373static void *mfcr2_monitor(
void *data)
14375 struct dahdi_mfcr2 *mfcr2 = data;
14393 for (i = 0; i < mfcr2->numchans; i++) {
14394 pvt = mfcr2->pvts[i];
14398 openr2_chan_set_idle(pvt->r2chan);
14399 openr2_chan_handle_cas(pvt->r2chan);
14405 for (i = 0; i < mfcr2->numchans; i++) {
14406 pollers[i].revents = 0;
14407 pollers[i].events = 0;
14408 pvt = mfcr2->pvts[i];
14415 if (mfcr2->nodev) {
14418 if (!pvt->r2chan) {
14423 openr2_chan_enable_read(pvt->r2chan);
14424 pollers[i].events = POLLIN | POLLPRI;
14431 if (pollsize == 0) {
14433 ast_debug(1,
"Monitor thread going idle since everybody has an owner\n");
14436 poll(
NULL, 0, maxsleep);
14442 pthread_testcancel();
14443 res = poll(pollers, mfcr2->numchans, maxsleep);
14444 pthread_testcancel();
14445 if ((res < 0) && (
errno != EINTR)) {
14450 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldstate);
14451 for (i = 0; i < mfcr2->numchans; i++) {
14452 pvt = mfcr2->pvts[i];
14456 if (pollers[i].revents & POLLPRI || pollers[i].revents & POLLIN) {
14457 openr2_chan_process_event(pvt->r2chan);
14460 pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldstate);
14467#if defined(HAVE_PRI)
14468static void dahdi_pri_message(
struct pri *pri,
char *s)
14474 int dchancount = 0;
14479 if (pris[x].pri.dchans[y]) {
14483 if (pris[x].pri.dchans[y] == pri) {
14494 if (1 < dchancount) {
14508 if (pridebugfd >= 0) {
14509 if (write(pridebugfd, s, strlen(s)) < 0) {
14518#if defined(HAVE_PRI)
14519static void dahdi_pri_error(
struct pri *pri,
char *s)
14525 int dchancount = 0;
14530 if (pris[x].pri.dchans[y]) {
14534 if (pris[x].pri.dchans[y] == pri) {
14545 if (1 < dchancount) {
14559 if (pridebugfd >= 0) {
14560 if (write(pridebugfd, s, strlen(s)) < 0) {
14569#if defined(HAVE_PRI)
14570static int prepare_pri(
struct dahdi_pri *pri)
14573 struct dahdi_params p;
14574 struct dahdi_bufferinfo bi;
14575 struct dahdi_spaninfo si;
14578 if (!pri->dchannels[i])
14580 if (pri->pri.fds[i] >= 0) {
14584 pri->pri.fds[i] = open(
"/dev/dahdi/channel", O_RDWR);
14585 if ((pri->pri.fds[i] < 0)) {
14587 pri->pri.fds[i], strerror(
errno));
14590 x = pri->dchannels[i];
14591 res = ioctl(pri->pri.fds[i], DAHDI_SPECIFY, &x);
14593 dahdi_close_pri_fd(pri, i);
14597 memset(&p, 0,
sizeof(p));
14598 res = ioctl(pri->pri.fds[i], DAHDI_GET_PARAMS, &p);
14600 dahdi_close_pri_fd(pri, i);
14604 if ((p.sigtype != DAHDI_SIG_HDLCFCS) && (p.sigtype != DAHDI_SIG_HARDHDLC)) {
14605 dahdi_close_pri_fd(pri, i);
14609 memset(&si, 0,
sizeof(si));
14610 res = ioctl(pri->pri.fds[i], DAHDI_SPANSTAT, &si);
14612 dahdi_close_pri_fd(pri, i);
14620 memset(&bi, 0,
sizeof(bi));
14621 bi.txbufpolicy = DAHDI_POLICY_IMMEDIATE;
14622 bi.rxbufpolicy = DAHDI_POLICY_IMMEDIATE;
14625 if (ioctl(pri->pri.fds[i], DAHDI_SET_BUFINFO, &bi)) {
14627 dahdi_close_pri_fd(pri, i);
14630 pri->pri.dchan_logical_span[i] = pris[p.spanno - 1].prilogicalspan;
14636#if defined(HAVE_PRI)
14637static char *complete_span_helper(
const char *line,
const char *
word,
int pos,
int state,
int rpos)
14645 for (which = span = 0; span <
NUM_SPANS; span++) {
14646 if (pris[span].pri.pri && ++which >
state) {
14657#if defined(HAVE_PRI)
14658static char *complete_span_4(
const char *line,
const char *
word,
int pos,
int state)
14660 return complete_span_helper(line,
word,pos,
state,3);
14664#if defined(HAVE_PRI)
14670 e->
command =
"pri set debug file";
14671 e->
usage =
"Usage: pri set debug file [output-file]\n"
14672 " Sends PRI debug output to the specified output file\n";
14685 ast_cli(
a->fd,
"Unable to open '%s' for writing\n",
a->argv[4]);
14691 if (pridebugfd >= 0)
14697 ast_cli(
a->fd,
"PRI debug output will be sent to '%s'\n",
a->argv[4]);
14702#if defined(HAVE_PRI)
14703static int action_pri_debug_file_set(
struct mansession *s,
const struct message *m)
14720 if (pridebugfd >= 0) {
14725 ast_copy_string(pridebugfilename, output_file,
sizeof(pridebugfilename));
14727 astman_send_ack(s, m,
"PRI debug output will now be sent to requested file.");
14733#if defined(HAVE_PRI)
14734static int action_pri_debug_file_unset(
struct mansession *s,
const struct message *m)
14738 if (pridebugfd >= 0) {
14751#if defined(HAVE_PRI)
14760 e->
command =
"pri set debug {on|off|hex|intense|0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15} span";
14762 "Usage: pri set debug {<level>|on|off|hex|intense} span <span>\n"
14763 " Enables debugging on a given PRI span\n"
14764 " Level is a bitmap of the following values:\n"
14765 " 1 General debugging incl. state changes\n"
14766 " 2 Decoded Q.931 messages\n"
14767 " 4 Decoded Q.921 messages\n"
14768 " 8 Raw hex dumps of Q.921 frames\n"
14769 " on - equivalent to 3\n"
14770 " hex - equivalent to 8\n"
14771 " intense - equivalent to 15\n";
14774 return complete_span_4(
a->line,
a->word,
a->pos,
a->n);
14780 if (!strcasecmp(
a->argv[3],
"on")) {
14782 }
else if (!strcasecmp(
a->argv[3],
"off")) {
14784 }
else if (!strcasecmp(
a->argv[3],
"intense")) {
14786 }
else if (!strcasecmp(
a->argv[3],
"hex")) {
14789 level = atoi(
a->argv[3]);
14791 span = atoi(
a->argv[5]);
14792 if ((span < 1) || (span >
NUM_SPANS)) {
14793 ast_cli(
a->fd,
"Invalid span %s. Should be a number %d to %d\n",
a->argv[5], 1,
NUM_SPANS);
14796 if (!pris[span-1].pri.pri) {
14797 ast_cli(
a->fd,
"No PRI running on span %d\n", span);
14802 if (level & 2) debugmask |= PRI_DEBUG_Q931_DUMP;
14803 if (level & 4) debugmask |= PRI_DEBUG_Q921_DUMP;
14804 if (level & 8) debugmask |= PRI_DEBUG_Q921_RAW;
14808 if (pris[span - 1].pri.dchans[x]) {
14809 pri_set_debug(pris[span - 1].pri.dchans[x], debugmask);
14815 if (0 <= pridebugfd) {
14818 ast_cli(
a->fd,
"Disabled PRI debug output to file '%s'\n",
14823 pris[span - 1].pri.debug = (level) ? 1 : 0;
14824 ast_cli(
a->fd,
"%s debugging on span %d\n", (level) ?
"Enabled" :
"Disabled", span);
14829#if defined(HAVE_PRI)
14849 if (!strcasecmp(level,
"on")) {
14851 }
else if (!strcasecmp(level,
"off")) {
14853 }
else if (!strcasecmp(level,
"intense")) {
14855 }
else if (!strcasecmp(level,
"hex")) {
14858 if (sscanf(level,
"%30d", &level_val) != 1) {
14864 if (sscanf(span,
"%30d", &span_val) != 1) {
14868 if ((span_val < 1) || (span_val >
NUM_SPANS)) {
14870 char id_text[256] =
"";
14873 snprintf(id_text,
sizeof(id_text),
"ActionID: %s\r\n",
id);
14878 "Message: Invalid span '%s' - Should be a number from 1 to %d\r\n"
14886 if (!pris[span_val-1].pri.pri) {
14891 if (level_val & 1) {
14894 if (level_val & 2) {
14895 debugmask |= PRI_DEBUG_Q931_DUMP;
14897 if (level_val & 4) {
14898 debugmask |= PRI_DEBUG_Q921_DUMP;
14900 if (level_val & 8) {
14901 debugmask |= PRI_DEBUG_Q921_RAW;
14906 if (pris[span_val - 1].pri.dchans[x]) {
14907 pri_set_debug(pris[span_val - 1].pri.dchans[x], debugmask);
14911 pris[span_val - 1].pri.debug = (level_val) ? 1 : 0;
14918#if defined(HAVE_PRI)
14919#if defined(HAVE_PRI_SERVICE_MESSAGES)
14925 int x, y, fd =
a->fd;
14926 int interfaceid = 0;
14927 char db_chan_name[20], db_answer[15];
14929 struct dahdi_pri *pri;
14931 if (
a->argc < 5 ||
a->argc > 6)
14933 if (strchr(
a->argv[4],
':')) {
14934 if (sscanf(
a->argv[4],
"%30d:%30d", &trunkgroup, &channel) != 2)
14936 if ((trunkgroup < 1) || (channel < 1))
14940 if (pris[x].pri.trunkgroup == trunkgroup) {
14946 ast_cli(fd,
"No such trunk group %d\n", trunkgroup);
14950 channel = atoi(
a->argv[4]);
14953 interfaceid = atoi(
a->argv[5]);
14958 if (pris[x].dchannels[y] == channel) {
14960 if (pri->pri.enable_service_message_support) {
14962 pri_maintenance_service(pri->pri.pri, interfaceid, -1, changestatus);
14966 "\n\tThis operation has not been enabled in chan_dahdi.conf, set 'service_message_support=yes' to use this operation.\n"
14967 "\tNote only 4ESS, 5ESS, and NI2 switch types are supported.\n\n");
14977 if (tmp->pri && tmp->
channel == channel) {
14980 if (!tmp->pri->enable_service_message_support) {
14983 "\n\tThis operation has not been enabled in chan_dahdi.conf, set 'service_message_support=yes' to use this operation.\n"
14984 "\tNote only 4ESS, 5ESS, and NI2 switch types are supported.\n\n");
14987 snprintf(db_chan_name,
sizeof(db_chan_name),
"%s/%d:%d", dahdi_db, tmp->
span, channel);
14989 switch(changestatus) {
14993 *why &= ~SRVST_NEAREND;
14995 snprintf(db_answer,
sizeof(db_answer),
"%s:%u", SRVST_TYPE_OOS, *why);
14996 ast_db_put(db_chan_name, SRVST_DBKEY, db_answer);
14998 dahdi_pri_update_span_devstate(tmp->pri);
15005 *why |= SRVST_NEAREND;
15006 snprintf(db_answer,
sizeof(db_answer),
"%s:%u", SRVST_TYPE_OOS, *why);
15007 ast_db_put(db_chan_name, SRVST_DBKEY, db_answer);
15008 dahdi_pri_update_span_devstate(tmp->pri);
15016 pri_maintenance_bservice(tmp->pri->pri, tmp->
sig_pvt, changestatus);
15023 ast_cli(fd,
"Unable to find given channel %d, possibly not a PRI\n",
channel);
15031 e->
command =
"pri service enable channel";
15033 "Usage: pri service enable channel <channel> [<interface id>]\n"
15034 " Send an AT&T / NFAS / CCS ANSI T1.607 maintenance message\n"
15035 " to restore a channel to service, with optional interface id\n"
15036 " as agreed upon with remote switch operator\n";
15041 return handle_pri_service_generic(e, cmd,
a, 0);
15048 e->
command =
"pri service disable channel";
15050 "Usage: pri service disable channel <chan num> [<interface id>]\n"
15051 " Send an AT&T / NFAS / CCS ANSI T1.607 maintenance message\n"
15052 " to remove a channel from service, with optional interface id\n"
15053 " as agreed upon with remote switch operator\n";
15058 return handle_pri_service_generic(e, cmd,
a, 2);
15063#if defined(HAVE_PRI)
15070 e->
command =
"pri show channels";
15072 "Usage: pri show channels\n"
15073 " Displays PRI channel information such as the current mapping\n"
15074 " of DAHDI B channels to Asterisk channel names and which calls\n"
15075 " are on hold or call-waiting. Calls on hold or call-waiting\n"
15076 " are not associated with any B channel.\n";
15086 for (span = 0; span <
NUM_SPANS; ++span) {
15087 if (pris[span].
pri.
pri) {
15095#if defined(HAVE_PRI)
15102 e->
command =
"pri show spans";
15104 "Usage: pri show spans\n"
15105 " Displays PRI span information\n";
15114 for (span = 0; span <
NUM_SPANS; span++) {
15115 if (pris[span].
pri.
pri) {
15123#if defined(HAVE_PRI)
15124#define container_of(ptr, type, member) \
15125 ((type *)((char *)(ptr) - offsetof(type, member)))
15142 struct dahdi_pri* dahdi_pri;
15143 pthread_t master = pri->
master;
15148 ast_debug(2,
"About to destroy DAHDI channels of span %d.\n", pri->
span);
15149 for (i = 0; i < pri->
numchans; i++) {
15161 cancel_code = pthread_cancel(master);
15162 pthread_kill(master, SIGURG);
15164 "Waiting to join thread of span %d "
15165 "with pid=%p cancel_code=%d\n",
15166 pri->
span, (
void *)master, cancel_code);
15167 res = pthread_join(master,
NULL);
15176 ast_debug(4,
"closing pri_fd %d\n", i);
15177 dahdi_close_pri_fd(dahdi_pri, i);
15178 dahdi_pri->dchannels[i] = 0;
15184static char *handle_pri_destroy_span(
struct ast_cli_entry *e,
int cmd,
15193 e->
command =
"pri destroy span";
15195 "Usage: pri destroy span <span>\n"
15196 " Destroys D-channel of span and its B-channels.\n"
15197 " DON'T USE THIS UNLESS YOU KNOW WHAT YOU ARE DOING.\n";
15200 return complete_span_4(
a->line,
a->word,
a->pos,
a->n);
15206 res = sscanf(
a->argv[3],
"%30d", &
span);
15207 if ((res != 1) || span < 1 || span >
NUM_SPANS) {
15209 "Invalid span '%s'. Should be a number from %d to %d\n",
15219 pri_destroy_span(
pri);
15225#if defined(HAVE_PRI)
15232 e->
command =
"pri show span";
15234 "Usage: pri show span <span>\n"
15235 " Displays PRI Information on a given PRI span\n";
15238 return complete_span_4(
a->line,
a->word,
a->pos,
a->n);
15243 span = atoi(
a->argv[3]);
15245 ast_cli(
a->fd,
"Invalid span '%s'. Should be a number from %d to %d\n",
a->argv[3], 1,
NUM_SPANS);
15259#if defined(HAVE_PRI)
15269 e->
command =
"pri show debug";
15271 "Usage: pri show debug\n"
15272 " Show the debug state of pri spans\n";
15281 if (pris[
span].
pri.dchans[x]) {
15283 ast_cli(
a->fd,
"Span %d: Debug: %s\tIntense: %s\n",
span+1, (
debug&PRI_DEBUG_Q931_STATE)?
"Yes" :
"No" ,(
debug&PRI_DEBUG_Q921_RAW)?
"Yes" :
"No" );
15291 if (pridebugfd >= 0)
15292 ast_cli(
a->fd,
"Logging PRI debug to file %s\n", pridebugfilename);
15296 ast_cli(
a->fd,
"No PRI running\n");
15301#if defined(HAVE_PRI)
15306 e->
command =
"pri show version";
15308 "Usage: pri show version\n"
15309 "Show libpri version information\n";
15315 ast_cli(
a->fd,
"libpri version: %s\n", pri_get_version());
15321#if defined(HAVE_PRI)
15323 AST_CLI_DEFINE(handle_pri_debug,
"Enables PRI debugging on a span"),
15324#if defined(HAVE_PRI_SERVICE_MESSAGES)
15325 AST_CLI_DEFINE(handle_pri_service_enable_channel,
"Return a channel to service"),
15326 AST_CLI_DEFINE(handle_pri_service_disable_channel,
"Remove a channel from service"),
15328 AST_CLI_DEFINE(handle_pri_show_channels,
"Displays PRI channel information"),
15329 AST_CLI_DEFINE(handle_pri_show_spans,
"Displays PRI span information"),
15330 AST_CLI_DEFINE(handle_pri_show_span,
"Displays PRI span information"),
15332 AST_CLI_DEFINE(handle_pri_show_debug,
"Displays current PRI debug settings"),
15333 AST_CLI_DEFINE(handle_pri_set_debug_file,
"Sends PRI debug output to the specified file"),
15344 e->
command =
"mfcr2 show version";
15346 "Usage: mfcr2 show version\n"
15347 " Shows the version of the OpenR2 library being used.\n";
15352 ast_cli(
a->fd,
"OpenR2 version: %s, revision: %s\n", openr2_get_version(), openr2_get_revision());
15358#define FORMAT "%4s %40s\n"
15360 int numvariants = 0;
15361 const openr2_variant_entry_t *variants;
15364 e->
command =
"mfcr2 show variants";
15366 "Usage: mfcr2 show variants\n"
15367 " Shows the list of MFC/R2 variants supported.\n";
15372 if (!(variants = openr2_proto_get_variant_list(&numvariants))) {
15373 ast_cli(
a->fd,
"Failed to get list of variants.\n");
15377 for (i = 0; i < numvariants; i++) {
15386#define FORMAT "%4s %4s %-7.7s %-7.7s %-8.8s %-9.9s %-16.16s %-8.8s %-8.8s\n"
15387 int filtertype = 0;
15394 openr2_context_t *r2context;
15395 openr2_variant_t r2variant;
15398 e->
command =
"mfcr2 show channels [group|context]";
15400 "Usage: mfcr2 show channels [group <group> | context <context>]\n"
15401 " Shows the DAHDI channels configured with MFC/R2 signaling.\n";
15406 if (!((
a->argc == 3) || (
a->argc == 5))) {
15409 if (
a->argc == 5) {
15410 if (!strcasecmp(
a->argv[3],
"group")) {
15411 targetnum = atoi(
a->argv[4]);
15412 if ((targetnum < 0) || (targetnum > 63))
15414 targetnum = 1 << targetnum;
15416 }
else if (!strcasecmp(
a->argv[3],
"context")) {
15422 ast_cli(
a->fd,
FORMAT,
"Chan",
"Link#",
"Variant",
"Max ANI",
"Max DNIS",
"ANI First",
"Immediate Accept",
"Tx CAS",
"Rx CAS");
15429 switch(filtertype) {
15431 if (p->
group != targetnum) {
15436 if (strcasecmp(p->
context,
a->argv[4])) {
15444 r2context = openr2_chan_get_context(p->r2chan);
15445 r2variant = openr2_context_get_variant(r2context);
15446 snprintf(channo,
sizeof(channo),
"%d", p->
channel);
15447 snprintf(linkno,
sizeof(linkno),
"%d", p->mfcr2->index);
15448 snprintf(anino,
sizeof(anino),
"%d", openr2_context_get_max_ani(r2context));
15449 snprintf(dnisno,
sizeof(dnisno),
"%d", openr2_context_get_max_dnis(r2context));
15450 ast_cli(
a->fd,
FORMAT, channo, linkno, openr2_proto_get_variant_string(r2variant),
15451 anino, dnisno, openr2_context_get_ani_first(r2context) ?
"Yes" :
"No",
15452 openr2_context_get_immediate_accept(r2context) ?
"Yes" :
"No",
15453 openr2_chan_get_tx_cas_string(p->r2chan), openr2_chan_get_rx_cas_string(p->r2chan));
15464 char *toklevel =
NULL;
15465 char *saveptr =
NULL;
15466 char *logval =
NULL;
15467 openr2_log_level_t loglevel = OR2_LOG_NOTHING;
15468 openr2_log_level_t tmplevel = OR2_LOG_NOTHING;
15471 e->
command =
"mfcr2 set debug";
15473 "Usage: mfcr2 set debug <loglevel> <channel>\n"
15474 " Set a new logging level for the specified channel.\n"
15475 " If no channel is specified the logging level will be applied to all channels.\n";
15483 channo = (
a->argc == 5) ? atoi(
a->argv[4]) : -1;
15485 toklevel = strtok_r(logval,
",", &saveptr);
15486 if (-1 == (tmplevel = openr2_log_get_level(toklevel))) {
15487 ast_cli(
a->fd,
"Invalid MFC/R2 logging level '%s'.\n",
a->argv[3]);
15489 }
else if (OR2_LOG_NOTHING == tmplevel) {
15490 loglevel = tmplevel;
15492 loglevel |= tmplevel;
15493 while ((toklevel = strtok_r(
NULL,
",", &saveptr))) {
15494 if (-1 == (tmplevel = openr2_log_get_level(toklevel))) {
15495 ast_cli(
a->fd,
"Ignoring invalid logging level: '%s'.\n", toklevel);
15498 loglevel |= tmplevel;
15506 if ((channo != -1) && (p->
channel != channo )) {
15509 openr2_chan_set_log_level(p->r2chan, loglevel);
15510 if (channo != -1) {
15511 ast_cli(
a->fd,
"MFC/R2 debugging set to '%s' for channel %d.\n",
a->argv[3], p->
channel);
15515 if ((channo != -1) && !p) {
15516 ast_cli(
a->fd,
"MFC/R2 channel %d not found.\n", channo);
15518 if (channo == -1) {
15519 ast_cli(
a->fd,
"MFC/R2 debugging set to '%s' for all channels.\n",
a->argv[3]);
15531 e->
command =
"mfcr2 call files [on|off]";
15533 "Usage: mfcr2 call files [on|off] <channel>\n"
15534 " Enable call files creation on the specified channel.\n"
15535 " If no channel is specified call files creation policy will be applied to all channels.\n";
15543 channo = (
a->argc == 5) ? atoi(
a->argv[4]) : -1;
15549 if ((channo != -1) && (p->
channel != channo )) {
15553 openr2_chan_enable_call_files(p->r2chan);
15555 openr2_chan_disable_call_files(p->r2chan);
15557 if (channo != -1) {
15559 ast_cli(
a->fd,
"MFC/R2 call files enabled for channel %d.\n", p->
channel);
15561 ast_cli(
a->fd,
"MFC/R2 call files disabled for channel %d.\n", p->
channel);
15566 if ((channo != -1) && !p) {
15567 ast_cli(
a->fd,
"MFC/R2 channel %d not found.\n", channo);
15569 if (channo == -1) {
15571 ast_cli(
a->fd,
"MFC/R2 Call files enabled for all channels.\n");
15573 ast_cli(
a->fd,
"MFC/R2 Call files disabled for all channels.\n");
15586 e->
command =
"mfcr2 set idle";
15588 "Usage: mfcr2 set idle <channel>\n"
15589 " DON'T USE THIS UNLESS YOU KNOW WHAT YOU ARE DOING.\n"
15590 " Force the given channel into IDLE state.\n"
15591 " If no channel is specified, all channels will be set to IDLE.\n";
15596 channo = (
a->argc == 4) ? atoi(
a->argv[3]) : -1;
15602 if ((channo != -1) && (p->
channel != channo )) {
15605 openr2_chan_set_idle(p->r2chan);
15610 if (channo != -1) {
15614 if ((channo != -1) && !p) {
15615 ast_cli(
a->fd,
"MFC/R2 channel %d not found.\n", channo);
15627 e->
command =
"mfcr2 set blocked";
15629 "Usage: mfcr2 set blocked <channel>\n"
15630 " DON'T USE THIS UNLESS YOU KNOW WHAT YOU ARE DOING.\n"
15631 " Force the given channel into BLOCKED state.\n"
15632 " If no channel is specified, all channels will be set to BLOCKED.\n";
15637 channo = (
a->argc == 4) ? atoi(
a->argv[3]) : -1;
15643 if ((channo != -1) && (p->
channel != channo )) {
15646 openr2_chan_set_blocked(p->r2chan);
15650 if (channo != -1) {
15654 if ((channo != -1) && !p) {
15655 ast_cli(
a->fd,
"MFC/R2 channel %d not found.\n", channo);
15661static void mfcr2_show_links_of(
struct ast_cli_args *
a,
struct r2links *list_head,
const char *title)
15663#define FORMAT "%-5s %-10s %-15s %-10s %s\n"
15668 char live_chans_str[5];
15669 char channel_list[R2_LINK_CAPACITY * 4];
15670 struct r2link_entry *cur;
15672 ast_cli(
a->fd,
FORMAT,
"Index",
"Thread",
"Dahdi-Device",
"Channels",
"Channel-List");
15674 struct dahdi_mfcr2 *mfcr2 = &cur->mfcr2;
15675 const char *thread_status =
NULL;
15682 if (mfcr2->r2master == 0L) {
15683 thread_status =
"zero";
15685 thread_status =
"none";
15687 thread_status =
"created";
15689 snprintf(index,
sizeof(index),
"%d", mfcr2->index);
15690 snprintf(live_chans_str,
sizeof(live_chans_str),
"%d", mfcr2->live_chans);
15696 for (i = 0; i < mfcr2->numchans &&
len <
sizeof(channel_list) - 1; i++) {
15703 if (prev_channo && prev_channo == channo - 1) {
15704 prev_channo = channo;
15708 if (inside_range) {
15710 len += snprintf(channel_list +
len,
sizeof(channel_list) -
len - 1,
"-%d,%d", prev_channo, channo);
15712 }
else if (prev_channo) {
15714 len += snprintf(channel_list +
len,
sizeof(channel_list) -
len - 1,
",%d", channo);
15717 len += snprintf(channel_list +
len,
sizeof(channel_list) -
len - 1,
"%d", channo);
15719 prev_channo = channo;
15722 if (inside_range) {
15724 len += snprintf(channel_list +
len,
sizeof(channel_list) -
len - 1,
"-%d", channo);
15726 }
else if (prev_channo) {
15728 len += snprintf(channel_list +
len,
sizeof(channel_list) -
len - 1,
",%d", channo);
15734 (mfcr2->nodev) ?
"MISSING" :
"OK",
15747 e->
command =
"mfcr2 show links";
15749 "Usage: mfcr2 show links\n"
15750 " Shows the DAHDI MFC/R2 links.\n";
15755 if (
a->argc != 3) {
15758 mfcr2_show_links_of(
a, &r2links,
"Live links\n");
15759 mfcr2_show_links_of(
a, &nodev_r2links,
"Links to be removed (device missing)\n");
15766 int wanted_link_index;
15767 int found_link = 0;
15768 struct r2link_entry *cur =
NULL;
15772 e->
command =
"mfcr2 destroy link";
15774 "Usage: mfcr2 destroy link <index-number>\n"
15775 " Destroys D-channel of link and its B-channels.\n"
15776 " DON'T USE THIS UNLESS YOU KNOW WHAT YOU ARE DOING.\n";
15784 res = sscanf(
a->argv[3],
"%30d", &wanted_link_index);
15785 if ((res != 1) || wanted_link_index < 1) {
15787 "Invalid link index '%s'. Should be a positive number\n",
a->argv[3]);
15792 struct dahdi_mfcr2 *mfcr2 = &cur->mfcr2;
15793 if (wanted_link_index == mfcr2->index) {
15801 if (! found_link) {
15802 ast_cli(
a->fd,
"No link found with index %d.\n", wanted_link_index);
15809 AST_CLI_DEFINE(handle_mfcr2_version,
"Show OpenR2 library version"),
15810 AST_CLI_DEFINE(handle_mfcr2_show_variants,
"Show supported MFC/R2 variants"),
15811 AST_CLI_DEFINE(handle_mfcr2_show_channels,
"Show MFC/R2 channels"),
15813 AST_CLI_DEFINE(handle_mfcr2_set_debug,
"Set MFC/R2 channel logging level"),
15814 AST_CLI_DEFINE(handle_mfcr2_call_files,
"Enable/Disable MFC/R2 call files"),
15815 AST_CLI_DEFINE(handle_mfcr2_set_idle,
"Reset MFC/R2 channel forcing it to IDLE"),
15816 AST_CLI_DEFINE(handle_mfcr2_set_blocked,
"Reset MFC/R2 channel forcing it to BLOCKED"),
15817 AST_CLI_DEFINE(handle_mfcr2_destroy_link,
"Destroy given MFC/R2 link"),
15828 e->
command =
"dahdi destroy channels";
15830 "Usage: dahdi destroy channels <from_channel> [<to_channel>]\n"
15831 " DON'T USE THIS UNLESS YOU KNOW WHAT YOU ARE DOING. Immediately removes a given channel, whether it is in use or not\n";
15836 if ((
a->argc < 4) ||
a->argc > 5) {
15839 start = atoi(
a->argv[3]);
15841 ast_cli(
a->fd,
"Invalid starting channel number %s.\n",
15845 if (
a->argc == 5) {
15846 end = atoi(
a->argv[4]);
15848 ast_cli(
a->fd,
"Invalid ending channel number %s.\n",
15858 "range end (%d) is smaller than range start (%d)\n",
15874 e->
command =
"dahdi create channels";
15875 e->
usage =
"Usage: dahdi create channels <from> [<to>] - a range of channels\n"
15876 " dahdi create channels new - add channels not yet created\n"
15877 "For ISDN and SS7 the range should include complete spans.\n";
15882 if ((
a->argc < 4) ||
a->argc > 5) {
15885 if (
a->argc == 4 && !strcmp(
a->argv[3],
"new")) {
15889 start = atoi(
a->argv[3]);
15891 ast_cli(
a->fd,
"Invalid starting channel number '%s'.\n",
15895 if (
a->argc == 5) {
15896 end = atoi(
a->argv[4]);
15898 ast_cli(
a->fd,
"Invalid ending channel number '%s'.\n",
15907 "range end (%d) is smaller than range start (%d)\n",
15945#if defined(HAVE_PRI) || defined(HAVE_SS7)
15952 ast_verb(1,
"Destroying channels and reloading DAHDI configuration.\n");
15954 ast_verb(4,
"Initial softhangup of all DAHDI channels complete.\n");
15956 dahdi_r2_destroy_links();
15959#if defined(HAVE_PRI)
15962 cancel_code = pthread_cancel(pris[i].pri.
master);
15963 pthread_kill(pris[i].pri.
master, SIGURG);
15964 ast_debug(4,
"Waiting to join thread of span %d with pid=%p, cancel_code=%d\n", i, (
void *) pris[i].pri.
master, cancel_code);
15966 ast_debug(4,
"Joined thread of span %d\n", i);
15971#if defined(HAVE_SS7)
15974 cancel_code = pthread_cancel(linksets[i].ss7.master);
15975 pthread_kill(linksets[i].ss7.master, SIGURG);
15976 ast_debug(4,
"Waiting to join thread of span %d with pid=%p, cancel_code=%d\n", i, (
void *) linksets[i].ss7.master, cancel_code);
15977 pthread_join(linksets[i].ss7.master,
NULL);
15978 ast_debug(4,
"Joined thread of span %d\n", i);
15987 ast_debug(4,
"Waiting to join monitor thread with pid=%p, cancel_code=%d\n", (
void *)
monitor_thread, cancel_code);
15989 ast_debug(4,
"Joined monitor thread\n");
15995 int x = DAHDI_FLASH;
16011 ast_verb(4,
"Final softhangup of all DAHDI channels complete.\n");
16021 dahdi_close_pri_fd(&(pris[i]), j);
16024 memset(pris, 0,
sizeof(pris));
16028 pri_set_error(dahdi_pri_error);
16029 pri_set_message(dahdi_pri_message);
16031#if defined(HAVE_SS7)
16034 dahdi_close_ss7_fd(&(linksets[i]), j);
16037 memset(linksets, 0,
sizeof(linksets));
16041 ss7_set_error(dahdi_ss7_error);
16042 ss7_set_message(dahdi_ss7_message);
16062 e->
command =
"dahdi restart";
16064 "Usage: dahdi restart\n"
16065 " Restarts the DAHDI channels: destroys them all and then\n"
16066 " re-reads them from chan_dahdi.conf.\n"
16067 " Note that this will STOP any running CALL on DAHDI channels.\n"
16093#define FORMAT "%7s %4d %-20.20s %-10.10s %-15.15s %-8.8s %-20.20s %-10.10s %-10.10s %-12.12s %-32.32s\n"
16094#define FORMAT2 "%7s %4s %-20.20s %-10.10s %-15.15s %-8.8s %-20.20s %-10.10s %-10.10s %-12.12s %-32.32s\n"
16096 int filtertype = 0;
16103 e->
command =
"dahdi show channels [group|context]";
16105 "Usage: dahdi show channels [ group <group> | context <context> ]\n"
16106 " Shows a list of available channels with optional filtering\n"
16107 " <group> must be a number between 0 and 63\n";
16115 if (!((
a->argc == 3) || (
a->argc == 5))) {
16119 if (
a->argc == 5) {
16120 if (!strcasecmp(
a->argv[3],
"group")) {
16121 targetnum = atoi(
a->argv[4]);
16122 if (63 < targetnum) {
16127 }
else if (!strcasecmp(
a->argv[3],
"context")) {
16132 ast_cli(
a->fd,
FORMAT2,
"Chan",
"Span",
"Signalling",
"Extension",
"Context",
"Language",
"MOH Interpret",
"Blocked",
"In Service",
"Alarms",
"Description");
16137 switch(filtertype) {
16139 if (!(tmp->
group & targetnum)) {
16144 if (strcasecmp(tmp->
context,
a->argv[4])) {
16153 snprintf(tmps,
sizeof(tmps),
"%d", tmp->
channel);
16161 blockstr[2] =
'\0';
16163 ast_cli(
a->fd,
FORMAT, tmps, tmp->
span,
sig2str(tmp->
sig), tmp->
exten, tmp->
context, tmp->
language, tmp->
mohinterpret, blockstr, tmp->
inservice ?
"Yes" :
"No",
16176 struct dahdi_confinfo ci;
16177 struct dahdi_params ps;
16184 e->
command =
"dahdi show channel";
16186 "Usage: dahdi show channel <chan num>\n"
16187 " Detailed information about a given channel\n";
16196 channel = atoi(
a->argv[3]);
16200 if (tmp->
channel == channel) {
16210#if defined(HAVE_PRI)
16211#if defined(HAVE_PRI_SUBADDR)
16220 for (v = tmp->
vars ; v ; v = v->
next)
16234 ast_cli(
a->fd,
"DSP: %s\n", tmp->
dsp ?
"yes" :
"no");
16237#if defined(BUSYDETECT_TONEONLY)
16238 ast_cli(
a->fd,
" Busy Detector Helper: BUSYDETECT_TONEONLY\n");
16239#elif defined(BUSYDETECT_COMPARE_TONE_AND_SILENCE)
16240 ast_cli(
a->fd,
" Busy Detector Helper: BUSYDETECT_COMPARE_TONE_AND_SILENCE\n");
16242#ifdef BUSYDETECT_DEBUG
16243 ast_cli(
a->fd,
" Busy Detector Debug: Enabled\n");
16248 ast_cli(
a->fd,
"TDD: %s\n", tmp->
tdd ?
"yes" :
"no");
16255 snprintf(hwrxgain,
sizeof(hwrxgain),
"%.1f", tmp->
hwrxgain);
16260 snprintf(hwtxgain,
sizeof(hwtxgain),
"%.1f", tmp->
hwtxgain);
16264 ast_cli(
a->fd,
"HW Gains (RX/TX): %s/%s\n", hwrxgain, hwtxgain);
16266 ast_cli(
a->fd,
"Dynamic Range Compression (RX/TX): %.2f/%.2f\n", tmp->
rxdrc, tmp->
txdrc);
16268 ast_cli(
a->fd,
"Echo Cancellation:\n");
16288 char calldir[OR2_MAX_PATH];
16289 openr2_context_t *r2context = openr2_chan_get_context(tmp->r2chan);
16290 openr2_variant_t r2variant = openr2_context_get_variant(r2context);
16291 ast_cli(
a->fd,
"MFC/R2 MF State: %s\n", openr2_chan_get_mf_state_string(tmp->r2chan));
16292 ast_cli(
a->fd,
"MFC/R2 MF Group: %s\n", openr2_chan_get_mf_group_string(tmp->r2chan));
16293 ast_cli(
a->fd,
"MFC/R2 State: %s\n", openr2_chan_get_r2_state_string(tmp->r2chan));
16294 ast_cli(
a->fd,
"MFC/R2 Call State: %s\n", openr2_chan_get_call_state_string(tmp->r2chan));
16295 ast_cli(
a->fd,
"MFC/R2 Call Files Enabled: %s\n", openr2_chan_get_call_files_enabled(tmp->r2chan) ?
"Yes" :
"No");
16296 ast_cli(
a->fd,
"MFC/R2 Variant: %s\n", openr2_proto_get_variant_string(r2variant));
16297 ast_cli(
a->fd,
"MFC/R2 Max ANI: %d\n", openr2_context_get_max_ani(r2context));
16298 ast_cli(
a->fd,
"MFC/R2 Max DNIS: %d\n", openr2_context_get_max_dnis(r2context));
16299#if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 2
16300 ast_cli(
a->fd,
"MFC/R2 DTMF Dialing: %s\n", openr2_context_get_dtmf_dialing(r2context,
NULL,
NULL) ?
"Yes" :
"No");
16301 ast_cli(
a->fd,
"MFC/R2 DTMF Detection: %s\n", openr2_context_get_dtmf_detection(r2context) ?
"Yes" :
"No");
16303 ast_cli(
a->fd,
"MFC/R2 Get ANI First: %s\n", openr2_context_get_ani_first(r2context) ?
"Yes" :
"No");
16304#if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 1
16305 ast_cli(
a->fd,
"MFC/R2 Skip Category Request: %s\n", openr2_context_get_skip_category_request(r2context) ?
"Yes" :
"No");
16307 ast_cli(
a->fd,
"MFC/R2 Immediate Accept: %s\n", openr2_context_get_immediate_accept(r2context) ?
"Yes" :
"No");
16308 ast_cli(
a->fd,
"MFC/R2 Accept on Offer: %s\n", tmp->mfcr2_accept_on_offer ?
"Yes" :
"No");
16309 ast_cli(
a->fd,
"MFC/R2 Charge Calls: %s\n", tmp->mfcr2_charge_calls ?
"Yes" :
"No");
16310 ast_cli(
a->fd,
"MFC/R2 Allow Collect Calls: %s\n", tmp->mfcr2_allow_collect_calls ?
"Yes" :
"No");
16311 ast_cli(
a->fd,
"MFC/R2 Forced Release: %s\n", tmp->mfcr2_forced_release ?
"Yes" :
"No");
16312 ast_cli(
a->fd,
"MFC/R2 MF Back Timeout: %dms\n", openr2_context_get_mf_back_timeout(r2context));
16313 ast_cli(
a->fd,
"MFC/R2 R2 Metering Pulse Timeout: %dms\n", openr2_context_get_metering_pulse_timeout(r2context));
16314 ast_cli(
a->fd,
"MFC/R2 Rx CAS: %s\n", openr2_chan_get_rx_cas_string(tmp->r2chan));
16315 ast_cli(
a->fd,
"MFC/R2 Tx CAS: %s\n", openr2_chan_get_tx_cas_string(tmp->r2chan));
16316 ast_cli(
a->fd,
"MFC/R2 MF Tx Signal: %d\n", openr2_chan_get_tx_mf_signal(tmp->r2chan));
16317 ast_cli(
a->fd,
"MFC/R2 MF Rx Signal: %d\n", openr2_chan_get_rx_mf_signal(tmp->r2chan));
16318 ast_cli(
a->fd,
"MFC/R2 Call Files Directory: %s\n", openr2_context_get_log_directory(r2context, calldir,
sizeof(calldir)));
16321#if defined(HAVE_SS7)
16342 if (tmp->logicalspan)
16343 ast_cli(
a->fd,
"PRI Logical Span: %d\n", tmp->logicalspan);
16345 ast_cli(
a->fd,
"PRI Logical Span: Implicit\n");
16348 memset(&ci, 0,
sizeof(ci));
16351 memset(&ci, 0,
sizeof(ci));
16353 ast_cli(
a->fd,
"Actual Confinfo: Num/%d, Mode/0x%04x\n", ci.confno, (
unsigned)ci.confmode);
16356 ast_cli(
a->fd,
"Actual Confmute: %s\n", x ?
"Yes" :
"No");
16358 memset(&ps, 0,
sizeof(ps));
16362 ast_cli(
a->fd,
"Hookstate (FXS only): %s\n", ps.rxisoffhook ?
"Offhook" :
"Onhook");
16380 e->
command =
"dahdi show cadences";
16382 "Usage: dahdi show cadences\n"
16383 " Shows all cadences currently defined\n";
16390 char tmp[16], tmp2[64];
16391 snprintf(tmp,
sizeof(tmp),
"r%d: ", i + 1);
16394 for (j = 0; j < 16; j++) {
16395 if (
cadences[i].ringcadence[j] == 0)
16397 snprintf(tmp,
sizeof(tmp),
"%d",
cadences[i].ringcadence[j]);
16403 strncat(output,
",",
sizeof(output) - strlen(output) - 1);
16404 strncat(output, tmp2,
sizeof(output) - strlen(output) - 1);
16413 alarmstr[0] =
'\0';
16414 if (spaninfo->alarms > 0) {
16415 if (spaninfo->alarms & DAHDI_ALARM_BLUE) {
16416 strcat(alarmstr,
"BLU/");
16418 if (spaninfo->alarms & DAHDI_ALARM_YELLOW) {
16419 strcat(alarmstr,
"YEL/");
16421 if (spaninfo->alarms & DAHDI_ALARM_RED) {
16422 strcat(alarmstr,
"RED/");
16424 if (spaninfo->alarms & DAHDI_ALARM_LOOPBACK) {
16425 strcat(alarmstr,
"LB/");
16427 if (spaninfo->alarms & DAHDI_ALARM_RECOVER) {
16428 strcat(alarmstr,
"REC/");
16430 if (spaninfo->alarms & DAHDI_ALARM_NOTOPEN) {
16431 strcat(alarmstr,
"NOP/");
16433 if (!strlen(alarmstr)) {
16434 strcat(alarmstr,
"UUU/");
16436 if (strlen(alarmstr)) {
16438 alarmstr[strlen(alarmstr) - 1] =
'\0';
16441 if (spaninfo->numchans) {
16442 strcpy(alarmstr,
"OK");
16444 strcpy(alarmstr,
"UNCONFIGURED");
16452 #define FORMAT "%4d %-40.40s %-7.7s %-6d %-6d %-6d %-3.3s %-4.4s %-8.8s %s\n"
16453 #define FORMAT2 "%4s %-40.40s %-7.7s %-6.6s %-6.6s %-6.6s %-3.3s %-4.4s %-8.8s %s\n"
16459 struct dahdi_spaninfo s;
16463 e->
command =
"dahdi show status";
16465 "Usage: dahdi show status\n"
16466 " Shows a list of DAHDI cards with status\n";
16471 ctl = open(
"/dev/dahdi/ctl", O_RDWR);
16473 ast_cli(
a->fd,
"No DAHDI found. Unable to open /dev/dahdi/ctl: %s\n", strerror(
errno));
16476 ast_cli(
a->fd,
FORMAT2,
"Span",
"Description",
"Alarms",
"IRQ",
"bpviol",
"CRC",
"Framing",
"Coding",
"Options",
"LBO");
16478 for (span = 1; span < DAHDI_MAX_SPANS; ++span) {
16480 res = ioctl(ctl, DAHDI_SPANSTAT, &s);
16485 ast_cli(
a->fd,
FORMAT, span, s.desc, alarmstr, s.irqmisses, s.bpvcount, s.crc4count,
16486 s.lineconfig & DAHDI_CONFIG_D4 ?
"D4" :
16487 s.lineconfig & DAHDI_CONFIG_ESF ?
"ESF" :
16488 s.lineconfig & DAHDI_CONFIG_CCS ?
"CCS" :
16490 s.lineconfig & DAHDI_CONFIG_B8ZS ?
"B8ZS" :
16491 s.lineconfig & DAHDI_CONFIG_HDB3 ?
"HDB3" :
16492 s.lineconfig & DAHDI_CONFIG_AMI ?
"AMI" :
16494 s.lineconfig & DAHDI_CONFIG_CRC4 ?
16495 s.lineconfig & DAHDI_CONFIG_NOTOPEN ?
"CRC4/YEL" :
"CRC4" :
16496 s.lineconfig & DAHDI_CONFIG_NOTOPEN ?
"YEL" :
"",
16509 int pseudo_fd = -1;
16510 struct dahdi_versioninfo vi;
16514 e->
command =
"dahdi show version";
16516 "Usage: dahdi show version\n"
16517 " Shows the DAHDI version in use\n";
16522 if ((pseudo_fd = open(
"/dev/dahdi/ctl", O_RDONLY)) < 0) {
16523 ast_cli(
a->fd,
"Failed to open control file to get version.\n");
16527 strcpy(vi.version,
"Unknown");
16528 strcpy(vi.echo_canceller,
"Unknown");
16530 if (ioctl(pseudo_fd, DAHDI_GETVERSION, &vi))
16531 ast_cli(
a->fd,
"Failed to get DAHDI version: %s\n", strerror(
errno));
16533 ast_cli(
a->fd,
"DAHDI Version: %s Echo Canceller: %s\n", vi.version, vi.echo_canceller);
16549 e->
command =
"dahdi set hwgain {rx|tx}";
16551 "Usage: dahdi set hwgain <rx|tx> <chan#> <gain>\n"
16552 " Sets the hardware gain on a given channel and overrides the\n"
16553 " value provided at module loadtime. Changes take effect\n"
16554 " immediately whether the channel is in use or not.\n"
16556 " <rx|tx> which direction do you want to change (relative to our module)\n"
16557 " <chan num> is the channel number relative to the device\n"
16558 " <gain> is the gain in dB (e.g. -3.5 for -3.5dB)\n"
16561 " * hwgain is only supportable by hardware with analog ports because\n"
16562 " hwgain works on the analog side of an analog-digital conversion.\n";
16571 if (!strcasecmp(
"rx",
a->argv[3]))
16573 else if (!strcasecmp(
"tx",
a->argv[3]))
16579 gain = atof(
a->argv[5]);
16592 ast_cli(
a->fd,
"Unable to set the hardware gain for channel %d: %s\n",
channel, strerror(
errno));
16596 ast_cli(
a->fd,
"Hardware %s gain set to %.1f dB on channel %d.\n",
16597 tx ?
"tx" :
"rx", gain,
channel);
16629 e->
command =
"dahdi set swgain {rx|tx}";
16631 "Usage: dahdi set swgain <rx|tx> <chan#> <gain>\n"
16632 " Sets the software gain on a given channel and overrides the\n"
16633 " value provided at module loadtime. Changes take effect\n"
16634 " immediately whether the channel is in use or not.\n"
16636 " <rx|tx> which direction do you want to change (relative to our module)\n"
16637 " <chan num> is the channel number relative to the device\n"
16638 " <gain> is the gain in dB (e.g. -3.5 for -3.5dB)\n";
16647 if (!strcasecmp(
"rx",
a->argv[3]))
16649 else if (!strcasecmp(
"tx",
a->argv[3]))
16655 gain = atof(
a->argv[5]);
16672 ast_cli(
a->fd,
"Unable to set the software gain for channel %d\n",
channel);
16677 ast_cli(
a->fd,
"Software %s gain set to %.2f dB on channel %d.\n",
16678 tx ?
"tx" :
"rx", gain,
channel);
16705 e->
command =
"dahdi set dnd";
16707 "Usage: dahdi set dnd <chan#> <on|off>\n"
16708 " Sets/resets DND (Do Not Disturb) mode on a channel.\n"
16709 " Changes take effect immediately.\n"
16710 " <chan num> is the channel number\n"
16711 " <on|off> Enable or disable DND mode?\n"
16721 if ((
channel = atoi(
a->argv[3])) <= 0) {
16722 ast_cli(
a->fd,
"Expected channel number, got '%s'\n",
a->argv[3]);
16731 ast_cli(
a->fd,
"Expected 'on' or 'off', got '%s'\n",
a->argv[4]);
16736 for (dahdi_chan =
iflist; dahdi_chan; dahdi_chan = dahdi_chan->
next) {
16763 e->
command =
"dahdi set mwi";
16765 "Usage: dahdi set mwi <chan#> <on|off|reset>\n"
16766 " Sets/unsets MWI (Message Waiting Indicator) manually on a channel.\n"
16767 " This may be used regardless of whether the channel is assigned any mailboxes.\n"
16768 " When active, this setting will override the voicemail status to set MWI.\n"
16769 " Once cleared, the voicemail status will resume control of MWI.\n"
16770 " Changes are queued for when the channel is idle and persist until cleared.\n"
16771 " <chan num> is the channel number\n"
16772 " <on|off|reset> Enable, disable, or reset Message Waiting Indicator override?\n"
16782 if ((
channel = atoi(
a->argv[3])) <= 0) {
16783 ast_cli(
a->fd,
"Expected channel number, got '%s'\n",
a->argv[3]);
16791 }
else if (!strcmp(
a->argv[4],
"reset")) {
16794 ast_cli(
a->fd,
"Expected 'on' or 'off' or 'reset', got '%s'\n",
a->argv[4]);
16799 for (dahdi_chan =
iflist; dahdi_chan; dahdi_chan = dahdi_chan->
next) {
16806 ast_cli(
a->fd,
"MWI '%s' queued for channel %d\n", on ?
"enable" :
"disable",
channel);
16884 if (sscanf(
channel,
"%30d", &chan_num) != 1) {
17000 for (i = 0; i < strlen(
number); i++) {
17015 int dahdichanquery;
17017 if (!dahdichannel || sscanf(dahdichannel,
"%30d", &dahdichanquery) != 1) {
17019 dahdichanquery = -1;
17024 snprintf(idText,
sizeof(idText),
"ActionID: %s\r\n",
id);
17036 if (dahdichanquery > 0 && tmp->
channel != dahdichanquery)
17044 "Event: DAHDIShowChannels\r\n"
17045 "DAHDIChannel: %d\r\n"
17048 "AccountCode: %s\r\n"
17049 "Signalling: %s\r\n"
17050 "SignallingCode: %d\r\n"
17054 "Description: %s\r\n"
17064 dahdi_dnd(tmp, -1) ?
"Enabled" :
"Disabled",
17069 "Event: DAHDIShowChannels\r\n"
17070 "DAHDIChannel: %d\r\n"
17071 "Signalling: %s\r\n"
17072 "SignallingCode: %d\r\n"
17076 "Description: %s\r\n"
17081 dahdi_dnd(tmp, -1) ?
"Enabled" :
"Disabled",
17105 struct dahdi_spaninfo spaninfo;
17107 ctl = open(
"/dev/dahdi/ctl", O_RDWR);
17115 snprintf(idText,
sizeof(idText),
"ActionID: %s\r\n",
id);
17119 for (span = 1; span < DAHDI_MAX_SPANS; ++span) {
17120 spaninfo.spanno = span;
17121 res = ioctl(ctl, DAHDI_SPANSTAT, &spaninfo);
17128 "Event: DAHDIShowStatus\r\n"
17130 "Description: %s\r\n"
17141 span, spaninfo.desc, alarmstr, spaninfo.irqmisses, spaninfo.bpvcount, spaninfo.crc4count,
17142 spaninfo.lineconfig & DAHDI_CONFIG_D4 ?
"D4" :
17143 spaninfo.lineconfig & DAHDI_CONFIG_ESF ?
"ESF" :
17144 spaninfo.lineconfig & DAHDI_CONFIG_CCS ?
"CCS" :
17146 spaninfo.lineconfig & DAHDI_CONFIG_B8ZS ?
"B8ZS" :
17147 spaninfo.lineconfig & DAHDI_CONFIG_HDB3 ?
"HDB3" :
17148 spaninfo.lineconfig & DAHDI_CONFIG_AMI ?
"AMI" :
17150 spaninfo.lineconfig & DAHDI_CONFIG_CRC4 ?
17151 spaninfo.lineconfig & DAHDI_CONFIG_NOTOPEN ?
"CRC4/YEL" :
"CRC4" :
17152 spaninfo.lineconfig & DAHDI_CONFIG_NOTOPEN ?
"YEL" :
"",
17164#if defined(HAVE_PRI)
17170 struct dahdi_pri *dspan;
17173 char action_id[256];
17174 const char *show_cmd =
"PRIShowSpans";
17178 span_query = atoi(span_str);
17184 snprintf(action_id,
sizeof(action_id),
"ActionID: %s\r\n",
id);
17186 action_id[0] =
'\0';
17192 for (idx = 0; idx <
ARRAY_LEN(pris); ++idx) {
17193 dspan = &pris[idx];
17196 if (0 < span_query && dspan->pri.span != span_query) {
17200 if (dspan->pri.pri) {
17213#if defined(HAVE_SS7)
17214static int linkset_addsigchan(
int sigchan)
17216 struct dahdi_ss7 *link;
17219 struct dahdi_params params;
17220 struct dahdi_bufferinfo bi;
17221 struct dahdi_spaninfo si;
17227 if (cur_ss7type < 0) {
17231 if (cur_pointcode < 0) {
17235 if (cur_adjpointcode < 0) {
17239 if (cur_defaultdpc < 0) {
17243 if (cur_networkindicator < 0) {
17247 link = ss7_resolve_linkset(cur_linkset);
17257 curfd = link->ss7.numsigchans;
17260 link->ss7.fds[curfd] = open(
"/dev/dahdi/channel", O_RDWR, 0600);
17261 if (link->ss7.fds[curfd] < 0) {
17266 if (ioctl(link->ss7.fds[curfd], DAHDI_SPECIFY, &sigchan) == -1) {
17267 dahdi_close_ss7_fd(link, curfd);
17274 memset(¶ms, 0,
sizeof(params));
17275 res = ioctl(link->ss7.fds[curfd], DAHDI_GET_PARAMS, ¶ms);
17277 dahdi_close_ss7_fd(link, curfd);
17278 ast_log(
LOG_ERROR,
"Unable to get parameters for sigchan %d (%s)\n", sigchan,
17282 if (params.sigtype != DAHDI_SIG_HDLCFCS
17283 && params.sigtype != DAHDI_SIG_HARDHDLC
17284 && params.sigtype != DAHDI_SIG_MTP2) {
17285 dahdi_close_ss7_fd(link, curfd);
17291 memset(&bi, 0,
sizeof(bi));
17292 bi.txbufpolicy = DAHDI_POLICY_IMMEDIATE;
17293 bi.rxbufpolicy = DAHDI_POLICY_IMMEDIATE;
17296 if (ioctl(link->ss7.fds[curfd], DAHDI_SET_BUFINFO, &bi)) {
17297 ast_log(
LOG_ERROR,
"Unable to set appropriate buffering on channel %d: %s\n",
17298 sigchan, strerror(
errno));
17299 dahdi_close_ss7_fd(link, curfd);
17304 memset(&si, 0,
sizeof(si));
17305 res = ioctl(link->ss7.fds[curfd], DAHDI_SPANSTAT, &si);
17307 dahdi_close_ss7_fd(link, curfd);
17308 ast_log(
LOG_ERROR,
"Unable to get span state for sigchan %d (%s)\n", sigchan,
17313 (params.sigtype == DAHDI_SIG_MTP2)
17314 ? SS7_TRANSPORT_DAHDIMTP2
17315 : SS7_TRANSPORT_DAHDIDCHAN,
17316 si.alarms, cur_networkindicator, cur_pointcode, cur_adjpointcode, cur_slc);
17318 dahdi_close_ss7_fd(link, curfd);
17322 ++link->ss7.numsigchans;
17328#if defined(HAVE_SS7)
17334 e->
command =
"ss7 set debug {on|off} linkset";
17336 "Usage: ss7 set debug {on|off} linkset <linkset>\n"
17337 " Enables debugging on a given SS7 linkset\n";
17347 span = atoi(
a->argv[5]);
17348 if ((span < 1) || (span >
NUM_SPANS)) {
17349 ast_cli(
a->fd,
"Invalid linkset %s. Should be a number from %d to %d\n",
a->argv[5], 1,
NUM_SPANS);
17352 if (!linksets[span-1].ss7.ss7) {
17353 ast_cli(
a->fd,
"No SS7 running on linkset %d\n", span);
17355 if (!strcasecmp(
a->argv[3],
"on")) {
17356 linksets[span - 1].ss7.debug = 1;
17358 ast_cli(
a->fd,
"Enabled debugging on linkset %d\n", span);
17360 linksets[span - 1].ss7.debug = 0;
17361 ss7_set_debug(linksets[span-1].ss7.ss7, 0);
17362 ast_cli(
a->fd,
"Disabled debugging on linkset %d\n", span);
17370#if defined(HAVE_SS7)
17380 e->
command =
"ss7 {block|unblock} cic";
17382 "Usage: ss7 {block|unblock} cic <linkset> <dpc> <CIC>\n"
17383 " Sends a remote {blocking|unblocking} request for the given CIC on the specified linkset\n";
17389 if (
a->argc == 6) {
17390 linkset = atoi(
a->argv[3]);
17395 if (!strcasecmp(
a->argv[1],
"block")) {
17397 }
else if (strcasecmp(
a->argv[1],
"unblock")) {
17401 if ((linkset < 1) || (linkset >
NUM_SPANS)) {
17402 ast_cli(
a->fd,
"Invalid linkset %s. Should be a number %d to %d\n",
a->argv[3], 1,
NUM_SPANS);
17406 if (!linksets[linkset-1].ss7.ss7) {
17407 ast_cli(
a->fd,
"No SS7 running on linkset %d\n", linkset);
17411 cic = atoi(
a->argv[5]);
17413 ast_cli(
a->fd,
"Invalid CIC specified!\n");
17417 dpc = atoi(
a->argv[4]);
17419 ast_cli(
a->fd,
"Invalid DPC specified!\n");
17423 for (i = 0; i < linksets[linkset-1].ss7.numchans; i++) {
17424 if (linksets[linkset-1].ss7.pvts[i] && linksets[linkset-1].ss7.pvts[i]->cic == cic && linksets[linkset-1].ss7.pvts[i]->dpc == dpc) {
17425 blocked = linksets[linkset-1].ss7.pvts[i]->locallyblocked;
17428 ast_cli(
a->fd,
"Unable to allocate new ss7call\n");
17430 ast_cli(
a->fd,
"Sent %sblocking request for linkset %d on CIC %d DPC %d\n", (do_block) ?
"" :
"un", linkset, cic, dpc);
17432 }
else if (!do_block && blocked) {
17433 ast_cli(
a->fd,
"CIC %d is hardware locally blocked!\n", cic);
17435 ast_cli(
a->fd,
"CIC %d %s locally blocked\n", cic, do_block ?
"already" :
"is not");
17441 ast_cli(
a->fd,
"Invalid CIC specified!\n");
17446#if defined(HAVE_SS7)
17458 e->
command =
"ss7 {reset|block|unblock} linkset";
17460 "Usage: ss7 {reset|block|unblock} linkset <linkset number>\n"
17461 " Sends a remote {reset|blocking|unblocking} request for all CICs on the given linkset\n";
17467 if (
a->argc == 4) {
17468 linkset = atoi(
a->argv[3]);
17473 if (!strcasecmp(
a->argv[1],
"block")) {
17474 do_what = DO_BLOCK;
17475 }
else if (!strcasecmp(
a->argv[1],
"unblock")) {
17476 do_what = DO_UNBLOCK;
17477 }
else if (!strcasecmp(
a->argv[1],
"reset")) {
17478 do_what = DO_RESET;
17483 if ((linkset < 1) || (linkset >
NUM_SPANS)) {
17484 ast_cli(
a->fd,
"Invalid linkset %s. Should be a number %d to %d\n",
a->argv[3], 1,
NUM_SPANS);
17488 if (!linksets[linkset - 1].ss7.ss7) {
17489 ast_cli(
a->fd,
"No SS7 running on linkset %d\n", linkset);
17493 for (i = 0; i < linksets[linkset - 1].ss7.numchans; i++) {
17495 if (linksets[linkset - 1].ss7.pvts[i]) {
17500 ast_cli(
a->fd,
"Sent remote %s request on CIC %d\n",
17501 (do_what == DO_BLOCK) ?
"blocking" :
"unblocking",
17502 linksets[linkset - 1].ss7.pvts[i]->cic);
17507 linksets[linkset - 1].ss7.pvts[i]->cic,
17508 linksets[linkset - 1].ss7.pvts[i]->dpc)) {
17509 ast_cli(
a->fd,
"Sent reset request on CIC %d\n",
17510 linksets[linkset - 1].ss7.pvts[i]->cic);
17521#if defined(HAVE_SS7)
17524 int linkset, cic, range, chanpos;
17525 int i, dpc, orient = 0;
17527 unsigned char state[255];
17531 e->
command =
"ss7 {block|unblock} group";
17533 "Usage: ss7 {block|unblock} group <linkset> <dpc> <1st. CIC> <range> [H]\n"
17534 " Sends a remote {blocking|unblocking} request for CIC range on the specified linkset\n";
17540 if (
a->argc == 7 ||
a->argc == 8) {
17541 linkset = atoi(
a->argv[3]);
17546 if (!strcasecmp(
a->argv[1],
"block")) {
17548 }
else if (strcasecmp(
a->argv[1],
"unblock")) {
17552 if (
a->argc == 8) {
17553 if (!strcasecmp(
a->argv[7],
"H")) {
17560 if ((linkset < 1) || (linkset >
NUM_SPANS)) {
17561 ast_cli(
a->fd,
"Invalid linkset %s. Should be a number %d to %d\n",
a->argv[4], 1,
NUM_SPANS);
17565 if (!linksets[linkset-1].ss7.ss7) {
17566 ast_cli(
a->fd,
"No SS7 running on linkset %d\n", linkset);
17570 cic = atoi(
a->argv[5]);
17572 ast_cli(
a->fd,
"Invalid CIC specified!\n");
17576 range = atoi(
a->argv[6]);
17578 if (range < 1 || range > (linksets[linkset - 1].ss7.type == SS7_ANSI ? 24 : 31)) {
17579 ast_cli(
a->fd,
"Invalid range specified!\n");
17583 dpc = atoi(
a->argv[4]);
17585 ast_cli(
a->fd,
"Invalid DPC specified!\n");
17592 ast_cli(
a->fd,
"Invalid CIC/RANGE\n");
17597 for (i = 0; i <= range; ++i) {
17604 ast_cli(
a->fd,
"Unable allocate new ss7call\n");
17606 ast_cli(
a->fd,
"Sending remote%s %sblocking request linkset %d on CIC %d range %d\n",
17607 orient ?
" hardware" :
"", do_block ?
"" :
"un", linkset, cic, range);
17614 pthread_kill(linksets[linkset-1].ss7.master, SIGURG);
17620#if defined(HAVE_SS7)
17623 int linkset, cic, range;
17628 e->
command =
"ss7 reset group";
17630 "Usage: ss7 reset group <linkset> <dpc> <1st CIC> <range>\n"
17631 " Send a GRS for the given CIC range on the specified linkset\n";
17637 if (
a->argc == 7) {
17638 linkset = atoi(
a->argv[3]);
17643 if ((linkset < 1) || (linkset >
NUM_SPANS)) {
17644 ast_cli(
a->fd,
"Invalid linkset %s. Should be a number %d to %d\n",
a->argv[4], 1,
NUM_SPANS);
17648 if (!linksets[linkset-1].ss7.ss7) {
17649 ast_cli(
a->fd,
"No SS7 running on linkset %d\n", linkset);
17653 cic = atoi(
a->argv[5]);
17656 ast_cli(
a->fd,
"Invalid CIC specified!\n");
17660 range = atoi(
a->argv[6]);
17661 if (range < 1 || range > (linksets[linkset - 1].ss7.type == SS7_ANSI ? 24 : 31)) {
17662 ast_cli(
a->fd,
"Invalid range specified!\n");
17666 dpc = atoi(
a->argv[4]);
17668 ast_cli(
a->fd,
"Invalid DPC specified!\n");
17675 ast_cli(
a->fd,
"Invalid CIC/RANGE\n");
17680 ast_cli(
a->fd,
"Unable to allocate new ss7call\n");
17682 ast_cli(
a->fd,
"GRS sent ... \n");
17689 pthread_kill(linksets[linkset-1].ss7.master, SIGURG);
17695#if defined(HAVE_SS7)
17702 e->
command =
"ss7 show calls";
17704 "Usage: ss7 show calls <linkset>\n"
17705 " Show SS7 calls on the specified linkset\n";
17711 if (
a->argc == 4) {
17712 linkset = atoi(
a->argv[3]);
17717 if ((linkset < 1) || (linkset >
NUM_SPANS)) {
17718 ast_cli(
a->fd,
"Invalid linkset %s. Should be a number %d to %d\n",
a->argv[3], 1,
NUM_SPANS);
17722 if (!linksets[linkset-1].ss7.ss7) {
17723 ast_cli(
a->fd,
"No SS7 running on linkset %d\n", linkset);
17728 isup_show_calls(linksets[linkset-1].ss7.ss7, &
ast_cli,
a->fd);
17735#if defined(HAVE_SS7)
17738 int linkset, cic, res;
17743 e->
command =
"ss7 reset cic";
17745 "Usage: ss7 reset cic <linkset> <dpc> <CIC>\n"
17746 " Send a RSC for the given CIC on the specified linkset\n";
17752 if (
a->argc == 6) {
17753 linkset = atoi(
a->argv[3]);
17758 if ((linkset < 1) || (linkset >
NUM_SPANS)) {
17759 ast_cli(
a->fd,
"Invalid linkset %s. Should be a number %d to %d\n",
a->argv[3], 1,
NUM_SPANS);
17763 if (!linksets[linkset-1].ss7.ss7) {
17764 ast_cli(
a->fd,
"No SS7 running on linkset %d\n", linkset);
17768 cic = atoi(
a->argv[5]);
17771 ast_cli(
a->fd,
"Invalid CIC specified!\n");
17775 dpc = atoi(
a->argv[4]);
17777 ast_cli(
a->fd,
"Invalid DPC specified!\n");
17783 ast_cli(
a->fd,
"%s RSC for linkset %d on CIC %d DPC %d\n", res ?
"Sent" :
"Failed", linkset, cic, dpc);
17789#if defined(HAVE_SS7)
17794 unsigned int arg = 0;
17801 "Usage: ss7 mtp3 <linkset> <slc> coo|coa|cbd|cba|eco|eca|tfp|tfa|lin|lun|lia|lua|lid|lfu <arg>\n"
17802 " Send a NET MNG message\n"
17803 " WARNING!!! WARNING!!! We are not a STP, just for testing/development purposes\n";
17813 linkset = atoi(
a->argv[2]);
17814 if ((linkset < 1) || (linkset >
NUM_SPANS)) {
17815 ast_cli(
a->fd,
"Invalid linkset %s. Should be a number %d to %d\n",
a->argv[2], 1,
NUM_SPANS);
17818 if (!linksets[linkset-1].ss7.ss7) {
17819 ast_cli(
a->fd,
"No SS7 running on linkset %d\n", linkset);
17823 slc = atoi(
a->argv[3]);
17825 if (
a->argc == 6) {
17826 arg = atoi(
a->argv[5]);
17830 res = mtp3_net_mng(linksets[linkset-1].ss7.ss7, slc,
a->argv[4], arg);
17835 pthread_kill(linksets[linkset-1].ss7.master, SIGURG);
17844#if defined(HAVE_SS7)
17848 unsigned int slc = 0;
17852 e->
command =
"ss7 restart mtp3";
17854 "Usage: ss7 restart mtp3 <linkset> <slc>\n"
17865 linkset = atoi(
a->argv[3]);
17866 if ((linkset < 1) || (linkset >
NUM_SPANS)) {
17867 ast_cli(
a->fd,
"Invalid linkset %s. Should be a number %d to %d\n",
a->argv[2], 1,
NUM_SPANS);
17870 if (!linksets[linkset-1].ss7.ss7) {
17871 ast_cli(
a->fd,
"No SS7 running on linkset %d\n", linkset);
17875 slc = atoi(
a->argv[4]);
17878 mtp3_init_restart(linksets[linkset-1].ss7.ss7, slc);
17883 pthread_kill(linksets[linkset-1].ss7.master, SIGURG);
17890#if defined(HAVE_SS7)
17897 e->
command =
"ss7 show linkset";
17899 "Usage: ss7 show linkset <span>\n"
17900 " Shows the status of an SS7 linkset.\n";
17910 linkset = atoi(
a->argv[3]);
17911 if ((linkset < 1) || (linkset >
NUM_SPANS)) {
17912 ast_cli(
a->fd,
"Invalid linkset %s. Should be a number %d to %d\n",
a->argv[3], 1,
NUM_SPANS);
17915 ss7 = &linksets[linkset - 1].ss7;
17917 ast_cli(
a->fd,
"No SS7 running on linkset %d\n", linkset);
17923 ast_cli(
a->fd,
"SS7 calling nai: %i\n",
ss7->calling_nai);
17924 ast_cli(
a->fd,
"SS7 called nai: %i\n",
ss7->called_nai);
17925 ast_cli(
a->fd,
"SS7 nationalprefix: %s\n",
ss7->nationalprefix);
17926 ast_cli(
a->fd,
"SS7 internationalprefix: %s\n",
ss7->internationalprefix);
17927 ast_cli(
a->fd,
"SS7 unknownprefix: %s\n",
ss7->unknownprefix);
17928 ast_cli(
a->fd,
"SS7 networkroutedprefix: %s\n",
ss7->networkroutedprefix);
17929 ast_cli(
a->fd,
"SS7 subscriberprefix: %s\n",
ss7->subscriberprefix);
17936#if defined(HAVE_SS7)
17943 e->
command =
"ss7 show channels";
17945 "Usage: ss7 show channels\n"
17946 " Displays SS7 channel information at a glance.\n";
17952 if (
a->argc != 3) {
17957 for (linkset = 0; linkset <
NUM_SPANS; ++linkset) {
17958 if (linksets[linkset].
ss7.ss7) {
17966#if defined(HAVE_SS7)
17969#define FORMAT "%5s %5s %6s %12s %-12s\n"
17970#define FORMAT2 "%5i %5i %6i %12s %-12s\n"
17971 int i, linkset, dpc = 0;
17978 e->
command =
"ss7 show cics";
17980 "Usage: ss7 show cics <linkset> [dpc]\n"
17981 " Shows the cics of an SS7 linkset.\n";
17987 if (
a->argc < 4 ||
a->argc > 5) {
17991 linkset = atoi(
a->argv[3]);
17993 if ((linkset < 1) || (linkset >
NUM_SPANS)) {
17994 ast_cli(
a->fd,
"Invalid linkset %s. Should be a number %d to %d\n",
a->argv[3], 1,
NUM_SPANS);
17998 if (!linksets[linkset-1].
ss7.ss7) {
17999 ast_cli(
a->fd,
"No SS7 running on linkset %d\n", linkset);
18002 ss7 = &linksets[linkset-1].ss7;
18004 if (
a->argc == 5) {
18005 dpc = atoi(
a->argv[4]);
18007 ast_cli(
a->fd,
"Invalid DPC specified!\n");
18012 ast_cli(
a->fd,
FORMAT,
"CIC",
"DPC",
"DAHDI",
"STATE",
"BLOCKING");
18014 for (i = 0; i <
ss7->numchans; i++) {
18015 if (!dpc || (
ss7->pvts[i] &&
ss7->pvts[i]->dpc == dpc)) {
18023 state =
"NotInServ";
18029 strcpy(blocking,
"L:");
18031 strcat(blocking,
"M");
18033 strcat(blocking,
" ");
18037 strcat(blocking,
"H");
18039 strcat(blocking,
" ");
18042 strcpy(blocking,
" ");
18046 strcat(blocking,
" R:");
18048 strcat(blocking,
"M");
18050 strcat(blocking,
" ");
18054 strcat(blocking,
"H");
18056 strcat(blocking,
" ");
18070#if defined(HAVE_SS7)
18075 e->
command =
"ss7 show version";
18077 "Usage: ss7 show version\n"
18078 " Show the libss7 version\n";
18084 ast_cli(
a->fd,
"libss7 version: %s\n", ss7_get_version());
18090#if defined(HAVE_SS7)
18092 AST_CLI_DEFINE(handle_ss7_debug,
"Enables SS7 debugging on a linkset"),
18093 AST_CLI_DEFINE(handle_ss7_cic_blocking,
"Blocks/Unblocks the given CIC"),
18094 AST_CLI_DEFINE(handle_ss7_linkset_mng,
"Resets/Blocks/Unblocks all CICs on a linkset"),
18095 AST_CLI_DEFINE(handle_ss7_group_blocking,
"Blocks/Unblocks the given CIC range"),
18097 AST_CLI_DEFINE(handle_ss7_group_reset,
"Resets the given CIC range"),
18100 AST_CLI_DEFINE(handle_ss7_show_linkset,
"Shows the status of a linkset"),
18101 AST_CLI_DEFINE(handle_ss7_show_channels,
"Displays SS7 channel information"),
18108#if defined(HAVE_PRI)
18109#if defined(HAVE_PRI_CCSS)
18156#if defined(HAVE_PRI)
18157#if defined(HAVE_PRI_CCSS)
18169static void dahdi_pri_cc_agent_destructor(
struct ast_cc_agent *agent)
18178#if defined(HAVE_PRI)
18179#if defined(HAVE_PRI_CCSS)
18181 .
type = dahdi_pri_cc_type,
18182 .init = dahdi_pri_cc_agent_init,
18191 .destructor = dahdi_pri_cc_agent_destructor,
18196#if defined(HAVE_PRI)
18197#if defined(HAVE_PRI_CCSS)
18199 .
type = dahdi_pri_cc_type,
18213#if defined(HAVE_PRI) || defined(HAVE_SS7)
18220 pthread_cancel(pris[i].pri.
master);
18221 pthread_kill(pris[i].pri.
master, SIGURG);
18226#ifdef HAVE_PRI_PROG_W_CAUSE
18230#if defined(HAVE_SS7)
18233 pthread_cancel(linksets[i].ss7.
master);
18234 pthread_kill(linksets[i].ss7.
master, SIGURG);
18239#if defined(HAVE_OPENR2)
18240 dahdi_r2_destroy_links();
18256#if defined(HAVE_PRI)
18283#if defined(HAVE_PRI)
18289 dahdi_close_pri_fd(&(pris[i]), j);
18293#if defined(HAVE_PRI_CCSS)
18300#if defined(HAVE_SS7)
18306 dahdi_close_ss7_fd(&(linksets[i]), j);
18308 if (linksets[i].ss7.
ss7) {
18309 ss7_destroy(linksets[i].ss7.
ss7);
18310 linksets[i].ss7.ss7 =
NULL;
18326#if defined(HAVE_PRI) || defined(HAVE_SS7)
18333#if defined(HAVE_SS7)
18343 int x, start, finish;
18346 if ((
reload == 0) && (
conf->chan.sig < 0) && !
conf->is_sig_auto) {
18347 ast_log(
LOG_ERROR,
"Signalling must be specified before any channels are.\n");
18353 while ((chan =
strsep(&
c,
","))) {
18354 if (sscanf(chan,
"%30d-%30d", &start, &finish) == 2) {
18356 }
else if (sscanf(chan,
"%30d", &start)) {
18359 }
else if (!strcasecmp(chan,
"pseudo")) {
18365 if (finish < start) {
18372 for (x = start; x <= finish; x++) {
18373 if (
conf->wanted_channels_start &&
18374 (x < conf->wanted_channels_start ||
18375 x >
conf->wanted_channels_end)
18385 (
reload == 1) ?
"reconfigure" :
"register",
value);
18399#define MAX_CHANLIST_LEN 80
18404 char *
params[DAHDI_MAX_ECHOCANPARAMS + 1];
18405 unsigned int param_count;
18417 if ((x == 32) || (x == 64) || (x == 128) || (x == 256) || (x == 512) || (x == 1024))
18424 for (x = 1; x < param_count; x++) {
18431 ast_log(
LOG_WARNING,
"Invalid echocancel parameter supplied at line %u: '%s'\n", line, params[x]);
18436 ast_log(
LOG_WARNING,
"Invalid echocancel parameter supplied at line %u: '%s'\n", line, param.name);
18444 ast_log(
LOG_WARNING,
"Invalid echocancel parameter value supplied at line %u: '%s'\n", line, param.value);
18452#if defined(HAVE_PRI)
18453#if defined(HAVE_PRI_DISPLAY_TEXT)
18463static unsigned long dahdi_display_text_option(
const char *
value)
18473 opt_str =
strsep(&val_str,
",");
18482 if (!strcasecmp(opt_str,
"block")) {
18483 options |= PRI_DISPLAY_OPTION_BLOCK;
18484 }
else if (!strcasecmp(opt_str,
"name_initial")) {
18485 options |= PRI_DISPLAY_OPTION_NAME_INITIAL;
18486 }
else if (!strcasecmp(opt_str,
"name_update")) {
18487 options |= PRI_DISPLAY_OPTION_NAME_UPDATE;
18488 }
else if (!strcasecmp(opt_str,
"name")) {
18489 options |= (PRI_DISPLAY_OPTION_NAME_INITIAL | PRI_DISPLAY_OPTION_NAME_UPDATE);
18490 }
else if (!strcasecmp(opt_str,
"text")) {
18491 options |= PRI_DISPLAY_OPTION_TEXT;
18499#if defined(HAVE_PRI)
18500#if defined(HAVE_PRI_DATETIME_SEND)
18510static int dahdi_datetime_send_option(
const char *
value)
18514 option = PRI_DATE_TIME_SEND_DEFAULT;
18517 option = PRI_DATE_TIME_SEND_NO;
18518 }
else if (!strcasecmp(
value,
"date")) {
18519 option = PRI_DATE_TIME_SEND_DATE;
18520 }
else if (!strcasecmp(
value,
"date_hh")) {
18521 option = PRI_DATE_TIME_SEND_DATE_HH;
18522 }
else if (!strcasecmp(
value,
"date_hhmm")) {
18523 option = PRI_DATE_TIME_SEND_DATE_HHMM;
18524 }
else if (!strcasecmp(
value,
"date_hhmmss")) {
18525 option = PRI_DATE_TIME_SEND_DATE_HHMMSS;
18534#define PROC_DAHDI_OPT_NOCHAN (1 << 0)
18536#define PROC_DAHDI_OPT_NOWARN (1 << 1)
18540 int count_pattern = 0;
18546 if (!sscanf(v->
value,
"%30d", &norval) && count_pattern == 0) {
18547 ast_log(
LOG_ERROR,
"busypattern= expects either busypattern=tonelength,quietlength or busypattern=t1length, q1length, t2length, q2length at line %d.\n", v->
lineno);
18551 busy_cadence->
pattern[count_pattern] = norval;
18554 if (count_pattern == 4) {
18558 temp = strchr(v->
value,
',');
18559 if (temp ==
NULL) {
18562 v->
value = temp + 1;
18564 busy_cadence->
length = count_pattern;
18566 if (count_pattern % 2 != 0) {
18568 ast_log(
LOG_ERROR,
"busypattern= expects either busypattern=tonelength,quietlength or busypattern=t1length, q1length, t2length, q2length at line %d.\n", v->
lineno);
18582 for (; v; v = v->
next) {
18587 if (!strcasecmp(v->
name,
"channel") || !strcasecmp(v->
name,
"channels")) {
18601 }
else if (!strcasecmp(v->
name,
"ignore_failed_channels")) {
18603 }
else if (!strcasecmp(v->
name,
"buffers")) {
18609 }
else if (!strcasecmp(v->
name,
"faxbuffers")) {
18613 }
else if (!strcasecmp(v->
name,
"dahdichan")) {
18616 }
else if (!strcasecmp(v->
name,
"usedistinctiveringdetection")) {
18618 }
else if (!strcasecmp(v->
name,
"distinctiveringaftercid")) {
18620 }
else if (!strcasecmp(v->
name,
"dring1context")) {
18622 }
else if (!strcasecmp(v->
name,
"dring2context")) {
18624 }
else if (!strcasecmp(v->
name,
"dring3context")) {
18626 }
else if (!strcasecmp(v->
name,
"dring1range")) {
18628 }
else if (!strcasecmp(v->
name,
"dring2range")) {
18630 }
else if (!strcasecmp(v->
name,
"dring3range")) {
18632 }
else if (!strcasecmp(v->
name,
"dring1")) {
18634 }
else if (!strcasecmp(v->
name,
"dring2")) {
18636 }
else if (!strcasecmp(v->
name,
"dring3")) {
18638 }
else if (!strcasecmp(v->
name,
"usecallerid")) {
18640 }
else if (!strcasecmp(v->
name,
"cidsignalling")) {
18641 if (!strcasecmp(v->
value,
"bell"))
18643 else if (!strcasecmp(v->
value,
"v23"))
18645 else if (!strcasecmp(v->
value,
"dtmf"))
18647 else if (!strcasecmp(v->
value,
"smdi"))
18649 else if (!strcasecmp(v->
value,
"v23_jp"))
18653 }
else if (!strcasecmp(v->
name,
"cidstart")) {
18654 if (!strcasecmp(v->
value,
"ring"))
18656 else if (!strcasecmp(v->
value,
"polarity_in"))
18658 else if (!strcasecmp(v->
value,
"polarity"))
18660 else if (!strcasecmp(v->
value,
"dtmf"))
18664 }
else if (!strcasecmp(v->
name,
"threewaycalling")) {
18666 }
else if (!strcasecmp(v->
name,
"threewaysilenthold")) {
18668 }
else if (!strcasecmp(v->
name,
"cancallforward")) {
18670 }
else if (!strcasecmp(v->
name,
"relaxdtmf")) {
18675 }
else if (!strcasecmp(v->
name,
"mailbox")) {
18677 }
else if (!strcasecmp(v->
name,
"description")) {
18679 }
else if (!strcasecmp(v->
name,
"hasvoicemail")) {
18685 if (strchr(cat,
'@')) {
18689 "%s@default", cat);
18692 }
else if (!strcasecmp(v->
name,
"adsi")) {
18694 }
else if (!strcasecmp(v->
name,
"usesmdi")) {
18696 }
else if (!strcasecmp(v->
name,
"smdiport")) {
18698 }
else if (!strcasecmp(v->
name,
"transfer")) {
18700 }
else if (!strcasecmp(v->
name,
"canpark")) {
18702 }
else if (!strcasecmp(v->
name,
"echocancelwhenbridged")) {
18704 }
else if (!strcasecmp(v->
name,
"busydetect")) {
18706 }
else if (!strcasecmp(v->
name,
"busycount")) {
18708 }
else if (!strcasecmp(v->
name,
"busypattern")) {
18710 }
else if (!strcasecmp(v->
name,
"calledsubscriberheld")) {
18712 }
else if (!strcasecmp(v->
name,
"lastnumredial")) {
18714 }
else if (!strcasecmp(v->
name,
"callprogress")) {
18718 }
else if (!strcasecmp(v->
name,
"waitfordialtone")) {
18720 }
else if (!strcasecmp(v->
name,
"dialtone_detect")) {
18721 if (!strcasecmp(v->
value,
"always")) {
18730 }
else if (!strcasecmp(v->
name,
"faxdetect")) {
18732 if (!strcasecmp(v->
value,
"incoming")) {
18734 }
else if (!strcasecmp(v->
value,
"outgoing")) {
18738 }
else if (!strcasecmp(v->
name,
"faxdetect_timeout")) {
18742 }
else if (!strcasecmp(v->
name,
"firstdigit_timeout")) {
18747 }
else if (!strcasecmp(v->
name,
"interdigit_timeout")) {
18752 }
else if (!strcasecmp(v->
name,
"matchdigit_timeout")) {
18757 }
else if (!strcasecmp(v->
name,
"echocancel")) {
18759 }
else if (!strcasecmp(v->
name,
"echotraining")) {
18760 if (sscanf(v->
value,
"%30d", &y) == 1) {
18761 if ((y < 10) || (y > 4000)) {
18770 }
else if (!strcasecmp(v->
name,
"hidecallerid")) {
18772 }
else if (!strcasecmp(v->
name,
"hidecalleridname")) {
18774 }
else if (!strcasecmp(v->
name,
"pulsedial")) {
18776 }
else if (!strcasecmp(v->
name,
"callreturn")) {
18778 }
else if (!strcasecmp(v->
name,
"callwaiting")) {
18780 }
else if (!strcasecmp(v->
name,
"callwaitingcallerid")) {
18782 }
else if (!strcasecmp(v->
name,
"callwaitingdeluxe")) {
18784 }
else if (!strcasecmp(v->
name,
"context")) {
18786 }
else if (!strcasecmp(v->
name,
"language")) {
18788 }
else if (!strcasecmp(v->
name,
"progzone")) {
18790 }
else if (!strcasecmp(v->
name,
"mohinterpret")
18791 ||!strcasecmp(v->
name,
"musiconhold") || !strcasecmp(v->
name,
"musicclass")) {
18793 }
else if (!strcasecmp(v->
name,
"mohsuggest")) {
18795 }
else if (!strcasecmp(v->
name,
"parkinglot")) {
18797 }
else if (!strcasecmp(v->
name,
"stripmsd")) {
18798 ast_log(
LOG_NOTICE,
"Configuration option \"%s\" has been deprecated. Please use dialplan instead\n", v->
name);
18800 }
else if (!strcasecmp(v->
name,
"jitterbuffers")) {
18802 }
else if (!strcasecmp(v->
name,
"group")) {
18804 }
else if (!strcasecmp(v->
name,
"callgroup")) {
18808 if (!strcasecmp(v->
value,
"none"))
18812 }
else if (!strcasecmp(v->
name,
"pickupgroup")) {
18816 if (!strcasecmp(v->
value,
"none"))
18820 }
else if (!strcasecmp(v->
name,
"namedcallgroup")) {
18822 ast_log(
LOG_WARNING,
"Only FXO signalled channels may belong to a named call group\n");
18825 }
else if (!strcasecmp(v->
name,
"namedpickupgroup")) {
18827 ast_log(
LOG_WARNING,
"Only FXO signalled channels may belong to a named pickup group\n");
18830 }
else if (!strcasecmp(v->
name,
"setvar")) {
18832 char *varval =
NULL;
18834 char varname[strlen(v->
value) + 1];
18835 strcpy(varname, v->
value);
18836 if ((varval = strchr(varname,
'='))) {
18846 }
else if (!strcasecmp(v->
name,
"immediate")) {
18848 }
else if (!strcasecmp(v->
name,
"immediatering")) {
18850 }
else if (!strcasecmp(v->
name,
"transfertobusy")) {
18852 }
else if (!strcasecmp(v->
name,
"dialmode")) {
18853 if (!strcasecmp(v->
value,
"pulse")) {
18855 }
else if (!strcasecmp(v->
value,
"dtmf") || !strcasecmp(v->
value,
"tone")) {
18857 }
else if (!strcasecmp(v->
value,
"none")) {
18862 }
else if (!strcasecmp(v->
name,
"mwimonitor")) {
18879 }
else if (!strcasecmp(v->
name,
"hwrxgain")) {
18881 if (strcasecmp(v->
value,
"disabled")) {
18888 }
else if (!strcasecmp(v->
name,
"hwtxgain")) {
18890 if (strcasecmp(v->
value,
"disabled")) {
18897 }
else if (!strcasecmp(v->
name,
"cid_rxgain")) {
18901 }
else if (!strcasecmp(v->
name,
"rxgain")) {
18905 }
else if (!strcasecmp(v->
name,
"txgain")) {
18909 }
else if (!strcasecmp(v->
name,
"txdrc")) {
18913 }
else if (!strcasecmp(v->
name,
"rxdrc")) {
18917 }
else if (!strcasecmp(v->
name,
"tonezone")) {
18921 }
else if (!strcasecmp(v->
name,
"callerid")) {
18922 if (!strcasecmp(v->
value,
"asreceived")) {
18928 }
else if (!strcasecmp(v->
name,
"fullname")) {
18930 }
else if (!strcasecmp(v->
name,
"cid_number")) {
18932 }
else if (!strcasecmp(v->
name,
"cid_tag")) {
18934 }
else if (!strcasecmp(v->
name,
"useincomingcalleridondahditransfer")) {
18936 }
else if (!strcasecmp(v->
name,
"restrictcid")) {
18938 }
else if (!strcasecmp(v->
name,
"usecallingpres")) {
18940 }
else if (!strcasecmp(v->
name,
"accountcode")) {
18942 }
else if (!strcasecmp(v->
name,
"amaflags")) {
18948 }
else if (!strcasecmp(v->
name,
"polarityonanswerdelay")) {
18950 }
else if (!strcasecmp(v->
name,
"answeronpolarityswitch")) {
18952 }
else if (!strcasecmp(v->
name,
"ani_info_digits")) {
18954 }
else if (!strcasecmp(v->
name,
"ani_wink_time")) {
18956 }
else if (!strcasecmp(v->
name,
"ani_timeout")) {
18958 }
else if (!strcasecmp(v->
name,
"hanguponpolarityswitch")) {
18960 }
else if (!strcasecmp(v->
name,
"autoreoriginate")) {
18962 }
else if (!strcasecmp(v->
name,
"sendcalleridafter")) {
18964 }
else if (!strcasecmp(v->
name,
"mwimonitornotify")) {
18968 }
else if (!strcasecmp(v->
name,
"mwisendtype")) {
18969#ifndef HAVE_DAHDI_LINEREVERSE_VMWI
18970 if (!strcasecmp(v->
value,
"rpas")) {
18977 memset(&confp->
chan.mwisend_setting, 0,
sizeof(confp->
chan.mwisend_setting));
18979 confp->
chan.mwisend_fsk = 0;
18981 confp->
chan.mwisend_fsk = 1;
18984 confp->
chan.mwisend_rpas = 1;
18986 confp->
chan.mwisend_rpas = 0;
18989 confp->
chan.mwisend_setting.vmwi_type |= DAHDI_VMWI_LREV;
18992 confp->
chan.mwisend_setting.vmwi_type |= DAHDI_VMWI_HVDC;
18995 confp->
chan.mwisend_setting.vmwi_type |= DAHDI_VMWI_HVAC;
18998 }
else if (
reload != 1) {
18999 if (!strcasecmp(v->
name,
"signalling") || !strcasecmp(v->
name,
"signaling")) {
19007 if (!strcasecmp(v->
value,
"em")) {
19009 }
else if (!strcasecmp(v->
value,
"em_e1")) {
19011 }
else if (!strcasecmp(v->
value,
"em_w")) {
19013 }
else if (!strcasecmp(v->
value,
"fxs_ls")) {
19015 }
else if (!strcasecmp(v->
value,
"fxs_gs")) {
19017 }
else if (!strcasecmp(v->
value,
"fxs_ks")) {
19019 }
else if (!strcasecmp(v->
value,
"fxo_ls")) {
19021 }
else if (!strcasecmp(v->
value,
"fxo_gs")) {
19023 }
else if (!strcasecmp(v->
value,
"fxo_ks")) {
19025 }
else if (!strcasecmp(v->
value,
"fxs_rx")) {
19028 }
else if (!strcasecmp(v->
value,
"fxo_rx")) {
19031 }
else if (!strcasecmp(v->
value,
"fxs_tx")) {
19034 }
else if (!strcasecmp(v->
value,
"fxo_tx")) {
19037 }
else if (!strcasecmp(v->
value,
"em_rx")) {
19040 }
else if (!strcasecmp(v->
value,
"em_tx")) {
19043 }
else if (!strcasecmp(v->
value,
"em_rxtx")) {
19046 }
else if (!strcasecmp(v->
value,
"em_txrx")) {
19049 }
else if (!strcasecmp(v->
value,
"sf")) {
19051 }
else if (!strcasecmp(v->
value,
"sf_w")) {
19053 }
else if (!strcasecmp(v->
value,
"sf_featd")) {
19055 }
else if (!strcasecmp(v->
value,
"sf_featdmf")) {
19057 }
else if (!strcasecmp(v->
value,
"sf_featb")) {
19059 }
else if (!strcasecmp(v->
value,
"sf")) {
19061 }
else if (!strcasecmp(v->
value,
"sf_rx")) {
19064 }
else if (!strcasecmp(v->
value,
"sf_tx")) {
19067 }
else if (!strcasecmp(v->
value,
"sf_rxtx")) {
19070 }
else if (!strcasecmp(v->
value,
"sf_txrx")) {
19073 }
else if (!strcasecmp(v->
value,
"featd")) {
19075 }
else if (!strcasecmp(v->
value,
"featdmf")) {
19077 }
else if (!strcasecmp(v->
value,
"featdmf_ta")) {
19079 }
else if (!strcasecmp(v->
value,
"e911")) {
19081 }
else if (!strcasecmp(v->
value,
"fgccama")) {
19083 }
else if (!strcasecmp(v->
value,
"fgccamamf")) {
19085 }
else if (!strcasecmp(v->
value,
"featb")) {
19088 }
else if (!strcasecmp(v->
value,
"pri_net")) {
19090 confp->pri.pri.nodetype = PRI_NETWORK;
19091 }
else if (!strcasecmp(v->
value,
"pri_cpe")) {
19093 confp->pri.pri.nodetype = PRI_CPE;
19094 }
else if (!strcasecmp(v->
value,
"bri_cpe")) {
19096 confp->pri.pri.nodetype = PRI_CPE;
19097 }
else if (!strcasecmp(v->
value,
"bri_net")) {
19099 confp->pri.pri.nodetype = PRI_NETWORK;
19100 }
else if (!strcasecmp(v->
value,
"bri_cpe_ptmp")) {
19102 confp->pri.pri.nodetype = PRI_CPE;
19103 }
else if (!strcasecmp(v->
value,
"bri_net_ptmp")) {
19104#if defined(HAVE_PRI_CALL_HOLD)
19106 confp->pri.pri.nodetype = PRI_NETWORK;
19108 ast_log(
LOG_WARNING,
"How cool would it be if someone implemented this mode! For now, sucks for you. (line %d)\n", v->
lineno);
19111#if defined(HAVE_SS7)
19112 }
else if (!strcasecmp(v->
value,
"ss7")) {
19116 }
else if (!strcasecmp(v->
value,
"mfcr2")) {
19119 }
else if (!strcasecmp(v->
value,
"auto")) {
19127 }
else if (!strcasecmp(v->
name,
"outsignalling") || !strcasecmp(v->
name,
"outsignaling")) {
19128 if (!strcasecmp(v->
value,
"em")) {
19130 }
else if (!strcasecmp(v->
value,
"em_e1")) {
19132 }
else if (!strcasecmp(v->
value,
"em_w")) {
19134 }
else if (!strcasecmp(v->
value,
"sf")) {
19136 }
else if (!strcasecmp(v->
value,
"sf_w")) {
19138 }
else if (!strcasecmp(v->
value,
"sf_featd")) {
19140 }
else if (!strcasecmp(v->
value,
"sf_featdmf")) {
19142 }
else if (!strcasecmp(v->
value,
"sf_featb")) {
19144 }
else if (!strcasecmp(v->
value,
"sf")) {
19146 }
else if (!strcasecmp(v->
value,
"featd")) {
19148 }
else if (!strcasecmp(v->
value,
"featdmf")) {
19150 }
else if (!strcasecmp(v->
value,
"featdmf_ta")) {
19152 }
else if (!strcasecmp(v->
value,
"e911")) {
19154 }
else if (!strcasecmp(v->
value,
"fgccama")) {
19156 }
else if (!strcasecmp(v->
value,
"fgccamamf")) {
19158 }
else if (!strcasecmp(v->
value,
"featb")) {
19164 }
else if (!strcasecmp(v->
name,
"pridialplan")) {
19165 if (!strcasecmp(v->
value,
"national")) {
19166 confp->pri.pri.dialplan = PRI_NATIONAL_ISDN + 1;
19167 }
else if (!strcasecmp(v->
value,
"unknown")) {
19168 confp->pri.pri.dialplan = PRI_UNKNOWN + 1;
19169 }
else if (!strcasecmp(v->
value,
"private")) {
19170 confp->pri.pri.dialplan = PRI_PRIVATE + 1;
19171 }
else if (!strcasecmp(v->
value,
"international")) {
19172 confp->pri.pri.dialplan = PRI_INTERNATIONAL_ISDN + 1;
19173 }
else if (!strcasecmp(v->
value,
"local")) {
19174 confp->pri.pri.dialplan = PRI_LOCAL_ISDN + 1;
19175 }
else if (!strcasecmp(v->
value,
"dynamic")) {
19176 confp->pri.pri.dialplan = -1;
19177 }
else if (!strcasecmp(v->
value,
"redundant")) {
19178 confp->pri.pri.dialplan = -2;
19182 }
else if (!strcasecmp(v->
name,
"prilocaldialplan")) {
19183 if (!strcasecmp(v->
value,
"national")) {
19184 confp->pri.pri.localdialplan = PRI_NATIONAL_ISDN + 1;
19185 }
else if (!strcasecmp(v->
value,
"unknown")) {
19186 confp->pri.pri.localdialplan = PRI_UNKNOWN + 1;
19187 }
else if (!strcasecmp(v->
value,
"private")) {
19188 confp->pri.pri.localdialplan = PRI_PRIVATE + 1;
19189 }
else if (!strcasecmp(v->
value,
"international")) {
19190 confp->pri.pri.localdialplan = PRI_INTERNATIONAL_ISDN + 1;
19191 }
else if (!strcasecmp(v->
value,
"local")) {
19192 confp->pri.pri.localdialplan = PRI_LOCAL_ISDN + 1;
19193 }
else if (!strcasecmp(v->
value,
"from_channel")) {
19194 confp->pri.pri.localdialplan = 0;
19195 }
else if (!strcasecmp(v->
value,
"dynamic")) {
19196 confp->pri.pri.localdialplan = -1;
19197 }
else if (!strcasecmp(v->
value,
"redundant")) {
19198 confp->pri.pri.localdialplan = -2;
19202 }
else if (!strcasecmp(v->
name,
"pricpndialplan")) {
19203 if (!strcasecmp(v->
value,
"national")) {
19204 confp->pri.pri.cpndialplan = PRI_NATIONAL_ISDN + 1;
19205 }
else if (!strcasecmp(v->
value,
"unknown")) {
19206 confp->pri.pri.cpndialplan = PRI_UNKNOWN + 1;
19207 }
else if (!strcasecmp(v->
value,
"private")) {
19208 confp->pri.pri.cpndialplan = PRI_PRIVATE + 1;
19209 }
else if (!strcasecmp(v->
value,
"international")) {
19210 confp->pri.pri.cpndialplan = PRI_INTERNATIONAL_ISDN + 1;
19211 }
else if (!strcasecmp(v->
value,
"local")) {
19212 confp->pri.pri.cpndialplan = PRI_LOCAL_ISDN + 1;
19213 }
else if (!strcasecmp(v->
value,
"from_channel")) {
19214 confp->pri.pri.cpndialplan = 0;
19215 }
else if (!strcasecmp(v->
value,
"dynamic")) {
19216 confp->pri.pri.cpndialplan = -1;
19217 }
else if (!strcasecmp(v->
value,
"redundant")) {
19218 confp->pri.pri.cpndialplan = -2;
19222 }
else if (!strcasecmp(v->
name,
"switchtype")) {
19223 if (!strcasecmp(v->
value,
"national"))
19224 confp->pri.pri.switchtype = PRI_SWITCH_NI2;
19225 else if (!strcasecmp(v->
value,
"ni1"))
19226 confp->pri.pri.switchtype = PRI_SWITCH_NI1;
19227 else if (!strcasecmp(v->
value,
"dms100"))
19228 confp->pri.pri.switchtype = PRI_SWITCH_DMS100;
19229 else if (!strcasecmp(v->
value,
"4ess"))
19230 confp->pri.pri.switchtype = PRI_SWITCH_ATT4ESS;
19231 else if (!strcasecmp(v->
value,
"5ess"))
19232 confp->pri.pri.switchtype = PRI_SWITCH_LUCENT5E;
19233 else if (!strcasecmp(v->
value,
"euroisdn"))
19234 confp->pri.pri.switchtype = PRI_SWITCH_EUROISDN_E1;
19235 else if (!strcasecmp(v->
value,
"qsig"))
19236 confp->pri.pri.switchtype = PRI_SWITCH_QSIG;
19241 }
else if (!strcasecmp(v->
name,
"msn")) {
19243 sizeof(confp->pri.pri.msn_list));
19244 }
else if (!strcasecmp(v->
name,
"nsf")) {
19245 if (!strcasecmp(v->
value,
"sdn"))
19246 confp->pri.pri.nsf = PRI_NSF_SDN;
19247 else if (!strcasecmp(v->
value,
"megacom"))
19248 confp->pri.pri.nsf = PRI_NSF_MEGACOM;
19249 else if (!strcasecmp(v->
value,
"tollfreemegacom"))
19250 confp->pri.pri.nsf = PRI_NSF_TOLL_FREE_MEGACOM;
19251 else if (!strcasecmp(v->
value,
"accunet"))
19252 confp->pri.pri.nsf = PRI_NSF_ACCUNET;
19253 else if (!strcasecmp(v->
value,
"none"))
19254 confp->pri.pri.nsf = PRI_NSF_NONE;
19257 confp->pri.pri.nsf = PRI_NSF_NONE;
19259 }
else if (!strcasecmp(v->
name,
"priindication")) {
19260 if (!strcasecmp(v->
value,
"outofband"))
19262 else if (!strcasecmp(v->
value,
"inband"))
19265 ast_log(
LOG_WARNING,
"'%s' is not a valid pri indication value, should be 'inband' or 'outofband' at line %d.\n",
19267 }
else if (!strcasecmp(v->
name,
"priexclusive")) {
19269 }
else if (!strcasecmp(v->
name,
"internationalprefix")) {
19270 ast_copy_string(confp->pri.pri.internationalprefix, v->
value,
sizeof(confp->pri.pri.internationalprefix));
19271 }
else if (!strcasecmp(v->
name,
"nationalprefix")) {
19272 ast_copy_string(confp->pri.pri.nationalprefix, v->
value,
sizeof(confp->pri.pri.nationalprefix));
19273 }
else if (!strcasecmp(v->
name,
"localprefix")) {
19275 }
else if (!strcasecmp(v->
name,
"privateprefix")) {
19276 ast_copy_string(confp->pri.pri.privateprefix, v->
value,
sizeof(confp->pri.pri.privateprefix));
19277 }
else if (!strcasecmp(v->
name,
"unknownprefix")) {
19278 ast_copy_string(confp->pri.pri.unknownprefix, v->
value,
sizeof(confp->pri.pri.unknownprefix));
19279 }
else if (!strcasecmp(v->
name,
"resetinterval")) {
19280 if (!strcasecmp(v->
value,
"never"))
19281 confp->pri.pri.resetinterval = -1;
19282 else if (atoi(v->
value) >= 60)
19283 confp->pri.pri.resetinterval = atoi(v->
value);
19285 ast_log(
LOG_WARNING,
"'%s' is not a valid reset interval, should be >= 60 seconds or 'never' at line %d.\n",
19287 }
else if (!strcasecmp(v->
name,
"force_restart_unavailable_chans")) {
19288 confp->pri.pri.force_restart_unavailable_chans =
ast_true(v->
value);
19289 }
else if (!strcasecmp(v->
name,
"minunused")) {
19290 confp->pri.pri.minunused = atoi(v->
value);
19291 }
else if (!strcasecmp(v->
name,
"minidle")) {
19292 confp->pri.pri.minidle = atoi(v->
value);
19293 }
else if (!strcasecmp(v->
name,
"idleext")) {
19295 }
else if (!strcasecmp(v->
name,
"idledial")) {
19297 }
else if (!strcasecmp(v->
name,
"overlapdial")) {
19300 }
else if (!strcasecmp(v->
value,
"incoming")) {
19302 }
else if (!strcasecmp(v->
value,
"outgoing")) {
19309#ifdef HAVE_PRI_PROG_W_CAUSE
19310 }
else if (!strcasecmp(v->
name,
"qsigchannelmapping")) {
19311 if (!strcasecmp(v->
value,
"logical")) {
19313 }
else if (!strcasecmp(v->
value,
"physical")) {
19319 }
else if (!strcasecmp(v->
name,
"discardremoteholdretrieval")) {
19320 confp->pri.pri.discardremoteholdretrieval =
ast_true(v->
value);
19321#if defined(HAVE_PRI_SERVICE_MESSAGES)
19322 }
else if (!strcasecmp(v->
name,
"service_message_support")) {
19324 if ((confp->pri.pri.switchtype == PRI_SWITCH_ATT4ESS
19325 || confp->pri.pri.switchtype == PRI_SWITCH_LUCENT5E
19326 || confp->pri.pri.switchtype == PRI_SWITCH_NI2) &&
ast_true(v->
value)) {
19327 confp->pri.pri.enable_service_message_support = 1;
19329 confp->pri.pri.enable_service_message_support = 0;
19332#ifdef HAVE_PRI_INBANDDISCONNECT
19333 }
else if (!strcasecmp(v->
name,
"inbanddisconnect")) {
19336 }
else if (!strcasecmp(v->
name,
"pritimer")) {
19337#ifdef PRI_GETSET_TIMERS
19348 timeridx = pri_timer2idx(timerc);
19350 if (timeridx < 0 || PRI_MAX_TIMERS <= timeridx) {
19352 "'%s' is not a valid ISDN timer at line %d.\n", timerc,
19354 }
else if (!
timer) {
19356 "'%s' is not a valid value for ISDN timer '%s' at line %d.\n",
19359 confp->pri.pri.pritimers[timeridx] =
timer;
19363 "'%s' is not a valid ISDN timer configuration string at line %d.\n",
19367 }
else if (!strcasecmp(v->
name,
"facilityenable")) {
19369#if defined(HAVE_PRI_AOC_EVENTS)
19370 }
else if (!strcasecmp(v->
name,
"aoc_enable")) {
19371 confp->pri.pri.aoc_passthrough_flag = 0;
19372 if (strchr(v->
value,
's') || strchr(v->
value,
'S')) {
19375 if (strchr(v->
value,
'd') || strchr(v->
value,
'D')) {
19378 if (strchr(v->
value,
'e') || strchr(v->
value,
'E')) {
19381 }
else if (!strcasecmp(v->
name,
"aoce_delayhangup")) {
19384#if defined(HAVE_PRI_CALL_HOLD)
19385 }
else if (!strcasecmp(v->
name,
"hold_disconnect_transfer")) {
19386 confp->pri.pri.hold_disconnect_transfer =
ast_true(v->
value);
19388 }
else if (!strcasecmp(v->
name,
"moh_signaling")
19389 || !strcasecmp(v->
name,
"moh_signalling")) {
19390 if (!strcasecmp(v->
value,
"moh")) {
19392 }
else if (!strcasecmp(v->
value,
"notify")) {
19394#if defined(HAVE_PRI_CALL_HOLD)
19395 }
else if (!strcasecmp(v->
value,
"hold")) {
19396 confp->pri.pri.moh_signaling = SIG_PRI_MOH_SIGNALING_HOLD;
19401#if defined(HAVE_PRI_CCSS)
19402 }
else if (!strcasecmp(v->
name,
"cc_ptmp_recall_mode")) {
19403 if (!strcasecmp(v->
value,
"global")) {
19404 confp->pri.pri.cc_ptmp_recall_mode = 0;
19405 }
else if (!strcasecmp(v->
value,
"specific")) {
19406 confp->pri.pri.cc_ptmp_recall_mode = 1;
19408 confp->pri.pri.cc_ptmp_recall_mode = 1;
19410 }
else if (!strcasecmp(v->
name,
"cc_qsig_signaling_link_req")) {
19411 if (!strcasecmp(v->
value,
"release")) {
19412 confp->pri.pri.cc_qsig_signaling_link_req = 0;
19413 }
else if (!strcasecmp(v->
value,
"retain")) {
19414 confp->pri.pri.cc_qsig_signaling_link_req = 1;
19415 }
else if (!strcasecmp(v->
value,
"do_not_care")) {
19416 confp->pri.pri.cc_qsig_signaling_link_req = 2;
19418 confp->pri.pri.cc_qsig_signaling_link_req = 1;
19420 }
else if (!strcasecmp(v->
name,
"cc_qsig_signaling_link_rsp")) {
19421 if (!strcasecmp(v->
value,
"release")) {
19422 confp->pri.pri.cc_qsig_signaling_link_rsp = 0;
19423 }
else if (!strcasecmp(v->
value,
"retain")) {
19424 confp->pri.pri.cc_qsig_signaling_link_rsp = 1;
19426 confp->pri.pri.cc_qsig_signaling_link_rsp = 1;
19429#if defined(HAVE_PRI_CALL_WAITING)
19430 }
else if (!strcasecmp(v->
name,
"max_call_waiting_calls")) {
19431 confp->pri.pri.max_call_waiting_calls = atoi(v->
value);
19432 if (confp->pri.pri.max_call_waiting_calls < 0) {
19434 confp->pri.pri.max_call_waiting_calls = 0;
19436 }
else if (!strcasecmp(v->
name,
"allow_call_waiting_calls")) {
19437 confp->pri.pri.allow_call_waiting_calls =
ast_true(v->
value);
19439#if defined(HAVE_PRI_MWI)
19440 }
else if (!strcasecmp(v->
name,
"mwi_mailboxes")) {
19442 sizeof(confp->pri.pri.mwi_mailboxes));
19443 }
else if (!strcasecmp(v->
name,
"mwi_vm_boxes")) {
19445 sizeof(confp->pri.pri.mwi_vm_boxes));
19446 }
else if (!strcasecmp(v->
name,
"mwi_vm_numbers")) {
19448 sizeof(confp->pri.pri.mwi_vm_numbers));
19450 }
else if (!strcasecmp(v->
name,
"append_msn_to_cid_tag")) {
19451 confp->pri.pri.append_msn_to_user_tag =
ast_true(v->
value);
19452 }
else if (!strcasecmp(v->
name,
"inband_on_setup_ack")) {
19454 }
else if (!strcasecmp(v->
name,
"inband_on_proceeding")) {
19456#if defined(HAVE_PRI_DISPLAY_TEXT)
19457 }
else if (!strcasecmp(v->
name,
"display_send")) {
19458 confp->pri.pri.display_flags_send = dahdi_display_text_option(v->
value);
19459 }
else if (!strcasecmp(v->
name,
"display_receive")) {
19460 confp->pri.pri.display_flags_receive = dahdi_display_text_option(v->
value);
19462#if defined(HAVE_PRI_MCID)
19463 }
else if (!strcasecmp(v->
name,
"mcid_send")) {
19466#if defined(HAVE_PRI_DATETIME_SEND)
19467 }
else if (!strcasecmp(v->
name,
"datetime_send")) {
19468 confp->pri.pri.datetime_send = dahdi_datetime_send_option(v->
value);
19470 }
else if (!strcasecmp(v->
name,
"layer1_presence")) {
19471 if (!strcasecmp(v->
value,
"required")) {
19472 confp->pri.pri.layer1_ignored = 0;
19473 }
else if (!strcasecmp(v->
value,
"ignore")) {
19474 confp->pri.pri.layer1_ignored = 1;
19477 confp->pri.pri.layer1_ignored = 0;
19479#if defined(HAVE_PRI_L2_PERSISTENCE)
19480 }
else if (!strcasecmp(v->
name,
"layer2_persistence")) {
19481 if (!strcasecmp(v->
value,
"keep_up")) {
19482 confp->pri.pri.l2_persistence = PRI_L2_PERSISTENCE_KEEP_UP;
19483 }
else if (!strcasecmp(v->
value,
"leave_down")) {
19484 confp->pri.pri.l2_persistence = PRI_L2_PERSISTENCE_LEAVE_DOWN;
19486 confp->pri.pri.l2_persistence = PRI_L2_PERSISTENCE_DEFAULT;
19489 }
else if (!strcasecmp(v->
name,
"colp_send")) {
19490 if (!strcasecmp(v->
value,
"block")) {
19492 }
else if (!strcasecmp(v->
value,
"connect")) {
19494 }
else if (!strcasecmp(v->
value,
"update")) {
19500#if defined(HAVE_SS7)
19501 }
else if (!strcasecmp(v->
name,
"ss7type")) {
19502 if (!strcasecmp(v->
value,
"itu")) {
19503 cur_ss7type = SS7_ITU;
19504 }
else if (!strcasecmp(v->
value,
"ansi")) {
19505 cur_ss7type = SS7_ANSI;
19509 }
else if (!strcasecmp(v->
name,
"slc")) {
19510 cur_slc = atoi(v->
value);
19511 }
else if (!strcasecmp(v->
name,
"linkset")) {
19512 cur_linkset = atoi(v->
value);
19513 }
else if (!strcasecmp(v->
name,
"pointcode")) {
19514 cur_pointcode = parse_pointcode(v->
value);
19515 }
else if (!strcasecmp(v->
name,
"adjpointcode")) {
19516 cur_adjpointcode = parse_pointcode(v->
value);
19517 }
else if (!strcasecmp(v->
name,
"defaultdpc")) {
19518 cur_defaultdpc = parse_pointcode(v->
value);
19519 }
else if (!strcasecmp(v->
name,
"cicbeginswith")) {
19520 cur_cicbeginswith = atoi(v->
value);
19521 }
else if (!strcasecmp(v->
name,
"networkindicator")) {
19522 if (!strcasecmp(v->
value,
"national")) {
19523 cur_networkindicator = SS7_NI_NAT;
19524 }
else if (!strcasecmp(v->
value,
"national_spare")) {
19525 cur_networkindicator = SS7_NI_NAT_SPARE;
19526 }
else if (!strcasecmp(v->
value,
"international")) {
19527 cur_networkindicator = SS7_NI_INT;
19528 }
else if (!strcasecmp(v->
value,
"international_spare")) {
19529 cur_networkindicator = SS7_NI_INT_SPARE;
19531 cur_networkindicator = -1;
19533 }
else if (!strcasecmp(v->
name,
"ss7_internationalprefix")) {
19534 ast_copy_string(confp->ss7.ss7.internationalprefix, v->
value,
sizeof(confp->ss7.ss7.internationalprefix));
19535 }
else if (!strcasecmp(v->
name,
"ss7_nationalprefix")) {
19536 ast_copy_string(confp->ss7.ss7.nationalprefix, v->
value,
sizeof(confp->ss7.ss7.nationalprefix));
19537 }
else if (!strcasecmp(v->
name,
"ss7_subscriberprefix")) {
19538 ast_copy_string(confp->ss7.ss7.subscriberprefix, v->
value,
sizeof(confp->ss7.ss7.subscriberprefix));
19539 }
else if (!strcasecmp(v->
name,
"ss7_unknownprefix")) {
19540 ast_copy_string(confp->ss7.ss7.unknownprefix, v->
value,
sizeof(confp->ss7.ss7.unknownprefix));
19541 }
else if (!strcasecmp(v->
name,
"ss7_networkroutedprefix")) {
19542 ast_copy_string(confp->ss7.ss7.networkroutedprefix, v->
value,
sizeof(confp->ss7.ss7.networkroutedprefix));
19543 }
else if (!strcasecmp(v->
name,
"ss7_called_nai")) {
19544 if (!strcasecmp(v->
value,
"national")) {
19545 confp->ss7.ss7.called_nai = SS7_NAI_NATIONAL;
19546 }
else if (!strcasecmp(v->
value,
"international")) {
19547 confp->ss7.ss7.called_nai = SS7_NAI_INTERNATIONAL;
19548 }
else if (!strcasecmp(v->
value,
"subscriber")) {
19549 confp->ss7.ss7.called_nai = SS7_NAI_SUBSCRIBER;
19550 }
else if (!strcasecmp(v->
value,
"unknown")) {
19551 confp->ss7.ss7.called_nai = SS7_NAI_UNKNOWN;
19552 }
else if (!strcasecmp(v->
value,
"dynamic")) {
19557 }
else if (!strcasecmp(v->
name,
"ss7_calling_nai")) {
19558 if (!strcasecmp(v->
value,
"national")) {
19559 confp->ss7.ss7.calling_nai = SS7_NAI_NATIONAL;
19560 }
else if (!strcasecmp(v->
value,
"international")) {
19561 confp->ss7.ss7.calling_nai = SS7_NAI_INTERNATIONAL;
19562 }
else if (!strcasecmp(v->
value,
"subscriber")) {
19563 confp->ss7.ss7.calling_nai = SS7_NAI_SUBSCRIBER;
19564 }
else if (!strcasecmp(v->
value,
"unknown")) {
19565 confp->ss7.ss7.calling_nai = SS7_NAI_UNKNOWN;
19566 }
else if (!strcasecmp(v->
value,
"dynamic")) {
19571 }
else if (!strcasecmp(v->
name,
"sigchan")) {
19573 sigchan = atoi(v->
value);
19574 res = linkset_addsigchan(sigchan);
19578 }
else if (!strcasecmp(v->
name,
"ss7_explicitacm")) {
19579 struct dahdi_ss7 *link;
19580 link = ss7_resolve_linkset(cur_linkset);
19588 link->ss7.flags &= ~LINKSET_FLAG_EXPLICITACM;
19590 }
else if (!strcasecmp(v->
name,
"ss7_autoacm")) {
19591 struct dahdi_ss7 *link;
19592 link = ss7_resolve_linkset(cur_linkset);
19600 link->ss7.flags &= ~LINKSET_FLAG_AUTOACM;
19602 }
else if (!strcasecmp(v->
name,
"ss7_initialhwblo")) {
19603 struct dahdi_ss7 *link;
19604 link = ss7_resolve_linkset(cur_linkset);
19612 link->ss7.flags &= ~LINKSET_FLAG_INITIALHWBLO;
19614 }
else if (!strcasecmp(v->
name,
"ss7_use_echocontrol")) {
19615 struct dahdi_ss7 *link;
19616 link = ss7_resolve_linkset(cur_linkset);
19624 link->ss7.flags &= ~LINKSET_FLAG_USEECHOCONTROL;
19626 }
else if (!strcasecmp(v->
name,
"ss7_default_echocontrol")) {
19627 struct dahdi_ss7 *link;
19628 link = ss7_resolve_linkset(cur_linkset);
19636 link->ss7.flags &= ~LINKSET_FLAG_DEFAULTECHOCONTROL;
19638 }
else if (!strncasecmp(v->
name,
"isup_timer.", 11)) {
19639 struct dahdi_ss7 *link;
19640 link = ss7_resolve_linkset(cur_linkset);
19645 if (!link->ss7.ss7) {
19647 }
else if (!ss7_set_isup_timer(link->ss7.ss7, strstr(v->
name,
".") + 1, atoi(v->
value))) {
19650 }
else if (!strncasecmp(v->
name,
"mtp3_timer.", 11)) {
19651 struct dahdi_ss7 *link;
19652 link = ss7_resolve_linkset(cur_linkset);
19657 if (!link->ss7.ss7) {
19659 }
else if (!ss7_set_mtp3_timer(link->ss7.ss7, strstr(v->
name,
".") + 1, atoi(v->
value))) {
19662 }
else if (!strcasecmp(v->
name,
"inr_if_no_calling")) {
19663 struct dahdi_ss7 *link;
19664 link = ss7_resolve_linkset(cur_linkset);
19669 if (!link->ss7.ss7) {
19672 ss7_set_flags(link->ss7.ss7, SS7_INR_IF_NO_CALLING);
19674 ss7_clear_flags(link->ss7.ss7, SS7_INR_IF_NO_CALLING);
19676 }
else if (!strcasecmp(v->
name,
"non_isdn_access")) {
19677 struct dahdi_ss7 *link;
19678 link = ss7_resolve_linkset(cur_linkset);
19683 if (!link->ss7.ss7) {
19686 ss7_clear_flags(link->ss7.ss7, SS7_ISDN_ACCESS_INDICATOR);
19688 ss7_set_flags(link->ss7.ss7, SS7_ISDN_ACCESS_INDICATOR);
19690 }
else if (!strcasecmp(v->
name,
"sls_shift")) {
19691 struct dahdi_ss7 *link;
19692 int sls_shift = atoi(v->
value);
19694 if (sls_shift < 0 || sls_shift > 7) {
19699 link = ss7_resolve_linkset(cur_linkset);
19704 if (!link->ss7.ss7) {
19707 ss7_set_sls_shift(link->ss7.ss7, sls_shift);
19709 }
else if (!strcasecmp(v->
name,
"cause_location")) {
19710 struct dahdi_ss7 *link;
19711 int cause_location = atoi(v->
value);
19713 if (cause_location < 0 || cause_location > 15) {
19714 ast_log(
LOG_ERROR,
"Invalid cause_location value. Must be between 0 and 15\n");
19717 link = ss7_resolve_linkset(cur_linkset);
19722 if (!link->ss7.ss7) {
19725 ss7_set_cause_location(link->ss7.ss7, cause_location);
19729 }
else if (!strcasecmp(v->
name,
"mfcr2_advanced_protocol_file")) {
19731 ast_log(
LOG_WARNING,
"MFC/R2 Protocol file '%s' will be used, you only should use this if you *REALLY KNOW WHAT YOU ARE DOING*.\n", confp->mfcr2.r2proto_file);
19732 }
else if (!strcasecmp(v->
name,
"mfcr2_logdir")) {
19734 }
else if (!strcasecmp(v->
name,
"mfcr2_variant")) {
19735 confp->mfcr2.variant = openr2_proto_get_variant(v->
value);
19736 if (OR2_VAR_UNKNOWN == confp->mfcr2.variant) {
19738 confp->mfcr2.variant = OR2_VAR_ITU;
19740 }
else if (!strcasecmp(v->
name,
"mfcr2_mfback_timeout")) {
19741 confp->mfcr2.mfback_timeout = atoi(v->
value);
19742 if (!confp->mfcr2.mfback_timeout) {
19743 ast_log(
LOG_WARNING,
"MF timeout of 0? hum, I will protect you from your ignorance. Setting default.\n");
19744 confp->mfcr2.mfback_timeout = -1;
19745 }
else if (confp->mfcr2.mfback_timeout > 0 && confp->mfcr2.mfback_timeout < 500) {
19746 ast_log(
LOG_WARNING,
"MF timeout less than 500ms is not recommended, you have been warned!\n");
19748 }
else if (!strcasecmp(v->
name,
"mfcr2_metering_pulse_timeout")) {
19749 confp->mfcr2.metering_pulse_timeout = atoi(v->
value);
19750 if (confp->mfcr2.metering_pulse_timeout > 500) {
19751 ast_log(
LOG_WARNING,
"Metering pulse timeout greater than 500ms is not recommended, you have been warned!\n");
19753#if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 2
19754 }
else if (!strcasecmp(v->
name,
"mfcr2_dtmf_detection")) {
19756 }
else if (!strcasecmp(v->
name,
"mfcr2_dtmf_dialing")) {
19758 }
else if (!strcasecmp(v->
name,
"mfcr2_dtmf_time_on")) {
19759 confp->mfcr2.dtmf_time_on = atoi(v->
value);
19760 }
else if (!strcasecmp(v->
name,
"mfcr2_dtmf_time_off")) {
19761 confp->mfcr2.dtmf_time_off = atoi(v->
value);
19763#if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 3
19764 }
else if (!strcasecmp(v->
name,
"mfcr2_dtmf_end_timeout")) {
19765 confp->mfcr2.dtmf_end_timeout = atoi(v->
value);
19767 }
else if (!strcasecmp(v->
name,
"mfcr2_get_ani_first")) {
19769 }
else if (!strcasecmp(v->
name,
"mfcr2_double_answer")) {
19771 }
else if (!strcasecmp(v->
name,
"mfcr2_charge_calls")) {
19773 }
else if (!strcasecmp(v->
name,
"mfcr2_accept_on_offer")) {
19775 }
else if (!strcasecmp(v->
name,
"mfcr2_allow_collect_calls")) {
19776 confp->mfcr2.allow_collect_calls =
ast_true(v->
value) ? 1 : 0;
19777 }
else if (!strcasecmp(v->
name,
"mfcr2_forced_release")) {
19779 }
else if (!strcasecmp(v->
name,
"mfcr2_immediate_accept")) {
19780 confp->mfcr2.immediate_accept =
ast_true(v->
value) ? 1 : 0;
19781#if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 1
19782 }
else if (!strcasecmp(v->
name,
"mfcr2_skip_category")) {
19783 confp->mfcr2.skip_category_request =
ast_true(v->
value) ? 1 : 0;
19785 }
else if (!strcasecmp(v->
name,
"mfcr2_call_files")) {
19787 }
else if (!strcasecmp(v->
name,
"mfcr2_max_ani")) {
19788 confp->mfcr2.max_ani = atoi(v->
value);
19792 }
else if (!strcasecmp(v->
name,
"mfcr2_max_dnis")) {
19793 confp->mfcr2.max_dnis = atoi(v->
value);
19797 }
else if (!strcasecmp(v->
name,
"mfcr2_category")) {
19798 confp->mfcr2.category = openr2_proto_get_category(v->
value);
19799 if (OR2_CALLING_PARTY_CATEGORY_UNKNOWN == confp->mfcr2.category) {
19800 confp->mfcr2.category = OR2_CALLING_PARTY_CATEGORY_NATIONAL_SUBSCRIBER;
19801 ast_log(
LOG_WARNING,
"Invalid MFC/R2 caller category '%s' at line %d. Using national subscriber as default.\n",
19804 }
else if (!strcasecmp(v->
name,
"mfcr2_logging")) {
19805 openr2_log_level_t tmplevel;
19812 clevel =
strsep(&logval,
",");
19813 if (-1 == (tmplevel = openr2_log_get_level(clevel))) {
19817 confp->mfcr2.loglevel |= tmplevel;
19820 }
else if (!strcasecmp(v->
name,
"cadence")) {
19822 int element_count,
c[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
19824 struct dahdi_ring_cadence new_cadence;
19825 int cid_location = -1;
19826 int firstcadencepos = 0;
19827 char original_args[80];
19828 int cadence_is_ok = 1;
19832 element_count = sscanf(v->
value,
"%30d,%30d,%30d,%30d,%30d,%30d,%30d,%30d,%30d,%30d,%30d,%30d,%30d,%30d,%30d,%30d", &
c[0], &
c[1], &
c[2], &
c[3], &
c[4], &
c[5], &
c[6], &
c[7], &
c[8], &
c[9], &
c[10], &
c[11], &
c[12], &
c[13], &
c[14], &
c[15]);
19835 if (element_count % 2 == 1) {
19836 ast_log(
LOG_ERROR,
"Must be a silence duration for each ring duration: %s at line %d.\n", original_args, v->
lineno);
19846 for (i = 0; i < element_count; i++) {
19848 ast_log(
LOG_ERROR,
"Ring or silence duration cannot be zero: %s at line %d.\n", original_args, v->
lineno);
19851 }
else if (
c[i] < 0) {
19854 if (cid_location == -1) {
19863 if (firstcadencepos == 0) {
19864 firstcadencepos = i;
19867 ast_log(
LOG_ERROR,
"First cadence position specified twice: %s at line %d.\n", original_args, v->
lineno);
19876 for (i = 0; i < 16; i++) {
19877 new_cadence.ringcadence[i] =
c[i];
19880 if (cadence_is_ok) {
19882 if (element_count < 2) {
19885 if (cid_location == -1) {
19890 cid_location = (cid_location + 1) / 2;
19905 }
else if (!strcasecmp(v->
name,
"ringtimeout")) {
19907 }
else if (!strcasecmp(v->
name,
"prewink")) {
19909 }
else if (!strcasecmp(v->
name,
"preflash")) {
19911 }
else if (!strcasecmp(v->
name,
"wink")) {
19913 }
else if (!strcasecmp(v->
name,
"flash")) {
19915 }
else if (!strcasecmp(v->
name,
"start")) {
19917 }
else if (!strcasecmp(v->
name,
"rxwink")) {
19919 }
else if (!strcasecmp(v->
name,
"rxflash")) {
19921 }
else if (!strcasecmp(v->
name,
"debounce")) {
19923 }
else if (!strcasecmp(v->
name,
"toneduration")) {
19927 struct dahdi_dialparams dps;
19929 ctlfd = open(
"/dev/dahdi/ctl", O_RDWR);
19935 toneduration = atoi(v->
value);
19936 if (toneduration > -1) {
19937 memset(&dps, 0,
sizeof(dps));
19939 dps.dtmf_tonelen = dps.mfv1_tonelen = toneduration;
19940 res = ioctl(ctlfd, DAHDI_SET_DIALPARAMS, &dps);
19948 }
else if (!strcasecmp(v->
name,
"defaultcic")) {
19950 }
else if (!strcasecmp(v->
name,
"defaultozz")) {
19952 }
else if (!strcasecmp(v->
name,
"mwilevel")) {
19954 }
else if (!strcasecmp(v->
name,
"dtmfcidlevel")) {
19956 }
else if (!strcasecmp(v->
name,
"reportalarms")) {
19957 if (!strcasecmp(v->
value,
"all"))
19959 if (!strcasecmp(v->
value,
"none"))
19961 else if (!strcasecmp(v->
value,
"channels"))
19963 else if (!strcasecmp(v->
value,
"spans"))
19975 "Dahdichan '%s' failure ignored: ignore_failed_channels.\n",
19993 for (tmp =
iflist, y=-1; tmp; tmp = tmp->
next) {
20011 if (
conf.chan.cc_params) {
20017 ast_verb(3,
"Automatically generated pseudo channel\n");
20081 static int had_cfg_before = 1;
20084 have_cfg_now = !!cfg;
20087 if (had_cfg_before) {
20116 have_cfg_now = !!cfg;
20118 if (had_cfg_before) {
20146 had_cfg_before = have_cfg_now;
20155 if (!strcasecmp(v->
name,
"trunkgroup")) {
20156 trunkgroup = atoi(v->
value);
20157 if (trunkgroup > 0) {
20158 if ((
c = strchr(v->
value,
','))) {
20160 memset(dchannels, 0,
sizeof(dchannels));
20162 dchannels[i] = atoi(
c + 1);
20163 if (dchannels[i] < 0) {
20164 ast_log(
LOG_WARNING,
"D-channel for trunk group %d must be a positive number at line %d of chan_dahdi.conf\n", trunkgroup, v->
lineno);
20167 c = strchr(
c + 1,
',');
20170 if (pri_create_trunkgroup(trunkgroup, dchannels)) {
20171 ast_log(
LOG_WARNING,
"Unable to create trunk group %d with Primary D-channel %d at line %d of chan_dahdi.conf\n", trunkgroup, dchannels[0], v->
lineno);
20173 ast_verb(2,
"Created trunk group %d with Primary D-channel %d and %d backup%s\n", trunkgroup, dchannels[0], i - 1, (i == 1) ?
"" :
"s");
20175 ast_log(
LOG_WARNING,
"Trunk group %d lacks any valid D-channels at line %d of chan_dahdi.conf\n", trunkgroup, v->
lineno);
20177 ast_log(
LOG_WARNING,
"Trunk group %d lacks a primary D-channel at line %d of chan_dahdi.conf\n", trunkgroup, v->
lineno);
20179 ast_log(
LOG_WARNING,
"Trunk group identifier must be a positive integer at line %d of chan_dahdi.conf\n", v->
lineno);
20180 }
else if (!strcasecmp(v->
name,
"spanmap")) {
20181 spanno = atoi(v->
value);
20183 if ((
c = strchr(v->
value,
','))) {
20184 trunkgroup = atoi(
c + 1);
20185 if (trunkgroup > 0) {
20186 if ((
c = strchr(
c + 1,
',')))
20187 logicalspan = atoi(
c + 1);
20190 if (logicalspan >= 0) {
20191 if (pri_create_spanmap(spanno - 1, trunkgroup, logicalspan)) {
20192 ast_log(
LOG_WARNING,
"Failed to map span %d to trunk group %d (logical span %d)\n", spanno, trunkgroup, logicalspan);
20194 ast_verb(2,
"Mapped span %d to trunk group %d (logical span %d)\n", spanno, trunkgroup, logicalspan);
20196 ast_log(
LOG_WARNING,
"Logical span must be a positive number, or '0' (for unspecified) at line %d of chan_dahdi.conf\n", v->
lineno);
20233 if (!strcasecmp(cat,
"general") ||
20234 !strcasecmp(cat,
"trunkgroups") ||
20235 !strcasecmp(cat,
"globals") ||
20236 !strcasecmp(cat,
"channels")) {
20269 if (!strcasecmp(cat,
"general")) {
20296 if (pris[x].pri.
pvts[0] &&
20298 prepare_pri(pris + x);
20303 ast_verb(2,
"Starting D-Channel on span %d\n", x + 1);
20308#if defined(HAVE_SS7)
20312 if (linksets[x].ss7.
ss7) {
20317 ast_verb(2,
"Starting SS7 linkset on span %d\n", x + 1);
20324 struct r2link_entry *cur;
20328 struct dahdi_mfcr2 *r2 = &cur->mfcr2;
20331 ast_log(
LOG_ERROR,
"Unable to start R2 monitor on channel group %d\n", x + 1);
20334 ast_verb(2,
"Starting R2 monitor on channel group %d\n", x + 1);
20388#if defined(HAVE_PRI) || defined(HAVE_SS7)
20409 memset(pris, 0,
sizeof(pris));
20413 pri_set_error(dahdi_pri_error);
20414 pri_set_message(dahdi_pri_message);
20416#ifdef HAVE_PRI_PROG_W_CAUSE
20419#if defined(HAVE_PRI_CCSS)
20427#
if defined(HAVE_PRI_CCSS)
20437#if defined(HAVE_SS7)
20438 memset(linksets, 0,
sizeof(linksets));
20442 ss7_set_error(dahdi_ss7_error);
20443 ss7_set_message(dahdi_ss7_message);
20462#if defined(HAVE_SS7)
20482#if defined(HAVE_PRI)
20496#define END_SILENCE_LEN 400
20497#define HEADER_MS 50
20498#define TRAILER_MS 5
20499#define HEADER_LEN ((HEADER_MS + TRAILER_MS) * 8)
20500#define ASCII_BYTES_PER_CHAR 80
20502 unsigned char *
buf,*mybuf;
20504 struct pollfd fds[1];
20505 int size,res,fd,
len,x;
20527 if ((!p->
tdd) && (!p->
mate)) {
20528#if defined(HAVE_PRI)
20529#if defined(HAVE_PRI_DISPLAY_TEXT)
20554 for (x = 0;
text[x]; x++) {
20582 fds[0].events = POLLOUT | POLLPRI;
20583 fds[0].revents = 0;
20584 res = poll(fds, 1, -1);
20590 if (fds[0].revents & POLLPRI) {
20594 if (!(fds[0].revents & POLLOUT)) {
20598 res = write(fd,
buf, size);
20637 .
requires =
"ccss",
20638 .optional_modules =
"res_smdi",
Common implementation-independent jitterbuffer stuff.
void ast_jb_configure(struct ast_channel *chan, const struct ast_jb_conf *conf)
Configures a jitterbuffer on a channel.
int ast_jb_read_conf(struct ast_jb_conf *conf, const char *varname, const char *value)
Sets jitterbuffer configuration property.
ADSI Support (built upon Caller*ID)
A-Law to Signed linear conversion.
struct sla_ringing_trunk * last
static int copy(char *infile, char *outfile)
Utility function to copy a file.
Persistent data storage (akin to *doze registry)
int ast_db_put(const char *family, const char *key, const char *value)
Store value addressed by family/key.
int ast_db_get(const char *family, const char *key, char *value, int valuelen)
Get key value specified by family/key.
int ast_db_del(const char *family, const char *key)
Delete entry in astdb.
char * strsep(char **str, const char *delims)
char * strcasestr(const char *, const char *)
Asterisk main include file. File version handling, generic pbx functions.
static struct chans chans
#define ast_alloca(size)
call __builtin_alloca to ensure we get gcc builtin semantics
#define ast_strdup(str)
A wrapper for strdup()
#define ast_strdupa(s)
duplicate a string in memory from the stack
#define ast_asprintf(ret, fmt,...)
A wrapper for asprintf()
#define ast_calloc(num, len)
A wrapper for calloc()
#define ast_malloc(len)
A wrapper for malloc()
#define ao2_ref(o, delta)
Reference/unreference an object and return the old refcount.
@ AST_BRIDGE_TRANSFER_SUCCESS
enum ast_transfer_result ast_bridge_transfer_attended(struct ast_channel *to_transferee, struct ast_channel *to_transfer_target)
Attended transfer.
void dahdi_native_unload(void)
int dahdi_native_load(const struct ast_channel_tech *tech)
Native DAHDI bridging support.
CallerID (and other GR30) management and generation Includes code and algorithms from the Zapata libr...
int ast_callerid_callwaiting_full_generate(unsigned char *buf, const char *name, const char *number, const char *ddn, int redirecting, int pres, int qualifier, struct ast_format *codec)
Generate Caller-ID spill but in a format suitable for Call Waiting(tm)'s Caller*ID(tm)
#define CID_UNKNOWN_NUMBER
int ast_gen_cas(unsigned char *outbuf, int sas, int len, struct ast_format *codec)
Generate a CAS (CPE Alert Signal) tone for 'n' samples.
int ast_callerid_full_generate(unsigned char *buf, const char *name, const char *number, const char *ddn, int redirecting, int pres, int qualifier, int format, struct ast_format *codec)
Generate Caller-ID spill from the "callerid" field of asterisk (in e-mail address like format)
int callerid_feed_jp(struct callerid_state *cid, unsigned char *ubuf, int samples, struct ast_format *codec)
Read samples into the state machine.
#define AST_PRES_USER_NUMBER_UNSCREENED
#define AST_PRES_UNAVAILABLE
int ast_callerid_vmwi_generate(unsigned char *buf, int active, int type, struct ast_format *codec, const char *name, const char *number, int flags)
Generate message waiting indicator.
#define AST_PRES_RESTRICTED
void callerid_free(struct callerid_state *cid)
This function frees callerid_state cid.
void callerid_get_with_redirecting(struct callerid_state *cid, char **name, char **number, int *flags, int *redirecting)
Extract info out of callerID state machine. Flags are listed above.
#define MAX_CALLERID_SIZE
const char * ast_redirecting_reason_name(const struct ast_party_redirecting_reason *data)
Convert redirecting reason value to text code.
void ast_shrink_phone_number(char *n)
Shrink a phone number in place to just digits (more accurately it just removes ()'s,...
int ast_callerid_callwaiting_generate(unsigned char *buf, const char *name, const char *number, struct ast_format *codec)
Generate Caller-ID spill but in a format suitable for Call Waiting(tm)'s Caller*ID(tm)
#define CID_PRIVATE_NUMBER
struct callerid_state * callerid_new(int cid_signalling)
Create a callerID state machine.
int callerid_feed(struct callerid_state *cid, unsigned char *ubuf, int samples, struct ast_format *codec)
Read samples into the state machine.
#define CID_MWI_TYPE_MDMF_FULL
void callerid_get_dtmf(char *cidstring, char *number, int *flags)
Get and parse DTMF-based callerid.
#define CID_START_POLARITY
void callerid_get(struct callerid_state *cid, char **number, char **name, int *flags)
Extract info out of callerID state machine. Flags are listed above.
#define CID_START_POLARITY_IN
int ast_callerid_split(const char *src, char *name, int namelen, char *num, int numlen)
#define CID_START_DTMF_NOALERT
Internal Asterisk hangup causes.
#define AST_CAUSE_SWITCH_CONGESTION
#define AST_CAUSE_CONGESTION
#define AST_CAUSE_UNALLOCATED
#define AST_CAUSE_INTERWORKING
#define AST_CAUSE_PROTOCOL_ERROR
#define AST_CAUSE_DESTINATION_OUT_OF_ORDER
#define AST_CAUSE_NO_USER_RESPONSE
#define AST_CAUSE_NORMAL_CIRCUIT_CONGESTION
#define AST_CAUSE_NOTDEFINED
#define AST_CAUSE_CALL_REJECTED
#define AST_CAUSE_NETWORK_OUT_OF_ORDER
#define AST_CAUSE_UNREGISTERED
#define AST_CAUSE_NO_ANSWER
#define AST_CAUSE_NORMAL_CLEARING
#define AST_CAUSE_USER_BUSY
Call Completion Supplementary Services API.
#define ast_cc_config_params_init()
Allocate and initialize an ast_cc_config_params structure.
#define AST_CC_GENERIC_MONITOR_TYPE
int ast_cc_monitor_register(const struct ast_cc_monitor_callbacks *callbacks)
Register a set of monitor callbacks with the core.
void ast_cc_config_params_destroy(struct ast_cc_config_params *params)
Free memory from CCSS configuration params.
void(* ast_cc_callback_fn)(struct ast_channel *chan, struct ast_cc_config_params *cc_params, const char *monitor_type, const char *const device_name, const char *const dialstring, void *private_data)
Callback made from ast_cc_callback for certain channel types.
int ast_cc_agent_register(const struct ast_cc_agent_callbacks *callbacks)
Register a set of agent callbacks with the core.
void ast_cc_copy_config_params(struct ast_cc_config_params *dest, const struct ast_cc_config_params *src)
copy CCSS configuration parameters from one structure to another
void ast_cc_monitor_unregister(const struct ast_cc_monitor_callbacks *callbacks)
Unregister a set of monitor callbacks with the core.
enum ast_cc_monitor_policies ast_get_cc_monitor_policy(struct ast_cc_config_params *config)
Get the cc_monitor_policy.
void ast_cc_agent_unregister(const struct ast_cc_agent_callbacks *callbacks)
Unregister a set of agent callbacks with the core.
int ast_cc_is_config_param(const char *const name)
Is this a CCSS configuration parameter?
int ast_cc_set_param(struct ast_cc_config_params *params, const char *const name, const char *value)
set a CCSS configuration parameter, given its name
static struct ao2_container * pvts
#define CALLPROGRESS_FAX_INCOMING
static int dahdi_create_channel_range(int start, int end)
static int dahdi_confmute(struct dahdi_pvt *p, int muted)
static ast_mutex_t ss_thread_lock
static int calc_energy(const unsigned char *buf, int len, struct ast_format *law)
#define CALLWAITING_SUPPRESS_SAMPLES
static int isourconf(struct dahdi_pvt *p, struct dahdi_subchannel *c)
static void release_doomed_pris(void)
static struct dahdi_pvt * round_robin[64]
static void my_set_new_owner(void *pvt, struct ast_channel *new_owner)
static int restore_gains(struct dahdi_pvt *p)
static void publish_channel_alarm_clear(int channel)
static int conf_del(struct dahdi_pvt *p, struct dahdi_subchannel *c, int index)
static char * dahdi_show_channels(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static void my_set_confirmanswer(void *pvt, int flag)
#define CIDCW_EXPIRE_SAMPLES
static int my_dahdi_write(struct dahdi_pvt *p, unsigned char *buf, int len, int idx, int linear)
static int my_callwait(void *pvt)
static int restore_conference(struct dahdi_pvt *p)
static void publish_span_alarm_clear(int span)
static ast_mutex_t iflock
Protect the interface list (of dahdi_pvt's)
static int dahdi_indicate(struct ast_channel *chan, int condition, const void *data, size_t datalen)
static void notify_message(char *mailbox, int thereornot)
Send MWI state change.
static struct dahdi_pvt * mkintf(int channel, const struct dahdi_chan_conf *conf, int reloading)
static int conf_add(struct dahdi_pvt *p, struct dahdi_subchannel *c, int index, int slavechannel)
static int unalloc_sub(struct dahdi_pvt *p, int x)
static int my_check_confirmanswer(void *pvt)
static const char *const events[]
static int reset_conf(struct dahdi_pvt *p)
static int my_is_dialing(void *pvt, enum analog_sub sub)
static int my_dial_digits(void *pvt, enum analog_sub sub, struct analog_dialoperation *dop)
static struct ast_manager_event_blob * dahdichannel_to_ami(struct stasis_message *msg)
static void my_cancel_cidspill(void *pvt)
static int isslavenative(struct dahdi_pvt *p, struct dahdi_pvt **out)
static int my_set_echocanceller(void *pvt, int enable)
static int dahdi_wink(struct dahdi_pvt *p, int index)
static char mwimonitornotify[PATH_MAX]
static char * alarm2str(int alm)
static void my_hangup_polarityswitch(void *pvt)
static int is_group_or_channel_match(struct dahdi_pvt *p, int span, ast_group_t groupmatch, int *groupmatched, int channelmatch, int *channelmatched)
static int dahdi_ring_phone(struct dahdi_pvt *p)
static char * dahdi_show_status(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
#define CALLWAITING_REPEAT_SAMPLES
static void dahdi_lock_sub_owner(struct dahdi_pvt *pvt, int sub_idx)
#define CALLPROGRESS_FAX_OUTGOING
static int dahdi_call(struct ast_channel *ast, const char *rdest, int timeout)
static int my_stop_cid_detect(void *pvt)
static int my_get_sub_fd(void *pvt, enum analog_sub sub)
static void my_set_needringing(void *pvt, int value)
static char * dahdi_destroy_channels(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static struct ast_jb_conf default_jbconf
static int dahdi_cc_callback(struct ast_channel *inbound, const char *dest, ast_cc_callback_fn callback)
Callback made when dial failed to get a channel out of dahdi_request().
static struct dahdi_pvt * find_channel_from_str(const char *channel)
static int __unload_module(void)
static void dahdi_softhangup_all(void)
static void dahdi_train_ec(struct dahdi_pvt *p)
static int build_channels(struct dahdi_chan_conf *conf, const char *value, int reload, int lineno)
static int dahdi_write(struct ast_channel *ast, struct ast_frame *frame)
static enum analog_event dahdievent_to_analogevent(int event)
static int dahdi_digit_begin(struct ast_channel *ast, char digit)
static void my_unlock_private(void *pvt)
static int dahdi_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
static void my_set_dialing(void *pvt, int is_dialing)
static void my_handle_dtmf(void *pvt, struct ast_channel *ast, enum analog_sub analog_index, struct ast_frame **dest)
static struct dahdi_pvt * fxo_pvt(struct ast_channel *chan)
Return DAHDI pivot if channel is FXO signalled.
static void publish_dnd_state(int channel, const char *status)
static int my_on_hook(void *pvt)
static int attempt_transfer(struct dahdi_pvt *p)
static int cidrings[NUM_CADENCE_MAX]
cidrings says in which pause to transmit the cid information, where the first pause is 1,...
static void my_set_pulsedial(void *pvt, int flag)
static int dahdi_digit_end(struct ast_channel *ast, char digit, unsigned int duration)
static char * dahdi_set_hwgain(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int dahdi_wait_event(int fd)
Avoid the silly dahdi_waitevent which ignores a bunch of events.
static void publish_channel_alarm(int channel, const char *alarm_txt)
static int canmatch_featurecode(const char *pickupexten, const char *exten)
static void dahdi_queue_frame(struct dahdi_pvt *p, struct ast_frame *f)
static int set_actual_gain(int fd, float rxgain, float txgain, float rxdrc, float txdrc, int law)
struct analog_callback analog_callbacks
static void dahdi_destroy_channel_range(int start, int end)
static char * dahdi_show_channel(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int my_unallocate_sub(void *pvt, enum analog_sub analogsub)
static void my_set_alarm(void *pvt, int in_alarm)
static int num_restart_pending
static int my_dsp_set_digitmode(void *pvt, enum analog_dsp_digitmode mode)
static int my_get_event(void *pvt)
static int available(struct dahdi_pvt **pvt, int is_specific_channel)
static int dahdi_devicestate(const char *data)
static int user_has_defined_cadences
static int dahdi_callwait(struct ast_channel *ast)
static void wakeup_sub(struct dahdi_pvt *p, int a)
static void my_set_callwaiting(void *pvt, int callwaiting_enable)
static int distinctiveringaftercid
static int my_is_off_hook(void *pvt)
static int mwi_send_init(struct dahdi_pvt *pvt)
static int dahdi_open(char *fn)
static void publish_dahdichannel(struct ast_channel *chan, ast_group_t group, int span, const char *dahdi_channel)
Sends a DAHDIChannel channel blob used to produce DAHDIChannel AMI messages.
static int my_check_waitingfordt(void *pvt)
static int setup_dahdi_int(int reload, struct dahdi_chan_conf *default_conf, struct dahdi_chan_conf *base_conf, struct dahdi_chan_conf *conf)
static void publish_span_alarm(int span, const char *alarm_txt)
static void my_set_outgoing(void *pvt, int is_outgoing)
static int dahdi_fake_event(struct dahdi_pvt *p, int mode)
static void my_set_inthreeway(void *pvt, enum analog_sub sub, int inthreeway)
static void destroy_dahdi_pvt(struct dahdi_pvt *pvt)
static int dahdi_hangup(struct ast_channel *ast)
static void * analog_ss_thread(void *data)
static int dahdi_sendtext(struct ast_channel *c, const char *text)
static void dahdi_ami_channel_event(struct dahdi_pvt *p, struct ast_channel *chan)
static void my_swap_subchannels(void *pvt, enum analog_sub a, struct ast_channel *ast_a, enum analog_sub b, struct ast_channel *ast_b)
#define PROC_DAHDI_OPT_NOCHAN
static void parse_busy_pattern(struct ast_variable *v, struct ast_dsp_busy_pattern *busy_cadence)
static int analogsub_to_dahdisub(enum analog_sub analogsub)
static void my_get_and_handle_alarms(void *pvt)
static void my_lock_private(void *pvt)
static int dahdi_answer(struct ast_channel *ast)
static const char tdesc[]
static void fill_txgain(struct dahdi_gains *g, float gain, float drc, int law)
static int dahdi_restart(void)
static int action_transfer(struct mansession *s, const struct message *m)
static int bump_gains(struct dahdi_pvt *p)
static void * do_monitor(void *data)
static int save_conference(struct dahdi_pvt *p)
static char * dahdi_set_dnd(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static void handle_clear_alarms(struct dahdi_pvt *p)
static int dahdi_queryoption(struct ast_channel *chan, int option, void *data, int *datalen)
static char * dahdi_sig2str(int sig)
static int dahdi_set_hook(int fd, int hs)
static int my_stop_callwait(void *pvt)
static struct ast_channel * dahdi_new_callid_clean(struct dahdi_pvt *i, int state, int startpbx, int idx, int law, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, ast_callid callid, int callid_created)
static int check_for_conference(struct dahdi_pvt *p)
static struct dahdi_ring_cadence AS_RP_cadence
static int my_distinctive_ring(struct ast_channel *chan, void *pvt, int idx, int *ringdata)
void dahdi_ec_enable(struct dahdi_pvt *p)
static int dahdi_setlinear(int dfd, int linear)
static int restart_monitor(void)
static void my_handle_notify_message(struct ast_channel *chan, void *pvt, int cid_flags, int neon_mwievent)
static int my_confmute(void *pvt, int mute)
static void * mwi_thread(void *data)
static int my_send_callerid(void *pvt, int cwcid, struct ast_party_caller *caller)
static int sigtype_to_signalling(int sigtype)
static void my_decrease_ss_count(void)
static char * handle_dahdi_show_cadences(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int has_voicemail(struct dahdi_pvt *p)
static void dahdi_iflist_extract(struct dahdi_pvt *pvt)
void dahdi_conf_update(struct dahdi_pvt *p)
static int alloc_sub(struct dahdi_pvt *p, int x)
static void my_start_polarityswitch(void *pvt)
static int digit_to_dtmfindex(char digit)
static int setup_dahdi(int reload)
STASIS_MESSAGE_TYPE_DEFN_LOCAL(dahdichannel_type,.to_ami=dahdichannel_to_ami,)
static char * dahdi_set_mwi(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int action_dahdidndon(struct mansession *s, const struct message *m)
static struct dahdi_pvt * iflist
#define NEED_MFDETECT(p)
Signaling types that need to use MF detection should be placed in this macro.
static int dahdi_setoption(struct ast_channel *chan, int option, void *data, int datalen)
static int set_actual_txgain(int fd, float gain, float drc, int law)
static int dahdi_func_write(struct ast_channel *chan, const char *function, char *data, const char *value)
static int my_wait_event(void *pvt)
static int my_getsigstr(struct ast_channel *chan, char *str, const char *term, int ms)
static struct ast_channel * my_new_analog_ast_channel(void *pvt, int state, int startpbx, enum analog_sub sub, const struct ast_channel *requestor)
static int analog_tone_to_dahditone(enum analog_tone tone)
static struct ast_str * create_channel_name(struct dahdi_pvt *i)
static int my_get_callerid(void *pvt, char *namebuf, char *numbuf, enum analog_event *ev, size_t timeout)
static int set_actual_rxgain(int fd, float gain, float drc, int law)
static int my_start(void *pvt)
static ast_mutex_t restart_lock
static struct ast_frame * dahdi_handle_event(struct ast_channel *ast)
static char defaultcic[64]
static const char config[]
static int action_dahdishowchannels(struct mansession *s, const struct message *m)
void dahdi_dtmf_detect_enable(struct dahdi_pvt *p)
static struct dahdi_pvt * find_next_iface_in_span(struct dahdi_pvt *cur)
static ast_cond_t ss_thread_complete
static void process_echocancel(struct dahdi_chan_conf *confp, const char *data, unsigned int line)
static void dahdi_iflist_insert(struct dahdi_pvt *pvt)
static struct ast_frame * dahdi_exception(struct ast_channel *ast)
static void my_answer_polarityswitch(void *pvt)
static struct ast_channel * dahdi_request(const char *type, struct ast_format_cap *cap, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *data, int *cause)
#define SMDI_MD_WAIT_TIMEOUT
static int my_have_progressdetect(void *pvt)
static char * dahdi_set_swgain(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int dahdi_func_read(struct ast_channel *chan, const char *function, char *data, char *buf, size_t len)
#define CANPROGRESSDETECT(p)
static char * dahdi_create_channels(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static void fill_rxgain(struct dahdi_gains *g, float gain, float drc, int law)
static int my_train_echocanceller(void *pvt)
static const char * event2str(int event)
#define CALLPROGRESS_PROGRESS
static void dahdi_close_sub(struct dahdi_pvt *chan_pvt, int sub_num)
static void my_set_polarity(void *pvt, int value)
void dahdi_ec_disable(struct dahdi_pvt *p)
static struct ast_frame * __dahdi_exception(struct ast_channel *ast)
static void handle_alarms(struct dahdi_pvt *p, int alms)
static void dahdi_handle_dtmf(struct ast_channel *ast, int idx, struct ast_frame **dest)
static struct dahdi_chan_conf dahdi_chan_conf_default(void)
static struct dahdi_pvt * duplicate_pseudo(struct dahdi_pvt *src)
static void swap_subs(struct dahdi_pvt *p, int a, int b)
static int my_set_linear_mode(void *pvt, enum analog_sub sub, int linear_mode)
static int dahdi_dnd(struct dahdi_pvt *dahdichan, int flag)
enable or disable the chan_dahdi Do-Not-Disturb mode for a DAHDI channel
static struct ast_channel * dahdi_new(struct dahdi_pvt *i, int state, int startpbx, int idx, int law, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, ast_callid callid)
static int drc_sample(int sample, float drc)
static int dahdi_get_event(int fd)
Avoid the silly dahdi_getevent which ignores a bunch of events.
static int ringt_base
Configured ring timeout base.
void dahdi_master_slave_unlink(struct dahdi_pvt *slave, struct dahdi_pvt *master, int needlock)
static ast_mutex_t monlock
Protect the monitoring thread, so only one process can kill or start it, and not when it's doing some...
#define ASCII_BYTES_PER_CHAR
static void my_all_subchannels_hungup(void *pvt)
static int my_ring(void *pvt)
static int my_start_cid_detect(void *pvt, int cid_signalling)
static int parse_buffers_policy(const char *parse, int *num_buffers, int *policy)
static struct dahdi_pvt * ifend
static char * dahdi_show_version(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int my_complete_conference_update(void *pvt, int needconference)
static struct @114 alarms[]
#define DEFAULT_DIALTONE_DETECT_TIMEOUT
static int mwi_send_process_buffer(struct dahdi_pvt *pvt, int num_read)
static void my_set_cadence(void *pvt, int *cid_rings, struct ast_channel *ast)
static void my_increase_ss_count(void)
#define REPORT_CHANNEL_ALARMS
static int my_play_tone(void *pvt, enum analog_sub sub, enum analog_tone tone)
static int my_wink(void *pvt, enum analog_sub sub)
static struct ast_channel_tech dahdi_tech
static struct ast_jb_conf global_jbconf
static int my_conf_add(void *pvt, enum analog_sub sub)
static int my_dsp_reset_and_flush_digits(void *pvt)
void dahdi_dtmf_detect_disable(struct dahdi_pvt *p)
#define PROC_DAHDI_OPT_NOWARN
#define MIN_MS_SINCE_FLASH
static int my_has_voicemail(void *pvt)
static int load_module(void)
Load the module.
static struct ast_frame * dahdi_read(struct ast_channel *ast)
static const char * my_get_orig_dialstring(void *pvt)
static int action_dahdirestart(struct mansession *s, const struct message *m)
static struct ast_custom_function polarity_function
static int get_alarms(struct dahdi_pvt *p)
static struct dahdi_pvt * determine_starting_point(const char *data, struct dahdi_starting_point *param)
#define gen_pvt_field_callback(type, field)
static int polarity_read(struct ast_channel *chan, const char *cmd, char *data, char *buffer, size_t buflen)
static int send_cwcidspill(struct dahdi_pvt *p)
static int my_conf_del(void *pvt, enum analog_sub sub)
static struct dahdi_ring_cadence cadences[NUM_CADENCE_MAX]
static int action_dahdidndoff(struct mansession *s, const struct message *m)
static int unload_module(void)
static int process_dahdi(struct dahdi_chan_conf *confp, const char *cat, struct ast_variable *v, int reload, int options)
static struct ast_cli_entry dahdi_cli[]
#define DEFAULT_CIDRINGS
Typically, how many rings before we should send Caller*ID.
static enum analog_sigtype dahdisig_to_analogsig(int sig)
static void dahdi_close(int fd)
static char defaultozz[64]
void dahdi_master_slave_link(struct dahdi_pvt *slave, struct dahdi_pvt *master)
static int my_off_hook(void *pvt)
const char *const subnames[]
static int my_allocate_sub(void *pvt, enum analog_sub analogsub)
static int usedistinctiveringdetection
static int polarity_write(struct ast_channel *chan, const char *cmd, char *data, const char *value)
static char * dahdi_restart_cmd(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static struct dahdi_pvt * find_channel(int channel)
static void * my_get_sigpvt_bridged_channel(struct ast_channel *chan)
static int send_callerid(struct dahdi_pvt *p)
static int set_hwgain(int fd, float gain, int tx_direction)
static void my_set_waitingfordt(void *pvt, struct ast_channel *ast)
static void build_alarm_info(char *restrict alarmstr, struct dahdi_spaninfo *spaninfo)
static int my_check_for_conference(void *pvt)
static int mwi_send_process_event(struct dahdi_pvt *pvt, int event)
static int my_flash(void *pvt)
static int ss_thread_count
static const char *const lbostr[]
int _dahdi_get_index(struct ast_channel *ast, struct dahdi_pvt *p, int nullok, const char *fname, unsigned long line)
#define REPORT_SPAN_ALARMS
static void deep_copy_dahdi_chan_conf(struct dahdi_chan_conf *dest, const struct dahdi_chan_conf *src)
static void my_deadlock_avoidance_private(void *pvt)
static struct dahdi_pvt * handle_init_event(struct dahdi_pvt *i, int event)
static void destroy_channel(struct dahdi_pvt *cur, int now)
static void my_set_ringtimeout(void *pvt, int ringt)
static void monitor_pfds_clean(void *arg)
static int action_dahdidialoffhook(struct mansession *s, const struct message *m)
static int dahdi_dial_str(struct dahdi_pvt *pvt, int operation, const char *dial_str)
static pthread_t monitor_thread
This is the thread for the monitor which checks for input on the channels which are not currently in ...
static int action_transferhangup(struct mansession *s, const struct message *m)
static int revert_fax_buffers(struct dahdi_pvt *p, struct ast_channel *ast)
static void destroy_all_channels(void)
static int action_dahdishowstatus(struct mansession *s, const struct message *m)
DAHDI internal API definitions.
static int dahdi_sig_pri_lib_handles(int signaling)
static int dahdi_analog_lib_handles(int signalling, int radio, int oprmode)
#define SIG_PRI_LIB_HANDLE_CASES
#define dahdi_get_index(ast, p, nullok)
static struct ast_timer * timer
General Asterisk PBX channel definitions.
void ast_channel_exten_set(struct ast_channel *chan, const char *value)
int ast_waitfordigit(struct ast_channel *c, int ms)
Waits for a digit.
const char * ast_channel_name(const struct ast_channel *chan)
static int ast_fdisset(struct pollfd *pfds, int fd, int maximum, int *start)
Helper function for migrating select to poll.
void ast_channel_rings_set(struct ast_channel *chan, int value)
void ast_channel_named_pickupgroups_set(struct ast_channel *chan, struct ast_namedgroups *value)
void ast_party_name_init(struct ast_party_name *init)
Initialize the given name structure.
void * ast_channel_tech_pvt(const struct ast_channel *chan)
struct ast_format * ast_channel_rawreadformat(struct ast_channel *chan)
void ast_party_number_init(struct ast_party_number *init)
Initialize the given number structure.
void ast_hangup(struct ast_channel *chan)
Hang up a channel.
#define ast_channel_alloc(needqueue, state, cid_num, cid_name, acctcode, exten, context, assignedids, requestor, amaflag,...)
Create a channel structure.
struct ast_channel * ast_channel_bridge_peer(struct ast_channel *chan)
Get the channel's bridge peer only if the bridge is two-party.
int ast_party_id_presentation(const struct ast_party_id *id)
Determine the overall presentation value for the given party.
#define CHECK_BLOCKING(c)
Set the blocking indication on the channel.
void ast_channel_nativeformats_set(struct ast_channel *chan, struct ast_format_cap *value)
#define ast_channel_lock(chan)
struct ast_party_redirecting * ast_channel_redirecting(struct ast_channel *chan)
void ast_channel_unregister(const struct ast_channel_tech *tech)
Unregister a channel technology.
unsigned short ast_channel_transfercapability(const struct ast_channel *chan)
struct ast_namedgroups * ast_ref_namedgroups(struct ast_namedgroups *groups)
int ast_waitfor(struct ast_channel *chan, int ms)
Wait for input on a channel.
int ast_channel_cc_params_init(struct ast_channel *chan, const struct ast_cc_config_params *base_params)
Set up datastore with CCSS parameters for a channel.
struct ast_flags * ast_channel_flags(struct ast_channel *chan)
unsigned long long ast_group_t
#define ast_channel_ref(c)
Increase channel reference count.
struct ast_party_connected_line * ast_channel_connected(struct ast_channel *chan)
int ast_queue_frame(struct ast_channel *chan, struct ast_frame *f)
Queue one or more frames to a channel's frame queue.
const char * ast_channel_uniqueid(const struct ast_channel *chan)
const char * ast_channel_accountcode(const struct ast_channel *chan)
const char * ast_channel_context(const struct ast_channel *chan)
void ast_party_caller_set(struct ast_party_caller *dest, const struct ast_party_caller *src, const struct ast_set_party_caller *update)
Set the caller information based on another caller source.
struct ast_frame * ast_read(struct ast_channel *chan)
Reads a frame.
#define ast_channel_trylock(chan)
int ast_queue_control_data(struct ast_channel *chan, enum ast_control_frame_type control, const void *data, size_t datalen)
Queue a control frame with payload.
void ast_party_caller_set_init(struct ast_party_caller *init, const struct ast_party_caller *guide)
Initialize the given caller structure using the given guide for a set update operation.
void ast_party_name_free(struct ast_party_name *doomed)
Destroy the party name contents.
void ast_set_callerid(struct ast_channel *chan, const char *cid_num, const char *cid_name, const char *cid_ani)
Set caller ID number, name and ANI and generate AMI event.
int ast_channel_fd(const struct ast_channel *chan, int which)
void ast_channel_internal_fd_set(struct ast_channel *chan, int which, int value)
int ast_queue_hangup_with_cause(struct ast_channel *chan, int cause)
Queue a hangup frame with hangupcause set.
void ast_channel_set_rawreadformat(struct ast_channel *chan, struct ast_format *format)
void ast_channel_tech_pvt_set(struct ast_channel *chan, void *value)
void ast_party_caller_free(struct ast_party_caller *doomed)
Destroy the caller party contents.
int ast_active_channels(void)
returns number of active/allocated channels
struct ast_namedgroups * ast_get_namedgroups(const char *s)
Create an ast_namedgroups set with group names from comma separated string.
void ast_channel_callgroup_set(struct ast_channel *chan, ast_group_t value)
int ast_check_hangup(struct ast_channel *chan)
Check to see if a channel is needing hang up.
int ast_channel_hangupcause(const struct ast_channel *chan)
void ast_channel_set_rawwriteformat(struct ast_channel *chan, struct ast_format *format)
struct ast_party_dialed * ast_channel_dialed(struct ast_channel *chan)
void ast_set_hangupsource(struct ast_channel *chan, const char *source, int force)
Set the source of the hangup in this channel and it's bridge.
int ast_softhangup(struct ast_channel *chan, int cause)
Softly hangup up a channel.
void ast_channel_named_callgroups_set(struct ast_channel *chan, struct ast_namedgroups *value)
void ast_channel_hangupcause_hash_set(struct ast_channel *chan, const struct ast_control_pvt_cause_code *cause_code, int datalen)
Sets the HANGUPCAUSE hash and optionally the SIP_CAUSE hash on the given channel.
int ast_queue_unhold(struct ast_channel *chan)
Queue an unhold frame.
int ast_queue_hold(struct ast_channel *chan, const char *musicclass)
Queue a hold frame.
void ast_channel_set_readformat(struct ast_channel *chan, struct ast_format *format)
int ast_channel_register(const struct ast_channel_tech *tech)
Register a channel technology (a new channel driver) Called by a channel module to register the kind ...
void ast_channel_softhangup_internal_flag_add(struct ast_channel *chan, int value)
#define ast_channel_unref(c)
Decrease channel reference count.
@ AST_FLAG_DISABLE_DEVSTATE_CACHE
void ast_party_number_free(struct ast_party_number *doomed)
Destroy the party number contents.
int ast_channel_get_up_time(struct ast_channel *chan)
Obtain how long it has been since the channel was answered.
void ast_channel_amaflags_set(struct ast_channel *chan, enum ama_flags value)
const char * ast_channel_language(const struct ast_channel *chan)
struct ast_bridge_channel * ast_channel_get_bridge_channel(struct ast_channel *chan)
Get a reference to the channel's bridge pointer.
void ast_channel_context_set(struct ast_channel *chan, const char *value)
void ast_channel_set_fd(struct ast_channel *chan, int which, int fd)
int ast_softhangup_nolock(struct ast_channel *chan, int cause)
Softly hangup up a channel (no channel lock)
enum ama_flags ast_channel_string2amaflag(const char *flag)
Convert a string to a detail record AMA flag.
struct ast_pbx * ast_channel_pbx(const struct ast_channel *chan)
const struct ast_channel_tech * ast_channel_tech(const struct ast_channel *chan)
struct ast_namedgroups * ast_unref_namedgroups(struct ast_namedgroups *groups)
int ast_channel_setoption(struct ast_channel *channel, int option, void *data, int datalen, int block)
Sets an option on a channel.
struct ast_party_caller * ast_channel_caller(struct ast_channel *chan)
void ast_channel_callid_set(struct ast_channel *chan, ast_callid value)
void ast_channel_hangupcause_set(struct ast_channel *chan, int value)
#define ast_channel_cleanup(c)
Cleanup a channel reference.
void ast_channel_pickupgroup_set(struct ast_channel *chan, ast_group_t value)
void ast_channel_adsicpe_set(struct ast_channel *chan, enum ast_channel_adsicpe value)
ast_group_t ast_get_group(const char *s)
void ast_channel_tech_set(struct ast_channel *chan, const struct ast_channel_tech *value)
int ast_safe_sleep(struct ast_channel *chan, int ms)
Wait for a specified amount of time, looking for hangups.
const char * ast_channel_exten(const struct ast_channel *chan)
#define ast_channel_unlock(chan)
#define AST_MAX_EXTENSION
void ast_channel_set_writeformat(struct ast_channel *chan, struct ast_format *format)
@ AST_SOFTHANGUP_EXPLICIT
@ AST_SOFTHANGUP_APPUNLOAD
ast_channel_state
ast_channel states
@ AST_STATE_DIALING_OFFHOOK
int ast_setstate(struct ast_channel *chan, enum ast_channel_state)
Change the state of a channel.
static struct ast_channel * callback(struct ast_channelstorage_instance *driver, ao2_callback_data_fn *cb_fn, void *arg, void *data, int ao2_flags)
Standard Command Line Interface.
int ast_cli_unregister_multiple(struct ast_cli_entry *e, int len)
Unregister multiple commands.
#define AST_CLI_DEFINE(fn, txt,...)
void ast_cli(int fd, const char *fmt,...)
#define ast_cli_register_multiple(e, len)
Register multiple commands.
static struct channel_usage channels
#define container_of(ptr, type, member)
@ AST_DEVSTATE_NOT_CACHABLE
int ast_devstate_changed(enum ast_device_state state, enum ast_devstate_cache cachable, const char *fmt,...)
Tells Asterisk the State for Device is changed.
int ast_devstate_changed_literal(enum ast_device_state state, enum ast_devstate_cache cachable, const char *device)
Tells Asterisk the State for Device is changed.
ast_device_state
Device States.
Convenient Signal Processing routines.
void ast_dsp_free(struct ast_dsp *dsp)
int ast_dsp_get_tcount(struct ast_dsp *dsp)
Get tcount (Threshold counter)
#define DSP_FEATURE_WAITDIALTONE
#define DSP_FEATURE_BUSY_DETECT
#define DSP_TONE_STATE_DIALTONE
void ast_dsp_digitreset(struct ast_dsp *dsp)
Reset DTMF detector.
#define DSP_DIGITMODE_MUTEMAX
void ast_dsp_set_busy_pattern(struct ast_dsp *dsp, const struct ast_dsp_busy_pattern *cadence)
Set expected lengths of the busy tone.
struct ast_frame * ast_dsp_process(struct ast_channel *chan, struct ast_dsp *dsp, struct ast_frame *inf)
Return AST_FRAME_NULL frames when there is silence, AST_FRAME_BUSY on busies, and call progress,...
#define DSP_FEATURE_DIGIT_DETECT
#define DSP_FEATURE_FAX_DETECT
#define DSP_FEATURE_CALL_PROGRESS
int ast_dsp_set_digitmode(struct ast_dsp *dsp, int digitmode)
Set digit mode.
#define DSP_DIGITMODE_MUTECONF
int ast_dsp_get_tstate(struct ast_dsp *dsp)
Get tstate (Tone State)
int ast_dsp_was_muted(struct ast_dsp *dsp)
Returns true if DSP code was muting any fragment of the last processed frame. Muting (squelching) hap...
#define DSP_TONE_STATE_RINGING
void ast_dsp_set_busy_count(struct ast_dsp *dsp, int cadences)
Set number of required cadences for busy.
void ast_dsp_set_features(struct ast_dsp *dsp, int features)
Select feature set.
#define DSP_DIGITMODE_DTMF
struct ast_dsp * ast_dsp_new(void)
Allocates a new dsp, assumes 8khz for internal sample rate.
#define DSP_DIGITMODE_RELAXDTMF
int ast_dsp_set_call_progress_zone(struct ast_dsp *dsp, char *zone)
Set zone for doing progress detection.
void ast_verbose(const char *fmt,...)
Call Parking and Pickup API Includes code and algorithms from the Zapata library.
Generic File Format Support. Should be included by clients of the file handling routines....
int ast_streamfile(struct ast_channel *c, const char *filename, const char *preflang)
Streams a file.
int ast_waitstream(struct ast_channel *c, const char *breakon)
Waits for a stream to stop or digit to be pressed.
static int len(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)
void astman_send_listack(struct mansession *s, const struct message *m, char *msg, char *listflag)
Send ack in manager transaction to begin a list.
void astman_send_error(struct mansession *s, const struct message *m, char *error)
Send error in manager transaction.
void ast_manager_publish_event(const char *type, int class_type, struct ast_json *obj)
Publish an event to AMI.
void astman_send_list_complete_start(struct mansession *s, const struct message *m, const char *event_name, int count)
Start the list complete event.
void astman_send_ack(struct mansession *s, const struct message *m, char *msg)
Send ack in manager transaction.
const char * astman_get_header(const struct message *m, char *var)
Get header from manager transaction.
void astman_send_list_complete_end(struct mansession *s)
End the list complete event.
void astman_append(struct mansession *s, const char *fmt,...)
int ast_manager_unregister(const char *action)
Unregister a registered manager command.
void ast_channel_stage_snapshot_done(struct ast_channel *chan)
Clear flag to indicate channel snapshot is being staged, and publish snapshot.
void ast_channel_publish_blob(struct ast_channel *chan, struct stasis_message_type *type, struct ast_json *blob)
Publish a channel blob message.
void ast_channel_stage_snapshot(struct ast_channel *chan)
Set flag to indicate channel snapshot is being staged.
#define AST_APP_ARG(name)
Define an application argument.
#define ast_app_separate_args(a, b, c, d)
int ast_app_has_voicemail(const char *mailboxes, const char *folder)
Determine if a given mailbox has any voicemail If folder is NULL, defaults to "INBOX"....
#define AST_DECLARE_APP_ARGS(name, arglist)
Declare a structure to hold an application's arguments.
int ast_safe_system(const char *s)
Safely spawn an OS shell command while closing file descriptors.
#define AST_STANDARD_APP_ARGS(args, parse)
Performs the 'standard' argument separation process for an application.
#define AST_NONSTANDARD_APP_ARGS(args, parse, sep)
Performs the 'nonstandard' argument separation process for an application.
Configuration File Parser.
#define ast_config_load(filename, flags)
Load a config file.
char * ast_category_browse(struct ast_config *config, const char *prev_name)
Browse categories.
struct ast_config * ast_config_new(void)
Create a new base configuration structure.
@ CONFIG_FLAG_FILEUNCHANGED
#define ast_variable_new(name, value, filename)
#define CONFIG_STATUS_FILEUNCHANGED
#define CONFIG_STATUS_FILEINVALID
void ast_config_destroy(struct ast_config *cfg)
Destroys a config.
int ast_variable_list_replace(struct ast_variable **head, struct ast_variable *replacement)
Replace a variable in the given list with a new value.
const char * ast_variable_retrieve(struct ast_config *config, const char *category, const char *variable)
void ast_variables_destroy(struct ast_variable *var)
Free variable list.
struct ast_variable * ast_variable_browse(const struct ast_config *config, const char *category_name)
struct ast_features_pickup_config * ast_get_chan_features_pickup_config(struct ast_channel *chan)
Get the pickup configuration options for a channel.
#define AST_OPTION_RELAXDTMF
#define AST_OPTION_TONE_VERIFY
#define AST_OPTION_RXGAIN
#define AST_OPTION_DIGIT_DETECT
#define AST_OPTION_OPRMODE
#define AST_OPTION_CC_AGENT_TYPE
#define AST_OPTION_FAX_DETECT
#define AST_OPTION_TXGAIN
#define AST_OPTION_ECHOCAN
#define AST_FRIENDLY_OFFSET
Offset into a frame's data buffer.
@ AST_CONTROL_RADIO_UNKEY
@ AST_CONTROL_PVT_CAUSE_CODE
#define AST_OPTION_AUDIO_MODE
struct ast_frame ast_null_frame
void ast_callid_threadstorage_auto_clean(ast_callid callid, int callid_created)
Use in conjunction with ast_callid_threadstorage_auto. Cleans up the references and if the callid was...
#define DEBUG_ATLEAST(level)
#define ast_debug(level,...)
Log a DEBUG message.
int ast_callid_threadstorage_auto(ast_callid *callid)
Checks thread storage for a callid and stores a reference if it exists. If not, then a new one will b...
void ast_log_callid(int level, const char *file, int line, const char *function, ast_callid callid, const char *fmt,...)
Used for sending a log message with a known call_id This is a modified logger function which is funct...
#define ast_verb(level,...)
#define ast_verbose_callid(callid,...)
void ast_json_unref(struct ast_json *value)
Decrease refcount on value. If refcount reaches zero, value is freed.
struct ast_json * ast_json_pack(char const *format,...)
Helper for creating complex JSON values.
const char * ast_json_string_get(const struct ast_json *string)
Get the value of a JSON string.
struct ast_json * ast_json_object_get(struct ast_json *object, const char *key)
Get a field from a JSON object.
intmax_t ast_json_integer_get(const struct ast_json *integer)
Get the value from a JSON integer.
AST_JSON_INT_T ast_json_int_t
Primarily used to cast when packing to an "I" type.
#define AST_LIST_HEAD_STATIC(name, type)
Defines a structure to be used to hold a list of specified type, statically initialized.
#define AST_LIST_LAST(head)
Returns the last entry contained in a list.
#define AST_LIST_TRAVERSE(head, var, field)
Loops over (traverses) the entries in a list.
#define AST_LIST_HEAD_INIT_VALUE
Defines initial values for a declaration of AST_LIST_HEAD.
#define AST_LIST_EMPTY(head)
Checks whether the specified list contains any entries.
#define AST_LIST_INSERT_TAIL(head, elm, field)
Appends a list entry to the tail of a list.
#define AST_LIST_ENTRY(type)
Declare a forward link structure inside a list entry.
#define AST_LIST_TRAVERSE_SAFE_END
Closes a safe loop traversal block.
#define AST_LIST_MOVE_CURRENT(newhead, field)
Move the current list entry to another list.
#define AST_LIST_LOCK(head)
Locks a list.
#define AST_LIST_REMOVE(head, elm, field)
Removes a specific entry from a list.
#define AST_LIST_TRAVERSE_SAFE_BEGIN(head, var, field)
Loops safely over (traverses) the entries in a list.
#define AST_LIST_REMOVE_HEAD(head, field)
Removes and returns the head entry from a list.
#define AST_LIST_UNLOCK(head)
Attempts to unlock a list.
Asterisk locking-related definitions:
#define ast_cond_destroy(cond)
#define ast_cond_wait(cond, mutex)
#define AST_PTHREADT_NULL
#define ast_cond_init(cond, attr)
#define ast_mutex_init(pmutex)
#define CHANNEL_DEADLOCK_AVOIDANCE(chan)
#define DEADLOCK_AVOIDANCE(lock)
#define AST_PTHREADT_STOP
#define ast_mutex_unlock(a)
int ast_atomic_fetchadd_int(volatile int *p, int v)
Atomically add v to *p and return the previous value of *p.
#define ast_mutex_trylock(a)
pthread_cond_t ast_cond_t
#define ast_mutex_destroy(a)
#define ast_mutex_lock(a)
#define AST_MUTEX_DEFINE_STATIC(mutex)
#define ast_cond_signal(cond)
The AMI - Asterisk Manager Interface - is a TCP protocol created to manage Asterisk with third-party ...
struct ast_str * ast_manager_build_channel_state_string(const struct ast_channel_snapshot *snapshot)
Generate the AMI message body from a channel snapshot.
#define EVENT_FLAG_SYSTEM
#define ast_manager_register_xml(action, authority, func)
Register a manager callback using XML documentation to describe the manager.
struct ast_manager_event_blob * ast_manager_event_blob_create(int event_flags, const char *manager_event, const char *extra_fields_fmt,...)
Construct a ast_manager_event_blob.
Asterisk module definitions.
#define ast_module_unref(mod)
Release a reference to the module.
#define ast_module_ref(mod)
Hold a reference to the module.
#define AST_MODULE_INFO(keystr, flags_to_set, desc, fields...)
@ AST_MODPRI_CHANNEL_DRIVER
@ AST_MODULE_SUPPORT_CORE
#define ASTERISK_GPL_KEY
The text the key() function should return.
int ast_unregister_application(const char *app)
Unregister an application.
@ AST_MODULE_LOAD_DECLINE
Module has failed to load, may be in an inconsistent state.
#define ast_register_application_xml(app, execute)
Register an application using XML documentation.
int ast_moh_start(struct ast_channel *chan, const char *mclass, const char *interpclass)
Turn on music on hold on a given channel.
void ast_moh_stop(struct ast_channel *chan)
Turn off music on hold on a given channel.
struct stasis_message_type * ast_mwi_state_type(void)
Get the Stasis Message Bus API message type for MWI messages.
void * ast_mwi_unsubscribe(struct ast_mwi_subscriber *sub)
Unsubscribe from the stasis topic and MWI.
struct stasis_cache * ast_mwi_state_cache(void)
Backend cache for ast_mwi_topic_cached().
struct ast_mwi_subscriber * ast_mwi_subscribe_pool(const char *mailbox, stasis_subscription_cb callback, void *data)
Add an MWI state subscriber, and stasis subscription to the mailbox.
#define ast_publish_mwi_state(mailbox, context, new_msgs, old_msgs)
Publish a MWI state update via stasis.
int ast_parking_blind_transfer_park(struct ast_bridge_channel *parker, const char *context, const char *exten, transfer_channel_cb parked_channel_cb, struct transfer_channel_data *parked_channel_data)
Perform a blind transfer to a parking extension.
int ast_parking_is_exten_park(const char *context, const char *exten)
Determine if the context/exten is a "parking" extension.
int ast_parking_provider_registered(void)
Check whether a parking provider is registered.
Asterisk file paths, configured in asterisk.conf.
const char * ast_config_AST_LOG_DIR
Core PBX routines and definitions.
enum ast_pbx_result ast_pbx_run(struct ast_channel *c)
Execute the PBX in the current thread.
const char * pbx_builtin_getvar_helper(struct ast_channel *chan, const char *name)
Return a pointer to the value of the corresponding channel variable.
int ast_exists_extension(struct ast_channel *c, const char *context, const char *exten, int priority, const char *callerid)
Determine whether an extension exists.
int pbx_builtin_setvar_helper(struct ast_channel *chan, const char *name, const char *value)
Add a variable to the channel variable stack, removing the most recently set value for the same name.
#define ast_custom_function_register(acf)
Register a custom function.
int ast_canmatch_extension(struct ast_channel *c, const char *context, const char *exten, int priority, const char *callerid)
Looks for a valid matching extension.
int ast_custom_function_unregister(struct ast_custom_function *acf)
Unregister a custom function.
enum ast_pbx_result ast_pbx_start(struct ast_channel *c)
Create a new thread and start the PBX.
int ast_ignore_pattern(const char *context, const char *pattern)
Checks to see if a number should be ignored.
int ast_matchmore_extension(struct ast_channel *c, const char *context, const char *exten, int priority, const char *callerid)
Looks to see if adding anything to this extension might match something. (exists ^ canmatch)
int ast_async_goto(struct ast_channel *chan, const char *context, const char *exten, int priority)
Set the channel to next execute the specified dialplan location.
int ast_pickup_call(struct ast_channel *chan)
Pickup a call.
struct stasis_forward * sub
static void to_ami(struct ast_sip_subscription *sub, struct ast_str **buf)
static int debug
Global debug status.
Say numbers and dates (maybe words one day too)
int analog_hangup(struct analog_pvt *p, struct ast_channel *ast)
int analog_available(struct analog_pvt *p)
struct ast_frame * analog_exception(struct analog_pvt *p, struct ast_channel *ast)
int analog_dnd(struct analog_pvt *p, int flag)
int analog_callwaiting_deluxe(struct analog_pvt *p, int option)
int analog_config_complete(struct analog_pvt *p)
void analog_handle_dtmf(struct analog_pvt *p, struct ast_channel *ast, enum analog_sub idx, struct ast_frame **dest)
int analog_call(struct analog_pvt *p, struct ast_channel *ast, const char *rdest, int timeout)
void analog_delete(struct analog_pvt *doomed)
Delete the analog private structure.
struct analog_pvt * analog_new(enum analog_sigtype signallingtype, void *private_data)
int analog_fixup(struct ast_channel *oldchan, struct ast_channel *newchan, void *newp)
enum analog_sigtype sigtype
struct ast_channel * analog_request(struct analog_pvt *p, int *callwait, const struct ast_channel *requestor)
void * analog_handle_init_event(struct analog_pvt *i, int event)
int analog_answer(struct analog_pvt *p, struct ast_channel *ast)
int analog_ss_thread_start(struct analog_pvt *p, struct ast_channel *chan)
Interface header for analog signaling module.
#define ANALOG_INTER_DIGIT_TIMEOUT
Default time (ms) to detect following digits.
#define ANALOG_MATCH_DIGIT_TIMEOUT
Default time (ms) to wait, in case of ambiguous match.
@ ANALOG_EVENT_HOOKCOMPLETE
@ ANALOG_EVENT_PULSE_START
@ ANALOG_EVENT_TX_CED_DETECTED
@ ANALOG_EVENT_NEONMWI_ACTIVE
@ ANALOG_EVENT_EC_DISABLED
@ ANALOG_EVENT_PULSEDIGIT
@ ANALOG_EVENT_RX_CED_DETECTED
@ ANALOG_EVENT_DIALCOMPLETE
@ ANALOG_EVENT_EC_NLP_ENABLED
@ ANALOG_EVENT_NEONMWI_INACTIVE
@ ANALOG_EVENT_EC_NLP_DISABLED
@ ANALOG_EVENT_RINGOFFHOOK
#define ANALOG_FIRST_DIGIT_TIMEOUT
Default time (ms) to detect first digit.
@ ANALOG_CID_START_DTMF_NOALERT
@ ANALOG_CID_START_POLARITY
@ ANALOG_CID_START_POLARITY_IN
Interface header for PRI signaling module.
int sig_pri_is_chan_available(struct sig_pri_chan *pvt)
void sig_pri_unload(void)
#define SIG_PRI_DEBUG_NORMAL
int pri_send_callrerouting_facility_exec(struct sig_pri_chan *p, enum ast_channel_state chanstate, const char *destination, const char *original, const char *reason)
int sig_pri_ami_show_spans(struct mansession *s, const char *show_cmd, struct sig_pri_span *pri, const int *dchannels, const char *action_id)
int sig_pri_cc_agent_status_req(struct ast_cc_agent *agent)
struct sig_pri_callback sig_pri_callbacks
int sig_pri_indicate(struct sig_pri_chan *p, struct ast_channel *chan, int condition, const void *data, size_t datalen)
void sig_pri_extract_called_num_subaddr(struct sig_pri_chan *p, const char *rdest, char *called, size_t called_buff_size)
#define SIG_PRI_NUM_DCHANS
int sig_pri_cc_agent_start_offer_timer(struct ast_cc_agent *agent)
int sig_pri_hangup(struct sig_pri_chan *p, struct ast_channel *ast)
int sig_pri_cc_monitor_unsuspend(struct ast_cc_monitor *monitor)
int sig_pri_available(struct sig_pri_chan **pvt, int is_specific_channel)
int sig_pri_call(struct sig_pri_chan *p, struct ast_channel *ast, const char *rdest, int timeout, int layer1)
#define DAHDI_OVERLAPDIAL_OUTGOING
int sig_pri_is_alarm_ignored(struct sig_pri_span *pri)
int sig_pri_cc_monitor_req_cc(struct ast_cc_monitor *monitor, int *available_timer_id)
int sig_pri_start_pri(struct sig_pri_span *pri)
int sig_pri_cc_monitor_cancel_available_timer(struct ast_cc_monitor *monitor, int *sched_id)
void sig_pri_cli_show_channels(int fd, struct sig_pri_span *pri)
void sig_pri_cc_agent_req_rsp(struct ast_cc_agent *agent, enum ast_cc_agent_response_reason reason)
int sig_pri_cc_monitor_suspend(struct ast_cc_monitor *monitor)
@ SIG_PRI_RESET_IDLE
The channel is not being RESTARTed.
#define DAHDI_OVERLAPDIAL_BOTH
void sig_pri_stop_pri(struct sig_pri_span *pri)
void sig_pri_cc_agent_destructor(struct ast_cc_agent *agent)
void sig_pri_cli_show_spans(int fd, int span, struct sig_pri_span *pri)
void sig_pri_init_pri(struct sig_pri_span *pri)
#define SIG_PRI_AOC_GRANT_D
#define DAHDI_OVERLAPDIAL_NONE
int sig_pri_cc_agent_start_monitoring(struct ast_cc_agent *agent)
#define DAHDI_CHAN_MAPPING_LOGICAL
int sig_pri_cc_agent_init(struct ast_cc_agent *agent, struct sig_pri_chan *pvt_chan)
void sig_pri_chan_alarm_notify(struct sig_pri_chan *p, int noalarm)
int sig_pri_load(const char *cc_type_name)
@ SIG_PRI_CALL_LEVEL_PROCEEDING
@ SIG_PRI_MOH_SIGNALING_MOH
@ SIG_PRI_MOH_SIGNALING_NOTIFY
int sig_pri_cc_agent_callee_available(struct ast_cc_agent *agent)
#define DAHDI_OVERLAPDIAL_INCOMING
struct ast_channel * sig_pri_request(struct sig_pri_chan *p, enum sig_pri_law law, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, int transfercapability)
#define SIG_PRI_AOC_GRANT_E
void sig_pri_fixup(struct ast_channel *oldchan, struct ast_channel *newchan, struct sig_pri_chan *pchan)
void sig_pri_cc_monitor_destructor(void *monitor_pvt)
void sig_pri_dial_complete(struct sig_pri_chan *pvt, struct ast_channel *ast)
struct sig_pri_chan * sig_pri_chan_new(void *pvt_data, struct sig_pri_span *pri, int logicalspan, int channo, int trunkgroup)
void pri_event_noalarm(struct sig_pri_span *pri, int index, int before_start_pri)
void sig_pri_cli_show_span(int fd, int *dchannels, struct sig_pri_span *pri)
void sig_pri_chan_delete(struct sig_pri_chan *doomed)
int sig_pri_answer(struct sig_pri_chan *p, struct ast_channel *ast)
#define SIG_PRI_AOC_GRANT_S
@ SIG_PRI_TONE_CONGESTION
@ SIG_PRI_TONE_DIALRECALL
void pri_event_alarm(struct sig_pri_span *pri, int index, int before_start_pri)
int sig_pri_cc_agent_stop_offer_timer(struct ast_cc_agent *agent)
void sig_pri_cli_show_channels_header(int fd)
void sig_pri_set_alarm(struct sig_pri_chan *p, int in_alarm)
int sig_pri_cc_agent_party_b_free(struct ast_cc_agent *agent)
int sig_pri_cc_monitor_status_rsp(struct ast_cc_monitor *monitor, enum ast_device_state devstate)
#define DAHDI_CHAN_MAPPING_PHYSICAL
int sig_pri_cc_agent_stop_ringing(struct ast_cc_agent *agent)
int sig_pri_digit_begin(struct sig_pri_chan *pvt, struct ast_channel *ast, char digit)
int pri_send_keypad_facility_exec(struct sig_pri_chan *p, const char *digits)
Interface header for SS7 signaling module.
void sig_ss7_cb_call_null(struct ss7 *ss7, struct isup_call *c, int lock)
void sig_ss7_link_noalarm(struct sig_ss7_linkset *linkset, int which)
void sig_ss7_cli_show_channels_header(int fd)
struct ast_channel * sig_ss7_request(struct sig_ss7_chan *p, enum sig_ss7_law law, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, int transfercapability)
void sig_ss7_init_linkset(struct sig_ss7_linkset *ss7)
void sig_ss7_link_alarm(struct sig_ss7_linkset *linkset, int which)
#define LINKSET_FLAG_EXPLICITACM
#define LINKSET_FLAG_AUTOACM
int sig_ss7_reset_group(struct sig_ss7_linkset *linkset, int cic, unsigned int dpc, int range)
int sig_ss7_available(struct sig_ss7_chan *p)
void sig_ss7_cb_notinservice(struct ss7 *ss7, int cic, unsigned int dpc)
int sig_ss7_reset_cic(struct sig_ss7_linkset *linkset, int cic, unsigned int dpc)
int sig_ss7_call(struct sig_ss7_chan *p, struct ast_channel *ast, const char *rdest)
void * ss7_linkset(void *data)
int sig_ss7_indicate(struct sig_ss7_chan *p, struct ast_channel *chan, int condition, const void *data, size_t datalen)
#define SS7_BLOCKED_MAINTENANCE
int sig_ss7_group_blocking(struct sig_ss7_linkset *linkset, int do_block, int startcic, int endcic, unsigned char state[], int type)
int sig_ss7_find_cic(struct sig_ss7_linkset *linkset, int cic, unsigned int dpc)
struct sig_ss7_callback sig_ss7_callbacks
void sig_ss7_set_alarm(struct sig_ss7_chan *p, int in_alarm)
@ SIG_SS7_TONE_DIALRECALL
@ SIG_SS7_TONE_CONGESTION
struct sig_ss7_chan * sig_ss7_chan_new(void *pvt_data, struct sig_ss7_linkset *ss7)
void sig_ss7_cli_show_channels(int fd, struct sig_ss7_linkset *linkset)
int sig_ss7_cic_blocking(struct sig_ss7_linkset *linkset, int do_block, int cic)
#define LINKSET_FLAG_DEFAULTECHOCONTROL
#define LINKSET_FLAG_USEECHOCONTROL
void sig_ss7_chan_delete(struct sig_ss7_chan *doomed)
#define LINKSET_FLAG_INITIALHWBLO
int sig_ss7_cb_hangup(struct ss7 *ss7, int cic, unsigned int dpc, int cause, int do_hangup)
int sig_ss7_add_sigchan(struct sig_ss7_linkset *linkset, int which, int ss7type, int transport, int inalarm, int networkindicator, int pointcode, int adjpointcode, int cur_slc)
int sig_ss7_hangup(struct sig_ss7_chan *p, struct ast_channel *ast)
void sig_ss7_fixup(struct ast_channel *oldchan, struct ast_channel *newchan, struct sig_ss7_chan *pchan)
#define SS7_BLOCKED_HARDWARE
#define SIG_SS7_NUM_DCHANS
int sig_ss7_answer(struct sig_ss7_chan *p, struct ast_channel *ast)
int sig_ss7_find_cic_range(struct sig_ss7_linkset *linkset, int startcic, int endcic, unsigned int dpc)
SMDI support for Asterisk.
struct ast_smdi_interface * ast_smdi_interface_find(const char *iface_name)
Find an SMDI interface with the specified name.
struct ast_smdi_md_message * ast_smdi_md_message_wait(struct ast_smdi_interface *iface, int timeout)
Get the next SMDI message from the queue.
#define SMDI_MAX_FILENAME_LEN
#define STASIS_MESSAGE_TYPE_CLEANUP(name)
Boiler-plate messaging macro for cleaning up message types.
void stasis_subscription_cb_noop(void *data, struct stasis_subscription *sub, struct stasis_message *message)
Stasis subscription callback function that does nothing.
#define STASIS_MESSAGE_TYPE_INIT(name)
Boiler-plate messaging macro for initializing message types.
void * stasis_message_data(const struct stasis_message *msg)
Get the data contained in a message.
struct stasis_message * stasis_cache_get(struct stasis_cache *cache, struct stasis_message_type *type, const char *id)
Retrieve an item from the cache for the ast_eid_default entity.
char * ast_str_buffer(const struct ast_str *buf)
Returns the string buffer within the ast_str buf.
#define S_OR(a, b)
returns the equivalent of logic or for strings: first one if not empty, otherwise second one.
int attribute_pure ast_true(const char *val)
Make sure something is true. Determine if a string containing a boolean value is "true"....
#define S_COR(a, b, c)
returns the equivalent of logic or for strings, with an additional boolean check: second one if not e...
static force_inline int attribute_pure ast_strlen_zero(const char *s)
int attribute_pure ast_false(const char *val)
Make sure something is false. Determine if a string containing a boolean value is "false"....
#define ast_str_create(init_len)
Create a malloc'ed dynamic length string.
int ast_str_set(struct ast_str **buf, ssize_t max_len, const char *fmt,...)
Set a dynamic string using variable arguments.
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
char * ast_strip(char *s)
Strip leading/trailing whitespace from a string.
int(*const play_tone)(void *pvt, enum analog_sub sub, enum analog_tone tone)
unsigned int immediatering
unsigned int permcallwaiting
unsigned int callwaitingdeluxepending
TRUE if a Call Waiting Deluxe action is currently pending.
unsigned int dahditrcallerid
int polarityonanswerdelay
char cid_num[AST_MAX_EXTENSION]
unsigned int permhidecallerid
unsigned int callwaitingcallerid
unsigned int ani_wink_time
enum analog_sigtype outsigmod
unsigned int usedistinctiveringdetection
unsigned int answeronpolarityswitch
unsigned int threewaycalling
int msgstate
-1 = unknown, 0 = no messages, 1 = new messages available
unsigned int hanguponpolarityswitch
unsigned int callwaitingdeluxe
enum analog_cid_start cid_start
struct ast_channel * owner
unsigned int use_smdi
TRUE if SMDI (Simplified Message Desk Interface) is enabled.
unsigned int call_qualifier
unsigned int lastnumredial
unsigned int ani_info_digits
enum analog_dialmode dialmode
unsigned int cancallforward
struct analog_subchannel subs[3]
unsigned int transfertobusy
char cid_name[AST_MAX_EXTENSION]
unsigned int calledsubscriberheld
char mohsuggest[MAX_MUSICCLASS]
unsigned int use_callerid
struct ast_channel * ss_astchan
struct ast_smdi_interface * smdi_iface
The SMDI interface to get SMDI messages from.
struct ast_party_caller caller
struct ast_channel * owner
Structure to pass both assignedid values to channel drivers.
Structure that contains information regarding a channel in a bridge.
struct ast_channel * chan
const char * type
Type of agent the callbacks belong to.
Callbacks defined by CC monitors.
const char * type
Type of monitor the callbacks belong to.
Blob of data associated with a channel.
struct ast_channel_snapshot * snapshot
Structure to describe a channel "technology", ie a channel driver See for examples:
struct ast_format_cap * capabilities
Main Channel structure associated with a channel.
char exten[AST_MAX_EXTENSION]
struct ast_party_redirecting redirecting
Redirecting/Diversion information.
descriptor for a cli entry.
char chan_name[AST_CHANNEL_NAME]
Data structure associated with a custom dialplan function.
Configuration relating to call pickup.
Structure used to handle boolean flags.
struct ast_format * format
Data structure associated with a single frame of data.
union ast_frame::@228 data
struct ast_frame_subclass subclass
enum ast_frame_type frametype
General jitterbuffer configuration.
unsigned int flags
Combination of the AST_JB_ENABLED, AST_JB_FORCED and AST_JB_LOG flags.
Abstract JSON element (object, array, string, int, ...).
Struct containing info for an AMI event to send out.
The structure that contains MWI state.
Caller Party information.
struct ast_party_id id
Caller party ID.
int ani2
Automatic Number Identification 2 (Info Digits)
struct ast_party_id ani
Automatic Number Identification (ANI)
struct ast_party_id id
Connected party ID.
struct ast_party_dialed::@210 number
Dialed/Called number.
char * str
Subscriber phone number (Malloced)
struct ast_party_subaddress subaddress
Subscriber subaddress.
char * tag
User-set "tag".
struct ast_party_name name
Subscriber name.
struct ast_party_number number
Subscriber phone number.
int presentation
Q.931 encoded presentation-indicator encoded field.
unsigned char valid
TRUE if the name information is valid/present.
char * str
Subscriber name (Malloced)
int presentation
Q.931 presentation-indicator and screening-indicator encoded fields.
unsigned char valid
TRUE if the number information is valid/present.
char * str
Subscriber phone number (Malloced)
int plan
Q.931 Type-Of-Number and Numbering-Plan encoded fields.
int code
enum AST_REDIRECTING_REASON value for redirection
struct ast_party_redirecting_reason reason
Reason for the redirection.
struct ast_party_id from
Who is redirecting the call (Sent to the party the call is redirected toward)
unsigned char valid
TRUE if the subaddress information is valid/present.
char * str
Malloced subaddress string.
An SMDI message desk message.
char calling_st[SMDI_MAX_STATION_NUM_LEN+1]
char fwd_st[SMDI_MAX_STATION_NUM_LEN+1]
Support for dynamic strings.
Structure for variables, used for configurations and for channel variables.
struct ast_variable * next
All configuration options for http media cache.
Channel configuration from chan_dahdi.conf . This struct is used for parsing the [channels] section o...
char smdi_port[SMDI_MAX_FILENAME_LEN]
The serial port to listen for SMDI data on.
int ignore_failed_channels
struct dahdi_params timing
int wanted_channels_end
Don't create channels above this number (infinity by default)
int wanted_channels_start
Don't create channels below this number.
struct ringContextData ringContext[3]
struct distRingData ringnum[3]
unsigned int echocanon
TRUE if echo cancellation is turned on.
char dialdest[256]
Delayed dialing for E911. Overlap digits for ISDN.
unsigned int immediate
TRUE if the channel should be answered immediately without attempting to gather any digits.
unsigned int immediatering
TRUE if audible ringback should be provided when immediate = yes.
unsigned int threewaysilenthold
TRUE if a three way dial tone should time out to silence.
enum DAHDI_IFLIST which_iflist
unsigned int permcallwaiting
TRUE if busy extensions will hear the call-waiting tone and can use hook-flash to switch between call...
float cid_rxgain
Amount of gain to increase during caller id.
struct dahdi_distRings drings
Distinctive Ring data.
struct ast_variable * vars
Channel variable list with associated values to set when a channel is created.
char cid_subaddr[AST_MAX_EXTENSION]
Caller ID subaddress from an incoming call.
unsigned int canpark
TRUE if support for call parking is enabled.
unsigned int bufferoverrideinuse
int law
Active PCM encoding format: DAHDI_LAW_ALAW or DAHDI_LAW_MULAW.
unsigned int hwtxgain_enabled
TRUE if hardware Tx gain set by Asterisk.
unsigned int dnd
TRUE if Do-Not-Disturb is enabled, present only for non sig_analog.
unsigned int ignoredtmf
TRUE if DTMF detection is disabled.
struct dahdi_dialoperation dop
DAHDI dial operation command struct for ioctl() call.
struct timeval dtmfcid_delay
unsigned int dahditrcallerid
TRUE if we should use the callerid from incoming call on dahdi transfer.
unsigned int doreoriginate
Internal flag for if we should actually process a reorigination.
unsigned char * cidspill
Analog caller ID waveform sample buffer.
int waitfordialtonetemp
Transient variable. Same as waitfordialtone, but temporarily set for a specific call,...
int cidlen
Length of the cidspill buffer containing samples.
int polarityonanswerdelay
Minimal time period (ms) between the answer polarity switch and hangup polarity switch.
int busycount
Number of times to see "busy" tone before hanging up.
char cid_num[AST_MAX_EXTENSION]
Caller ID number from an incoming call.
int ringt
Ring timeout timer??
struct ast_mwi_subscriber * mwi_event_sub
Opaque event subscription parameters for message waiting indication support.
ast_group_t group
Bitmapped groups this belongs to.
int sendcalleridafter
Send caller ID on FXS after this many rings. Set to 1 for US.
struct dahdi_pvt * oprpeer
unsigned int permhidecallerid
TRUE if the outgoing caller ID is blocked/restricted/hidden.
unsigned int mwisendactive
TRUE if a MWI message sending thread is active.
struct mwisend_info mwisend_data
int interdigit_timeout
Time (ms) to detect following digits (in an analog phone)
unsigned int mwimonitor_rpas
TRUE if the FXO port monitors for rpas precursor to fsk MWI indications from the other end.
struct dahdi_pvt * master
unsigned int confirmanswer
TRUE if to wait for a DTMF digit to confirm answer.
unsigned int restartpending
unsigned int mwimonitoractive
TRUE if an MWI monitor thread is currently active.
unsigned int outgoing
TRUE if we originated the call leg.
unsigned int faxdetect_timeout
The number of seconds into call to disable fax detection. (0 = disabled)
unsigned int callwaitingcallerid
TRUE if send caller ID for Call Waiting.
unsigned int manages_span_alarms
TRUE if the channel alarms will be managed also as Span ones.
unsigned int ani_wink_time
INTEGER, length of time to wait before sending ANI wink in ms.
int waitfordialtone
Number of milliseconds to wait for dialtone.
unsigned int locallyblocked
Bitmask for the channel being locally blocked.
unsigned int adsi
TRUE if ADSI (Analog Display Services Interface) available.
unsigned int usedistinctiveringdetection
TRUE if distinctive rings are to be detected.
unsigned int answeronpolarityswitch
TRUE if we can use a polarity reversal to mark when an outgoing call is answered by the remote party.
unsigned int threewaycalling
TRUE if three way calling is enabled.
struct dahdi_subchannel subs[3]
struct dahdi_confinfo saveconf
unsigned int use_callingpres
TRUE if we will use the calling presentation setting from the Asterisk channel for outgoing calls.
unsigned int pulse
TRUE if we will pulse dial.
int dialtone_scanning_time_elapsed
unsigned int priexclusive
TRUE if PRI B channels are always exclusively selected.
char mailbox[AST_MAX_MAILBOX_UNIQUEID]
Voice mailbox location.
float hwrxgain
Hardware Rx gain set by chan_dahdi.conf.
int echotraining
Echo training time. 0 = disabled.
char callwait_num[AST_MAX_EXTENSION]
Call waiting number.
float hwtxgain
Hardware Tx gain set by chan_dahdi.conf.
int waitfordialtoneduration
Transient variable. Stored off waitfordialtone duration at runtime.
int dsp_features
DSP feature flags: DSP_FEATURE_xxx.
unsigned int callwaiting
TRUE if busy extensions will hear the call-waiting tone and can use hook-flash to switch between call...
char exten[AST_MAX_EXTENSION]
Extension to use in the dialplan.
int callprogress
Bitmapped call progress detection flags. CALLPROGRESS_xxx values.
int callwaitcas
TRUE if Call Waiting (CW) CPE Alert Signal (CAS) is being sent.
struct timeval polaritydelaytv
Start delay time if polarityonanswerdelay is nonzero.
unsigned int hanguponpolarityswitch
TRUE if the call will be considered "hung up" on a polarity reversal.
char dnid[AST_MAX_EXTENSION]
Dialed Number Identifier.
char dialstring[AST_CHANNEL_NAME]
unsigned int callwaitingdeluxe
TRUE if Call Waiting Deluxe options should be available.
char call_forward[AST_MAX_EXTENSION]
Accumulated call forwarding number.
char description[32]
A description for the channel configuration.
unsigned int firstradio
TRUE if over a radio and dahdi_read() has been called.
unsigned int remotelyblocked
Bitmask for the channel being remotely blocked. 1 maintenance, 2 blocked in hardware.
struct dahdi_pvt::@115 echocancel
Echo cancel parameters.
unsigned int hidecallerid
TRUE if the outgoing caller ID is blocked/hidden.
unsigned int echobreak
XXX BOOLEAN Purpose???
struct dahdi_echocanparam params[DAHDI_MAX_ECHOCANPARAMS]
unsigned int callreturn
TRUE if call return is enabled. (*69, if your dialplan doesn't catch this first)
struct ast_namedgroups * named_pickupgroups
Named pickup groups this belongs to.
struct ast_channel * owner
char rdnis[AST_MAX_EXTENSION]
Redirecting Directory Number Information Service (RDNIS) number.
unsigned int faxhandled
TRUE if a fax tone has already been handled.
unsigned int use_smdi
TRUE if SMDI (Simplified Message Desk Interface) is enabled.
struct callerid_state * cs
int cid_ani2
Automatic Number Identification code from PRI.
struct ast_namedgroups * named_callgroups
Named call groups this belongs to.
int callwaitrings
Number of call waiting rings.
unsigned int mwimonitor_neon
TRUE if the FXO port monitors for neon type MWI indications from the other end.
unsigned int dialednone
TRUE if analog type line dialed no digits in Dial()
unsigned int hwrxgain_enabled
TRUE if hardware Rx gain set by Asterisk.
int law_default
Default call PCM encoding format: DAHDI_LAW_ALAW or DAHDI_LAW_MULAW.
int fake_event
Holding place for event injected from outside normal operation.
char echorest[20]
Filled with 'w'. XXX Purpose??
struct dahdi_pvt * slaves[MAX_SLAVES]
unsigned int ani_timeout
INTEGER, length of ANI failure timeout in ms.
int dtmfcid_holdoff_state
unsigned int lastnumredial
TRUE if last number redial enabled.
unsigned int mwioverride_active
TRUE if a manual MWI override is active for a channel.
unsigned int mwimonitor_fsk
TRUE if the FXO port monitors for fsk type MWI indications from the other end.
int ringt_base
Ring timeout base.
unsigned int destroy
TRUE if the channel is to be destroyed on hangup. (Used by pseudo channels.)
unsigned int restrictcid
TRUE if caller ID is restricted.
char defcontext[AST_MAX_CONTEXT]
Default distinctive ring context.
unsigned int priindication_oob
TRUE if PRI congestion/busy indications are sent out-of-band.
unsigned int ani_info_digits
INTEGER, number of ANI INFO digits on a CAMA trunk. older switches use 1 INFO digit,...
unsigned int busydetect
TRUE if busy detection is enabled. (Listens for the beep-beep busy pattern.)
unsigned int hidecalleridname
TRUE if hide just the name not the number for legacy PBX use.
struct timeval waitingfordt
struct ast_dsp * dsp
Opaque DSP configuration structure.
ast_group_t pickupgroup
Bitmapped pickup groups this belongs to.
unsigned int reoriginate
TRUE if FXS (FXO-signalled) channel should reoriginate for user to make a new call.
int cidpos
Position in the cidspill buffer to send out next.
char context[AST_MAX_CONTEXT]
The configured context for incoming calls.
unsigned int cancallforward
TRUE if support for call forwarding enabled. Dial *72 to enable call forwarding. Dial *73 to disable ...
int radio
Nonzero if the signaling type is sent over a radio.
char parkinglot[AST_MAX_EXTENSION]
unsigned int hardwaredtmf
TRUE if DTMF detection needs to be done by hardware.
char begindigit
DTMF digit in progress. 0 when no digit in progress.
struct ast_cc_config_params * cc_params
unsigned int mate
TRUE if TDD in MATE mode.
float txgain
Software Tx gain set by chan_dahdi.conf.
int firstdigit_timeout
Time (ms) to detect first digit (in an analog phone)
struct dahdi_echocanparams head
unsigned int echocanbridged
TRUE if echo cancellation enabled when bridged.
char finaldial[64]
Second part of SIG_FEATDMF_TA wink operation.
unsigned int transfer
TRUE if call transfer is enabled.
unsigned int transfertobusy
TRUE if allowed to flash-transfer to busy channels.
unsigned int inalarm
TRUE if in an alarm condition.
char cid_name[AST_MAX_EXTENSION]
Caller ID name from an incoming call.
unsigned int inservice
TRUE if channel is out of reset and ready.
char language[MAX_LANGUAGE]
Language configured for calls.
unsigned int digital
TRUE if the transfer capability of the call is digital.
char accountcode[AST_MAX_ACCOUNT_CODE]
unsigned int mwioverride_disposition
Manual MWI disposition (on/off)
struct ast_dsp_busy_pattern busy_cadence
Busy cadence pattern description.
int stripmsd
Number of most significant digits/characters to strip from the dialed number.
unsigned int pulsedial
TRUE if a pulsed digit was detected. (Pulse dial phone detected)
unsigned int calledsubscriberheld
TRUE if Called Subscriber held is enabled. This allows a single incoming call to hold a DAHDI channel...
int muting
TRUE if confrence is muted.
char cid_tag[AST_MAX_EXTENSION]
Caller ID tag from incoming call.
int matchdigit_timeout
Time (ms) to wait, in case of ambiguous match (in an analog phone)
char mohsuggest[MAX_MUSICCLASS]
Suggested music-on-hold class for peer channel to use for calls.
unsigned int use_callerid
TRUE if caller ID is used on this channel.
float rxgain
Software Rx gain set by chan_dahdi.conf.
int polarity
Current line interface polarity. POLARITY_IDLE, POLARITY_REV.
ast_group_t callgroup
Bitmapped call groups this belongs to.
unsigned int dialing
TRUE if in the process of dialing digits or sending something.
unsigned int usefaxbuffers
char callwait_name[AST_MAX_EXTENSION]
Call waiting name.
char mohinterpret[MAX_MUSICCLASS]
The configured music-on-hold class to use for calls.
int dialtone_detect
Number of frames to watch for dialtone in incoming calls.
struct ast_smdi_interface * smdi_iface
The SMDI interface to get SMDI messages from.
int cid_ton
Caller ID Q.931 TON/NPI field values. Set by PRI. Zero otherwise.
struct ast_channel * owner
struct dahdi_confinfo curconf
short buffer[AST_FRIENDLY_OFFSET/2+READ_SIZE]
unsigned int needcongestion
In case you didn't read that giant block of text above the mansession_session struct,...
unsigned char buf[READ_SIZE]
mwisend_states mwisend_current
struct ast_channel * peer
char contextData[AST_MAX_CONTEXT]
void(*const handle_dchan_exception)(struct sig_pri_span *pri, int index)
struct sig_pri_span * pri
enum sig_pri_reset_state resetting
Channel reset/restart state.
unsigned int allocated
TRUE when this channel is allocated.
unsigned int use_callingpres
unsigned int priexclusive
unsigned int hidecallerid
unsigned int priindication_oob
unsigned int hidecalleridname
char context[AST_MAX_CONTEXT]
unsigned int no_b_channel
TRUE if this interface has no B channel. (call hold and call waiting)
unsigned int use_callerid
char mohinterpret[MAX_MUSICCLASS]
struct sig_pri_chan * pvts[SIG_PRI_MAX_CHANNELS]
char idleext[AST_MAX_EXTENSION]
int fds[SIG_PRI_NUM_DCHANS]
int congestion_devstate
Congestion device state of the span.
char idledial[AST_MAX_EXTENSION]
void(*const lock_private)(void *pvt)
unsigned int locallyblocked
Bitmask for the channel being locally blocked.
unsigned int use_callingpres
TRUE if we will use the calling presentation setting from the Asterisk channel for outgoing calls.
struct isup_call * ss7call
Opaque libss7 call control structure.
unsigned int remotelyblocked
Bitmask for the channel being remotely blocked.
unsigned int hidecallerid
TRUE if the outgoing caller ID is blocked/hidden.
struct ast_channel * owner
char context[AST_MAX_CONTEXT]
unsigned int inalarm
TRUE if channel is associated with a link that is down.
unsigned int inservice
TRUE if channel is in service.
int stripmsd
Number of most significant digits/characters to strip from the dialed number.
unsigned int use_callerid
TRUE if caller ID is used on this channel.
char mohinterpret[MAX_MUSICCLASS]
int fds[SIG_SS7_NUM_DCHANS]
struct sig_ss7_chan * pvts[SIG_SS7_MAX_CHANNELS]
struct sla_ringing_trunk * next
TTY/TDD Generation support.
#define TDD_BYTES_PER_CHAR
int tdd_generate(struct tdd_state *tdd, unsigned char *buf, const char *string)
struct tdd_state * tdd_new(void)
void tdd_free(struct tdd_state *tdd)
int ast_tdd_gen_ecdisa(unsigned char *outbuf, int len)
int tdd_feed(struct tdd_state *tdd, unsigned char *ubuf, int samples)
Handy terminal functions for vt* terms.
char * term_color(char *outbuf, const char *inbuf, int fgcolor, int bgcolor, int maxout)
Colorize a specified string by adding terminal color codes.
int ast_remaining_ms(struct timeval start, int max_ms)
Calculate remaining milliseconds given a starting timestamp and upper bound.
int64_t ast_tvdiff_ms(struct timeval end, struct timeval start)
Computes the difference (in milliseconds) between two struct timeval instances.
struct timeval ast_tvnow(void)
Returns current timeval. Meant to replace calls to gettimeofday().
struct timeval ast_tv(ast_time_t sec, ast_suseconds_t usec)
Returns a timeval from sec, usec.
General Asterisk channel transcoding definitions.
#define AST_TRANS_CAP_DIGITAL
u-Law to Signed linear conversion
#define RAII_VAR(vartype, varname, initval, dtor)
Declare a variable that will call a destructor function when it goes out of scope.
#define ast_pthread_create(a, b, c, d)
#define ast_pthread_create_background(a, b, c, d)
#define ast_clear_flag(p, flag)
long int ast_random(void)
#define ast_pthread_create_detached(a, b, c, d)
#define ast_set_flag(p, flag)