retronetworking
/
chan-capi
mirror of https://github.com/MelwareDE/chan-capi.git
13
0
Fork 0
Code Issues Projects Releases Wiki Activity
chan-capi/chan_capi_utils.c

1810 lines
47 KiB
C
Raw Blame History

/*
* An implementation of Common ISDN API 2.0 for Asterisk
*
* Copyright (C) 2006-2009 Cytronics & Melware
*
* Armin Schindler <armin@melware.de>
*
* capi_sendf() by Eicon Networks / Dialogic
*
* This program is free software and may be modified and
* distributed under the terms of the GNU Public License.
*/
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <sys/types.h>
#include "chan_capi_platform.h"
#include "xlaw.h"
#include "chan_capi20.h"
#include "chan_capi.h"
#include "chan_capi_rtp.h"
#include "chan_capi_utils.h"
#include "chan_capi_supplementary.h"
#ifdef DIVA_STREAMING
#include "platform.h"
#include "diva_streaming_result.h"
#include "diva_streaming_messages.h"
#include "diva_streaming_vector.h"
#include "diva_streaming_manager.h"
#endif
int capidebug = 0;
char *emptyid = "\0";
AST_MUTEX_DEFINE_STATIC(verbose_lock);
AST_MUTEX_DEFINE_STATIC(messagenumber_lock);
AST_MUTEX_DEFINE_STATIC(capi_put_lock);
AST_MUTEX_DEFINE_STATIC(peerlink_lock);
AST_MUTEX_DEFINE_STATIC(nullif_lock);
static _cword capi_MessageNumber;
static struct capi_pvt *nulliflist = NULL;
static int controller_nullplcis[CAPI_MAX_CONTROLLERS];
#define CAPI_MAX_PEERLINKCHANNELS 32
static struct peerlink_s {
struct ast_channel *channel;
time_t age;
} peerlinkchannel[CAPI_MAX_PEERLINKCHANNELS];
#ifdef DIVA_STREAMING
AST_MUTEX_DEFINE_STATIC(stream_write_lock);
typedef enum _diva_stream_state {
DivaStreamCreated = 0,
DivaStreamActive = 1,
DivaStreamCancelSent = 2,
DivaStreamDisconnectSent = 3,
DivaStreamDisconnected = 4
} diva_stream_state_t;
typedef struct _diva_stream_scheduling_entry {
diva_entity_link_t link;
struct _diva_stream *diva_stream;
diva_stream_state_t diva_stream_state;
struct capi_pvt *i;
int rx_flow_control;
int tx_flow_control;
char vname[CAPI_MAX_STRING]; /* Cached from capi_pvt */
dword PLCI; /* Cached from capi_pvt */
time_t cancel_start;
} diva_stream_scheduling_entry_t;
static diva_entity_queue_t diva_streaming_new; /* protected by stream_write_lock, new streams */
#endif
/*
* helper for <pbx>_verbose
*/
void cc_verbose_internal(char *text, ...)
{
char line[4096];
va_list ap;
va_start(ap, text);
vsnprintf(line, sizeof(line), text, ap);
va_end(ap);
line[sizeof(line)-1]=0;
#if 0
{
FILE *fp;
if ((fp = fopen("/tmp/cclog", "a")) != NULL) {
fprintf(fp, "%s", line);
fclose(fp);
}
}
#endif
cc_mutex_lock(&verbose_lock);
cc_pbx_verbose("%s", line);
cc_mutex_unlock(&verbose_lock);
}
/*
* hangup and remove null-interface
*/
void capi_remove_nullif(struct capi_pvt *i)
{
struct capi_pvt *ii;
struct capi_pvt *tmp = NULL;
int state;
if (i->channeltype != CAPI_CHANNELTYPE_NULL) {
return;
}
cc_mutex_lock(&i->lock);
if (i->line_plci != 0) {
ii = i->line_plci;
i->line_plci = 0;
capi_remove_nullif(ii);
}
cc_mutex_unlock(&i->lock);
if (i->PLCI != 0) {
/* if the interface is in use, hangup first */
cc_mutex_lock(&i->lock);
state = i->state;
i->state = CAPI_STATE_DISCONNECTING;
capi_activehangup(i, state);
cc_mutex_unlock(&i->lock);
return;
}
cc_mutex_lock(&nullif_lock);
ii = nulliflist;
while (ii) {
if (ii == i) {
if (!tmp) {
nulliflist = ii->next;
} else {
tmp->next = ii->next;
}
cc_verbose(3, 1, VERBOSE_PREFIX_4 "%s: removed null-interface from controller %d.\n",
i->vname, i->controller);
if (i->smoother)
ast_smoother_free(i->smoother);
cc_mutex_destroy(&i->lock);
ast_cond_destroy(&i->event_trigger);
controller_nullplcis[i->controller - 1]--;
free(i);
break;
}
tmp = ii;
ii = ii->next;
}
cc_mutex_unlock(&nullif_lock);
}
int capi_verify_resource_plci(const struct capi_pvt *i) {
const struct capi_pvt *ii;
cc_mutex_lock(&nullif_lock);
for (ii = nulliflist; ii != 0 && ii != i; ii = ii->next);
cc_mutex_unlock(&nullif_lock);
return ((ii == i) ? 0 : -1);
}
/*
* create new null-interface
*/
struct capi_pvt *capi_mknullif(struct ast_channel *c, unsigned long long controllermask)
{
struct capi_pvt *tmp;
unsigned int controller = 1;
int contrcount;
int channelcount = 0xffff;
int maxcontr = (CAPI_MAX_CONTROLLERS > (sizeof(controllermask)*8)) ?
(sizeof(controllermask)*8) : CAPI_MAX_CONTROLLERS;
cc_verbose(3, 1, VERBOSE_PREFIX_4 "capi_mknullif: find controller for mask 0x%lx\n",
controllermask);
/* find the next controller of mask with least plcis used */
for (contrcount = 0; contrcount < maxcontr; contrcount++) {
if ((controllermask & (1ULL << contrcount)) != 0) {
if (controller_nullplcis[contrcount] < channelcount) {
channelcount = controller_nullplcis[contrcount];
controller = contrcount + 1;
}
}
}
tmp = malloc(sizeof(struct capi_pvt));
if (!tmp) {
return NULL;
}
memset(tmp, 0, sizeof(struct capi_pvt));
cc_mutex_init(&tmp->lock);
ast_cond_init(&tmp->event_trigger, NULL);
snprintf(tmp->name, sizeof(tmp->name) - 1, "%s-NULLPLCI", c->name);
snprintf(tmp->vname, sizeof(tmp->vname) - 1, "%s", tmp->name);
tmp->channeltype = CAPI_CHANNELTYPE_NULL;
tmp->used = c;
tmp->peer = c;
tmp->cip = CAPI_CIPI_SPEECH;
tmp->transfercapability = PRI_TRANS_CAP_SPEECH;
tmp->controller = controller;
tmp->doEC = 1;
tmp->doEC_global = 1;
tmp->ecOption = EC_OPTION_DISABLE_NEVER;
tmp->ecTail = EC_DEFAULT_TAIL;
tmp->isdnmode = CAPI_ISDNMODE_MSN;
tmp->ecSelector = FACILITYSELECTOR_ECHO_CANCEL;
tmp->capability = capi_capability;
tmp->rxgain = 1.0;
tmp->txgain = 1.0;
capi_gains(&tmp->g, 1.0, 1.0);
if (!(capi_create_reader_writer_pipe(tmp))) {
free(tmp);
return NULL;
}
tmp->bproto = CC_BPROTO_TRANSPARENT;
tmp->doB3 = CAPI_B3_DONT;
tmp->smoother = ast_smoother_new(CAPI_MAX_B3_BLOCK_SIZE);
tmp->isdnstate |= CAPI_ISDN_STATE_PBX;
cc_mutex_lock(&nullif_lock);
tmp->next = nulliflist; /* prepend */
nulliflist = tmp;
controller_nullplcis[tmp->controller - 1]++;
cc_mutex_unlock(&nullif_lock);
/* connect to driver */
tmp->outgoing = 1;
tmp->state = CAPI_STATE_CONNECTPENDING;
tmp->MessageNumber = get_capi_MessageNumber();
capi_sendf(NULL, 0, CAPI_CONNECT_REQ, controller, tmp->MessageNumber,
"w()()()()(www()()()())()()()((wwbbb)()()())",
0, 1,1,0, 3,0,0,0,0);
cc_verbose(3, 1, VERBOSE_PREFIX_4 "%s: created null-interface on controller %d.\n",
tmp->vname, tmp->controller);
return tmp;
}
struct capi_pvt *capi_mkresourceif(struct ast_channel *c, unsigned long long controllermask, struct capi_pvt *data_plci_ifc) {
struct capi_pvt *data_ifc /*, *line_ifc */;
unsigned int controller = 1;
if (data_plci_ifc == 0) {
int contrcount;
int channelcount = 0xffff;
int maxcontr = (CAPI_MAX_CONTROLLERS > (sizeof(controllermask)*8)) ?
(sizeof(controllermask)*8) : CAPI_MAX_CONTROLLERS;
cc_verbose(3, 1, VERBOSE_PREFIX_4 "capi_mkresourceif: find controller for mask 0x%lx\n",
controllermask);
/* find the next controller of mask with least plcis used */
for (contrcount = 0; contrcount < maxcontr; contrcount++) {
if ((controllermask & (1ULL << contrcount)) != 0) {
if (controller_nullplcis[contrcount] < channelcount) {
channelcount = controller_nullplcis[contrcount];
controller = contrcount + 1;
}
}
}
} else {
controller = data_plci_ifc->controller;
}
data_ifc = malloc(sizeof(struct capi_pvt));
if (data_ifc == 0) {
return NULL;
}
memset(data_ifc, 0, sizeof(struct capi_pvt));
cc_mutex_init(&data_ifc->lock);
ast_cond_init(&data_ifc->event_trigger, NULL);
snprintf(data_ifc->name, sizeof(data_ifc->name) - 1, "%s-%sPLCI", c->name, (data_plci_ifc == 0) ? "DATA" : "LINE");
snprintf(data_ifc->vname, sizeof(data_ifc->vname) - 1, "%s", data_ifc->name);
data_ifc->channeltype = CAPI_CHANNELTYPE_NULL;
data_ifc->resource_plci_type = (data_plci_ifc == 0) ? CAPI_RESOURCE_PLCI_DATA : CAPI_RESOURCE_PLCI_LINE;
data_ifc->used = c;
data_ifc->peer = c;
data_ifc->cip = CAPI_CIPI_SPEECH;
data_ifc->transfercapability = PRI_TRANS_CAP_SPEECH;
data_ifc->controller = controller;
data_ifc->doEC = 1;
data_ifc->doEC_global = 1;
data_ifc->ecOption = EC_OPTION_DISABLE_NEVER;
data_ifc->ecTail = EC_DEFAULT_TAIL;
data_ifc->isdnmode = CAPI_ISDNMODE_MSN;
data_ifc->ecSelector = FACILITYSELECTOR_ECHO_CANCEL;
data_ifc->capability = capi_capability;
data_ifc->rxgain = 1.0;
data_ifc->txgain = 1.0;
capi_gains(&data_ifc->g, 1.0, 1.0);
if (data_plci_ifc == 0) {
if (!(capi_create_reader_writer_pipe(data_ifc))) {
free(data_ifc);
return NULL;
}
} else {
data_ifc->readerfd = -1;
data_ifc->writerfd = -1;
}
data_ifc->bproto = CC_BPROTO_TRANSPARENT;
data_ifc->doB3 = CAPI_B3_DONT;
data_ifc->smoother = ast_smoother_new(CAPI_MAX_B3_BLOCK_SIZE);
data_ifc->isdnstate |= CAPI_ISDN_STATE_PBX;
cc_mutex_lock(&nullif_lock);
data_ifc->next = nulliflist; /* prepend */
nulliflist = data_ifc;
controller_nullplcis[data_ifc->controller - 1]++;
cc_mutex_unlock(&nullif_lock);
/* connect to driver */
data_ifc->outgoing = 1;
data_ifc->state = CAPI_STATE_CONNECTPENDING;
data_ifc->MessageNumber = get_capi_MessageNumber();
cc_mutex_lock(&data_ifc->lock);
capi_sendf(data_ifc,
1,
CAPI_MANUFACTURER_REQ,
controller,
data_ifc->MessageNumber,
"dw(wbb(www()()()()))",
_DI_MANU_ID,
_DI_ASSIGN_PLCI,
(data_plci_ifc == 0) ? 4 : 5, /* data */
(data_plci_ifc == 0) ? 0 : (unsigned char)(data_plci_ifc->PLCI >> 8), /* bchannel */
1, /* connect */
1, 1, 0);
cc_mutex_unlock(&data_ifc->lock);
if (data_plci_ifc != 0) {
if (data_ifc->PLCI == 0) {
cc_log(LOG_WARNING, "%s: failed to create\n", data_ifc->vname);
capi_remove_nullif(data_ifc);
data_ifc = 0;
} else {
cc_mutex_lock(&data_plci_ifc->lock);
data_plci_ifc->line_plci = data_ifc;
capi_sendf(data_plci_ifc, 1, CAPI_FACILITY_REQ, data_plci_ifc->PLCI, get_capi_MessageNumber(),
"w(w(d()))",
FACILITYSELECTOR_LINE_INTERCONNECT,
0x0001, /* CONNECT */
0x00000000 /* mask */
);
cc_mutex_unlock(&data_plci_ifc->lock);
data_ifc->data_plci = data_plci_ifc;
data_ifc->writerfd = data_plci_ifc->writerfd;
data_plci_ifc->writerfd = -1;
}
}
if (data_ifc != 0) {
cc_verbose(3, 1, VERBOSE_PREFIX_4 "%s: created %s-resource-interface on controller %d.\n",
data_ifc->vname, (data_plci_ifc == 0) ? "data" : "line", data_ifc->controller);
}
return data_ifc;
}
/*
* get a new capi message number atomically
*/
_cword get_capi_MessageNumber(void)
{
_cword mn;
cc_mutex_lock(&messagenumber_lock);
capi_MessageNumber++;
if (capi_MessageNumber == 0) {
/* avoid zero */
capi_MessageNumber = 1;
}
mn = capi_MessageNumber;
cc_mutex_unlock(&messagenumber_lock);
return mn;
}
/*
* find the interface (pvt) the PLCI belongs to
*/
struct capi_pvt *capi_find_interface_by_plci(unsigned int plci)
{
struct capi_pvt *i;
if (unlikely(plci == 0))
return NULL;
for (i = capi_iflist; i; i = i->next) {
if (i->PLCI == plci)
return i;
}
cc_mutex_lock(&nullif_lock);
for (i = nulliflist; i; i = i->next) {
if (i->PLCI == plci)
break;
}
cc_mutex_unlock(&nullif_lock);
return i;
}
/*
* find the interface (pvt) the messagenumber belongs to
*/
struct capi_pvt *capi_find_interface_by_msgnum(unsigned short msgnum)
{
struct capi_pvt *i;
if (msgnum == 0x0000)
return NULL;
for (i = capi_iflist; i; i = i->next) {
if ((i->PLCI == 0) && (i->MessageNumber == msgnum))
return i;
}
cc_mutex_lock(&nullif_lock);
for (i = nulliflist; i; i = i->next) {
if ((i->PLCI == 0) && (i->MessageNumber == msgnum))
break;
}
cc_mutex_unlock(&nullif_lock);
return i;
}
/*
* wait for a specific message
*/
MESSAGE_EXCHANGE_ERROR capi_wait_conf(struct capi_pvt *i, unsigned short wCmd)
{
MESSAGE_EXCHANGE_ERROR error = 0;
struct timespec abstime;
unsigned char command, subcommand;
subcommand = wCmd & 0xff;
command = (wCmd & 0xff00) >> 8;
i->waitevent = (unsigned int)wCmd;
abstime.tv_sec = time(NULL) + 2;
abstime.tv_nsec = 0;
cc_verbose(4, 1, "%s: wait for %s (0x%x)\n",
i->vname, capi_cmd2str(command, subcommand), i->waitevent);
if (ast_cond_timedwait(&i->event_trigger, &i->lock, &abstime) != 0) {
error = -1;
cc_log(LOG_WARNING, "%s: timed out waiting for %s\n",
i->vname, capi_cmd2str(command, subcommand));
} else {
cc_verbose(4, 1, "%s: cond signal received for %s\n",
i->vname, capi_cmd2str(command, subcommand));
}
return error;
}
/*
* log an error in sending capi message
*/
static void log_capi_error_message(MESSAGE_EXCHANGE_ERROR err, unsigned char* msg)
{
if (err) {
_cmsg _CMSG, *CMSG = &_CMSG;
capi_message2cmsg(CMSG, msg);
cc_log(LOG_ERROR, "CAPI error sending %s (NCCI=%#x) (error=%#x %s)\n",
capi_cmsg2str(CMSG), (unsigned int)HEADER_CID(CMSG),
err, capi_info_string((unsigned int)err));
}
}
/*
* log verbose a capi message
*/
static void log_capi_message(_cmsg *CMSG)
{
unsigned short wCmd;
wCmd = HEADER_CMD(CMSG);
if ((wCmd == CAPI_P_REQ(DATA_B3)) ||
(wCmd == CAPI_P_RESP(DATA_B3))) {
cc_verbose(7, 1, "%s\n", capi_cmsg2str(CMSG));
} else {
cc_verbose(4, 1, "%s\n", capi_cmsg2str(CMSG));
}
}
/*
* write a capi message to capi device
*/
static MESSAGE_EXCHANGE_ERROR _capi_put_msg(unsigned char *msg)
{
MESSAGE_EXCHANGE_ERROR error;
_cmsg CMSG;
if (cc_mutex_lock(&capi_put_lock)) {
cc_log(LOG_WARNING, "Unable to lock chan_capi put!\n");
return -1;
}
if (cc_verbose_check(4, 1) != 0) {
capi_message2cmsg(&CMSG, msg);
log_capi_message(&CMSG);
}
error = capi20_put_message(capi_ApplID, msg);
if (cc_mutex_unlock(&capi_put_lock)) {
cc_log(LOG_WARNING, "Unable to unlock chan_capi put!\n");
return -1;
}
log_capi_error_message(error, msg);
return error;
}
/*
* wait some time for a new capi message
*/
MESSAGE_EXCHANGE_ERROR capidev_check_wait_get_cmsg(_cmsg *CMSG)
{
MESSAGE_EXCHANGE_ERROR Info;
struct timeval tv;
tv.tv_sec = 0;
#ifdef DIVA_STREAMING
tv.tv_usec = 5000;
#else
tv.tv_usec = 500000;
#endif
Info = capi20_waitformessage(capi_ApplID, &tv);
if (Info == 0x0000) {
Info = capi_get_cmsg(CMSG, capi_ApplID);
#if (CAPI_OS_HINT == 1) || (CAPI_OS_HINT == 2)
if (Info == 0x0000) {
/*
* For BSD allow controller 0:
*/
if ((HEADER_CID(CMSG) & 0xFF) == 0) {
HEADER_CID(CMSG) += capi_num_controllers;
}
}
#endif
}
if ((Info != 0x0000) && (Info != 0x1104)) {
if (capidebug) {
cc_log(LOG_DEBUG, "Error waiting for cmsg... INFO = %#x\n", Info);
}
}
return Info;
}
/*
* Eicon's capi_sendf() function to create capi messages easily
* and send this message.
* Copyright by Eicon Networks / Dialogic
*/
MESSAGE_EXCHANGE_ERROR capi_sendf(
struct capi_pvt *capii, int waitconf,
_cword command, _cdword Id, _cword Number, char * format, ...)
{
MESSAGE_EXCHANGE_ERROR ret;
int i, j;
unsigned int d;
unsigned char *p, *p_length;
unsigned char *string;
unsigned short header_length;
va_list ap;
capi_prestruct_t *s;
unsigned char msg[2048];
write_capi_word(&msg[2], capi_ApplID);
msg[4] = (unsigned char)((command >> 8) & 0xff);
msg[5] = (unsigned char)(command & 0xff);
write_capi_word(&msg[6], Number);
write_capi_dword(&msg[8], Id);
p = &msg[12];
p_length = 0;
va_start(ap, format);
for (i = 0; format[i]; i++) {
if (unlikely(((p - (&msg[0])) + 12) >= sizeof(msg))) {
cc_log(LOG_ERROR, "capi_sendf: message too big (%d)\n",
(int)(p - (&msg[0])));
return 0x1004;
}
switch(format[i]) {
case 'b': /* byte */
d = (unsigned char)va_arg(ap, unsigned int);
*(p++) = (unsigned char) d;
break;
case 'w': /* word (2 bytes) */
d = (unsigned short)va_arg(ap, unsigned int);
*(p++) = (unsigned char) d;
*(p++) = (unsigned char)(d >> 8);
break;
case 'd': /* double word (4 bytes) */
d = va_arg(ap, unsigned int);
*(p++) = (unsigned char) d;
*(p++) = (unsigned char)(d >> 8);
*(p++) = (unsigned char)(d >> 16);
*(p++) = (unsigned char)(d >> 24);
break;
case 's': /* struct, length is the first byte */
string = va_arg(ap, unsigned char *);
if (string == NULL) {
*(p++) = 0;
} else {
for (j = 0; j <= string[0]; j++)
*(p++) = string[j];
}
break;
case 'a': /* ascii string, NULL terminated string */
string = va_arg(ap, unsigned char *);
for (j = 0; string[j] != '\0'; j++)
*(++p) = string[j];
*((p++)-j) = (unsigned char) j;
break;
case 'c': /* predefined capi_prestruct_t */
s = va_arg(ap, capi_prestruct_t *);
if (s->wLen < 0xff) {
*(p++) = (unsigned char)(s->wLen);
} else {
*(p++) = 0xff;
*(p++) = (unsigned char)(s->wLen);
*(p++) = (unsigned char)(s->wLen >> 8);
}
for (j = 0; j < s->wLen; j++)
*(p++) = s->info[j];
break;
case '(': /* begin of a structure */
*p = (p_length) ? p - p_length : 0;
p_length = p++;
break;
case ')': /* end of structure */
if (p_length) {
j = *p_length;
*p_length = (unsigned char)((p - p_length) - 1);
p_length = (j != 0) ? p_length - j : 0;
} else {
cc_log(LOG_ERROR, "capi_sendf: inconsistent format \"%s\"\n",
format);
}
break;
default:
cc_log(LOG_ERROR, "capi_sendf: unknown format \"%s\"\n",
format);
}
}
va_end(ap);
if (p_length) {
cc_log(LOG_ERROR, "capi_sendf: inconsistent format \"%s\"\n", format);
}
header_length = (unsigned short)(p - (&msg[0]));
if ((sizeof(void *) > 4) && (command == CAPI_DATA_B3_REQ)) {
void* req_data;
va_start(ap, format);
req_data = va_arg(ap, void *);
va_end(ap);
header_length += 8;
write_capi_dword(&msg[12], 0);
memcpy(&msg[22], &req_data, sizeof(void *));
}
write_capi_word(&msg[0], header_length);
ret = _capi_put_msg(&msg[0]);
if ((!(ret)) && (waitconf)) {
ret = capi_wait_conf(capii, (command & 0xff00) | CAPI_CONF);
}
return ret;
}
/*
* decode capi 2.0 info word
*/
char *capi_info_string(unsigned int info)
{
switch (info) {
/* informative values (corresponding message was processed) */
case 0x0001:
return "NCPI not supported by current protocol, NCPI ignored";
case 0x0002:
return "Flags not supported by current protocol, flags ignored";
case 0x0003:
return "Alert already sent by another application";
/* error information concerning CAPI_REGISTER */
case 0x1001:
return "Too many applications";
case 0x1002:
return "Logical block size to small, must be at least 128 Bytes";
case 0x1003:
return "Buffer exceeds 64 kByte";
case 0x1004:
return "Message buffer size too small, must be at least 1024 Bytes";
case 0x1005:
return "Max. number of logical connections not supported";
case 0x1006:
return "Reserved";
case 0x1007:
return "The message could not be accepted because of an internal busy condition";
case 0x1008:
return "OS resource error (no memory ?)";
case 0x1009:
return "CAPI not installed";
case 0x100A:
return "Controller does not support external equipment";
case 0x100B:
return "Controller does only support external equipment";
/* error information concerning message exchange functions */
case 0x1101:
return "Illegal application number";
case 0x1102:
return "Illegal command or subcommand or message length less than 12 bytes";
case 0x1103:
return "The message could not be accepted because of a queue full condition !! The error code does not imply that CAPI cannot receive messages directed to another controller, PLCI or NCCI";
case 0x1104:
return "Queue is empty";
case 0x1105:
return "Queue overflow, a message was lost !! This indicates a configuration error. The only recovery from this error is to perform a CAPI_RELEASE";
case 0x1106:
return "Unknown notification parameter";
case 0x1107:
return "The Message could not be accepted because of an internal busy condition";
case 0x1108:
return "OS Resource error (no memory ?)";
case 0x1109:
return "CAPI not installed";
case 0x110A:
return "Controller does not support external equipment";
case 0x110B:
return "Controller does only support external equipment";
/* error information concerning resource / coding problems */
case 0x2001:
return "Message not supported in current state";
case 0x2002:
return "Illegal Controller / PLCI / NCCI";
case 0x2003:
return "Out of PLCIs";
case 0x2004:
return "Out of NCCIs";
case 0x2005:
return "Out of LISTEN requests";
case 0x2006:
return "Out of FAX resources (protocol T.30)";
case 0x2007:
return "Illegal message parameter coding";
/* error information concerning requested services */
case 0x3001:
return "B1 protocol not supported";
case 0x3002:
return "B2 protocol not supported";
case 0x3003:
return "B3 protocol not supported";
case 0x3004:
return "B1 protocol parameter not supported";
case 0x3005:
return "B2 protocol parameter not supported";
case 0x3006:
return "B3 protocol parameter not supported";
case 0x3007:
return "B protocol combination not supported";
case 0x3008:
return "NCPI not supported";
case 0x3009:
return "CIP Value unknown";
case 0x300A:
return "Flags not supported (reserved bits)";
case 0x300B:
return "Facility not supported";
case 0x300C:
return "Data length not supported by current protocol";
case 0x300D:
return "Reset procedure not supported by current protocol";
case 0x300E:
return "TEI assignment failed or supplementary service not supported";
case 0x3010:
return "Request not allowed in this state";
/* informations about the clearing of a physical connection */
case 0x3301:
return "Protocol error layer 1 (broken line or B-channel removed by signalling protocol)";
case 0x3302:
return "Protocol error layer 2";
case 0x3303:
return "Protocol error layer 3";
case 0x3304:
return "Another application got that call";
/* T.30 specific reasons */
case 0x3311:
return "Connecting not successful (remote station is no FAX G3 machine)";
case 0x3312:
return "Connecting not successful (training error)";
case 0x3313:
return "Disconnected before transfer (remote station does not support transfer mode, e.g. resolution)";
case 0x3314:
return "Disconnected during transfer (remote abort)";
case 0x3315:
return "Disconnected during transfer (remote procedure error, e.g. unsuccessful repetition of T.30 commands)";
case 0x3316:
return "Disconnected during transfer (local tx data underrun)";
case 0x3317:
return "Disconnected during transfer (local rx data overflow)";
case 0x3318:
return "Disconnected during transfer (local abort)";
case 0x3319:
return "Illegal parameter coding (e.g. SFF coding error)";
/* disconnect causes from the network according to ETS 300 102-1/Q.931 */
case 0x3481:
return "Unallocated (unassigned) number";
case 0x3482:
return "No route to specified transit network";
case 0x3483:
return "No route to destination";
case 0x3486:
return "Channel unacceptable";
case 0x3487:
return "Call awarded and being delivered in an established channel";
case 0x3490:
return "Normal call clearing";
case 0x3491:
return "User busy";
case 0x3492:
return "No user responding";
case 0x3493:
return "No answer from user (user alerted)";
case 0x3495:
return "Call rejected";
case 0x3496:
return "Number changed";
case 0x349A:
return "Non-selected user clearing";
case 0x349B:
return "Destination out of order";
case 0x349C:
return "Invalid number format";
case 0x349D:
return "Facility rejected";
case 0x349E:
return "Response to STATUS ENQUIRY";
case 0x349F:
return "Normal, unspecified";
case 0x34A2:
return "No circuit / channel available";
case 0x34A6:
return "Network out of order";
case 0x34A9:
return "Temporary failure";
case 0x34AA:
return "Switching equipment congestion";
case 0x34AB:
return "Access information discarded";
case 0x34AC:
return "Requested circuit / channel not available";
case 0x34AF:
return "Resources unavailable, unspecified";
case 0x34B1:
return "Quality of service unavailable";
case 0x34B2:
return "Requested facility not subscribed";
case 0x34B9:
return "Bearer capability not authorized";
case 0x34BA:
return "Bearer capability not presently available";
case 0x34BF:
return "Service or option not available, unspecified";
case 0x34C1:
return "Bearer capability not implemented";
case 0x34C2:
return "Channel type not implemented";
case 0x34C5:
return "Requested facility not implemented";
case 0x34C6:
return "Only restricted digital information bearer capability is available";
case 0x34CF:
return "Service or option not implemented, unspecified";
case 0x34D1:
return "Invalid call reference value";
case 0x34D2:
return "Identified channel does not exist";
case 0x34D3:
return "A suspended call exists, but this call identity does not";
case 0x34D4:
return "Call identity in use";
case 0x34D5:
return "No call suspended";
case 0x34D6:
return "Call having the requested call identity has been cleared";
case 0x34D8:
return "Incompatible destination";
case 0x34DB:
return "Invalid transit network selection";
case 0x34DF:
return "Invalid message, unspecified";
case 0x34E0:
return "Mandatory information element is missing";
case 0x34E1:
return "Message type non-existent or not implemented";
case 0x34E2:
return "Message not compatible with call state or message type non-existent or not implemented";
case 0x34E3:
return "Information element non-existent or not implemented";
case 0x34E4:
return "Invalid information element contents";
case 0x34E5:
return "Message not compatible with call state";
case 0x34E6:
return "Recovery on timer expiry";
case 0x34EF:
return "Protocol error, unspecified";
case 0x34FF:
return "Interworking, unspecified";
/* B3 protocol 7 (Modem) */
case 0x3500:
return "Normal end of connection";
case 0x3501:
return "Carrier lost";
case 0x3502:
return "Error on negotiation, i.e. no modem with error correction at other end";
case 0x3503:
return "No answer to protocol request";
case 0x3504:
return "Remote modem only works in synchronous mode";
case 0x3505:
return "Framing fails";
case 0x3506:
return "Protocol negotiation fails";
case 0x3507:
return "Other modem sends wrong protocol request";
case 0x3508:
return "Sync information (data or flags) missing";
case 0x3509:
return "Normal end of connection from the other modem";
case 0x350a:
return "No answer from other modem";
case 0x350b:
return "Protocol error";
case 0x350c:
return "Error on compression";
case 0x350d:
return "No connect (timeout or wrong modulation)";
case 0x350e:
return "No protocol fall-back allowed";
case 0x350f:
return "No modem or fax at requested number";
case 0x3510:
return "Handshake error";
/* error info concerning the requested supplementary service */
case 0x3600:
return "Supplementary service not subscribed";
case 0x3603:
return "Supplementary service not available";
case 0x3604:
return "Supplementary service not implemented";
case 0x3606:
return "Invalid served user number";
case 0x3607:
return "Invalid call state";
case 0x3608:
return "Basic service not provided";
case 0x3609:
return "Supplementary service not requested for an incoming call";
case 0x360a:
return "Supplementary service interaction not allowed";
case 0x360b:
return "Resource unavailable";
/* error info concerning the context of a supplementary service request */
case 0x3700:
return "Duplicate invocation";
case 0x3701:
return "Unrecognized operation";
case 0x3702:
return "Mistyped argument";
case 0x3703:
return "Resource limitation";
case 0x3704:
return "Initiator releasing";
case 0x3705:
return "Unrecognized linked-ID";
case 0x3706:
return "Linked response unexpected";
case 0x3707:
return "Unexpected child operation";
/* Line Interconnect */
case 0x3800:
return "PLCI has no B-channel";
case 0x3801:
return "Lines not compatible";
case 0x3802:
return "PLCI(s) is (are) not in any or not in the same interconnection";
default:
return NULL;
}
}
/*
* show the text for a CAPI message info value
*/
void show_capi_info(struct capi_pvt *i, _cword info)
{
char *p;
char *name = "?";
if (info == 0x0000) {
/* no error, do nothing */
return;
}
if (!(p = capi_info_string((unsigned int)info))) {
/* message not available */
return;
}
if (i)
name = i->vname;
cc_verbose(3, 0, VERBOSE_PREFIX_4 "%s: CAPI INFO 0x%04x: %s\n",
name, info, p);
}
/*
* send Listen to specified controller
*/
unsigned capi_ListenOnController(unsigned int CIPmask, unsigned controller)
{
MESSAGE_EXCHANGE_ERROR error;
int waitcount = 50;
_cmsg CMSG;
error = capi_sendf(NULL, 0, CAPI_LISTEN_REQ, controller, get_capi_MessageNumber(),
"ddd()()",
0x0000ffff,
CIPmask,
0
);
if (error)
goto done;
while (waitcount) {
error = capidev_check_wait_get_cmsg(&CMSG);
if (IS_LISTEN_CONF(&CMSG)) {
error = LISTEN_CONF_INFO(&CMSG);
ListenOnSupplementary(controller);
break;
}
usleep(30000);
waitcount--;
}
if (!waitcount)
error = 0x100F;
done:
return error;
}
/*
* Activate access to vendor specific extensions
*/
unsigned capi_ManufacturerAllowOnController(unsigned controller)
{
MESSAGE_EXCHANGE_ERROR error;
int waitcount = 50;
unsigned char manbuf[CAPI_MANUFACTURER_LEN];
_cmsg CMSG;
if (capi20_get_manufacturer(controller, manbuf) == NULL) {
error = CapiRegOSResourceErr;
goto done;
}
if ((strstr((char *)manbuf, "Eicon") == 0) &&
(strstr((char *)manbuf, "Dialogic") == 0)) {
error = 0x100F;
goto done;
}
error = capi_sendf (NULL, 0, CAPI_MANUFACTURER_REQ, controller, get_capi_MessageNumber(),
"dw(d)", _DI_MANU_ID, _DI_OPTIONS_REQUEST, 0x00000020L);
if (error)
goto done;
while (waitcount) {
error = capidev_check_wait_get_cmsg(&CMSG);
if (IS_MANUFACTURER_CONF(&CMSG) && (CMSG.ManuID == _DI_MANU_ID) &&
((CMSG.Class & 0xffff) == _DI_OPTIONS_REQUEST)) {
error = (MESSAGE_EXCHANGE_ERROR)(CMSG.Class >> 16);
break;
}
usleep(30000);
waitcount--;
}
if (!waitcount)
error = 0x100F;
done:
return error;
}
#ifdef DIVA_STREAMING
static int divaStreamingMessageRx (void* user_context, dword message, dword length, const struct _diva_streaming_vector* v, dword nr_v)
{
diva_stream_scheduling_entry_t* pE = (diva_stream_scheduling_entry_t*)user_context;
dword message_type = (message & 0xff);
if (message_type == 0) { /* IDI message */
dword offset = 0;
diva_streaming_vector_t vind[8];
byte Ind = 0;
int vind_nr = 0;
int process_indication;
do {
vind_nr = sizeof(vind)/sizeof(vind[0]);
offset = diva_streaming_get_indication_data (offset, message, length, v, nr_v, &Ind, vind, &vind_nr);
process_indication = (diva_streaming_idi_supported_ind (Ind, vind_nr != 0, vind_nr != 0 ? (byte*)vind->data : (byte*)"") != 0);
if (likely(process_indication != 0)) {
if (likely(Ind == 8)) {
if (likely(pE->i != 0 && pE->i->NCCI != 0))
capidev_handle_data_b3_indication_vector (pE->i, vind, vind_nr);
} else {
dword i = 0, k = 0;
word data_length;
byte ind_data_buffer[2048+512];
data_length = (word)diva_streaming_read_vector_data (vind, vind_nr, &i, &k, ind_data_buffer, sizeof(ind_data_buffer));
DBG_TRC(("Ind: %02x length:%u", Ind, data_length))
}
}
} while (offset != 0);
} else if (message_type == 0xff) { /* System message */
switch ((byte)(message >> 8)) {
case DIVA_STREAM_MESSAGE_INIT: /* Stream active */
cc_verbose(3, 0, VERBOSE_PREFIX_2 "%s: stream active (PLCI=%#x)\n", pE->vname, pE->PLCI);
if (pE->diva_stream_state == DivaStreamCreated) {
pE->diva_stream_state = DivaStreamActive;
} else if (pE->diva_stream_state == DivaStreamCancelSent) {
pE->diva_stream->release_stream(pE->diva_stream);
pE->i = 0;
pE->diva_stream_state = DivaStreamDisconnectSent;
}
break;
case DIVA_STREAM_MESSAGE_RX_TX_ACK: /* Resolved Tx flow control */
/* cc_verbose(4, 1, "%s: stream tx ack (PLCI=%#x)\n", pE->vname, pE->PLCI); */
break;
case DIVA_STREAM_MESSAGE_SYNC_ACK: /* Sync ack request acknowledge */
cc_verbose(4, 1, "%s: stream sync ack (PLCI=%#x, sequence=%08x)\n", pE->vname, pE->PLCI, length);
break;
case DIVA_STREAM_MESSAGE_RELEASE_ACK: /* Release stream acknowledge */
pE->diva_stream_state = DivaStreamDisconnected;
pE->diva_stream = 0;
cc_verbose(3, 0, VERBOSE_PREFIX_2 "%s: stream released (PLCI=%#x)\n", pE->vname, pE->PLCI);
break;
case DIVA_STREAM_MESSAGE_INIT_ERROR: /* Failed to initialize stream */
pE->diva_stream_state = DivaStreamDisconnected;
pE->diva_stream = 0;
cc_verbose(3, 0, VERBOSE_PREFIX_2 "%s: stream init error (PLCI=%#x, error=%d)\n", pE->vname, pE->PLCI, length);
break;
default:
cc_verbose(3, 0, VERBOSE_PREFIX_2 "%s: stream unknown system message (PLCI=%#x, message=%08x)\n", pE->vname, pE->PLCI, message);
break;
}
} else {
cc_verbose(3, 0, VERBOSE_PREFIX_2 "%s: unknown stream message (PLCI=%#x, message=%08x)\n", pE->vname, pE->PLCI, message);
}
return (0);
}
/*
* Create Diva stream
*
*/
void capi_DivaStreamingOn(struct capi_pvt *i)
{
diva_stream_scheduling_entry_t* pE;
int ret;
char trace_ident[8];
pE = malloc (sizeof(*pE));
if (pE == 0)
return;
snprintf (trace_ident, sizeof(trace_ident), "C%02x", (byte)i->PLCI);
trace_ident[sizeof(trace_ident)-1] = 0;
cc_mutex_lock(&stream_write_lock);
ret = diva_stream_create (&pE->diva_stream, NULL, 255, divaStreamingMessageRx, pE, trace_ident);
if (ret == 0) {
byte* description = (byte*)pE->diva_stream->description (pE->diva_stream);
MESSAGE_EXCHANGE_ERROR error;
description[3] |= 0x01;
error = capi_sendf (NULL, 0, CAPI_MANUFACTURER_REQ, i->PLCI, get_capi_MessageNumber(),
"dws", _DI_MANU_ID, _DI_STREAM_CTRL, description);
if (error == 0) {
pE->diva_stream_state = DivaStreamCreated;
pE->PLCI = i->PLCI;
pE->i = i;
i->diva_stream_entry = pE;
memcpy (pE->vname, i->vname, MIN(sizeof(pE->vname), sizeof(i->vname)));
pE->vname[sizeof(pE->vname)-1] = 0;
pE->rx_flow_control = 0;
pE->tx_flow_control = 0;
diva_q_add_tail (&diva_streaming_new, &pE->link);
} else {
pE->diva_stream->release (pE->diva_stream);
free (pE);
}
}
cc_mutex_unlock(&stream_write_lock);
}
/*
* Remove stream info
*
* To remove stream from one active connection:
* remove stream info
* disconnect B3
* remove stream
* select_b
*/
void capi_DivaStreamingRemoveInfo(struct capi_pvt *i)
{
byte description[] = { 2, 0, 0 };
MESSAGE_EXCHANGE_ERROR error;
int send;
cc_mutex_lock(&stream_write_lock);
send = i->diva_stream_entry != 0;
cc_mutex_unlock(&stream_write_lock);
if (send != 0)
error = capi_sendf (NULL, 0, CAPI_MANUFACTURER_REQ, i->PLCI, get_capi_MessageNumber(),
"dws", _DI_MANU_ID, _DI_STREAM_CTRL, description);
}
void capi_DivaStreamingRemove(struct capi_pvt *i)
{
diva_stream_scheduling_entry_t* pE = i->diva_stream_entry;
int send_cancel = 0;
cc_mutex_lock(&stream_write_lock);
pE = i->diva_stream_entry;
if (pE != 0) {
i->diva_stream_entry = 0;
pE->i = 0;
if (pE->diva_stream_state == DivaStreamCreated) {
if (i->NCCI != 0) {
/*
If NCCI is not sen then this is no possibility to send cancel request
to queued in the IDI L2 streaming info. But in user mode this is OK,
if removing PLCI CAPI removes networking entity and this operation
causes cancellation of create streaming request.
Timeout is only for the rare case where create streaming request was newer
sent to hardware.
*/
send_cancel = 1;
}
pE->diva_stream_state = DivaStreamCancelSent;
pE->cancel_start = time(NULL) + 5;
DBG_LOG(("stream cancelled [%p]", pE->diva_stream))
} else if (pE->diva_stream_state == DivaStreamActive) {
pE->diva_stream->release_stream(pE->diva_stream);
pE->diva_stream_state = DivaStreamDisconnectSent;
}
}
cc_mutex_unlock(&stream_write_lock);
if (send_cancel != 0) {
static byte data[] = { 0x8 /* CONTROL */, 0x01 /* CANCEL */};
MESSAGE_EXCHANGE_ERROR error;
error = capi_sendf(NULL, 0, CAPI_DATA_B3_REQ, i->NCCI, get_capi_MessageNumber(),
"dwww", data, sizeof(data), 0, 1U << 4);
if (likely(error == 0)) {
cc_mutex_lock(&i->lock);
i->B3count++;
cc_mutex_unlock(&i->lock);
}
}
}
/*
This is only one used to access streaming scheduling list routine.
This ensures list can be accessed w/o anly locks
To ensure exclusive access scheduling queue is static function variable
*/
void divaStreamingWakeup (void) {
static diva_entity_queue_t active_streams;
diva_entity_link_t* link;
time_t current_time = time (NULL);
cc_mutex_lock(&stream_write_lock);
while ((link = diva_q_get_head (&diva_streaming_new)) != 0) {
diva_stream_scheduling_entry_t* pE = DIVAS_CONTAINING_RECORD(link, diva_stream_scheduling_entry_t, link);
diva_q_remove (&diva_streaming_new, &pE->link);
diva_q_add_tail (&active_streams, &pE->link);
}
cc_mutex_unlock(&stream_write_lock);
for (link = diva_q_get_head (&active_streams); likely(link != 0);) {
diva_entity_link_t* next = diva_q_get_next(link);
diva_stream_scheduling_entry_t* pE = DIVAS_CONTAINING_RECORD(link, diva_stream_scheduling_entry_t, link);
cc_mutex_lock(&stream_write_lock);
pE->diva_stream->wakeup (pE->diva_stream);
if (unlikely(pE->diva_stream_state == DivaStreamCancelSent && pE->cancel_start < current_time)) {
DBG_LOG(("stream reclaimed [%p]", pE->diva_stream))
pE->diva_stream->release (pE->diva_stream);
pE->diva_stream_state = DivaStreamDisconnected;
pE->diva_stream = 0;
}
if (unlikely(pE->diva_stream == 0)) {
diva_q_remove (&active_streams, &pE->link);
if (pE->i != 0) {
pE->i->diva_stream_entry = 0;
}
free (pE);
}
cc_mutex_unlock(&stream_write_lock);
link = next;
}
}
#endif
/*
* convert a number
*/
char *capi_number_func(unsigned char *data, unsigned int strip, char *buf)
{
unsigned int len;
if (data == NULL) {
buf[0] = '\0';
return buf;
}
if (data[0] == 0xff) {
len = read_capi_word(&data[1]);
data += 2;
} else {
len = data[0];
data += 1;
}
if (len > (AST_MAX_EXTENSION - 1))
len = (AST_MAX_EXTENSION - 1);
/* convert a capi struct to a \0 terminated string */
if ((!len) || (len < strip))
return NULL;
len = len - strip;
data += strip;
memcpy(buf, data, len);
buf[len] = '\0';
return buf;
}
/*
* parse the dialstring
*/
void capi_parse_dialstring(char *buffer, char **interface, char **dest, char **param, char **ocid)
{
int cp = 0;
char *buffer_p = buffer;
char *oc;
/* interface is the first part of the string */
*interface = buffer;
*dest = emptyid;
*param = emptyid;
*ocid = NULL;
while (*buffer_p) {
if (*buffer_p == '/') {
*buffer_p = 0;
buffer_p++;
if (cp == 0) {
*dest = buffer_p;
cp++;
} else if (cp == 1) {
*param = buffer_p;
cp++;
} else {
cc_log(LOG_WARNING, "Too many parts in dialstring '%s'\n",
buffer);
}
continue;
}
buffer_p++;
}
if ((oc = strchr(*dest, ':')) != NULL) {
*ocid = *dest;
*oc = '\0';
*dest = oc + 1;
}
cc_verbose(3, 1, VERBOSE_PREFIX_4 "parsed dialstring: '%s' '%s' '%s' '%s'\n",
*interface, (*ocid) ? *ocid : "NULL", *dest, *param);
return;
}
/*
* Add a new peer link id
*/
int cc_add_peer_link_id(struct ast_channel *c)
{
int a;
cc_mutex_lock(&peerlink_lock);
for (a = 0; a < CAPI_MAX_PEERLINKCHANNELS; a++) {
if (peerlinkchannel[a].channel == NULL) {
peerlinkchannel[a].channel = c;
peerlinkchannel[a].age = time(NULL);
break;
} else {
/* remove too old entries */
if ((peerlinkchannel[a].age + 60) < time(NULL)) {
peerlinkchannel[a].channel = NULL;
cc_verbose(3, 1, VERBOSE_PREFIX_4 CC_MESSAGE_NAME
": peerlink %d timeout-erase\n", a);
}
}
}
cc_mutex_unlock(&peerlink_lock);
if (a == CAPI_MAX_PEERLINKCHANNELS) {
return -1;
}
return a;
}
/*
* Get and remove peer link id
*/
struct ast_channel *cc_get_peer_link_id(const char *p)
{
int id = -1;
struct ast_channel *chan = NULL;
if (p) {
id = (int)strtol(p, NULL, 0);
}
cc_mutex_lock(&peerlink_lock);
if ((id >= 0) && (id < CAPI_MAX_PEERLINKCHANNELS)) {
chan = peerlinkchannel[id].channel;
peerlinkchannel[id].channel = NULL;
}
cc_verbose(3, 1, VERBOSE_PREFIX_4 CC_MESSAGE_NAME
": peerlink %d allocated, peer is %s\n", id, (chan)?chan->name:"unlinked");
cc_mutex_unlock(&peerlink_lock);
return chan;
}
/*
* create pipe for interface connection
*/
int capi_create_reader_writer_pipe(struct capi_pvt *i)
{
int fds[2];
int flags;
if (pipe(fds) != 0) {
cc_log(LOG_ERROR, "%s: unable to create pipe.\n",
i->vname);
return 0;
}
i->readerfd = fds[0];
i->writerfd = fds[1];
flags = fcntl(i->readerfd, F_GETFL);
fcntl(i->readerfd, F_SETFL, flags | O_NONBLOCK);
flags = fcntl(i->writerfd, F_GETFL);
fcntl(i->writerfd, F_SETFL, flags | O_NONBLOCK);
return 1;
}
/*
* read a frame from the pipe
*/
struct ast_frame *capi_read_pipeframe(struct capi_pvt *i)
{
struct ast_frame *f;
int readsize;
if (i == NULL) {
cc_log(LOG_ERROR, "channel has no interface\n");
return NULL;
}
if (i->readerfd == -1) {
cc_log(LOG_ERROR, "no readerfd\n");
return NULL;
}
f = &i->f;
f->frametype = AST_FRAME_NULL;
FRAME_SUBCLASS_INTEGER(f->subclass) = 0;
readsize = read(i->readerfd, f, sizeof(struct ast_frame));
if ((readsize != sizeof(struct ast_frame)) && (readsize > 0)) {
cc_log(LOG_ERROR, "did not read a whole frame (len=%d, err=%d)\n",
readsize, errno);
}
f->mallocd = 0;
f->FRAME_DATA_PTR = NULL;
if ((f->frametype == AST_FRAME_CONTROL) &&
(FRAME_SUBCLASS_INTEGER(f->subclass) == AST_CONTROL_HANGUP)) {
return NULL;
}
if ((f->frametype == AST_FRAME_VOICE) && (f->datalen > 0)) {
if (f->datalen > sizeof(i->frame_data)) {
cc_log(LOG_ERROR, "f.datalen(%d) greater than space of frame_data(%d)\n",
f->datalen, (int)sizeof(i->frame_data));
f->datalen = sizeof(i->frame_data);
}
readsize = read(i->readerfd, i->frame_data + AST_FRIENDLY_OFFSET, f->datalen);
if (readsize != f->datalen) {
cc_log(LOG_ERROR, "did not read whole frame data\n");
}
f->FRAME_DATA_PTR = i->frame_data + AST_FRIENDLY_OFFSET;
}
return f;
}
/*
* write for a channel
*/
int capi_write_frame(struct capi_pvt *i, struct ast_frame *f)
{
MESSAGE_EXCHANGE_ERROR error;
int j = 0;
unsigned char *buf;
struct ast_frame *fsmooth;
int txavg=0;
int ret = 0;
int B3Blocks = 1;
if (unlikely(!i)) {
cc_log(LOG_ERROR, "channel has no interface\n");
return -1;
}
{
struct capi_pvt *ii = i;
cc_mutex_lock(&ii->lock);
if (i->line_plci != 0)
i = i->line_plci;
cc_mutex_unlock(&ii->lock);
}
if (unlikely((!(i->isdnstate & CAPI_ISDN_STATE_B3_UP)) || (!i->NCCI) ||
((i->isdnstate & (CAPI_ISDN_STATE_B3_CHANGE | CAPI_ISDN_STATE_LI))))) {
return 0;
}
if ((!(i->ntmode)) && (i->state != CAPI_STATE_CONNECTED)) {
return 0;
}
if (unlikely(f->frametype == AST_FRAME_NULL)) {
return 0;
}
if (unlikely((!f->FRAME_DATA_PTR) || (!f->datalen))) {
/* prodding from Asterisk, just returning */
return 0;
}
if (unlikely(f->frametype == AST_FRAME_DTMF)) {
cc_log(LOG_ERROR, "dtmf frame should be written\n");
return 0;
}
if (unlikely(f->frametype != AST_FRAME_VOICE)) {
cc_log(LOG_ERROR,"not a voice frame\n");
return 0;
}
if (unlikely(i->FaxState & CAPI_FAX_STATE_ACTIVE)) {
cc_verbose(3, 1, VERBOSE_PREFIX_2 "%s: write on fax activity?\n",
i->vname);
return 0;
}
if (i->isdnstate & CAPI_ISDN_STATE_RTP) {
if (unlikely((!(FRAME_SUBCLASS_CODEC(f->subclass) & i->codec)) &&
(FRAME_SUBCLASS_CODEC(f->subclass) != capi_capability))) {
cc_log(LOG_ERROR, "don't know how to write subclass %s(%d)\n",
ast_getformatname(FRAME_SUBCLASS_CODEC(f->subclass)),
FRAME_SUBCLASS_INTEGER(f->subclass));
return 0;
}
return capi_write_rtp(i, f);
}
if (unlikely(i->B3count >= CAPI_MAX_B3_BLOCKS)) {
cc_verbose(3, 1, VERBOSE_PREFIX_4 "%s: B3count is full, dropping packet.\n",
i->vname);
return 0;
}
if (i->bproto == CC_BPROTO_VOCODER) {
#ifdef DIVA_STREAMING
cc_mutex_lock(&stream_write_lock);
if (i->diva_stream_entry != 0) {
int written = 0, ready = 0;
B3Blocks = 0;
if ((ready = (i->diva_stream_entry->diva_stream_state == DivaStreamActive)) &&
(i->diva_stream_entry->diva_stream->get_tx_free (i->diva_stream_entry->diva_stream) > 2*CAPI_MAX_B3_BLOCK_SIZE+128)) {
written = i->diva_stream_entry->diva_stream->write (i->diva_stream_entry->diva_stream, 8U << 8 | DIVA_STREAM_MESSAGE_TX_IDI_REQUEST, f->FRAME_DATA_PTR, f->datalen);
i->diva_stream_entry->diva_stream->flush_stream(i->diva_stream_entry->diva_stream);
}
cc_mutex_unlock(&stream_write_lock);
error = written != f->datalen;
if (unlikely(error != 0)) {
cc_verbose(3, 1, VERBOSE_PREFIX_4 "%s: stream is %s, dropping packet.\n", i->vname, (ready != 0) ? "full" : "not ready");
}
} else
#endif
{
#ifdef DIVA_STREAMING
cc_mutex_unlock(&stream_write_lock);
#endif
buf = &(i->send_buffer[(i->send_buffer_handle % CAPI_MAX_B3_BLOCKS) *
(CAPI_MAX_B3_BLOCK_SIZE + AST_FRIENDLY_OFFSET)]);
i->send_buffer_handle++;
memcpy (buf, f->FRAME_DATA_PTR, f->datalen);
error = capi_sendf(NULL, 0, CAPI_DATA_B3_REQ, i->NCCI, get_capi_MessageNumber(),
"dwww", buf, f->datalen, i->send_buffer_handle, 0);
}
if (likely(error == 0)) {
cc_mutex_lock(&i->lock);
i->B3count += B3Blocks;
i->B3q -= f->datalen;
if (i->B3q < 0)
i->B3q = 0;
cc_mutex_unlock(&i->lock);
}
return 0;
}
if ((!i->smoother) || (ast_smoother_feed(i->smoother, f) != 0)) {
cc_log(LOG_ERROR, "%s: failed to fill smoother\n", i->vname);
return 0;
}
for (fsmooth = ast_smoother_read(i->smoother);
fsmooth != NULL;
fsmooth = ast_smoother_read(i->smoother)) {
buf = &(i->send_buffer[(i->send_buffer_handle % CAPI_MAX_B3_BLOCKS) *
(CAPI_MAX_B3_BLOCK_SIZE + AST_FRIENDLY_OFFSET)]);
i->send_buffer_handle++;
if ((i->doES == 1) && (!capi_tcap_is_digital(i->transfercapability))) {
for (j = 0; j < fsmooth->datalen; j++) {
buf[j] = capi_reversebits[ ((unsigned char *)fsmooth->FRAME_DATA_PTR)[j] ];
if (capi_capability == AST_FORMAT_ULAW) {
txavg += abs( capiULAW2INT[capi_reversebits[ ((unsigned char*)fsmooth->FRAME_DATA_PTR)[j]]] );
} else {
txavg += abs( capiALAW2INT[capi_reversebits[ ((unsigned char*)fsmooth->FRAME_DATA_PTR)[j]]] );
}
}
txavg = txavg / j;
for(j = 0; j < ECHO_TX_COUNT - 1; j++) {
i->txavg[j] = i->txavg[j+1];
}
i->txavg[ECHO_TX_COUNT - 1] = txavg;
} else {
if ((i->txgain == 1.0) || (capi_tcap_is_digital(i->transfercapability))) {
for (j = 0; j < fsmooth->datalen; j++) {
buf[j] = capi_reversebits[((unsigned char *)fsmooth->FRAME_DATA_PTR)[j]];
}
} else {
for (j = 0; j < fsmooth->datalen; j++) {
buf[j] = i->g.txgains[capi_reversebits[((unsigned char *)fsmooth->FRAME_DATA_PTR)[j]]];
}
}
}
error = 1;
if (i->B3q > 0) {
#if defined(DIVA_STREAMING)
if (i->diva_stream_entry != 0) {
int written = 0, ready = 0;
B3Blocks = 0;
cc_mutex_lock(&stream_write_lock);
if ((ready = (i->diva_stream_entry->diva_stream_state == DivaStreamActive)) &&
(i->diva_stream_entry->diva_stream->get_tx_free (i->diva_stream_entry->diva_stream) > 2*CAPI_MAX_B3_BLOCK_SIZE+128)) {
written = i->diva_stream_entry->diva_stream->write (i->diva_stream_entry->diva_stream, 8U << 8 | DIVA_STREAM_MESSAGE_TX_IDI_REQUEST, buf, fsmooth->datalen);
i->diva_stream_entry->diva_stream->flush_stream(i->diva_stream_entry->diva_stream);
}
cc_mutex_unlock(&stream_write_lock);
error = written != fsmooth->datalen;
if (unlikely(error != 0)) {
cc_verbose(3, 1, VERBOSE_PREFIX_4 "%s: stream is %s, dropping packet.\n", i->vname, (ready != 0) ? "full" : "not ready");
}
} else
#endif
{
error = capi_sendf(NULL, 0, CAPI_DATA_B3_REQ, i->NCCI, get_capi_MessageNumber(),
"dwww", buf, fsmooth->datalen, i->send_buffer_handle, 0);
}
} else {
cc_verbose(3, 1, VERBOSE_PREFIX_4 "%s: too much voice to send for NCCI=%#x\n",
i->vname, i->NCCI);
}
if (likely(!error)) {
cc_mutex_lock(&i->lock);
i->B3count += B3Blocks;
i->B3q -= fsmooth->datalen;
if (i->B3q < 0)
i->B3q = 0;
cc_mutex_unlock(&i->lock);
}
}
return ret;
}
Reference in New Issue View Git Blame Copy Permalink