chan-capi/chan_capi_utils.c

/*
 * 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 <ctype.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"
#include "chan_capi_divastreaming_utils.h"
#endif
#ifdef DIVA_STATUS
#include "divastatus_ifc.h"
#define CC_HW_STATE_OK(__x__) ((pbx_capi_get_controller((__x__)) == NULL) || \
																(pbx_capi_get_controller((__x__))->hwState != (int)DivaStatusHardwareStateERROR))
#else
#define CC_HW_STATE_OK(__x__) (1)
#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];

/*
 * 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);
				i->smoother = 0;
			}
			cc_mutex_destroy(&i->lock);
			ast_cond_destroy(&i->event_trigger);
			controller_nullplcis[i->controller - 1]--;
			ast_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) && CC_HW_STATE_OK(contrcount + 1)) {
			if (controller_nullplcis[contrcount] < channelcount) {
				channelcount = controller_nullplcis[contrcount];
				controller = contrcount + 1;
			}
		}
	}

	tmp = ast_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 != 0) ? c->name : "BRIDGE");
	snprintf(tmp->vname, sizeof(tmp->vname) - 1, "%s", tmp->name);

	tmp->channeltype = CAPI_CHANNELTYPE_NULL;

	tmp->used = c;
	tmp->peer = c;
	if (c == NULL)
		tmp->virtualBridgePeer = 1;

	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 (c != 0) {
		if (!(capi_create_reader_writer_pipe(tmp))) {
			ast_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();

#ifdef DIVA_STREAMING
	tmp->diva_stream_entry = 0;
	if (pbx_capi_streaming_supported (tmp) != 0) {
		capi_DivaStreamingOn(tmp, 1, tmp->MessageNumber);
	}
#endif

	if (c == NULL) {
		cc_mutex_lock(&tmp->lock);
	}
	capi_sendf((c != NULL) ? NULL : tmp, c == NULL, CAPI_CONNECT_REQ, controller, tmp->MessageNumber,
		"w()()()()(www()()()())()()()((wwbbb)()()())",
		 0,       1,1,0,              3,0,0,0,0);
	if (c == NULL) {
		cc_mutex_unlock(&tmp->lock);
		if (tmp->PLCI == 0) {
			cc_log(LOG_WARNING, "%s: failed to create\n", tmp->vname);
			capi_remove_nullif(tmp);
			tmp = NULL;
		}
	}
	if (tmp != NULL) {
		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,
	cc_format_t codecs,
	int all)
{
	struct capi_pvt *data_ifc /*, *line_ifc */;
	unsigned int controller = 1;
	int fmt = 0;

	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) && CC_HW_STATE_OK(contrcount + 1)) {
				if (controller_nullplcis[contrcount] < channelcount) {
					channelcount = controller_nullplcis[contrcount];
					controller = contrcount + 1;
				}
			}
		}
	} else {
		controller = data_plci_ifc->controller;
		codecs = (all != 0) ? pbx_capi_get_controller_codecs (controller) : codecs;
		fmt = pbx_capi_get_controller_codecs (controller) & codecs & cc_get_formats_as_bits(c->nativeformats);
		if (fmt != 0)
			fmt = cc_get_best_codec_as_bits(fmt);
	}

	data_ifc = ast_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 = (fmt != 0 && data_plci_ifc != 0) ? fmt : capi_capability;
	data_ifc->codec      = (fmt != 0 && data_plci_ifc != 0) ? fmt : data_ifc->codec;

	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))) {
			ast_free(data_ifc);
			return NULL;
		}
	} else {
		data_ifc->readerfd = -1;
		data_ifc->writerfd = -1;
	}

	data_ifc->bproto = (fmt != 0 && data_plci_ifc != 0) ? CC_BPROTO_VOCODER : 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);

#ifdef DIVA_STREAMING
	data_ifc->diva_stream_entry = 0;
	if (data_plci_ifc == 0) {
		capi_DivaStreamingStreamNotUsed(data_ifc, 1, data_ifc->MessageNumber);
	} else {
		if (pbx_capi_streaming_supported (data_ifc) != 0) {
			capi_DivaStreamingOn(data_ifc, 1, data_ifc->MessageNumber);
		}
	}
#endif

	capi_sendf(data_ifc,
		1,
		CAPI_MANUFACTURER_REQ,
		controller,
		data_ifc->MessageNumber,
		"dw(wbb(wwws()()()))",
		_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 */
		(data_ifc->bproto == CC_BPROTO_VOCODER) ? 0x1f : 1, 1, 0,
		diva_get_b1_conf(data_ifc));
	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: