Import chan_dect
Re-import chan_dect due to a switch to the trunk branch. Signed-off-by: Patrick McHardy <kaber@trash.net>
This commit is contained in:
parent
7cab80cd33
commit
3d546f101d
|
|
@ -90,6 +90,8 @@ chan_h323.so: chan_h323.o h323/libchanh323.a
|
|||
endif
|
||||
endif
|
||||
|
||||
chan_dect.so: LIBS+=-ldect
|
||||
|
||||
chan_misdn.o: _ASTCFLAGS+=-Imisdn
|
||||
|
||||
misdn_config.o: _ASTCFLAGS+=-Imisdn
|
||||
|
|
|
|||
|
|
@ -0,0 +1,992 @@
|
|||
/*
|
||||
* Asterisk DECT Channel driver
|
||||
*
|
||||
* Copyright (c) 2009 Patrick McHardy <kaber@trash.net>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 as
|
||||
* published by the Free Software Foundation.
|
||||
*/
|
||||
|
||||
#include "asterisk.h"
|
||||
#include "asterisk/lock.h"
|
||||
#include "asterisk/channel.h"
|
||||
#include "asterisk/config.h"
|
||||
#include "asterisk/module.h"
|
||||
#include "asterisk/pbx.h"
|
||||
#include "asterisk/sched.h"
|
||||
#include "asterisk/io.h"
|
||||
#include "asterisk/cli.h"
|
||||
#include "asterisk/causes.h"
|
||||
#include "asterisk/abstract_jb.h"
|
||||
|
||||
#include <dect/libdect.h>
|
||||
#include <dect/terminal.h>
|
||||
|
||||
#define CONFIG_FILE "dect.conf"
|
||||
|
||||
ASTERISK_FILE_VERSION(__FILE__, "$Revision")
|
||||
|
||||
static const struct ast_channel_tech dect_tech;
|
||||
static struct dect_handle *dh;
|
||||
static struct sched_context *sched;
|
||||
static struct io_context *io;
|
||||
|
||||
static const struct ast_jb_conf dect_default_jbconf = {
|
||||
.max_size = -1,
|
||||
.resync_threshold = -1,
|
||||
.impl = "",
|
||||
};
|
||||
|
||||
struct {
|
||||
struct ast_jb_conf jbconf;
|
||||
char default_context[AST_MAX_CONTEXT];
|
||||
} dect_cfg;
|
||||
|
||||
static AST_LIST_HEAD_STATIC(dect_pt_list, dect_pt);
|
||||
|
||||
struct dect_pt {
|
||||
AST_LIST_ENTRY(dect_pt) list;
|
||||
char name[64];
|
||||
struct dect_ipui ipui;
|
||||
|
||||
AST_DECLARE_STRING_FIELDS( AST_STRING_FIELD(regexten);
|
||||
AST_STRING_FIELD(context);
|
||||
AST_STRING_FIELD(language);
|
||||
AST_STRING_FIELD(cid_num);
|
||||
AST_STRING_FIELD(cid_name);
|
||||
AST_STRING_FIELD(ring_pattern);
|
||||
);
|
||||
|
||||
unsigned int display_lines;
|
||||
unsigned int display_columns;
|
||||
};
|
||||
|
||||
struct dect_pvt {
|
||||
struct dect_pt *pt;
|
||||
struct dect_call *call;
|
||||
struct ast_channel *chan;
|
||||
|
||||
AST_DECLARE_STRING_FIELDS( AST_STRING_FIELD(cid_num);
|
||||
AST_STRING_FIELD(cid_name);
|
||||
AST_STRING_FIELD(display);
|
||||
);
|
||||
int timer_id;
|
||||
};
|
||||
|
||||
static int dect_release_reason_to_ast(enum dect_release_reasons reason)
|
||||
{
|
||||
switch (reason) {
|
||||
case DECT_RELEASE_NORMAL:
|
||||
return AST_CAUSE_NORMAL_CLEARING;
|
||||
case DECT_RELEASE_UNEXPECTED_MESSAGE:
|
||||
case DECT_RELEASE_UNKNOWN_TRANSACTION_IDENTIFIER:
|
||||
return AST_CAUSE_INVALID_MSG_UNSPECIFIED;
|
||||
case DECT_RELEASE_MANDATORY_IE_MISSING:
|
||||
return AST_CAUSE_MANDATORY_IE_MISSING;
|
||||
case DECT_RELEASE_INVALID_IE_CONTENTS:
|
||||
return AST_CAUSE_INVALID_IE_CONTENTS;
|
||||
case DECT_RELEASE_INCOMPATIBLE_SERVICE:
|
||||
case DECT_RELEASE_SERVICE_NOT_IMPLEMENTED:
|
||||
case DECT_RELEASE_NEGOTIATION_NOT_SUPPORTED:
|
||||
case DECT_RELEASE_INVALID_IDENTITY:
|
||||
case DECT_RELEASE_AUTHENTICATION_FAILED:
|
||||
case DECT_RELEASE_UNKNOWN_IDENTITY:
|
||||
case DECT_RELEASE_NEGOTIATION_FAILED:
|
||||
case DECT_RELEASE_TIMER_EXPIRY:
|
||||
case DECT_RELEASE_PARTIAL_RELEASE:
|
||||
case DECT_RELEASE_UNKNOWN:
|
||||
return AST_CAUSE_NORMAL;
|
||||
/* user values */
|
||||
case DECT_RELEASE_USER_DETACHED:
|
||||
case DECT_RELEASE_USER_NOT_IN_RANGE:
|
||||
return AST_CAUSE_SUBSCRIBER_ABSENT;
|
||||
case DECT_RELEASE_USER_UNKNOWN:
|
||||
return AST_CAUSE_NO_ROUTE_DESTINATION;
|
||||
case DECT_RELEASE_USER_ALREADY_ACTIVE:
|
||||
case DECT_RELEASE_USER_BUSY:
|
||||
return AST_CAUSE_USER_BUSY;
|
||||
case DECT_RELEASE_USER_REJECTION:
|
||||
return AST_CAUSE_CALL_REJECTED;
|
||||
case DECT_RELEASE_USER_CALL_MODIFY:
|
||||
/* external handover values */
|
||||
case DECT_RELEASE_EXTERNAL_HANDOVER_NOT_SUPPORTED:
|
||||
case DECT_RELEASE_NETWORK_PARAMETERS_MISSING:
|
||||
case DECT_RELEASE_EXTERNAL_HANDOVER_RELEASE:
|
||||
return AST_CAUSE_NORMAL;
|
||||
/* temporary overload values */
|
||||
case DECT_RELEASE_OVERLOAD:
|
||||
case DECT_RELEASE_INSUFFICIENT_RESOURCES:
|
||||
case DECT_RELEASE_INSUFFICIENT_BEARERS_AVAILABLE:
|
||||
return AST_CAUSE_NORMAL_CIRCUIT_CONGESTION;
|
||||
case DECT_RELEASE_IWU_CONGESTION:
|
||||
return AST_CAUSE_SWITCH_CONGESTION;
|
||||
default:
|
||||
return AST_CAUSE_NORMAL;
|
||||
}
|
||||
}
|
||||
|
||||
static struct dect_pt *dect_pt_get_by_name(const char *name)
|
||||
{
|
||||
struct dect_pt *pt;
|
||||
|
||||
AST_LIST_TRAVERSE(&dect_pt_list, pt, list) {
|
||||
if (!strcasecmp(pt->name, name))
|
||||
return pt;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static struct dect_pt *dect_pt_get_by_ipui(const struct dect_ipui *ipui)
|
||||
{
|
||||
struct dect_pt *pt;
|
||||
|
||||
AST_LIST_TRAVERSE(&dect_pt_list, pt, list) {
|
||||
if (!dect_ipui_cmp(&pt->ipui, ipui))
|
||||
return pt;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static struct dect_pt *dect_init_portable(const char *name,
|
||||
const struct ast_variable *v)
|
||||
{
|
||||
struct dect_pt *pt;
|
||||
|
||||
pt = ast_malloc(sizeof(*pt));
|
||||
if (pt == NULL)
|
||||
return NULL;
|
||||
memset(pt, 0, sizeof(*pt));
|
||||
ast_copy_string(pt->name, name, sizeof(pt->name));
|
||||
|
||||
ast_string_field_init(pt, 512);
|
||||
ast_string_field_set(pt, context, dect_cfg.default_context);
|
||||
ast_string_field_set(pt, regexten, "");
|
||||
ast_string_field_set(pt, language, "");
|
||||
ast_string_field_set(pt, cid_num, "");
|
||||
ast_string_field_set(pt, cid_name, "");
|
||||
ast_string_field_set(pt, ring_pattern, "0");
|
||||
pt->ipui.put = DECT_IPUI_N;
|
||||
|
||||
for (; v != NULL; v = v->next) {
|
||||
if (!strcasecmp(v->name, "emc")) {
|
||||
pt->ipui.pun.n.ipei.emc = strtoul(v->value, NULL, 16);
|
||||
} else if (!strcasecmp(v->name, "psn")) {
|
||||
pt->ipui.pun.n.ipei.psn = strtoul(v->value, NULL, 16);
|
||||
} else if (!strcasecmp(v->name, "context")) {
|
||||
ast_string_field_set(pt, context, v->value);
|
||||
} else if (!strcasecmp(v->name, "regexten")) {
|
||||
ast_string_field_set(pt, regexten, v->value);
|
||||
} else if (!strcasecmp(v->name, "language")) {
|
||||
ast_string_field_set(pt, language, v->value);
|
||||
} else if (!strcasecmp(v->name, "cid_number")) {
|
||||
ast_string_field_set(pt, cid_num, v->value);
|
||||
} else if (!strcasecmp(v->name, "cid_name")) {
|
||||
ast_string_field_set(pt, cid_name, v->value);
|
||||
} else if (!strcasecmp(v->name, "ring_pattern")) {
|
||||
ast_string_field_set(pt, ring_pattern, v->value);
|
||||
}
|
||||
}
|
||||
|
||||
AST_LIST_INSERT_TAIL(&dect_pt_list, pt, list);
|
||||
return pt;
|
||||
}
|
||||
|
||||
static void dect_register_extension(const struct dect_pt *pt, bool onoff)
|
||||
{
|
||||
struct pbx_find_info q = { .stacklen = 0 };
|
||||
char *ext, *extenp, *context;
|
||||
char exten[256];
|
||||
|
||||
if (ast_strlen_zero(dect_cfg.default_context))
|
||||
return;
|
||||
|
||||
ast_copy_string(exten, S_OR(pt->regexten, pt->name), sizeof(exten));
|
||||
extenp = exten;
|
||||
while ((ext = strsep(&extenp, "&")) != NULL) {
|
||||
context = strchr(ext, '@');
|
||||
if (context != NULL) {
|
||||
*context++ = '\0';
|
||||
if (!ast_context_find(context)) {
|
||||
ast_log(LOG_WARNING, "Context %s for PT %s does not exist",
|
||||
context, pt->name);
|
||||
continue;
|
||||
}
|
||||
} else
|
||||
context = dect_cfg.default_context;
|
||||
|
||||
if (onoff) {
|
||||
if (!ast_exists_extension(NULL, context, ext, 1, NULL)) {
|
||||
ast_add_extension(context, 1, ext, 1, NULL, NULL, "Noop",
|
||||
ast_strdup(pt->name), ast_free, "DECT");
|
||||
}
|
||||
} else if (pbx_find_extension(NULL, NULL, &q, context, ext, 1,
|
||||
NULL, "", E_MATCH)) {
|
||||
ast_context_remove_extension(context, ext, 1, NULL);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static int dect_init_call(struct dect_pvt *pvt, enum ast_channel_state state,
|
||||
const char *exten)
|
||||
{
|
||||
struct dect_pt *pt = pvt->pt;
|
||||
struct ast_channel *chan;
|
||||
|
||||
ast_string_field_init(pvt, 512);
|
||||
|
||||
chan = ast_channel_alloc(1, state, pt->cid_num, pt->cid_name, "",
|
||||
exten, pt->context, 0, 0,
|
||||
"DECT/%s-%08lx", pt->name, (long)pvt);
|
||||
if (chan == NULL)
|
||||
return -1;
|
||||
|
||||
chan->tech = &dect_tech;
|
||||
chan->nativeformats = AST_FORMAT_G726_AAL2;
|
||||
chan->readformat = AST_FORMAT_G726_AAL2;
|
||||
chan->rawreadformat = AST_FORMAT_G726_AAL2;
|
||||
chan->writeformat = AST_FORMAT_G726_AAL2;
|
||||
chan->rawwriteformat = AST_FORMAT_G726_AAL2;
|
||||
chan->tech_pvt = pvt;
|
||||
|
||||
if (exten != NULL)
|
||||
ast_copy_string(chan->exten, exten, sizeof(chan->exten));
|
||||
if (!ast_strlen_zero(pt->language))
|
||||
ast_string_field_set(chan, language, pt->language);
|
||||
|
||||
ast_jb_configure(chan, &dect_cfg.jbconf);
|
||||
|
||||
ast_module_ref(ast_module_info->self);
|
||||
pvt->chan = chan;
|
||||
|
||||
if (state != AST_STATE_RESERVED && state != AST_STATE_DIALING) {
|
||||
if (ast_pbx_start(chan)) {
|
||||
ast_log(LOG_WARNING, "Unable to start PBX\n");
|
||||
ast_hangup(chan);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int dect_try_to_connect_call(struct dect_pvt *pvt)
|
||||
{
|
||||
struct ast_channel *chan = pvt->chan;
|
||||
struct dect_pt *pt = pvt->pt;
|
||||
|
||||
if (!ast_exists_extension(NULL, pt->context, chan->exten, 1, NULL))
|
||||
return -1;
|
||||
ast_log(LOG_NOTICE, "connecting call\n");
|
||||
if (ast_pbx_start(chan)) {
|
||||
ast_log(LOG_WARNING, "Unable to start PBX\n");
|
||||
ast_hangup(chan);
|
||||
} else
|
||||
ast_setstate(chan, AST_STATE_RING);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int dect_answer(struct ast_channel *chan)
|
||||
{
|
||||
struct dect_pvt *pvt = chan->tech_pvt;
|
||||
struct dect_mncc_connect_param connect = {};
|
||||
|
||||
ast_log(LOG_NOTICE, "answer call state %u\n", chan->_state);
|
||||
if (chan->_state == AST_STATE_UP || chan->_state == AST_STATE_RINGING)
|
||||
return 0;
|
||||
|
||||
dect_mncc_connect_req(dh, pvt->call, &connect);
|
||||
ast_setstate(chan, AST_STATE_UP);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int dect_call(struct ast_channel *chan, char *dest, int timeout)
|
||||
{
|
||||
struct dect_pvt *pvt = chan->tech_pvt;
|
||||
struct dect_mncc_setup_param param;
|
||||
struct dect_ie_basic_service service;
|
||||
|
||||
/* Store CallerID for ALERTING state */
|
||||
ast_string_field_set(pvt, cid_num, chan->cid.cid_num);
|
||||
ast_string_field_set(pvt, cid_name, chan->cid.cid_name);
|
||||
|
||||
dect_ie_init(&service);
|
||||
service.class = DECT_CALL_CLASS_NORMAL;
|
||||
service.service = DECT_SERVICE_BASIC_SPEECH_DEFAULT;
|
||||
|
||||
memset(¶m, 0, sizeof(param));
|
||||
param.basic_service = &service;
|
||||
dect_mncc_setup_req(dh, pvt->call, &pvt->pt->ipui, ¶m);
|
||||
|
||||
ast_setstate(pvt->chan, AST_STATE_DIALING);
|
||||
chan->hangupcause = AST_CAUSE_NORMAL_CLEARING;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct ast_channel *dect_request_call(const char *type, format_t format,
|
||||
const struct ast_channel *requestor,
|
||||
void *data, int *cause)
|
||||
{
|
||||
struct dect_pvt *pvt;
|
||||
struct dect_call *call;
|
||||
struct dect_pt *pt;
|
||||
const char *name = data;
|
||||
|
||||
pt = dect_pt_get_by_name(name);
|
||||
if (pt == NULL) {
|
||||
ast_log(LOG_NOTICE, "Call to unknown PT '%s' requested\n", name);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
call = dect_call_alloc(dh);
|
||||
if (call == NULL)
|
||||
return NULL;
|
||||
pvt = dect_call_priv(call);
|
||||
|
||||
ast_log(LOG_NOTICE, "Outgoing call to %s\n", pt->name);
|
||||
pvt->pt = pt;
|
||||
pvt->call = call;
|
||||
if (dect_init_call(pvt, AST_STATE_RESERVED, NULL) < 0)
|
||||
return NULL;
|
||||
|
||||
return pvt->chan;
|
||||
}
|
||||
|
||||
static int dect_hangup(struct ast_channel *chan)
|
||||
{
|
||||
struct dect_pvt *pvt = chan->tech_pvt;
|
||||
struct dect_ie_release_reason release_reason;
|
||||
struct dect_mncc_release_param param;
|
||||
|
||||
ast_log(LOG_NOTICE, "Hangup\n");
|
||||
|
||||
if (chan->_state != AST_STATE_DOWN) {
|
||||
dect_ie_init(&release_reason);
|
||||
release_reason.reason = DECT_RELEASE_NORMAL;
|
||||
|
||||
memset(¶m, 0, sizeof(param));
|
||||
param.release_reason = &release_reason;
|
||||
dect_mncc_release_req(dh, pvt->call, ¶m);
|
||||
}
|
||||
|
||||
chan->tech_pvt = NULL;
|
||||
ast_setstate(chan, AST_STATE_DOWN);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int dect_indicate(struct ast_channel *chan, int condition,
|
||||
const void *data, size_t datalen)
|
||||
{
|
||||
struct dect_pvt *pvt = chan->tech_pvt;
|
||||
struct dect_mncc_alert_param alert;
|
||||
struct dect_ie_progress_indicator progress;
|
||||
struct dect_ie_signal signal;
|
||||
int res = 0;
|
||||
|
||||
switch (condition) {
|
||||
case AST_CONTROL_RINGING:
|
||||
ast_log(LOG_NOTICE, "Ringing\n");
|
||||
memset(&alert, 0, sizeof(alert));
|
||||
if (0) {
|
||||
alert.signal = dect_signal_init(&signal, DECT_SIGNAL_RING_BACK_TONE_ON);
|
||||
} else {
|
||||
dect_ie_init(&progress);
|
||||
progress.location = DECT_LOCATION_PRIVATE_NETWORK_SERVING_LOCAL_USER;
|
||||
progress.progress = DECT_PROGRESS_INBAND_INFORMATION_NOW_AVAILABLE;
|
||||
dect_ie_list_add(&progress, &alert.progress_indicator);
|
||||
}
|
||||
dect_mncc_alert_req(dh, pvt->call, &alert);
|
||||
ast_setstate(chan, AST_STATE_RINGING);
|
||||
res = -1;
|
||||
break;
|
||||
case AST_CONTROL_BUSY:
|
||||
case AST_CONTROL_CONGESTION:
|
||||
case AST_CONTROL_PROCEEDING:
|
||||
case AST_CONTROL_PROGRESS:
|
||||
case AST_CONTROL_HOLD:
|
||||
case AST_CONTROL_UNHOLD:
|
||||
case AST_CONTROL_VIDUPDATE:
|
||||
case AST_CONTROL_T38_PARAMETERS:
|
||||
case AST_CONTROL_SRCUPDATE:
|
||||
case -1:
|
||||
res = -1;
|
||||
ast_log(LOG_NOTICE, "Indicate %d\n", condition);
|
||||
break;
|
||||
default:
|
||||
ast_log(LOG_NOTICE, "Indicate unknown condition %d\n", condition);
|
||||
res = -1;
|
||||
break;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
static int dect_write(struct ast_channel *chan, struct ast_frame *f)
|
||||
{
|
||||
struct dect_pvt *pvt = chan->tech_pvt;
|
||||
struct dect_msg_buf mb;
|
||||
unsigned int len = f->datalen;
|
||||
|
||||
mb.data = f->data.ptr;
|
||||
mb.len = 40;
|
||||
while (len >= 40) {
|
||||
dect_dl_u_data_req(dh, pvt->call, &mb);
|
||||
mb.data += 40;
|
||||
len -= 40;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct ast_frame *dect_read(struct ast_channel *chan)
|
||||
{
|
||||
ast_log(LOG_NOTICE, "read\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int dect_fixup(struct ast_channel *old, struct ast_channel *new)
|
||||
{
|
||||
ast_log(LOG_NOTICE, "fixup\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct ast_channel_tech dect_tech = {
|
||||
.type = "DECT",
|
||||
.description = "Digital Enhanced Cordless Telecommunications (DECT)",
|
||||
.capabilities = AST_FORMAT_G726_AAL2,
|
||||
.answer = dect_answer,
|
||||
.requester = dect_request_call,
|
||||
.call = dect_call,
|
||||
.hangup = dect_hangup,
|
||||
.indicate = dect_indicate,
|
||||
.write = dect_write,
|
||||
.read = dect_read,
|
||||
.fixup = dect_fixup,
|
||||
};
|
||||
|
||||
static void dect_mncc_setup_ind(struct dect_handle *dh, struct dect_call *call,
|
||||
struct dect_mncc_setup_param *param)
|
||||
{
|
||||
struct dect_mncc_setup_ack_param setup_ack;
|
||||
struct dect_mncc_call_proc_param call_proc;
|
||||
struct dect_mncc_release_param release;
|
||||
struct dect_ie_release_reason release_reason;
|
||||
struct dect_ie_delimiter_request delimiter_request;
|
||||
struct dect_ie_signal signal;
|
||||
struct dect_pvt *pvt = dect_call_priv(call);
|
||||
struct dect_pt *pt;
|
||||
enum ast_channel_state state;
|
||||
const char *exten;
|
||||
|
||||
pt = dect_pt_get_by_ipui(dect_call_portable_identity(call));
|
||||
if (pt == NULL) {
|
||||
ast_log(LOG_NOTICE, "Incoming call from unknown PT\n");
|
||||
|
||||
memset(&release, 0, sizeof(release));
|
||||
release.release_reason = dect_ie_init(&release_reason);
|
||||
release_reason.reason = DECT_RELEASE_UNKNOWN_IDENTITY;
|
||||
dect_mncc_reject_req(dh, call, &release);
|
||||
return;
|
||||
}
|
||||
|
||||
ast_log(LOG_NOTICE, "Incoming call from %s\n", pt->name);
|
||||
|
||||
/* If the phone supplies the entire number en-bloc, enter call
|
||||
* proceeding state. A number is considered complete when contained
|
||||
* in a called party number IE, or a multi-keypad IE and the extension
|
||||
* exists. When no number is supplied and an 's' extension exists in
|
||||
* the context, the call is also moved to call proceeding state and
|
||||
* further decisions are left to the PBX.
|
||||
*
|
||||
* Otherwise enter overlap sending and wait for further information.
|
||||
*/
|
||||
state = AST_STATE_RING;
|
||||
exten = NULL;
|
||||
|
||||
if (param->called_party_number != NULL)
|
||||
; //ast_copy_string(exten, param->called_party_number.info, sizeof(exten));
|
||||
else if (param->keypad != NULL && param->keypad->info[0] < 0x80)
|
||||
exten = (char *)param->keypad->info;
|
||||
else {
|
||||
exten = "s";
|
||||
if (!ast_exists_extension(NULL, pt->context, exten, 1, NULL)) {
|
||||
state = AST_STATE_DIALING;
|
||||
exten = "";
|
||||
}
|
||||
}
|
||||
|
||||
if (state == AST_STATE_RING) {
|
||||
memset(&call_proc, 0, sizeof(call_proc));
|
||||
dect_mncc_call_proc_req(dh, call, &call_proc);
|
||||
} else {
|
||||
dect_ie_init(&delimiter_request);
|
||||
dect_signal_init(&signal, DECT_SIGNAL_DIAL_TONE_ON);
|
||||
|
||||
memset(&setup_ack, 0, sizeof(setup_ack));
|
||||
setup_ack.delimiter_request = &delimiter_request;
|
||||
setup_ack.signal = &signal;
|
||||
dect_mncc_setup_ack_req(dh, call, &setup_ack);
|
||||
}
|
||||
|
||||
pvt->pt = pt;
|
||||
pvt->call = call;
|
||||
dect_init_call(pvt, state, exten);
|
||||
|
||||
/* WTF? Asterisk eats (actually leaks) the first queued frame when
|
||||
* answering a channel. Give it something to eat :| */
|
||||
if (state == AST_STATE_DIALING)
|
||||
ast_queue_control(pvt->chan, -1);
|
||||
}
|
||||
|
||||
static void dect_mncc_setup_ack_ind(struct dect_handle *dh, struct dect_call *call,
|
||||
struct dect_mncc_setup_ack_param *param)
|
||||
{
|
||||
ast_log(LOG_NOTICE, "MNCC_SETUP_ACK-ind\n");
|
||||
}
|
||||
|
||||
static void dect_mncc_reject_ind(struct dect_handle *dh, struct dect_call *call,
|
||||
struct dect_mncc_release_param *param)
|
||||
{
|
||||
ast_log(LOG_NOTICE, "MNCC_REJECT-ind\n");
|
||||
}
|
||||
|
||||
#if 0
|
||||
static int dect_display_timer(const void *data)
|
||||
{
|
||||
struct dect_pvt *pvt = (struct dect_pvt *)data;
|
||||
struct dect_ie_display display;
|
||||
struct dect_mncc_info_param info = { .display = &display};
|
||||
|
||||
dect_display_init(&display);
|
||||
dect_display_append_char(&display, DECT_C_RETURN);
|
||||
dect_display_append_char(&display, DECT_C_RETURN);
|
||||
|
||||
dect_mncc_info_req(dh, pvt->call, &info);
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
|
||||
static void dect_mncc_alert_ind(struct dect_handle *dh, struct dect_call *call,
|
||||
struct dect_mncc_alert_param *param)
|
||||
{
|
||||
struct dect_pvt *pvt = dect_call_priv(call);
|
||||
struct dect_ie_display display;
|
||||
struct dect_ie_signal signal;
|
||||
struct dect_mncc_info_param info = { .signal = &signal, .display = &display};
|
||||
unsigned int name_len, num_len;
|
||||
char pattern[16];
|
||||
const char *c;
|
||||
|
||||
ast_log(LOG_NOTICE, "MNCC_ALERT-ind\n");
|
||||
|
||||
ast_copy_string(pattern, pvt->pt->ring_pattern, sizeof(pattern));
|
||||
c = pbx_builtin_getvar_helper(pvt->chan, "RING_PATTERN");
|
||||
if (c != NULL)
|
||||
ast_copy_string(pattern, c, sizeof(pattern));
|
||||
|
||||
if (strcasecmp(pattern, "silent")) {
|
||||
dect_ie_init(&signal);
|
||||
signal.code = DECT_SIGNAL_ALERTING_BASE | (atoi(c) & 0xf);
|
||||
}
|
||||
|
||||
dect_display_init(&display);
|
||||
name_len = strlen(pvt->cid_name);
|
||||
num_len = strlen(pvt->cid_num);
|
||||
if (name_len > 0 || num_len > 0) {
|
||||
dect_display_append_char(&display, DECT_C_CLEAR_DISPLAY);
|
||||
if (name_len > 0) {
|
||||
dect_display_append(&display, pvt->cid_name, name_len);
|
||||
dect_display_append(&display, " <", 2);
|
||||
}
|
||||
|
||||
if (num_len > 0)
|
||||
dect_display_append(&display, pvt->cid_num, num_len);
|
||||
|
||||
if (name_len > 0)
|
||||
dect_display_append(&display, ">", 1);
|
||||
//pvt->pt->timer_id = ast_sched_add(sched, 500, dect_display_timer, pvt);
|
||||
}
|
||||
|
||||
dect_mncc_info_req(dh, call, &info);
|
||||
|
||||
ast_queue_control(pvt->chan, AST_CONTROL_RINGING);
|
||||
ast_setstate(pvt->chan, AST_STATE_RINGING);
|
||||
}
|
||||
|
||||
static void dect_mncc_connect_ind(struct dect_handle *dh, struct dect_call *call,
|
||||
struct dect_mncc_connect_param *param)
|
||||
{
|
||||
struct dect_pvt *pvt = dect_call_priv(call);
|
||||
|
||||
ast_log(LOG_NOTICE, "MNCC_CONNECT-ind\n");
|
||||
ast_queue_control(pvt->chan, AST_CONTROL_ANSWER);
|
||||
dect_mncc_connect_res(dh, call, param);
|
||||
}
|
||||
|
||||
static void dect_mncc_release_ind(struct dect_handle *dh, struct dect_call *call,
|
||||
struct dect_mncc_release_param *param)
|
||||
{
|
||||
struct dect_pvt *pvt = dect_call_priv(call);
|
||||
|
||||
ast_log(LOG_NOTICE, "MNCC_RELEASE-ind\n");
|
||||
ast_setstate(pvt->chan, AST_STATE_DOWN);
|
||||
pvt->chan->hangupcause =
|
||||
dect_release_reason_to_ast(param->release_reason->reason);
|
||||
ast_queue_hangup(pvt->chan);
|
||||
|
||||
dect_mncc_release_res(dh, call, param);
|
||||
}
|
||||
|
||||
static void dect_mncc_release_cfm(struct dect_handle *dh, struct dect_call *call,
|
||||
struct dect_mncc_release_param *param)
|
||||
{
|
||||
ast_log(LOG_NOTICE, "MNCC_RELEASE-cfm\n");
|
||||
}
|
||||
|
||||
static void dect_dl_u_data_ind(struct dect_handle *dh, struct dect_call *call,
|
||||
struct dect_msg_buf *mb)
|
||||
{
|
||||
struct dect_pvt *pvt = dect_call_priv(call);
|
||||
struct ast_frame f;
|
||||
|
||||
if (pvt->chan->_state == AST_STATE_DOWN)
|
||||
return;
|
||||
|
||||
memset(&f, 0, sizeof(f));
|
||||
f.frametype = AST_FRAME_VOICE;
|
||||
f.subclass.integer = AST_FORMAT_G726_AAL2;
|
||||
f.samples = mb->len * 2;
|
||||
f.datalen = mb->len;
|
||||
f.data.ptr = mb->data;
|
||||
f.offset = AST_FRIENDLY_OFFSET;
|
||||
|
||||
ast_queue_frame(pvt->chan, &f);
|
||||
}
|
||||
|
||||
static void dect_keypad_info(struct dect_pvt *pvt,
|
||||
const struct dect_ie_keypad *keypad)
|
||||
{
|
||||
struct ast_frame f = { .frametype = AST_FRAME_DTMF, };
|
||||
struct ast_channel *chan = pvt->chan;
|
||||
unsigned int i;
|
||||
|
||||
if (chan->_state == AST_STATE_DIALING) {
|
||||
strncat(chan->exten, (char *)keypad->info, keypad->len);
|
||||
dect_try_to_connect_call(pvt);
|
||||
} else {
|
||||
for (i = 0; i < keypad->len; i++) {
|
||||
ast_verbose("keypad: '%c' (%x)\n", keypad->info[i], keypad->info[i]);
|
||||
f.subclass.integer = keypad->info[i];
|
||||
ast_queue_frame(chan, &f);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void dect_mncc_info_ind(struct dect_handle *dh, struct dect_call *call,
|
||||
struct dect_mncc_info_param *param)
|
||||
{
|
||||
struct dect_pvt *pvt = dect_call_priv(call);
|
||||
|
||||
if (param->keypad != NULL)
|
||||
dect_keypad_info(pvt, param->keypad);
|
||||
}
|
||||
|
||||
static const struct dect_cc_ops dect_cc_ops = {
|
||||
.priv_size = sizeof(struct dect_pvt),
|
||||
.mncc_setup_ind = dect_mncc_setup_ind,
|
||||
.mncc_setup_ack_ind = dect_mncc_setup_ack_ind,
|
||||
.mncc_reject_ind = dect_mncc_reject_ind,
|
||||
.mncc_call_proc_ind = NULL,
|
||||
.mncc_alert_ind = dect_mncc_alert_ind,
|
||||
.mncc_connect_ind = dect_mncc_connect_ind,
|
||||
.mncc_connect_cfm = NULL,
|
||||
.mncc_release_ind = dect_mncc_release_ind,
|
||||
.mncc_release_cfm = dect_mncc_release_cfm,
|
||||
.mncc_facility_ind = NULL,
|
||||
.mncc_info_ind = dect_mncc_info_ind,
|
||||
.mncc_modify_ind = NULL,
|
||||
.mncc_modify_cfm = NULL,
|
||||
.mncc_hold_ind = NULL,
|
||||
.mncc_hold_cfm = NULL,
|
||||
.mncc_retrieve_ind = NULL,
|
||||
.mncc_retrieve_cfm = NULL,
|
||||
.mncc_iwu_info_ind = NULL,
|
||||
.dl_u_data_ind = dect_dl_u_data_ind,
|
||||
};
|
||||
|
||||
static void dect_mm_locate_ind(struct dect_handle *dh,
|
||||
struct dect_mm_endpoint *mme,
|
||||
struct dect_mm_locate_param *param)
|
||||
{
|
||||
ast_log(LOG_NOTICE, "MM_LOCATE-ind\n");
|
||||
}
|
||||
|
||||
static void dect_mm_identity_assign_cfm(struct dect_handle *dh,
|
||||
struct dect_mm_endpoint *mme, bool accept,
|
||||
struct dect_mm_identity_assign_param *param)
|
||||
{
|
||||
ast_log(LOG_NOTICE, "MN_IDENTITY_ASSIGN-cfm\n");
|
||||
}
|
||||
|
||||
static const struct dect_mm_ops dect_mm_ops = {
|
||||
.mm_locate_ind = dect_mm_locate_ind,
|
||||
.mm_identity_assign_cfm = dect_mm_identity_assign_cfm,
|
||||
};
|
||||
|
||||
static int dect_show_debug(const char *fmt, va_list ap)
|
||||
{
|
||||
ast_verbose_ap(fmt, ap);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int dect_load_config(void)
|
||||
{
|
||||
struct ast_flags cfg_flags = {};
|
||||
struct ast_config *cfg;
|
||||
struct ast_variable *v;
|
||||
struct dect_pt *pt;
|
||||
char *cat;
|
||||
|
||||
memcpy(&dect_cfg.jbconf, &dect_default_jbconf, sizeof(struct ast_jb_conf));
|
||||
|
||||
cfg = ast_config_load(CONFIG_FILE, cfg_flags);
|
||||
if (cfg == CONFIG_STATUS_FILEINVALID) {
|
||||
ast_log(LOG_ERROR, "Config file %s is in an invalid format.\n",
|
||||
CONFIG_FILE);
|
||||
return AST_MODULE_LOAD_DECLINE;
|
||||
}
|
||||
|
||||
if (cfg == NULL) {
|
||||
ast_log(LOG_ERROR, "Unable to load config %s\n", CONFIG_FILE);
|
||||
return AST_MODULE_LOAD_DECLINE;
|
||||
}
|
||||
|
||||
for (v = ast_variable_browse(cfg, "general"); v != NULL; v = v->next) {
|
||||
/* jitter buffer configuration */
|
||||
if (!ast_jb_read_conf(&dect_cfg.jbconf, v->name, v->value))
|
||||
continue;
|
||||
|
||||
if (!strcasecmp(v->name, "context")) {
|
||||
ast_copy_string(dect_cfg.default_context, v->value,
|
||||
sizeof(dect_cfg.default_context));
|
||||
}
|
||||
}
|
||||
|
||||
/* Phone configuration */
|
||||
cat = NULL;
|
||||
while ((cat = ast_category_browse(cfg, cat)) != NULL) {
|
||||
if (!strcasecmp(cat, "general"))
|
||||
continue;
|
||||
pt = dect_init_portable(cat, ast_variable_browse(cfg, cat));
|
||||
if (pt == NULL)
|
||||
return AST_MODULE_LOAD_DECLINE;
|
||||
dect_register_extension(pt, true);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Asterisk CLI commands
|
||||
*/
|
||||
|
||||
static char *dect_cli_debug(struct ast_cli_entry *e, int cmd,
|
||||
struct ast_cli_args *a)
|
||||
{
|
||||
const char *arg;
|
||||
|
||||
switch (cmd) {
|
||||
case CLI_INIT:
|
||||
e->command = "dect set debug {on|off}";
|
||||
e->usage = "Usage: dect set debug {on|off}\n";
|
||||
return NULL;
|
||||
case CLI_GENERATE:
|
||||
return NULL;
|
||||
}
|
||||
|
||||
arg = a->argv[e->args - 1];
|
||||
if (!strcasecmp(arg, "on")) {
|
||||
dect_set_debug_hook(dect_show_debug);
|
||||
ast_cli(a->fd, "DECT debugging enabled\n");
|
||||
} else if (!strcasecmp(arg, "off")) {
|
||||
dect_set_debug_hook(NULL);
|
||||
ast_cli(a->fd, "DECT debugging disabled\n");
|
||||
} else
|
||||
return CLI_SHOWUSAGE;
|
||||
|
||||
return CLI_SUCCESS;
|
||||
}
|
||||
|
||||
static struct ast_cli_entry dect_cli_cmds[] = {
|
||||
AST_CLI_DEFINE(dect_cli_debug, "Enable/Disable DECT debugging"),
|
||||
};
|
||||
|
||||
/*
|
||||
* libdect event ops
|
||||
*/
|
||||
|
||||
struct dect_fd_priv {
|
||||
int *id;
|
||||
};
|
||||
|
||||
static int dect_io_callback(int *id, int fd, short io_events, void *data)
|
||||
{
|
||||
struct dect_fd *dfd = data;
|
||||
uint32_t events = 0;
|
||||
|
||||
if (io_events & (AST_IO_IN | AST_IO_ERR | AST_IO_HUP))
|
||||
events |= DECT_FD_READ;
|
||||
if (io_events & AST_IO_OUT)
|
||||
events |= DECT_FD_WRITE;
|
||||
dfd->callback(dh, dfd, events);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int dect_register_fd(const struct dect_handle *dh, struct dect_fd *dfd,
|
||||
uint32_t events)
|
||||
{
|
||||
struct dect_fd_priv *priv = (struct dect_fd_priv *)dfd->priv;
|
||||
short io_events = 0;
|
||||
|
||||
if (events & DECT_FD_READ)
|
||||
io_events |= AST_IO_IN;
|
||||
if (events & DECT_FD_WRITE)
|
||||
io_events |= AST_IO_OUT;
|
||||
|
||||
priv->id = ast_io_add(io, dfd->fd, dect_io_callback, io_events, dfd);;
|
||||
return priv->id ? 0 : -1;
|
||||
}
|
||||
|
||||
static void dect_unregister_fd(const struct dect_handle *dh, struct dect_fd *dfd)
|
||||
{
|
||||
struct dect_fd_priv *priv = (struct dect_fd_priv *)dfd->priv;
|
||||
|
||||
ast_io_remove(io, priv->id);
|
||||
}
|
||||
|
||||
struct dect_timer_priv {
|
||||
int id;
|
||||
};
|
||||
|
||||
static int dect_timer_callback(const void *data)
|
||||
{
|
||||
struct dect_timer *timer = (struct dect_timer *)data;;
|
||||
|
||||
timer->callback(dh, timer);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void dect_start_timer(const struct dect_handle *dh,
|
||||
struct dect_timer *timer,
|
||||
const struct timeval *tv)
|
||||
{
|
||||
struct dect_timer_priv *priv = (struct dect_timer_priv *)timer->priv;
|
||||
|
||||
priv->id = ast_sched_add(sched, tv->tv_sec * 1000 + tv->tv_usec / 1000,
|
||||
dect_timer_callback, timer);
|
||||
}
|
||||
|
||||
static void dect_stop_timer(const struct dect_handle *dh,
|
||||
struct dect_timer *timer)
|
||||
{
|
||||
struct dect_timer_priv *priv = (struct dect_timer_priv *)timer->priv;
|
||||
|
||||
AST_SCHED_DEL(sched, priv->id);
|
||||
}
|
||||
|
||||
static const struct dect_event_ops dect_event_ops = {
|
||||
.fd_priv_size = sizeof(struct dect_fd_priv),
|
||||
.register_fd = dect_register_fd,
|
||||
.unregister_fd = dect_unregister_fd,
|
||||
.timer_priv_size = sizeof(struct dect_timer_priv),
|
||||
.start_timer = dect_start_timer,
|
||||
.stop_timer = dect_stop_timer,
|
||||
};
|
||||
|
||||
static struct dect_ops dect_ops = {
|
||||
.event_ops = &dect_event_ops,
|
||||
.cc_ops = &dect_cc_ops,
|
||||
.mm_ops = &dect_mm_ops,
|
||||
};
|
||||
|
||||
static pthread_t io_thread = AST_PTHREADT_NULL;
|
||||
|
||||
static void *dect_io_thread(void *ignore)
|
||||
{
|
||||
int timeout;
|
||||
|
||||
while (1) {
|
||||
pthread_testcancel();
|
||||
timeout = ast_sched_wait(sched);
|
||||
if (timeout < 0)
|
||||
timeout = 1000;
|
||||
ast_io_wait(io, timeout);
|
||||
ast_sched_runq(sched);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int dect_io_thread_start(void)
|
||||
{
|
||||
int err;
|
||||
|
||||
err = ast_pthread_create_background(&io_thread, NULL, dect_io_thread, NULL);
|
||||
if (err < 0) {
|
||||
ast_log(LOG_ERROR, "Unable to start IO thread\n");
|
||||
return err;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int dect_load_module(void)
|
||||
{
|
||||
sched = sched_context_create();
|
||||
if (sched == NULL) {
|
||||
ast_log(LOG_ERROR, "Unable to create scheduler context\n");
|
||||
goto err1;
|
||||
}
|
||||
|
||||
io = io_context_create();
|
||||
if (io == NULL) {
|
||||
ast_log(LOG_ERROR, "Unable to create IO context\n");
|
||||
goto err2;
|
||||
}
|
||||
|
||||
if (ast_channel_register(&dect_tech)) {
|
||||
ast_log(LOG_ERROR, "Unable to register 'DECT' channel\n");
|
||||
goto err3;
|
||||
}
|
||||
|
||||
ast_cli_register_multiple(dect_cli_cmds, ARRAY_LEN(dect_cli_cmds));
|
||||
|
||||
dect_load_config();
|
||||
|
||||
if (dect_io_thread_start() < 0)
|
||||
goto err4;
|
||||
|
||||
dh = dect_alloc_handle(&dect_ops);
|
||||
if (dh == NULL) {
|
||||
ast_log(LOG_ERROR, "Unable to allocate DECT handle\n");
|
||||
goto err5;
|
||||
}
|
||||
|
||||
if (dect_init(dh) < 0) {
|
||||
ast_log(LOG_ERROR, "Unable to initialize DECT handle\n");
|
||||
goto err6;
|
||||
}
|
||||
|
||||
return AST_MODULE_LOAD_SUCCESS;
|
||||
err6:
|
||||
err5:
|
||||
err4:
|
||||
err3:
|
||||
err2:
|
||||
sched_context_destroy(sched);
|
||||
err1:
|
||||
return AST_MODULE_LOAD_FAILURE;
|
||||
}
|
||||
|
||||
static int dect_unload_module(void)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "DECT",
|
||||
.load = dect_load_module,
|
||||
.unload = dect_unload_module,
|
||||
);
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
[general]
|
||||
context = default
|
||||
|
||||
;------------------------------ JITTER BUFFER CONFIGURATION --------------------------
|
||||
; jbenable = yes ; Enables the use of a jitterbuffer on the receiving side of an
|
||||
; DECT channel. Defaults to "no". An enabled jitterbuffer will
|
||||
; be used only if the sending side can create and the receiving
|
||||
; side can not accept jitter. The DECT channel can't accept jitter,
|
||||
; thus an enabled jitterbuffer on the receive DECT side will always
|
||||
; be used if the sending side can create jitter.
|
||||
|
||||
; jbmaxsize = 200 ; Max length of the jitterbuffer in milliseconds.
|
||||
|
||||
; jbresyncthreshold = 1000 ; Jump in the frame timestamps over which the jitterbuffer is
|
||||
; resynchronized. Useful to improve the quality of the voice, with
|
||||
; big jumps in/broken timestamps, usually sent from exotic devices
|
||||
; and programs. Defaults to 1000.
|
||||
|
||||
; jbimpl = fixed ; Jitterbuffer implementation, used on the receiving side of a DECT
|
||||
; channel. Two implementations are currently available - "fixed"
|
||||
; (with size always equals to jbmax-size) and "adaptive" (with
|
||||
; variable size, actually the new jb of IAX2). Defaults to fixed.
|
||||
|
||||
; jblog = no ; Enables jitterbuffer frame logging. Defaults to "no".
|
||||
;-----------------------------------------------------------------------------------
|
||||
|
||||
[phone1]
|
||||
emc = 08ae
|
||||
psn = 83d1e
|
||||
regexten = 601
|
||||
|
||||
language = de
|
||||
cid_number = 601
|
||||
cid_name = kaber
|
||||
ring_pattern = 3
|
||||
|
||||
display_lines = 1
|
||||
display_columns = 11
|
||||
|
||||
[phone2]
|
||||
emc = 08ae
|
||||
psn = 8969f
|
||||
regexten = 602
|
||||
language = de
|
||||
|
||||
[phone3]
|
||||
emc = 08ae
|
||||
psn = 5b9a0
|
||||
regexten = 603
|
||||
language = de
|
||||
|
|
@ -377,6 +377,7 @@ AST_EXT_LIB_SETUP([CAP], [POSIX 1.e capabilities], [cap])
|
|||
AST_EXT_LIB_SETUP([CURSES], [curses], [curses])
|
||||
AST_EXT_LIB_SETUP([CRYPTO], [OpenSSL Cryptography], [crypto])
|
||||
AST_EXT_LIB_SETUP([DAHDI], [DAHDI], [dahdi])
|
||||
AST_EXT_LIB_SETUP([DECT], [libdect], [dect])
|
||||
AST_EXT_LIB_SETUP([FFMPEG], [Ffmpeg and avcodec], [avcodec])
|
||||
AST_EXT_LIB_SETUP([GSM], [External GSM], [gsm], [, use 'internal' GSM otherwise])
|
||||
AST_EXT_LIB_SETUP([GTK2], [gtk2], [gtk2])
|
||||
|
|
@ -1895,6 +1896,8 @@ if test "${PBX_PWLIB}" = "1" -a "${USE_OPENH323}" != "no" ; then
|
|||
[${PWLIB_INCLUDE}], [${PWLIB_LIB}])
|
||||
fi
|
||||
|
||||
AST_EXT_LIB_CHECK([DECT], [dect], [dect_alloc_handle])
|
||||
|
||||
AST_EXT_LIB_CHECK([LUA], [lua5.1], [luaL_newstate], [lua5.1/lua.h], [-lm])
|
||||
if test "x${PBX_LUA}" = "x1" ; then
|
||||
if test x"${LUA_DIR}" = x; then
|
||||
|
|
|
|||
Reference in New Issue