<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[Freeswitch-trunk][14551] </title>
</head>
<body>
<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<div id="header">FreeSWITCH Subversion</div>
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://fisheye.freeswitch.org/changelog/FreeSWITCH?cs=14551">14551</a></dd>
<dt>Author</dt> <dd>gmaruzz</dd>
<dt>Date</dt> <dd>2009-08-18 04:37:23 -0500 (Tue, 18 Aug 2009)</dd>
</dl>
<h3>Log Message</h3>
<pre>celliax: added chan_celliax.c and celliax_additional.c from asterisk distr, beginning to modifying mod_celliax.c</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#freeswitchbranchesgmaruzzmod_celliaxcelliax_protocolc">freeswitch/branches/gmaruzz/mod_celliax/celliax_protocol.c</a></li>
<li><a href="#freeswitchbranchesgmaruzzmod_celliaxmod_celliaxc">freeswitch/branches/gmaruzz/mod_celliax/mod_celliax.c</a></li>
</ul>
<h3>Added Paths</h3>
<ul>
<li><a href="#freeswitchbranchesgmaruzzmod_celliaxcelliax_additionalc">freeswitch/branches/gmaruzz/mod_celliax/celliax_additional.c</a></li>
<li><a href="#freeswitchbranchesgmaruzzmod_celliaxchan_celliaxc">freeswitch/branches/gmaruzz/mod_celliax/chan_celliax.c</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="freeswitchbranchesgmaruzzmod_celliaxcelliax_additionalc"></a>
<div class="addfile"><h4>Added: freeswitch/branches/gmaruzz/mod_celliax/celliax_additional.c (0 => 14551)</h4>
<pre class="diff"><span>
<span class="info">--- freeswitch/branches/gmaruzz/mod_celliax/celliax_additional.c (rev 0)
+++ freeswitch/branches/gmaruzz/mod_celliax/celliax_additional.c 2009-08-18 09:37:23 UTC (rev 14551)
</span><span class="lines">@@ -0,0 +1,7022 @@
</span><ins>+//indent -gnu -ts4 -br -brs -cdw -lp -ce -nbfda -npcs -nprs -npsl -nbbo -saf -sai -saw -cs -bbo -nhnl -nut -sob -l90
+#include "celliax.h"
+#include "iconv.h"
+
+extern int celliax_debug;
+extern char *celliax_console_active;
+extern char celliax_type[];
+extern struct celliax_pvt *celliax_iflist;
+extern int celliax_dir_entry_extension;
+
+#ifndef GIOVA48
+#define SAMPLES_PER_FRAME 160
+#else // GIOVA48
+#define SAMPLES_PER_FRAME 960
+#endif // GIOVA48
+
+#ifdef CELLIAX_ALSA
+/*! \brief ALSA pcm format, according to endianess */
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+snd_pcm_format_t celliax_format = SND_PCM_FORMAT_S16_LE;
+#else
+snd_pcm_format_t celliax_format = SND_PCM_FORMAT_S16_BE;
+#endif
+
+/*!
+ * \brief Initialize the ALSA soundcard channels (capture AND playback) used by one interface (a multichannel soundcard can be used by multiple interfaces)
+ * \param p the celliax_pvt of the interface
+ *
+ * This function call alsa_open_dev to initialize the ALSA soundcard for each channel (capture AND playback) used by one interface (a multichannel soundcard can be used by multiple interfaces). Called by sound_init
+ *
+ * \return zero on success, -1 on error.
+ */
+int alsa_init(struct celliax_pvt *p)
+{
+ p->alsac = alsa_open_dev(p, SND_PCM_STREAM_CAPTURE);
+ if (!p->alsac) {
+ ERRORA("Failed opening ALSA capture device: %s\n", CELLIAX_P_LOG, p->alsacname);
+ if (alsa_shutdown(p)) {
+ ERRORA("alsa_shutdown failed\n", CELLIAX_P_LOG);
+ return -1;
+ }
+ return -1;
+ }
+ p->alsap = alsa_open_dev(p, SND_PCM_STREAM_PLAYBACK);
+ if (!p->alsap) {
+ ERRORA("Failed opening ALSA playback device: %s\n", CELLIAX_P_LOG, p->alsapname);
+ if (alsa_shutdown(p)) {
+ ERRORA("alsa_shutdown failed\n", CELLIAX_P_LOG);
+ return -1;
+ }
+ return -1;
+ }
+
+ /* make valgrind very happy */
+ snd_config_update_free_global();
+ return 0;
+}
+
+/*!
+ * \brief Shutdown the ALSA soundcard channels (input and output) used by one interface (a multichannel soundcard can be used by multiple interfaces)
+ * \param p the celliax_pvt of the interface
+ *
+ * This function shutdown the ALSA soundcard channels (input and output) used by one interface (a multichannel soundcard can be used by multiple interfaces). Called by sound_init
+ *
+ * \return zero on success, -1 on error.
+ */
+
+int alsa_shutdown(struct celliax_pvt *p)
+{
+
+ int err;
+
+ if (p->alsap) {
+ err = snd_pcm_drop(p->alsap);
+ if (err < 0) {
+ ERRORA("device [%s], snd_pcm_drop failed with error '%s'\n", CELLIAX_P_LOG,
+ p->alsapname, snd_strerror(err));
+ return -1;
+ }
+ err = snd_pcm_close(p->alsap);
+ if (err < 0) {
+ ERRORA("device [%s], snd_pcm_close failed with error '%s'\n", CELLIAX_P_LOG,
+ p->alsapname, snd_strerror(err));
+ return -1;
+ }
+ }
+ if (p->alsac) {
+ err = snd_pcm_drop(p->alsac);
+ if (err < 0) {
+ ERRORA("device [%s], snd_pcm_drop failed with error '%s'\n", CELLIAX_P_LOG,
+ p->alsacname, snd_strerror(err));
+ return -1;
+ }
+ err = snd_pcm_close(p->alsac);
+ if (err < 0) {
+ ERRORA("device [%s], snd_pcm_close failed with error '%s'\n", CELLIAX_P_LOG,
+ p->alsacname, snd_strerror(err));
+ return -1;
+ }
+ }
+
+ return 0;
+}
+
+/*!
+ * \brief Setup and open the ALSA device (capture OR playback)
+ * \param p the celliax_pvt of the interface
+ * \param stream the ALSA capture/playback definition
+ *
+ * This function setup and open the ALSA device (capture OR playback). Called by alsa_init
+ *
+ * \return zero on success, -1 on error.
+ */
+snd_pcm_t *alsa_open_dev(struct celliax_pvt * p, snd_pcm_stream_t stream)
+{
+
+ snd_pcm_t *handle = NULL;
+ snd_pcm_hw_params_t *params;
+ snd_pcm_sw_params_t *swparams;
+ snd_pcm_uframes_t buffer_size;
+ int err;
+ size_t n;
+ //snd_pcm_uframes_t xfer_align;
+ unsigned int rate;
+ snd_pcm_uframes_t start_threshold, stop_threshold;
+ snd_pcm_uframes_t period_size = 0;
+ snd_pcm_uframes_t chunk_size = 0;
+ int start_delay = 0;
+ int stop_delay = 0;
+ snd_pcm_state_t state;
+ snd_pcm_info_t *info;
+
+ period_size = p->alsa_period_size;
+
+ snd_pcm_hw_params_alloca(&params);
+ snd_pcm_sw_params_alloca(&swparams);
+
+ if (stream == SND_PCM_STREAM_CAPTURE) {
+ err = snd_pcm_open(&handle, p->alsacname, stream, 0 | SND_PCM_NONBLOCK);
+ } else {
+ err = snd_pcm_open(&handle, p->alsapname, stream, 0 | SND_PCM_NONBLOCK);
+ }
+ if (err < 0) {
+ ERRORA
+ ("snd_pcm_open failed with error '%s' on device '%s', if you are using a plughw:n device please change it to be a default:n device (so to allow it to be shared with other concurrent programs), or maybe you are using an ALSA voicemodem and slmodemd"
+ " is running?\n", CELLIAX_P_LOG, snd_strerror(err),
+ stream == SND_PCM_STREAM_CAPTURE ? p->alsacname : p->alsapname);
+ return NULL;
+ }
+
+ snd_pcm_info_alloca(&info);
+
+ if ((err = snd_pcm_info(handle, info)) < 0) {
+ ERRORA("info error: %s", CELLIAX_P_LOG, snd_strerror(err));
+ return NULL;
+ }
+
+ err = snd_pcm_nonblock(handle, 1);
+ if (err < 0) {
+ ERRORA("nonblock setting error: %s", CELLIAX_P_LOG, snd_strerror(err));
+ return NULL;
+ }
+
+ err = snd_pcm_hw_params_any(handle, params);
+ if (err < 0) {
+ ERRORA("Broken configuration for this PCM, no configurations available: %s\n",
+ CELLIAX_P_LOG, snd_strerror(err));
+ return NULL;
+ }
+
+ err = snd_pcm_hw_params_set_access(handle, params, SND_PCM_ACCESS_RW_INTERLEAVED);
+ if (err < 0) {
+ ERRORA("Access type not available: %s\n", CELLIAX_P_LOG, snd_strerror(err));
+ return NULL;
+ }
+ err = snd_pcm_hw_params_set_format(handle, params, celliax_format);
+ if (err < 0) {
+ ERRORA("Sample format non available: %s\n", CELLIAX_P_LOG, snd_strerror(err));
+ return NULL;
+ }
+ err = snd_pcm_hw_params_set_channels(handle, params, 1);
+ if (err < 0) {
+ DEBUGA_SOUND("Channels count set failed: %s\n", CELLIAX_P_LOG, snd_strerror(err));
+ }
+#if 1
+ unsigned int chan_num;
+ err = snd_pcm_hw_params_get_channels(params, &chan_num);
+ if (err < 0) {
+ ERRORA("Channels count non available: %s\n", CELLIAX_P_LOG, snd_strerror(err));
+ return NULL;
+ }
+ if (chan_num < 1 || chan_num > 2) {
+ ERRORA("Channels count MUST BE 1 or 2, it is: %d\n", CELLIAX_P_LOG, chan_num);
+ ERRORA("Channels count MUST BE 1 or 2, it is: %d on %s %s\n", CELLIAX_P_LOG, chan_num,
+ p->alsapname, p->alsacname);
+ return NULL;
+ } else {
+ if (chan_num == 1) {
+ if (stream == SND_PCM_STREAM_CAPTURE)
+ p->alsa_capture_is_mono = 1;
+ else
+ p->alsa_play_is_mono = 1;
+ } else {
+ if (stream == SND_PCM_STREAM_CAPTURE)
+ p->alsa_capture_is_mono = 0;
+ else
+ p->alsa_play_is_mono = 0;
+ }
+ }
+#else
+ p->alsa_capture_is_mono = 1;
+ p->alsa_play_is_mono = 1;
+#endif
+
+#if 0
+ unsigned int buffer_time = 0;
+ unsigned int period_time = 0;
+ snd_pcm_uframes_t period_frames = 0;
+ snd_pcm_uframes_t buffer_frames = 0;
+
+ if (buffer_time == 0 && buffer_frames == 0) {
+ err = snd_pcm_hw_params_get_buffer_time_max(params, &buffer_time, 0);
+ assert(err >= 0);
+ if (buffer_time > 500000)
+ buffer_time = 500000;
+ }
+ if (period_time == 0 && period_frames == 0) {
+ if (buffer_time > 0)
+ period_time = buffer_time / 4;
+ else
+ period_frames = buffer_frames / 4;
+ }
+ if (period_time > 0)
+ err = snd_pcm_hw_params_set_period_time_near(handle, params, &period_time, 0);
+ else
+ err = snd_pcm_hw_params_set_period_size_near(handle, params, &period_frames, 0);
+ assert(err >= 0);
+ if (buffer_time > 0) {
+ err = snd_pcm_hw_params_set_buffer_time_near(handle, params, &buffer_time, 0);
+ } else {
+ err = snd_pcm_hw_params_set_buffer_size_near(handle, params, &buffer_frames);
+ }
+#endif
+
+#if 1
+ rate = p->celliax_sound_rate;
+ err = snd_pcm_hw_params_set_rate_near(handle, params, &rate, 0);
+ if ((float) p->celliax_sound_rate * 1.05 < rate
+ || (float) p->celliax_sound_rate * 0.95 > rate) {
+ WARNINGA("Rate is not accurate (requested = %iHz, got = %iHz)\n", CELLIAX_P_LOG,
+ p->celliax_sound_rate, rate);
+ }
+
+ if (err < 0) {
+ ERRORA("Error setting rate: %s\n", CELLIAX_P_LOG, snd_strerror(err));
+ return NULL;
+ }
+ p->celliax_sound_rate = rate;
+
+ err = snd_pcm_hw_params_set_period_size_near(handle, params, &period_size, 0);
+
+ if (err < 0) {
+ ERRORA("Error setting period_size: %s\n", CELLIAX_P_LOG, snd_strerror(err));
+ return NULL;
+ }
+
+ p->alsa_period_size = period_size;
+
+ p->alsa_buffer_size = p->alsa_period_size * p->alsa_periods_in_buffer;
+
+ err = snd_pcm_hw_params_set_buffer_size_near(handle, params, &p->alsa_buffer_size);
+
+ if (err < 0) {
+ ERRORA("Error setting buffer_size: %s\n", CELLIAX_P_LOG, snd_strerror(err));
+ return NULL;
+ }
+#endif
+
+ err = snd_pcm_hw_params(handle, params);
+ if (err < 0) {
+ ERRORA("Unable to install hw params: %s\n", CELLIAX_P_LOG, snd_strerror(err));
+ return NULL;
+ }
+
+ snd_pcm_hw_params_get_period_size(params, &chunk_size, 0);
+ snd_pcm_hw_params_get_buffer_size(params, &buffer_size);
+ if (chunk_size == buffer_size) {
+ ERRORA("Can't use period equal to buffer size (%lu == %lu)\n", CELLIAX_P_LOG,
+ chunk_size, buffer_size);
+ return NULL;
+ }
+
+ snd_pcm_sw_params_current(handle, swparams);
+
+#if 0
+ err = snd_pcm_sw_params_get_xfer_align(swparams, &xfer_align);
+ if (err < 0) {
+ ERRORA("Unable to obtain xfer align: %s\n", CELLIAX_P_LOG, snd_strerror(err));
+ }
+ NOTICA("xfer_align: %d\n", CELLIAX_P_LOG, xfer_align);
+ /* for some reason, on some platforms, xfer_align here is zero, that gives a floating point exception later. So, let's try to force it to 160, the frame size used by celliax */
+ xfer_align = p->alsa_period_size;
+ NOTICA("xfer_align: %d\n", CELLIAX_P_LOG, xfer_align);
+
+ err = snd_pcm_sw_params_set_xfer_align(handle, swparams, xfer_align);
+ if (err < 0) {
+ ERRORA("Error setting xfer_align: %s\n", CELLIAX_P_LOG, snd_strerror(err));
+ }
+ NOTICA("xfer_align: %d\n", CELLIAX_P_LOG, xfer_align);
+
+ err = snd_pcm_sw_params_get_xfer_align(swparams, &xfer_align);
+ if (err < 0) {
+ ERRORA("Unable to obtain xfer align: %s\n", CELLIAX_P_LOG, snd_strerror(err));
+ }
+ NOTICA("xfer_align: %d\n", CELLIAX_P_LOG, xfer_align);
+#endif
+
+ /*
+ if (sleep_min)
+ xfer_align = 1;
+ err = snd_pcm_sw_params_set_sleep_min(handle, swparams,
+ 0);
+
+ if (err < 0) {
+ ERRORA("Error setting slep_min: %s\n", CELLIAX_P_LOG, snd_strerror(err));
+ }
+ */
+ n = chunk_size;
+ err = snd_pcm_sw_params_set_avail_min(handle, swparams, n);
+ if (err < 0) {
+ ERRORA("Error setting avail_min: %s\n", CELLIAX_P_LOG, snd_strerror(err));
+ }
+#if 0
+ /* round up to closest transfer boundary */
+ if (xfer_align == 0) { //so to avoid floating point exception ????
+ xfer_align = 160;
+ }
+ //original n = (buffer_size / xfer_align) * xfer_align;
+ n = (chunk_size / xfer_align) * xfer_align;
+#endif
+ if (stream == SND_PCM_STREAM_CAPTURE) {
+ start_delay = 1;
+ }
+ if (start_delay <= 0) {
+ start_threshold = n + (double) rate *start_delay / 1000000;
+ } else {
+ start_threshold = (double) rate *start_delay / 1000000;
+ }
+ if (start_threshold < 1)
+ start_threshold = 1;
+ if (start_threshold > n)
+ start_threshold = n;
+ err = snd_pcm_sw_params_set_start_threshold(handle, swparams, start_threshold);
+ if (err < 0) {
+ ERRORA("Error setting start_threshold: %s\n", CELLIAX_P_LOG, snd_strerror(err));
+ }
+
+ if (stop_delay <= 0)
+ stop_threshold = buffer_size + (double) rate *stop_delay / 1000000;
+ else
+ stop_threshold = (double) rate *stop_delay / 1000000;
+
+ if (stream == SND_PCM_STREAM_CAPTURE) {
+ stop_threshold = -1;
+ }
+
+ err = snd_pcm_sw_params_set_stop_threshold(handle, swparams, stop_threshold);
+
+ if (err < 0) {
+ ERRORA("Error setting stop_threshold: %s\n", CELLIAX_P_LOG, snd_strerror(err));
+ }
+#if 0
+ err = snd_pcm_sw_params_set_xfer_align(handle, swparams, xfer_align);
+
+ if (err < 0) {
+ ERRORA("Error setting xfer_align: %s\n", CELLIAX_P_LOG, snd_strerror(err));
+ }
+#endif
+
+ if (snd_pcm_sw_params(handle, swparams) < 0) {
+ ERRORA("Error installing software parameters: %s\n", CELLIAX_P_LOG,
+ snd_strerror(err));
+ }
+
+ err = snd_pcm_poll_descriptors_count(handle);
+ if (err <= 0) {
+ ERRORA("Unable to get a poll descriptors count, error is %s\n", CELLIAX_P_LOG,
+ snd_strerror(err));
+ return NULL;
+ }
+
+ if (err != 1) { //number of poll descriptors
+ DEBUGA_SOUND("Can't handle more than one device\n", CELLIAX_P_LOG);
+ return NULL;
+ }
+
+ err = snd_pcm_poll_descriptors(handle, &p->pfd, err);
+ if (err != 1) {
+ ERRORA("snd_pcm_poll_descriptors failed, %s\n", CELLIAX_P_LOG, snd_strerror(err));
+ return NULL;
+ }
+ DEBUGA_SOUND("Acquired fd %d from the poll descriptor\n", CELLIAX_P_LOG, p->pfd.fd);
+
+ if (stream == SND_PCM_STREAM_CAPTURE) {
+ p->celliax_sound_capt_fd = p->pfd.fd;
+ }
+
+ state = snd_pcm_state(handle);
+
+ if (state != SND_PCM_STATE_RUNNING) {
+ if (state != SND_PCM_STATE_PREPARED) {
+ err = snd_pcm_prepare(handle);
+ if (err) {
+ ERRORA("snd_pcm_prepare failed, %s\n", CELLIAX_P_LOG, snd_strerror(err));
+ return NULL;
+ }
+ DEBUGA_SOUND("prepared!\n", CELLIAX_P_LOG);
+ }
+ if (stream == SND_PCM_STREAM_CAPTURE) {
+ err = snd_pcm_start(handle);
+ if (err) {
+ ERRORA("snd_pcm_start failed, %s\n", CELLIAX_P_LOG, snd_strerror(err));
+ return NULL;
+ }
+ DEBUGA_SOUND("started!\n", CELLIAX_P_LOG);
+ }
+ }
+ if (option_debug > 1) {
+ snd_output_t *output = NULL;
+ err = snd_output_stdio_attach(&output, stdout, 0);
+ if (err < 0) {
+ ERRORA("snd_output_stdio_attach failed: %s\n", CELLIAX_P_LOG, snd_strerror(err));
+ }
+ snd_pcm_dump(handle, output);
+ }
+ if (option_debug > 1)
+ DEBUGA_SOUND("ALSA handle = %ld\n", CELLIAX_P_LOG, (long int) handle);
+ return handle;
+
+}
+
+/*! \brief Read audio frames from interface */
+
+struct ast_frame *alsa_read(struct celliax_pvt *p)
+{
+ static struct ast_frame f;
+ static short __buf[CELLIAX_FRAME_SIZE + AST_FRIENDLY_OFFSET / 2];
+ static short __buf2[(CELLIAX_FRAME_SIZE + AST_FRIENDLY_OFFSET / 2) * 2];
+ short *buf;
+ short *buf2;
+ static int readpos = 0;
+ static int left = CELLIAX_FRAME_SIZE;
+ snd_pcm_state_t state;
+ int r = 0;
+ int off = 0;
+ int error = 0;
+ //time_t now_timestamp;
+
+ //memset(&f, 0, sizeof(struct ast_frame)); //giova
+
+ f.frametype = AST_FRAME_NULL;
+ f.subclass = 0;
+ f.samples = 0;
+ f.datalen = 0;
+ f.data = NULL;
+ f.offset = 0;
+ f.src = celliax_type;
+ f.mallocd = 0;
+ f.delivery.tv_sec = 0;
+ f.delivery.tv_usec = 0;
+
+ state = snd_pcm_state(p->alsac);
+ if (state != SND_PCM_STATE_RUNNING) {
+ DEBUGA_SOUND("ALSA read state is not SND_PCM_STATE_RUNNING\n", CELLIAX_P_LOG);
+
+ if (state != SND_PCM_STATE_PREPARED) {
+ error = snd_pcm_prepare(p->alsac);
+ if (error) {
+ ERRORA("snd_pcm_prepare failed, %s\n", CELLIAX_P_LOG, snd_strerror(error));
+ return &f;
+ }
+ DEBUGA_SOUND("prepared!\n", CELLIAX_P_LOG);
+ }
+ usleep(1000);
+ error = snd_pcm_start(p->alsac);
+ if (error) {
+ ERRORA("snd_pcm_start failed, %s\n", CELLIAX_P_LOG, snd_strerror(error));
+ return &f;
+ }
+ DEBUGA_SOUND("started!\n", CELLIAX_P_LOG);
+ usleep(1000);
+ }
+
+ buf = __buf + AST_FRIENDLY_OFFSET / 2;
+ buf2 = __buf2 + ((AST_FRIENDLY_OFFSET / 2) * 2);
+
+ if (p->alsa_capture_is_mono) {
+ r = snd_pcm_readi(p->alsac, buf + readpos, left);
+ } else {
+ r = snd_pcm_readi(p->alsac, buf2 + (readpos * 2), left);
+
+ int a = 0;
+ int i = 0;
+ for (i = 0; i < (CELLIAX_FRAME_SIZE + AST_FRIENDLY_OFFSET / 2) * 2;) {
+ __buf[a] = (__buf2[i] + __buf2[i + 1]) / 2; //comment out this line to use only left
+ //__buf[a] = __buf2[i]; // enable this line to use only left
+ a++;
+ i++;
+ i++;
+ }
+ }
+
+ if (r == -EPIPE) {
+ ERRORA("XRUN read\n\n\n\n\n", CELLIAX_P_LOG);
+ return &f;
+ } else if (r == -ESTRPIPE) {
+ ERRORA("-ESTRPIPE\n", CELLIAX_P_LOG);
+ return &f;
+
+ } else if (r == -EAGAIN) {
+ DEBUGA_SOUND("ALSA read -EAGAIN, the soundcard is not ready to be read by celliax\n",
+ CELLIAX_P_LOG);
+ while (r == -EAGAIN) {
+ usleep(1000);
+
+ if (p->alsa_capture_is_mono) {
+ r = snd_pcm_readi(p->alsac, buf + readpos, left);
+ } else {
+ r = snd_pcm_readi(p->alsac, buf2 + (readpos * 2), left);
+
+ int a = 0;
+ int i = 0;
+ for (i = 0; i < (CELLIAX_FRAME_SIZE + AST_FRIENDLY_OFFSET / 2) * 2;) {
+ __buf[a] = (__buf2[i] + __buf2[i + 1]) / 2;
+ a++;
+ i++;
+ i++;
+ }
+ }
+
+ }
+ } else if (r < 0) {
+ WARNINGA("ALSA Read error: %s\n", CELLIAX_P_LOG, snd_strerror(r));
+ } else if (r >= 0) {
+ //DEBUGA_SOUND("read: r=%d, readpos=%d, left=%d, off=%d\n", CELLIAX_P_LOG, r, readpos, left, off);
+ off -= r; //what is the meaning of this? a leftover, probably
+ }
+ /* Update positions */
+ readpos += r;
+ left -= r;
+
+ if (readpos >= CELLIAX_FRAME_SIZE) {
+ /* A real frame */
+ readpos = 0;
+ left = CELLIAX_FRAME_SIZE;
+
+ f.frametype = AST_FRAME_VOICE;
+ f.subclass = AST_FORMAT_SLINEAR;
+ f.samples = CELLIAX_FRAME_SIZE;
+ f.datalen = CELLIAX_FRAME_SIZE * 2;
+ f.data = buf;
+ f.offset = AST_FRIENDLY_OFFSET;
+ f.src = celliax_type;
+ f.mallocd = 0;
+#ifdef ALSA_MONITOR
+ alsa_monitor_read((char *) buf, CELLIAX_FRAME_SIZE * 2);
+#endif
+
+ }
+ return &f;
+}
+
+/*! \brief Write audio frames to interface */
+int alsa_write(struct celliax_pvt *p, struct ast_frame *f)
+{
+ static char sizbuf[8000];
+ static char sizbuf2[16000];
+ static char silencebuf[8000];
+ static int sizpos = 0;
+ int len = sizpos;
+ int pos;
+ int res = 0;
+ time_t now_timestamp;
+ /* size_t frames = 0; */
+ snd_pcm_state_t state;
+ snd_pcm_sframes_t delayp1;
+ snd_pcm_sframes_t delayp2;
+
+ /* We have to digest the frame in 160-byte portions */
+ if (f->datalen > sizeof(sizbuf) - sizpos) {
+ ERRORA("Frame too large\n", CELLIAX_P_LOG);
+ res = -1;
+ } else {
+ memcpy(sizbuf + sizpos, f->data, f->datalen);
+ len += f->datalen;
+ pos = 0;
+#ifdef ALSA_MONITOR
+ alsa_monitor_write(sizbuf, len);
+#endif
+ state = snd_pcm_state(p->alsap);
+ if (state == SND_PCM_STATE_XRUN) {
+ int i;
+
+ DEBUGA_SOUND
+ ("You've got an ALSA write XRUN in the past (celliax can't fill the soundcard buffer fast enough). If this happens often (not after silence or after a pause in the speech, that's OK), and appear to damage the sound quality, first check if you have some IRQ problem, maybe sharing the soundcard IRQ with a broken or heavy loaded ethernet or graphic card. Then consider to increase the alsa_periods_in_buffer (now is set to %d) for this interface in the config file\n",
+ CELLIAX_P_LOG, p->alsa_periods_in_buffer);
+ res = snd_pcm_prepare(p->alsap);
+ if (res) {
+ ERRORA("audio play prepare failed: %s\n", CELLIAX_P_LOG, snd_strerror(res));
+ } else {
+ res = snd_pcm_format_set_silence(celliax_format, silencebuf, len / 2);
+ if (res < 0) {
+ DEBUGA_SOUND("Silence error %s\n", CELLIAX_P_LOG, snd_strerror(res));
+ res = -1;
+ }
+ for (i = 0; i < (p->alsa_periods_in_buffer - 1); i++) {
+ res = snd_pcm_writei(p->alsap, silencebuf, len / 2);
+ if (res != len / 2) {
+ DEBUGA_SOUND("Write returned a different quantity: %d\n", CELLIAX_P_LOG, res);
+ res = -1;
+ } else if (res < 0) {
+ DEBUGA_SOUND("Write error %s\n", CELLIAX_P_LOG, snd_strerror(res));
+ res = -1;
+ }
+ }
+ }
+
+ }
+
+ res = snd_pcm_delay(p->alsap, &delayp1);
+ if (res < 0) {
+ DEBUGA_SOUND("Error %d on snd_pcm_delay: \"%s\"\n", CELLIAX_P_LOG, res,
+ snd_strerror(res));
+ res = snd_pcm_prepare(p->alsap);
+ if (res) {
+ DEBUGA_SOUND("snd_pcm_prepare failed: '%s'\n", CELLIAX_P_LOG, snd_strerror(res));
+ }
+ res = snd_pcm_delay(p->alsap, &delayp1);
+ }
+
+ delayp2 = snd_pcm_avail_update(p->alsap);
+ if (delayp2 < 0) {
+ DEBUGA_SOUND("Error %d on snd_pcm_avail_update: \"%s\"\n", CELLIAX_P_LOG,
+ (int) delayp2, snd_strerror(delayp2));
+
+ res = snd_pcm_prepare(p->alsap);
+ if (res) {
+ DEBUGA_SOUND("snd_pcm_prepare failed: '%s'\n", CELLIAX_P_LOG, snd_strerror(res));
+ }
+ delayp2 = snd_pcm_avail_update(p->alsap);
+ }
+
+ if ( /* delayp1 != 0 && delayp1 != 160 */
+ delayp1 < 160 || delayp2 > p->alsa_buffer_size) {
+
+ res = snd_pcm_prepare(p->alsap);
+ if (res) {
+ DEBUGA_SOUND
+ ("snd_pcm_prepare failed while trying to prevent an ALSA write XRUN: %s, delayp1=%d, delayp2=%d\n",
+ CELLIAX_P_LOG, snd_strerror(res), (int) delayp1, (int) delayp2);
+ } else {
+
+ int i;
+ for (i = 0; i < (p->alsa_periods_in_buffer - 1); i++) {
+ res = snd_pcm_format_set_silence(celliax_format, silencebuf, len / 2);
+ if (res < 0) {
+ DEBUGA_SOUND("Silence error %s\n", CELLIAX_P_LOG, snd_strerror(res));
+ res = -1;
+ }
+ res = snd_pcm_writei(p->alsap, silencebuf, len / 2);
+ if (res < 0) {
+ DEBUGA_SOUND("Write error %s\n", CELLIAX_P_LOG, snd_strerror(res));
+ res = -1;
+ } else if (res != len / 2) {
+ DEBUGA_SOUND("Write returned a different quantity: %d\n", CELLIAX_P_LOG, res);
+ res = -1;
+ }
+ }
+
+ DEBUGA_SOUND
+ ("PREVENTING an ALSA write XRUN (celliax can't fill the soundcard buffer fast enough). If this happens often (not after silence or after a pause in the speech, that's OK), and appear to damage the sound quality, first check if you have some IRQ problem, maybe sharing the soundcard IRQ with a broken or heavy loaded ethernet or graphic card. Then consider to increase the alsa_periods_in_buffer (now is set to %d) for this interface in the config file. delayp1=%d, delayp2=%d\n",
+ CELLIAX_P_LOG, p->alsa_periods_in_buffer, (int) delayp1, (int) delayp2);
+ }
+
+ }
+
+ memset(sizbuf2, 0, sizeof(sizbuf2));
+ if (p->alsa_play_is_mono) {
+ res = snd_pcm_writei(p->alsap, sizbuf, len / 2);
+ } else {
+ int a = 0;
+ int i = 0;
+ for (i = 0; i < 8000;) {
+ sizbuf2[a] = sizbuf[i];
+ a++;
+ i++;
+ sizbuf2[a] = sizbuf[i];
+ a++;
+ i--;
+ sizbuf2[a] = sizbuf[i]; // comment out this line to use only left
+ a++;
+ i++;
+ sizbuf2[a] = sizbuf[i]; // comment out this line to use only left
+ a++;
+ i++;
+ }
+ res = snd_pcm_writei(p->alsap, sizbuf2, len);
+ }
+ if (res == -EPIPE) {
+ DEBUGA_SOUND
+ ("ALSA write EPIPE (XRUN) (celliax can't fill the soundcard buffer fast enough). If this happens often (not after silence or after a pause in the speech, that's OK), and appear to damage the sound quality, first check if you have some IRQ problem, maybe sharing the soundcard IRQ with a broken or heavy loaded ethernet or graphic card. Then consider to increase the alsa_periods_in_buffer (now is set to %d) for this interface in the config file. delayp1=%d, delayp2=%d\n",
+ CELLIAX_P_LOG, p->alsa_periods_in_buffer, (int) delayp1, (int) delayp2);
+ res = snd_pcm_prepare(p->alsap);
+ if (res) {
+ ERRORA("audio play prepare failed: %s\n", CELLIAX_P_LOG, snd_strerror(res));
+ } else {
+
+ if (p->alsa_play_is_mono) {
+ res = snd_pcm_writei(p->alsap, sizbuf, len / 2);
+ } else {
+ int a = 0;
+ int i = 0;
+ for (i = 0; i < 8000;) {
+ sizbuf2[a] = sizbuf[i];
+ a++;
+ i++;
+ sizbuf2[a] = sizbuf[i];
+ a++;
+ i--;
+ sizbuf2[a] = sizbuf[i];
+ a++;
+ i++;
+ sizbuf2[a] = sizbuf[i];
+ a++;
+ i++;
+ }
+ res = snd_pcm_writei(p->alsap, sizbuf2, len);
+ }
+
+ }
+
+ } else {
+ if (res == -ESTRPIPE) {
+ ERRORA("You've got some big problems\n", CELLIAX_P_LOG);
+ } else if (res == -EAGAIN) {
+ res = 0;
+ } else if (res < 0) {
+ ERRORA("Error %d on audio write: \"%s\"\n", CELLIAX_P_LOG, res,
+ snd_strerror(res));
+ }
+ }
+ }
+
+ if (p->audio_play_reset_period) {
+ time(&now_timestamp);
+ if ((now_timestamp - p->audio_play_reset_timestamp) > p->audio_play_reset_period) {
+ if (option_debug)
+ DEBUGA_SOUND("reset audio play\n", CELLIAX_P_LOG);
+ res = snd_pcm_wait(p->alsap, 1000);
+ if (res < 0) {
+ ERRORA("audio play wait failed: %s\n", CELLIAX_P_LOG, snd_strerror(res));
+ }
+ res = snd_pcm_drop(p->alsap);
+ if (res) {
+ ERRORA("audio play drop failed: %s\n", CELLIAX_P_LOG, snd_strerror(res));
+ }
+ res = snd_pcm_prepare(p->alsap);
+ if (res) {
+ ERRORA("audio play prepare failed: %s\n", CELLIAX_P_LOG, snd_strerror(res));
+ }
+ res = snd_pcm_wait(p->alsap, 1000);
+ if (res < 0) {
+ ERRORA("audio play wait failed: %s\n", CELLIAX_P_LOG, snd_strerror(res));
+ }
+ time(&p->audio_play_reset_timestamp);
+ }
+ }
+ res = 0;
+ if (res > 0)
+ res = 0;
+ return res;
+}
+
+
+/*! \brief Write audio frames to interface */
+#endif /* CELLIAX_ALSA */
+
+#ifdef CELLIAX_PORTAUDIO
+int celliax_portaudio_devlist(struct celliax_pvt *p)
+{
+ int i, numDevices;
+ const PaDeviceInfo *deviceInfo;
+
+ numDevices = Pa_GetDeviceCount();
+ if (numDevices < 0) {
+ return 0;
+ }
+ for (i = 0; i < numDevices; i++) {
+ deviceInfo = Pa_GetDeviceInfo(i);
+ NOTICA
+ ("Found PORTAUDIO device: id=%d\tname=%s\tmax input channels=%d\tmax output channels=%d\n",
+ CELLIAX_P_LOG, i, deviceInfo->name, deviceInfo->maxInputChannels,
+ deviceInfo->maxOutputChannels);
+ }
+
+ return numDevices;
+}
+
+int celliax_portaudio_init(struct celliax_pvt *p)
+{
+ PaError err;
+ int c;
+ PaStreamParameters inputParameters, outputParameters;
+ int numdevices;
+ const PaDeviceInfo *deviceInfo;
+
+#ifndef GIOVA48
+ setenv("PA_ALSA_PLUGHW", "1", 1);
+#endif // GIOVA48
+
+ err = Pa_Initialize();
+ if (err != paNoError)
+ return err;
+
+ numdevices = celliax_portaudio_devlist(p);
+
+ if (p->portaudiocindex > (numdevices - 1)) {
+ ERRORA("Portaudio Capture id=%d is out of range: valid id are from 0 to %d\n",
+ CELLIAX_P_LOG, p->portaudiocindex, (numdevices - 1));
+ return -1;
+ }
+
+ if (p->portaudiopindex > (numdevices - 1)) {
+ ERRORA("Portaudio Playback id=%d is out of range: valid id are from 0 to %d\n",
+ CELLIAX_P_LOG, p->portaudiopindex, (numdevices - 1));
+ return -1;
+ }
+ //inputParameters.device = 0;
+ if (p->portaudiocindex != -1) {
+ inputParameters.device = p->portaudiocindex;
+ } else {
+ inputParameters.device = Pa_GetDefaultInputDevice();
+ }
+ deviceInfo = Pa_GetDeviceInfo(inputParameters.device);
+ NOTICA
+ ("Using INPUT PORTAUDIO device: id=%d\tname=%s\tmax input channels=%d\tmax output channels=%d\n",
+ CELLIAX_P_LOG, inputParameters.device, deviceInfo->name,
+ deviceInfo->maxInputChannels, deviceInfo->maxOutputChannels);
+ if (deviceInfo->maxInputChannels == 0) {
+ ERRORA
+ ("No INPUT channels on device: id=%d\tname=%s\tmax input channels=%d\tmax output channels=%d\n",
+ CELLIAX_P_LOG, inputParameters.device, deviceInfo->name,
+ deviceInfo->maxInputChannels, deviceInfo->maxOutputChannels);
+ return -1;
+ }
+ inputParameters.channelCount = 1;
+ inputParameters.sampleFormat = paInt16;
+ //inputParameters.suggestedLatency = Pa_GetDeviceInfo(inputParameters.device)->defaultHighInputLatency;
+ inputParameters.suggestedLatency = 0.1;
+ inputParameters.hostApiSpecificStreamInfo = NULL;
+
+ //outputParameters.device = 3;
+ if (p->portaudiopindex != -1) {
+ outputParameters.device = p->portaudiopindex;
+ } else {
+ outputParameters.device = Pa_GetDefaultOutputDevice();
+ }
+ deviceInfo = Pa_GetDeviceInfo(outputParameters.device);
+ NOTICA
+ ("Using OUTPUT PORTAUDIO device: id=%d\tname=%s\tmax input channels=%d\tmax output channels=%d\n",
+ CELLIAX_P_LOG, outputParameters.device, deviceInfo->name,
+ deviceInfo->maxInputChannels, deviceInfo->maxOutputChannels);
+ if (deviceInfo->maxOutputChannels == 0) {
+ ERRORA
+ ("No OUTPUT channels on device: id=%d\tname=%s\tmax input channels=%d\tmax output channels=%d\n",
+ CELLIAX_P_LOG, inputParameters.device, deviceInfo->name,
+ deviceInfo->maxInputChannels, deviceInfo->maxOutputChannels);
+ return -1;
+ }
+#ifndef GIOVA48
+ outputParameters.channelCount = 1;
+#else // GIOVA48
+ outputParameters.channelCount = 2;
+#endif // GIOVA48
+ outputParameters.sampleFormat = paInt16;
+ //outputParameters.suggestedLatency = Pa_GetDeviceInfo(outputParameters.device)->defaultHighOutputLatency;
+ outputParameters.suggestedLatency = 0.1;
+ outputParameters.hostApiSpecificStreamInfo = NULL;
+
+/* build the pipe that will be polled on by pbx */
+ c = pipe(p->audiopipe);
+ if (c) {
+ ERRORA("Unable to create audio pipe\n", CELLIAX_P_LOG);
+ return -1;
+ }
+ fcntl(p->audiopipe[0], F_SETFL, O_NONBLOCK);
+ fcntl(p->audiopipe[1], F_SETFL, O_NONBLOCK);
+
+ err =
+#ifndef GIOVA48
+ OpenAudioStream(&p->stream, &inputParameters, &outputParameters, 8000,
+ paDitherOff | paClipOff, SAMPLES_PER_FRAME, p->audiopipe[1],
+ &p->speexecho, &p->speexpreprocess, &p->owner);
+
+#else // GIOVA48
+ OpenAudioStream(&p->stream, &inputParameters, &outputParameters, 48000,
+ paDitherOff | paClipOff, SAMPLES_PER_FRAME, p->audiopipe[1],
+ &p->speexecho, &p->speexpreprocess, &p->owner);
+
+#endif // GIOVA48
+ if (err != paNoError) {
+ ERRORA("Unable to open audio stream: %s\n", CELLIAX_P_LOG, Pa_GetErrorText(err));
+ return -1;
+ }
+
+/* the pipe is our audio fd for pbx to poll on */
+ p->celliax_sound_capt_fd = p->audiopipe[0];
+
+ return 0;
+}
+
+int celliax_portaudio_write(struct celliax_pvt *p, struct ast_frame *f)
+{
+ int samples;
+#ifdef GIOVA48
+ //short buf[CELLIAX_FRAME_SIZE * 2];
+ short buf[3840];
+ short *buf2;
+
+ //ERRORA("1 f->datalen=: %d\n", CELLIAX_P_LOG, f->datalen);
+
+ memset(buf, '\0', CELLIAX_FRAME_SIZE * 2);
+
+ buf2 = f->data;
+
+ int i = 0, a = 0;
+
+ for (i = 0; i < f->datalen / sizeof(short); i++) {
+//stereo, 2 chan 48 -> mono 8
+ buf[a] = buf2[i];
+ a++;
+ buf[a] = buf2[i];
+ a++;
+ buf[a] = buf2[i];
+ a++;
+ buf[a] = buf2[i];
+ a++;
+ buf[a] = buf2[i];
+ a++;
+ buf[a] = buf2[i];
+ a++;
+ buf[a] = buf2[i];
+ a++;
+ buf[a] = buf2[i];
+ a++;
+ buf[a] = buf2[i];
+ a++;
+ buf[a] = buf2[i];
+ a++;
+ buf[a] = buf2[i];
+ a++;
+ buf[a] = buf2[i];
+ a++;
+ /*
+ */
+ }
+ f->data = &buf;
+ f->datalen = f->datalen * 6;
+ //ERRORA("2 f->datalen=: %d\n", CELLIAX_P_LOG, f->datalen);
+ //f->datalen = f->datalen;
+#endif // GIOVA48
+
+#ifdef ASTERISK_VERSION_1_6_0_1
+ samples =
+ WriteAudioStream(p->stream, (short *) f->data.ptr,
+ (int) (f->datalen / sizeof(short)));
+#else
+ samples =
+ WriteAudioStream(p->stream, (short *) f->data, (int) (f->datalen / sizeof(short)));
+#endif /* ASTERISK_VERSION_1_6_0_1 */
+
+ if (samples != (int) (f->datalen / sizeof(short)))
+ ERRORA("WriteAudioStream wrote: %d of %d\n", CELLIAX_P_LOG, samples,
+ (int) (f->datalen / sizeof(short)));
+
+ return 0;
+}
+
+struct ast_frame *celliax_portaudio_read(struct celliax_pvt *p)
+{
+ static struct ast_frame f;
+ static short __buf[CELLIAX_FRAME_SIZE + AST_FRIENDLY_OFFSET / 2];
+ short *buf;
+ static short __buf2[CELLIAX_FRAME_SIZE + AST_FRIENDLY_OFFSET / 2];
+ short *buf2;
+ int samples;
+ char c;
+
+ memset(__buf, '\0', (CELLIAX_FRAME_SIZE + AST_FRIENDLY_OFFSET / 2));
+
+ buf = __buf + AST_FRIENDLY_OFFSET / 2;
+
+ memset(__buf2, '\0', (CELLIAX_FRAME_SIZE + AST_FRIENDLY_OFFSET / 2));
+
+ buf2 = __buf2 + AST_FRIENDLY_OFFSET / 2;
+
+ f.frametype = AST_FRAME_NULL;
+ f.subclass = 0;
+ f.samples = 0;
+ f.datalen = 0;
+
+#ifdef ASTERISK_VERSION_1_6_0_1
+ f.data.ptr = NULL;
+#else
+ f.data = NULL;
+#endif /* ASTERISK_VERSION_1_6_0_1 */
+ f.offset = 0;
+ f.src = celliax_type;
+ f.mallocd = 0;
+ f.delivery.tv_sec = 0;
+ f.delivery.tv_usec = 0;
+
+ if ((samples = ReadAudioStream(p->stream, buf, SAMPLES_PER_FRAME)) == 0) {
+ //do nothing
+ } else {
+#ifdef GIOVA48
+ int i = 0, a = 0;
+
+ samples = samples / 6;
+ for (i = 0; i < samples; i++) {
+ buf2[i] = buf[a];
+ a = a + 6; //mono, 1 chan 48 -> 8
+ }
+ buf = buf2;
+
+ /* A real frame */
+ f.frametype = AST_FRAME_VOICE;
+ f.subclass = AST_FORMAT_SLINEAR;
+ f.samples = CELLIAX_FRAME_SIZE / 6;
+ f.datalen = CELLIAX_FRAME_SIZE * 2 / 6;
+#else // GIOVA48
+ /* A real frame */
+ f.frametype = AST_FRAME_VOICE;
+ f.subclass = AST_FORMAT_SLINEAR;
+ f.samples = CELLIAX_FRAME_SIZE;
+ f.datalen = CELLIAX_FRAME_SIZE * 2;
+#endif // GIOVA48
+
+#ifdef ASTERISK_VERSION_1_6_0_1
+ f.data.ptr = buf;
+#else
+ f.data = buf;
+#endif /* ASTERISK_VERSION_1_6_0_1 */
+ f.offset = AST_FRIENDLY_OFFSET;
+ f.src = celliax_type;
+ f.mallocd = 0;
+ }
+
+ read(p->audiopipe[0], &c, 1);
+
+ return &f;
+}
+
+int celliax_portaudio_shutdown(struct celliax_pvt *p)
+{
+ PaError err;
+
+ err = CloseAudioStream(p->stream);
+
+ if (err != paNoError)
+ ERRORA("not able to CloseAudioStream\n", CELLIAX_P_LOG);
+
+ Pa_Terminate();
+ return 0;
+}
+#endif // CELLIAX_PORTAUDIO
+
+int celliax_serial_sync_AT(struct celliax_pvt *p)
+{
+ usleep(10000); /* 10msec */
+ time(&p->celliax_serial_synced_timestamp);
+ return 0;
+}
+
+int celliax_serial_getstatus_AT(struct celliax_pvt *p)
+{
+ int res;
+
+ if (p->owner) {
+ if (p->owner->_state != AST_STATE_UP && p->owner->_state != AST_STATE_DOWN) {
+ DEBUGA_AT("No getstatus, we're neither UP nor DOWN\n", CELLIAX_P_LOG);
+ return 0;
+ }
+ }
+
+ PUSHA_UNLOCKA(&p->controldev_lock);
+ LOKKA(&p->controldev_lock);
+ res = celliax_serial_write_AT_ack(p, "AT");
+ if (res) {
+ ERRORA("AT was not acknowledged, continuing but maybe there is a problem\n",
+ CELLIAX_P_LOG);
+ }
+ usleep(1000);
+
+ if (strlen(p->at_query_battchg)) {
+ res =
+ celliax_serial_write_AT_expect(p, p->at_query_battchg, p->at_query_battchg_expect);
+ if (res) {
+ WARNINGA("%s does not get %s from the phone. Continuing.\n", CELLIAX_P_LOG,
+ p->at_query_battchg, p->at_query_battchg_expect);
+ }
+ usleep(1000);
+ }
+
+ if (strlen(p->at_query_signal)) {
+ res =
+ celliax_serial_write_AT_expect(p, p->at_query_signal, p->at_query_signal_expect);
+ if (res) {
+ WARNINGA("%s does not get %s from the phone. Continuing.\n", CELLIAX_P_LOG,
+ p->at_query_signal, p->at_query_signal_expect);
+ }
+ usleep(1000);
+ }
+ //FIXME all the following commands in config!
+
+ if (p->sms_cnmi_not_supported) {
+ res = celliax_serial_write_AT_ack(p, "AT+MMGL=\"HEADER ONLY\"");
+ if (res) {
+ WARNINGA
+ ("%s does not get %s from the modem, maybe a long msg is incoming. If this cellmodem is not a Motorola, you are arriving here because your cellmodem do not supports CNMI kind of incoming SMS alert; please let it know to the developers of Celliax. If this cellmodem is a Motorola and this message keeps repeating, and you cannot correctly receive SMSs from this interface, please manually clean all messages from the cellmodem/SIM. Continuing.\n",
+ CELLIAX_P_LOG, "AT+MMGL=\"HEADER ONLY\"", "OK");
+ } else {
+ usleep(1000);
+ if (p->unread_sms_msg_id) {
+ char at_command[256];
+
+ if (p->no_ucs2 == 0) {
+ res = celliax_serial_write_AT_ack(p, "AT+CSCS=\"UCS2\"");
+ if (res) {
+ ERRORA
+ ("AT+CSCS=\"UCS2\" (set TE messages to ucs2) do not got OK from the phone\n",
+ CELLIAX_P_LOG);
+ memset(p->sms_message, 0, sizeof(p->sms_message));
+ }
+ }
+
+ memset(at_command, 0, sizeof(at_command));
+ sprintf(at_command, "AT+CMGR=%d", p->unread_sms_msg_id);
+ memset(p->sms_message, 0, sizeof(p->sms_message));
+
+ p->reading_sms_msg = 1;
+ res = celliax_serial_write_AT_ack(p, at_command);
+ p->reading_sms_msg = 0;
+ if (res) {
+ ERRORA
+ ("AT+CMGR (read SMS) do not got OK from the phone, message sent was:|||%s|||\n",
+ CELLIAX_P_LOG, at_command);
+ }
+ res = celliax_serial_write_AT_ack(p, "AT+CSCS=\"GSM\"");
+ if (res) {
+ ERRORA
+ ("AT+CSCS=\"GSM\" (set TE messages to GSM) do not got OK from the phone\n",
+ CELLIAX_P_LOG);
+ }
+ memset(at_command, 0, sizeof(at_command));
+ sprintf(at_command, "AT+CMGD=%d", p->unread_sms_msg_id); /* delete the message */
+ p->unread_sms_msg_id = 0;
+ res = celliax_serial_write_AT_ack(p, at_command);
+ if (res) {
+ ERRORA
+ ("AT+CMGD (Delete SMS) do not got OK from the phone, message sent was:|||%s|||\n",
+ CELLIAX_P_LOG, at_command);
+ }
+
+ if (strlen(p->sms_message)) {
+
+ manager_event(EVENT_FLAG_SYSTEM, "CELLIAXincomingsms",
+ "Interface: %s\r\nSMS_Message: %s\r\n", p->name, p->sms_message);
+
+ if (strlen(p->sms_receiving_program)) {
+ int fd1[2];
+ pid_t pid1;
+ char *arg1[] = { p->sms_receiving_program, (char *) NULL };
+ int i;
+
+ NOTICA("incoming SMS message:>>>%s<<<\n", CELLIAX_P_LOG, p->sms_message);
+ pipe(fd1);
+ pid1 = fork();
+
+ if (pid1 == 0) { //child
+ int err;
+
+ dup2(fd1[0], 0); // Connect stdin to pipe output
+ close(fd1[1]); // close input pipe side
+ setsid(); //session id
+ err = execvp(arg1[0], arg1); //exec our program, with stdin connected to pipe output
+ if (err) {
+ ERRORA
+ ("'sms_receiving_program' is set in config file to '%s', and it gave us back this error: %d, (%s). SMS received was:---%s---\n",
+ CELLIAX_P_LOG, p->sms_receiving_program, err, strerror(errno),
+ p->sms_message);
+ }
+ close(fd1[0]); // close output pipe side
+ } //starting here continue the parent
+ close(fd1[0]); // close output pipe side
+ // write the msg on the pipe input
+ for (i = 0; i < strlen(p->sms_message); i++) {
+ write(fd1[1], &p->sms_message[i], 1);
+ }
+ close(fd1[1]); // close pipe input, let our program know we've finished
+ } else {
+ ERRORA
+ ("got SMS incoming message, but 'sms_receiving_program' is not set in config file. SMS received was:---%s---\n",
+ CELLIAX_P_LOG, p->sms_message);
+ }
+ }
+#if 1 //is this one needed? maybe it can interrupt an incoming call that is just to announce itself
+ if (p->phone_callflow == CALLFLOW_CALL_IDLE
+ && p->interface_state == AST_STATE_DOWN && p->owner == NULL) {
+ /* we're not in a call, neither calling */
+ res = celliax_serial_write_AT_ack(p, "AT+CKPD=\"EEE\"");
+ if (res) {
+ ERRORA
+ ("AT+CKPD=\"EEE\" (cellphone screen back to user) do not got OK from the phone\n",
+ CELLIAX_P_LOG);
+ }
+ }
+#endif
+ }
+ }
+ }
+
+ UNLOCKA(&p->controldev_lock);
+ POPPA_UNLOCKA(&p->controldev_lock);
+ return 0;
+}
+
+int celliax_serial_read_AT(struct celliax_pvt *p, int look_for_ack, int timeout_usec,
+ int timeout_sec, const char *expected_string, int expect_crlf)
+{
+ int select_err;
+ int res;
+ fd_set read_fds;
+ struct timeval timeout;
+ char tmp_answer[AT_BUFSIZ];
+ char tmp_answer2[AT_BUFSIZ];
+ char *tmp_answer_ptr;
+ char *last_line_ptr;
+ int i = 0;
+ int read_count = 0;
+ int la_counter = 0;
+ int at_ack = -1;
+ int la_read = 0;
+
+ FD_ZERO(&read_fds);
+ FD_SET(p->controldevfd, &read_fds);
+
+ //NOTICA (" INSIDE this celliax_serial_device %s \n", CELLIAX_P_LOG, p->controldevice_name);
+ tmp_answer_ptr = tmp_answer;
+ memset(tmp_answer, 0, sizeof(char) * AT_BUFSIZ);
+
+ timeout.tv_sec = timeout_sec;
+ timeout.tv_usec = timeout_usec;
+ PUSHA_UNLOCKA(&p->controldev_lock);
+ LOKKA(&p->controldev_lock);
+
+ while ((select_err = select(p->controldevfd + 1, &read_fds, NULL, NULL, &timeout)) > 0) {
+ timeout.tv_sec = timeout_sec; //reset the timeout, linux modify it
+ timeout.tv_usec = timeout_usec; //reset the timeout, linux modify it
+ read_count =
+ read(p->controldevfd, tmp_answer_ptr, AT_BUFSIZ - (tmp_answer_ptr - tmp_answer));
+
+ if (read_count == 0) {
+ ERRORA
+ ("read 0 bytes!!! Nenormalno! Marking this celliax_serial_device %s as dead, andif it is owned by a channel, hanging up. Maybe the phone is stuck, switched off, power down or battery exhausted\n",
+ CELLIAX_P_LOG, p->controldevice_name);
+ p->controldev_dead = 1;
+ close(p->controldevfd);
+ UNLOCKA(&p->controldev_lock);
+ if (p->owner) {
+ p->owner->hangupcause = AST_CAUSE_FAILURE;
+ celliax_queue_control(p->owner, AST_CONTROL_HANGUP);
+ }
+ return -1;
+ }
+
+ if (option_debug > 90) {
+ //DEBUGA_AT("1 read %d bytes, --|%s|--\n", CELLIAX_P_LOG, read_count, tmp_answer_ptr);
+ //DEBUGA_AT("2 read %d bytes, --|%s|--\n", CELLIAX_P_LOG, read_count, tmp_answer);
+ }
+ tmp_answer_ptr = tmp_answer_ptr + read_count;
+
+ char *token_ptr;
+
+ la_counter = 0;
+ memset(tmp_answer2, 0, sizeof(char) * AT_BUFSIZ);
+ strcpy(tmp_answer2, tmp_answer);
+ if ((token_ptr = strtok(tmp_answer2, "\n\r"))) {
+ last_line_ptr = token_ptr;
+ strncpy(p->line_array.result[la_counter], token_ptr, AT_MESG_MAX_LENGTH);
+ if (strlen(token_ptr) > AT_MESG_MAX_LENGTH) {
+ WARNINGA
+ ("AT mesg longer than buffer, original message was: |%s|, in buffer only: |%s|\n",
+ CELLIAX_P_LOG, token_ptr, p->line_array.result[la_counter]);
+ }
+ la_counter++;
+ while ((token_ptr = strtok(NULL, "\n\r"))) {
+ last_line_ptr = token_ptr;
+ strncpy(p->line_array.result[la_counter], token_ptr, AT_MESG_MAX_LENGTH);
+ if (strlen(token_ptr) > AT_MESG_MAX_LENGTH) {
+ WARNINGA
+ ("AT mesg longer than buffer, original message was: |%s|, in buffer only: |%s|\n",
+ CELLIAX_P_LOG, token_ptr, p->line_array.result[la_counter]);
+ }
+ la_counter++;
+ }
+ } else {
+ last_line_ptr = tmp_answer;
+ }
+
+ if (expected_string && !expect_crlf) {
+ DEBUGA_AT
+ ("last_line_ptr=|%s|, expected_string=|%s|, expect_crlf=%d, memcmp(last_line_ptr, expected_string, strlen(expected_string)) = %d\n",
+ CELLIAX_P_LOG, last_line_ptr, expected_string, expect_crlf, memcmp(last_line_ptr,
+ expected_string,
+ strlen
+ (expected_string)));
+ }
+
+ if (expected_string && !expect_crlf
+ && !memcmp(last_line_ptr, expected_string, strlen(expected_string))
+ ) {
+ strncpy(p->line_array.result[la_counter], last_line_ptr, AT_MESG_MAX_LENGTH);
+ // match expected string -> accept it withtout CRLF
+ la_counter++;
+
+ }
+ /* if the last line read was not a complete line, we'll read the rest in the future */
+ else if (tmp_answer[strlen(tmp_answer) - 1] != '\r'
+ && tmp_answer[strlen(tmp_answer) - 1] != '\n')
+ la_counter--;
+
+ /* let's list the complete lines read so far, without re-listing the lines that has yet been listed */
+ if (option_debug > 1) {
+ for (i = la_read; i < la_counter; i++)
+ DEBUGA_AT("Read line %d: |%s|\n", CELLIAX_P_LOG, i, p->line_array.result[i]);
+ }
+
+ /* let's interpret the complete lines read so far (WITHOUT looking for OK, ERROR, and EXPECTED_STRING), without re-interpreting the lines that has been yet interpreted, so we're sure we don't miss anything */
+ for (i = la_read; i < la_counter; i++) {
+
+ if ((strcmp(p->line_array.result[i], "RING") == 0)) {
+ /* with first RING we wait for callid */
+ gettimeofday(&(p->ringtime), NULL);
+ /* give CALLID (+CLIP) a chance, wait for the next RING before answering */
+ if (p->phone_callflow == CALLFLOW_INCOMING_RING) {
+ /* we're at the second ring, set the interface state, will be answered by celliax_do_monitor */
+ DEBUGA_AT("|%s| got second RING\n", CELLIAX_P_LOG, p->line_array.result[i]);
+ p->interface_state = AST_STATE_RING;
+ } else {
+ /* we're at the first ring, so there is no CALLID yet thus clean the previous one
+ just in case we don't receive the caller identification in this new call */
+ memset(p->callid_name, 0, sizeof(p->callid_name));
+ memset(p->callid_number, 0, sizeof(p->callid_number));
+ /* only send AT+CLCC? if the device previously reported its support */
+ if (p->at_has_clcc != 0) {
+ /* we're at the first ring, try to get CALLID (with +CLCC) */
+ DEBUGA_AT("|%s| got first RING, sending AT+CLCC?\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ res = celliax_serial_write_AT_noack(p, "AT+CLCC?");
+ if (res) {
+ ERRORA("AT+CLCC? (call list) was not correctly sent to the phone\n",
+ CELLIAX_P_LOG);
+ }
+ } else {
+ DEBUGA_AT("|%s| got first RING, but not sending AT+CLCC? as this device "
+ "seems not to support\n", CELLIAX_P_LOG, p->line_array.result[i]);
+ }
+ }
+ p->phone_callflow = CALLFLOW_INCOMING_RING;
+ }
+
+ if ((strncmp(p->line_array.result[i], "+CLCC", 5) == 0)) {
+ /* with clcc we wait for clip */
+ memset(p->callid_name, 0, sizeof(p->callid_name));
+ memset(p->callid_number, 0, sizeof(p->callid_number));
+ int commacount = 0;
+ int a = 0;
+ int b = 0;
+ int c = 0;
+
+ for (a = 0; a < strlen(p->line_array.result[i]); a++) {
+
+ if (p->line_array.result[i][a] == ',') {
+ commacount++;
+ }
+ if (commacount == 5) {
+ if (p->line_array.result[i][a] != ',' && p->line_array.result[i][a] != '"') {
+ p->callid_number[b] = p->line_array.result[i][a];
+ b++;
+ }
+ }
+ if (commacount == 7) {
+ if (p->line_array.result[i][a] != ',' && p->line_array.result[i][a] != '"') {
+ p->callid_name[c] = p->line_array.result[i][a];
+ c++;
+ }
+ }
+ }
+
+ p->phone_callflow = CALLFLOW_INCOMING_RING;
+ DEBUGA_AT("|%s| CLCC CALLID: name is %s, number is %s\n", CELLIAX_P_LOG,
+ p->line_array.result[i],
+ p->callid_name[0] ? p->callid_name : "not available",
+ p->callid_number[0] ? p->callid_number : "not available");
+ }
+
+ if ((strncmp(p->line_array.result[i], "+CLIP", 5) == 0)) {
+ /* with CLIP, we want to answer right away */
+ memset(p->callid_name, 0, sizeof(p->callid_name));
+ memset(p->callid_number, 0, sizeof(p->callid_number));
+
+ int commacount = 0;
+ int a = 0;
+ int b = 0;
+ int c = 0;
+
+ for (a = 7; a < strlen(p->line_array.result[i]); a++) {
+ if (p->line_array.result[i][a] == ',') {
+ commacount++;
+ }
+ if (commacount == 0) {
+ if (p->line_array.result[i][a] != ',' && p->line_array.result[i][a] != '"') {
+ p->callid_number[b] = p->line_array.result[i][a];
+ b++;
+ }
+ }
+ if (commacount == 4) {
+ if (p->line_array.result[i][a] != ',' && p->line_array.result[i][a] != '"') {
+ p->callid_name[c] = p->line_array.result[i][a];
+ c++;
+ }
+ }
+ }
+
+ if (p->interface_state != AST_STATE_RING) {
+ gettimeofday(&(p->call_incoming_time), NULL);
+ DEBUGA_AT("AST_STATE_RING call_incoming_time.tv_sec=%ld\n",
+ CELLIAX_P_LOG, p->call_incoming_time.tv_sec);
+
+ }
+
+ p->interface_state = AST_STATE_RING;
+ p->phone_callflow = CALLFLOW_INCOMING_RING;
+ DEBUGA_AT("|%s| CLIP INCOMING CALLID: name is %s, number is %s\n", CELLIAX_P_LOG,
+ p->line_array.result[i],
+ p->callid_name[0] != 1 ? p->callid_name : "not available",
+ p->callid_number[0] ? p->callid_number : "not available");
+ }
+
+ if ((strcmp(p->line_array.result[i], "BUSY") == 0)) {
+ p->phone_callflow = CALLFLOW_CALL_LINEBUSY;
+ if (option_debug > 1)
+ DEBUGA_AT("|%s| CALLFLOW_CALL_LINEBUSY\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ if (p->interface_state != AST_STATE_DOWN && p->owner) {
+ ast_setstate(p->owner, AST_STATE_BUSY);
+ celliax_queue_control(p->owner, AST_CONTROL_BUSY);
+ } else {
+ ERRORA("Why BUSY now?\n", CELLIAX_P_LOG);
+ }
+ }
+ if ((strcmp(p->line_array.result[i], "NO ANSWER") == 0)) {
+ p->phone_callflow = CALLFLOW_CALL_NOANSWER;
+ if (option_debug > 1)
+ DEBUGA_AT("|%s| CALLFLOW_CALL_NOANSWER\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ if (p->interface_state != AST_STATE_DOWN && p->owner) {
+ p->owner->hangupcause = AST_CAUSE_NO_ANSWER;
+ celliax_queue_control(p->owner, AST_CONTROL_HANGUP);
+ } else {
+ ERRORA("Why NO ANSWER now?\n", CELLIAX_P_LOG);
+ }
+ }
+ if ((strcmp(p->line_array.result[i], "NO CARRIER") == 0)) {
+ p->phone_callflow = CALLFLOW_CALL_NOCARRIER;
+ if (option_debug > 1)
+ DEBUGA_AT("|%s| CALLFLOW_CALL_NOCARRIER\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ if (p->interface_state != AST_STATE_DOWN && p->owner) {
+ p->owner->hangupcause = AST_CAUSE_FAILURE;
+ celliax_queue_control(p->owner, AST_CONTROL_HANGUP);
+ } else {
+ ERRORA("Why NO CARRIER now?\n", CELLIAX_P_LOG);
+ }
+ }
+
+ if ((strncmp(p->line_array.result[i], "+CBC:", 5) == 0)) {
+ int power_supply, battery_strenght, err;
+
+ power_supply = battery_strenght = 0;
+
+ err =
+ sscanf(&p->line_array.result[i][6], "%d,%d", &power_supply, &battery_strenght);
+ if (err < 2) {
+ DEBUGA_AT("|%s| is not formatted as: |+CBC: xx,yy| now trying |+CBC:xx,yy|\n",
+ CELLIAX_P_LOG, p->line_array.result[i]);
+
+ err =
+ sscanf(&p->line_array.result[i][5], "%d,%d", &power_supply,
+ &battery_strenght);
+ DEBUGA_AT("|%s| +CBC: Powered by %s, battery strenght=%d\n", CELLIAX_P_LOG,
+ p->line_array.result[i], power_supply ? "power supply" : "battery",
+ battery_strenght);
+
+ }
+
+ if (err < 2) {
+ DEBUGA_AT("|%s| is not formatted as: |+CBC:xx,yy| giving up\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ }
+
+ else {
+ if (option_debug > 1)
+ DEBUGA_AT("|%s| +CBC: Powered by %s, battery strenght=%d\n", CELLIAX_P_LOG,
+ p->line_array.result[i], power_supply ? "power supply" : "battery",
+ battery_strenght);
+ if (!power_supply) {
+ if (battery_strenght < 10) {
+ ERRORA("|%s| BATTERY ALMOST EXHAUSTED\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ } else if (battery_strenght < 20) {
+ WARNINGA("|%s| BATTERY LOW\n", CELLIAX_P_LOG, p->line_array.result[i]);
+
+ }
+
+ }
+ }
+
+ }
+
+ if ((strncmp(p->line_array.result[i], "+CSQ:", 5) == 0)) {
+ int signal_quality, ber, err;
+
+ signal_quality = ber = 0;
+
+ err = sscanf(&p->line_array.result[i][6], "%d,%d", &signal_quality, &ber);
+ if (option_debug > 1)
+ DEBUGA_AT("|%s| +CSQ: Signal Quality: %d, Error Rate=%d\n", CELLIAX_P_LOG,
+ p->line_array.result[i], signal_quality, ber);
+ if (err < 2) {
+ ERRORA("|%s| is not formatted as: |+CSQ: xx,yy|\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ } else {
+ if (signal_quality < 11 || signal_quality == 99) {
+ WARNINGA
+ ("|%s| CELLPHONE GETS ALMOST NO SIGNAL, consider to move it or additional antenna\n",
+ CELLIAX_P_LOG, p->line_array.result[i]);
+ } else if (signal_quality < 15) {
+ WARNINGA("|%s| CELLPHONE GETS SIGNAL LOW\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+
+ }
+
+ }
+
+ }
+ if ((strncmp(p->line_array.result[i], "+CMGW:", 6) == 0)) {
+ int err;
+
+ err = sscanf(&p->line_array.result[i][7], "%s", p->at_cmgw);
+ DEBUGA_AT("|%s| +CMGW: %s\n", CELLIAX_P_LOG, p->line_array.result[i], p->at_cmgw);
+ if (err < 1) {
+ ERRORA("|%s| is not formatted as: |+CMGW: xxxx|\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ }
+
+ }
+
+ /* at_call_* are unsolicited messages sent by the modem to signal us about call processing activity and events */
+ if ((strcmp(p->line_array.result[i], p->at_call_idle) == 0)) {
+ p->phone_callflow = CALLFLOW_CALL_IDLE;
+ if (option_debug > 1)
+ DEBUGA_AT("|%s| CALLFLOW_CALL_IDLE\n", CELLIAX_P_LOG, p->line_array.result[i]);
+ if (p->interface_state != AST_STATE_DOWN && p->owner) {
+ DEBUGA_AT("just received a remote HANGUP\n", CELLIAX_P_LOG);
+ p->owner->hangupcause = AST_CAUSE_NORMAL;
+ celliax_queue_control(p->owner, AST_CONTROL_HANGUP);
+ DEBUGA_AT("just sent AST_CONTROL_HANGUP\n", CELLIAX_P_LOG);
+ }
+ }
+
+ if ((strcmp(p->line_array.result[i], p->at_call_incoming) == 0)) {
+
+ //char list_command[64];
+
+ if (option_debug > 1)
+ DEBUGA_AT("|%s| CALLFLOW_CALL_INCOMING\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+
+ if (p->phone_callflow != CALLFLOW_CALL_INCOMING
+ && p->phone_callflow != CALLFLOW_INCOMING_RING) {
+ //mark the time of CALLFLOW_CALL_INCOMING
+ gettimeofday(&(p->call_incoming_time), NULL);
+ p->phone_callflow = CALLFLOW_CALL_INCOMING;
+ DEBUGA_AT("CALLFLOW_CALL_INCOMING call_incoming_time.tv_sec=%ld\n",
+ CELLIAX_P_LOG, p->call_incoming_time.tv_sec);
+
+ }
+ }
+
+ if ((strcmp(p->line_array.result[i], p->at_call_active) == 0)) {
+ p->phone_callflow = CALLFLOW_CALL_ACTIVE;
+ if (option_debug > 1)
+ DEBUGA_AT("|%s| CALLFLOW_CALL_ACTIVE\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+
+ if (p->owner && p->interface_state == CALLFLOW_CALL_DIALING) {
+ DEBUGA_PBX("just received a remote ANSWER\n", CELLIAX_P_LOG);
+ if (p->owner->_state != AST_STATE_UP) {
+ celliax_queue_control(p->owner, AST_CONTROL_RINGING);
+ DEBUGA_PBX("just sent AST_CONTROL_RINGING\n", CELLIAX_P_LOG);
+ DEBUGA_PBX("going to send AST_CONTROL_ANSWER\n", CELLIAX_P_LOG);
+ celliax_queue_control(p->owner, AST_CONTROL_ANSWER);
+ DEBUGA_PBX("just sent AST_CONTROL_ANSWER\n", CELLIAX_P_LOG);
+ }
+ } else {
+ }
+ p->interface_state = AST_STATE_UP;
+ DEBUGA_PBX("just interface_state UP\n", CELLIAX_P_LOG);
+ }
+
+ if ((strcmp(p->line_array.result[i], p->at_call_calling) == 0)) {
+ p->phone_callflow = CALLFLOW_CALL_DIALING;
+ if (option_debug > 1)
+ DEBUGA_AT("|%s| CALLFLOW_CALL_DIALING\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ }
+ if ((strcmp(p->line_array.result[i], p->at_call_failed) == 0)) {
+ p->phone_callflow = CALLFLOW_CALL_FAILED;
+ if (option_debug > 1)
+ DEBUGA_AT("|%s| CALLFLOW_CALL_FAILED\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ if (p->interface_state != AST_STATE_DOWN && p->owner) {
+ p->owner->hangupcause = AST_CAUSE_FAILURE;
+ celliax_queue_control(p->owner, AST_CONTROL_HANGUP);
+ }
+ }
+
+ if ((strncmp(p->line_array.result[i], "+CSCA:", 6) == 0)) { //TODO SMS FIXME in config!
+ if (option_debug > 1)
+ DEBUGA_AT("|%s| +CSCA: Message Center Address!\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ }
+
+ if ((strncmp(p->line_array.result[i], "+CMGF:", 6) == 0)) { //TODO SMS FIXME in config!
+ if (option_debug > 1)
+ DEBUGA_AT("|%s| +CMGF: Message Format!\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ }
+
+ if ((strncmp(p->line_array.result[i], "+CMTI:", 6) == 0)) { //TODO SMS FIXME in config!
+ int err;
+ int pos;
+
+ //FIXME all the following commands in config!
+ if (option_debug)
+ DEBUGA_AT("|%s| +CMTI: Incoming SMS!\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+
+ err = sscanf(&p->line_array.result[i][12], "%d", &pos);
+ if (err < 1) {
+ ERRORA("|%s| is not formatted as: |+CMTI: \"MT\",xx|\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ } else {
+ DEBUGA_AT("|%s| +CMTI: Incoming SMS in position: %d!\n", CELLIAX_P_LOG,
+ p->line_array.result[i], pos);
+ p->unread_sms_msg_id = pos;
+ usleep(1000);
+
+ if (p->unread_sms_msg_id) {
+ char at_command[256];
+
+ if (p->no_ucs2 == 0) {
+ res = celliax_serial_write_AT_ack(p, "AT+CSCS=\"UCS2\"");
+ if (res) {
+ ERRORA
+ ("AT+CSCS=\"UCS2\" (set TE messages to ucs2) do not got OK from the phone, continuing\n",
+ CELLIAX_P_LOG);
+ //memset(p->sms_message, 0, sizeof(p->sms_message));
+ }
+ }
+
+ memset(at_command, 0, sizeof(at_command));
+ sprintf(at_command, "AT+CMGR=%d", p->unread_sms_msg_id);
+ memset(p->sms_message, 0, sizeof(p->sms_message));
+
+ p->reading_sms_msg = 1;
+ res = celliax_serial_write_AT_ack(p, at_command);
+ p->reading_sms_msg = 0;
+ if (res) {
+ ERRORA
+ ("AT+CMGR (read SMS) do not got OK from the phone, message sent was:|||%s|||\n",
+ CELLIAX_P_LOG, at_command);
+ }
+ res = celliax_serial_write_AT_ack(p, "AT+CSCS=\"GSM\"");
+ if (res) {
+ ERRORA
+ ("AT+CSCS=\"GSM\" (set TE messages to GSM) do not got OK from the phone\n",
+ CELLIAX_P_LOG);
+ }
+ memset(at_command, 0, sizeof(at_command));
+ sprintf(at_command, "AT+CMGD=%d", p->unread_sms_msg_id); /* delete the message */
+ p->unread_sms_msg_id = 0;
+ res = celliax_serial_write_AT_ack(p, at_command);
+ if (res) {
+ ERRORA
+ ("AT+CMGD (Delete SMS) do not got OK from the phone, message sent was:|||%s|||\n",
+ CELLIAX_P_LOG, at_command);
+ }
+
+ if (strlen(p->sms_message)) {
+ manager_event(EVENT_FLAG_SYSTEM, "CELLIAXincomingsms",
+ "Interface: %s\r\nSMS_Message: %s\r\n", p->name,
+ p->sms_message);
+ if (strlen(p->sms_receiving_program)) {
+ int fd1[2];
+ pid_t pid1;
+ char *arg1[] = { p->sms_receiving_program, (char *) NULL };
+ int i;
+
+ NOTICA("incoming SMS message:>>>%s<<<\n", CELLIAX_P_LOG, p->sms_message);
+ pipe(fd1);
+ pid1 = fork();
+
+ if (pid1 == 0) { //child
+ int err;
+
+ dup2(fd1[0], 0); // Connect stdin to pipe output
+ close(fd1[1]); // close input pipe side
+ close(p->controldevfd);
+ setsid(); //session id
+ err = execvp(arg1[0], arg1); //exec our program, with stdin connected to pipe output
+ if (err) {
+ ERRORA
+ ("'sms_receiving_program' is set in config file to '%s', and it gave us back this error: %d, (%s). SMS received was:---%s---\n",
+ CELLIAX_P_LOG, p->sms_receiving_program, err, strerror(errno),
+ p->sms_message);
+ }
+ close(fd1[0]); // close output pipe side
+ }
+//starting here continue the parent
+ close(fd1[0]); // close output pipe side
+ // write the msg on the pipe input
+ for (i = 0; i < strlen(p->sms_message); i++) {
+ write(fd1[1], &p->sms_message[i], 1);
+ }
+ close(fd1[1]); // close pipe input, let our program know we've finished
+ } else {
+ ERRORA
+ ("got SMS incoming message, but 'sms_receiving_program' is not set in config file. SMS received was:---%s---\n",
+ CELLIAX_P_LOG, p->sms_message);
+ }
+ }
+#if 1 //is this one needed? maybe it can interrupt an incoming call that is just to announce itself
+ if (p->phone_callflow == CALLFLOW_CALL_IDLE
+ && p->interface_state == AST_STATE_DOWN && p->owner == NULL) {
+ /* we're not in a call, neither calling */
+ res = celliax_serial_write_AT_ack(p, "AT+CKPD=\"EEE\"");
+ if (res) {
+ ERRORA
+ ("AT+CKPD=\"EEE\" (cellphone screen back to user) do not got OK from the phone\n",
+ CELLIAX_P_LOG);
+ }
+ }
+#endif
+ } //unread_msg_id
+
+ } //CMTI well formatted
+
+ } //CMTI
+
+ if ((strncmp(p->line_array.result[i], "+MMGL:", 6) == 0)) { //TODO MOTOROLA SMS FIXME in config!
+ int err = 0;
+ //int unread_msg_id=0;
+
+ if (option_debug)
+ DEBUGA_AT("|%s| +MMGL: Listing Motorola SMSs!\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+
+ err = sscanf(&p->line_array.result[i][7], "%d", &p->unread_sms_msg_id);
+ if (err < 1) {
+ ERRORA("|%s| is not formatted as: |+MMGL: xx|\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ }
+ }
+ if ((strncmp(p->line_array.result[i], "+CMGL:", 6) == 0)) { //TODO SMS FIXME in config!
+ if (option_debug)
+ DEBUGA_AT("|%s| +CMGL: Listing SMSs!\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ }
+ if ((strncmp(p->line_array.result[i], "+MMGR:", 6) == 0)) { //TODO MOTOROLA SMS FIXME in config!
+ if (option_debug)
+ DEBUGA_AT("|%s| +MMGR: Reading Motorola SMS!\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ if (p->reading_sms_msg)
+ p->reading_sms_msg++;
+ }
+ if ((strncmp(p->line_array.result[i], "+CMGR: \"STO U", 13) == 0)) { //TODO SMS FIXME in config!
+ if (option_debug)
+ DEBUGA_AT("|%s| +CMGR: Reading stored UNSENT SMS!\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ } else if ((strncmp(p->line_array.result[i], "+CMGR: \"STO S", 13) == 0)) { //TODO SMS FIXME in config!
+ if (option_debug)
+ DEBUGA_AT("|%s| +CMGR: Reading stored SENT SMS!\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ } else if ((strncmp(p->line_array.result[i], "+CMGR: \"REC R", 13) == 0)) { //TODO SMS FIXME in config!
+ if (option_debug)
+ DEBUGA_AT("|%s| +CMGR: Reading received READ SMS!\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ } else if ((strncmp(p->line_array.result[i], "+CMGR: \"REC U", 13) == 0)) { //TODO SMS FIXME in config!
+ if (option_debug)
+ DEBUGA_AT("|%s| +CMGR: Reading received UNREAD SMS!\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ if (p->reading_sms_msg)
+ p->reading_sms_msg++;
+ }
+
+ if ((strcmp(p->line_array.result[i], "+MCST: 17") == 0)) { /* motorola call processing unsolicited messages */
+ p->phone_callflow = CALLFLOW_CALL_INFLUX;
+ if (option_debug > 1)
+ DEBUGA_AT("|%s| CALLFLOW_CALL_INFLUX\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ }
+
+ if ((strcmp(p->line_array.result[i], "+MCST: 68") == 0)) { /* motorola call processing unsolicited messages */
+ p->phone_callflow = CALLFLOW_CALL_NOSERVICE;
+ if (option_debug > 1)
+ DEBUGA_AT("|%s| CALLFLOW_CALL_NOSERVICE\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ if (p->interface_state != AST_STATE_DOWN && p->owner) {
+ p->owner->hangupcause = AST_CAUSE_FAILURE;
+ celliax_queue_control(p->owner, AST_CONTROL_HANGUP);
+ }
+ }
+ if ((strcmp(p->line_array.result[i], "+MCST: 70") == 0)) { /* motorola call processing unsolicited messages */
+ p->phone_callflow = CALLFLOW_CALL_OUTGOINGRESTRICTED;
+ if (option_debug > 1)
+ DEBUGA_AT("|%s| CALLFLOW_CALL_OUTGOINGRESTRICTED\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ if (p->interface_state != AST_STATE_DOWN && p->owner) {
+ p->owner->hangupcause = AST_CAUSE_FAILURE;
+ celliax_queue_control(p->owner, AST_CONTROL_HANGUP);
+ }
+ }
+ if ((strcmp(p->line_array.result[i], "+MCST: 72") == 0)) { /* motorola call processing unsolicited messages */
+ p->phone_callflow = CALLFLOW_CALL_SECURITYFAIL;
+ if (option_debug > 1)
+ DEBUGA_AT("|%s| CALLFLOW_CALL_SECURITYFAIL\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ if (p->interface_state != AST_STATE_DOWN && p->owner) {
+ p->owner->hangupcause = AST_CAUSE_FAILURE;
+ celliax_queue_control(p->owner, AST_CONTROL_HANGUP);
+ }
+ }
+
+ if ((strncmp(p->line_array.result[i], "+CPBR", 5) == 0)) { /* phonebook stuff begins */
+
+ if (p->phonebook_querying) { /* probably phonebook struct begins */
+ int err, first_entry, last_entry, number_lenght, text_lenght;
+
+ if (option_debug)
+ DEBUGA_AT("phonebook struct: |%s|\n", CELLIAX_P_LOG, p->line_array.result[i]);
+
+ err =
+ sscanf(&p->line_array.result[i][8], "%d-%d),%d,%d", &first_entry, &last_entry,
+ &number_lenght, &text_lenght);
+ if (err < 4) {
+
+ err =
+ sscanf(&p->line_array.result[i][7], "%d-%d,%d,%d", &first_entry,
+ &last_entry, &number_lenght, &text_lenght);
+ }
+
+ if (err < 4) {
+ ERRORA
+ ("phonebook struct: |%s| is nor formatted as: |+CPBR: (1-750),40,14| neither as: |+CPBR: 1-750,40,14|\n",
+ CELLIAX_P_LOG, p->line_array.result[i]);
+ } else {
+
+ if (option_debug)
+ DEBUGA_AT
+ ("First entry: %d, last entry: %d, phone number max lenght: %d, text max lenght: %d\n",
+ CELLIAX_P_LOG, first_entry, last_entry, number_lenght, text_lenght);
+ p->phonebook_first_entry = first_entry;
+ p->phonebook_last_entry = last_entry;
+ p->phonebook_number_lenght = number_lenght;
+ p->phonebook_text_lenght = text_lenght;
+ }
+
+ } else { /* probably phonebook entry begins */
+
+ if (p->phonebook_listing) {
+ int err, entry_id, entry_type;
+
+ char entry_number[256];
+ char entry_text[256];
+
+ if (option_debug)
+ DEBUGA_AT("phonebook entry: |%s|\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+
+ err =
+ sscanf(&p->line_array.result[i][7], "%d,\"%255[0-9+]\",%d,\"%255[^\"]\"",
+ &entry_id, entry_number, &entry_type, entry_text);
+ if (err < 4) {
+ ERRORA
+ ("err=%d, phonebook entry: |%s| is not formatted as: |+CPBR: 504,\"+39025458068\",145,\"ciao a tutti\"|\n",
+ CELLIAX_P_LOG, err, p->line_array.result[i]);
+ } else {
+ //TODO: sanitize entry_text
+ if (option_debug)
+ DEBUGA_AT("Number: %s, Text: %s, Type: %d\n", CELLIAX_P_LOG, entry_number,
+ entry_text, entry_type);
+ /* write entry in phonebook file */
+ if (p->phonebook_writing_fp) {
+ celliax_dir_entry_extension++;
+
+ fprintf(p->phonebook_writing_fp,
+ "%s => ,%sSKO,,,hidefromdir=%s|phonebook_direct_calling_ext=%d%s%.4d|phonebook_entry_fromcell=%s|phonebook_entry_owner=%s\n",
+ entry_number, entry_text, "no",
+ p->celliax_dir_entry_extension_prefix, "2",
+ celliax_dir_entry_extension, "yes", "not_specified");
+ fprintf(p->phonebook_writing_fp,
+ "%s => ,%sDO,,,hidefromdir=%s|phonebook_direct_calling_ext=%d%s%.4d|phonebook_entry_fromcell=%s|phonebook_entry_owner=%s\n",
+ entry_number, entry_text, "no",
+ p->celliax_dir_entry_extension_prefix, "3",
+ celliax_dir_entry_extension, "yes", "not_specified");
+ }
+ }
+
+ }
+
+ if (p->phonebook_listing_received_calls) {
+ int err, entry_id, entry_type;
+
+ char entry_number[256] = "";
+ char entry_text[256] = "";
+
+ if (option_debug)
+ DEBUGA_AT("phonebook entry: |%s|\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+
+ err =
+ sscanf(&p->line_array.result[i][7], "%d,\"%255[0-9+]\",%d,\"%255[^\"]\"",
+ &entry_id, entry_number, &entry_type, entry_text);
+ if (err < 1) { //we match only on the progressive id, maybe the remote party has not sent its number, and/or there is no corresponding text entry in the phone directory
+ ERRORA
+ ("err=%d, phonebook entry: |%s| is not formatted as: |+CPBR: 504,\"+39025458068\",145,\"ciao a tutti\"|\n",
+ CELLIAX_P_LOG, err, p->line_array.result[i]);
+ } else {
+ //TODO: sanitize entry_text
+
+ if (option_debug)
+ DEBUGA_AT("Number: %s, Text: %s, Type: %d\n", CELLIAX_P_LOG, entry_number,
+ entry_text, entry_type);
+ memset(p->callid_name, 0, sizeof(p->callid_name));
+ memset(p->callid_number, 0, sizeof(p->callid_number));
+ strncpy(p->callid_name, entry_text, sizeof(p->callid_name));
+ strncpy(p->callid_number, entry_number, sizeof(p->callid_number));
+ if (option_debug)
+ DEBUGA_AT("incoming callid: Text: %s, Number: %s\n", CELLIAX_P_LOG,
+ p->callid_name, p->callid_number);
+
+ DEBUGA_AT("|%s| CPBR INCOMING CALLID: name is %s, number is %s\n",
+ CELLIAX_P_LOG, p->line_array.result[i],
+ p->callid_name[0] != 1 ? p->callid_name : "not available",
+ p->callid_number[0] ? p->callid_number : "not available");
+
+ /* mark the time of RING */
+ gettimeofday(&(p->ringtime), NULL);
+ p->interface_state = AST_STATE_RING;
+ p->phone_callflow = CALLFLOW_INCOMING_RING;
+
+ }
+
+ }
+
+ else {
+ DEBUGA_AT("phonebook entry: |%s|\n", CELLIAX_P_LOG, p->line_array.result[i]);
+
+ }
+ }
+
+ }
+
+ if ((strncmp(p->line_array.result[i], "*ECAV", 5) == 0) || (strncmp(p->line_array.result[i], "*ECAM", 5) == 0)) { /* sony-ericsson call processing unsolicited messages */
+ int res, ccid, ccstatus, calltype, processid, exitcause, number, type;
+ res = ccid = ccstatus = calltype = processid = exitcause = number = type = 0;
+ res =
+ sscanf(&p->line_array.result[i][6], "%d,%d,%d,%d,%d,%d,%d", &ccid, &ccstatus,
+ &calltype, &processid, &exitcause, &number, &type);
+ /* only changes the phone_callflow if enought parameters were parsed */
+ if (res >= 3) {
+ switch (ccstatus) {
+ case 0:
+ if (p->owner) {
+ ast_setstate(p->owner, AST_STATE_DOWN);
+ p->owner->hangupcause = AST_CAUSE_NORMAL;
+ celliax_queue_control(p->owner, AST_CONTROL_HANGUP);
+ }
+ p->phone_callflow = CALLFLOW_CALL_IDLE;
+ p->interface_state = AST_STATE_DOWN;
+ if (option_debug > 1)
+ DEBUGA_AT("|%s| Sony-Ericsson *ECAM/*ECAV: IDLE\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ break;
+ case 1:
+ if (option_debug > 1)
+ DEBUGA_AT("|%s| Sony-Ericsson *ECAM/*ECAV: CALLING\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ break;
+ case 2:
+ if (p->owner) {
+ ast_setstate(p->owner, AST_STATE_DIALING);
+ }
+ p->interface_state = CALLFLOW_CALL_DIALING;
+ if (option_debug > 1)
+ DEBUGA_AT("|%s| Sony-Ericsson *ECAM/*ECAV: CONNECTING\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ break;
+ case 3:
+ if (p->owner) {
+ ast_setstate(p->owner, AST_STATE_UP);
+ celliax_queue_control(p->owner, AST_CONTROL_ANSWER);
+ }
+ p->phone_callflow = CALLFLOW_CALL_ACTIVE;
+ p->interface_state = AST_STATE_UP;
+ if (option_debug > 1)
+ DEBUGA_AT("|%s| Sony-Ericsson *ECAM/*ECAV: ACTIVE\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ break;
+ case 4:
+ if (option_debug > 1)
+ DEBUGA_AT
+ ("|%s| Sony-Ericsson *ECAM/*ECAV: don't know how to handle HOLD event\n",
+ CELLIAX_P_LOG, p->line_array.result[i]);
+ break;
+ case 5:
+ if (option_debug > 1)
+ DEBUGA_AT
+ ("|%s| Sony-Ericsson *ECAM/*ECAV: don't know how to handle WAITING event\n",
+ CELLIAX_P_LOG, p->line_array.result[i]);
+ break;
+ case 6:
+ if (option_debug > 1)
+ DEBUGA_AT
+ ("|%s| Sony-Ericsson *ECAM/*ECAV: don't know how to handle ALERTING event\n",
+ CELLIAX_P_LOG, p->line_array.result[i]);
+ break;
+ case 7:
+ if (p->owner) {
+ ast_setstate(p->owner, AST_STATE_BUSY);
+ celliax_queue_control(p->owner, AST_CONTROL_BUSY);
+ }
+ p->phone_callflow = CALLFLOW_CALL_LINEBUSY;
+ p->interface_state = AST_STATE_BUSY;
+ if (option_debug > 1)
+ DEBUGA_AT("|%s| Sony-Ericsson *ECAM/*ECAV: BUSY\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ break;
+ }
+ } else {
+ if (option_debug > 1)
+ DEBUGA_AT("|%s| Sony-Ericsson *ECAM/*ECAV: could not parse parameters\n",
+ CELLIAX_P_LOG, p->line_array.result[i]);
+ }
+
+ }
+
+ /* at_indicator_* are unsolicited messages sent by the phone to signal us that some of its visual indicators on its screen has changed, based on CIND CMER ETSI docs */
+ if ((strcmp(p->line_array.result[i], p->at_indicator_noservice_string) == 0)) {
+ if (option_debug > 1)
+ ERRORA("|%s| at_indicator_noservice_string\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ }
+
+ if ((strcmp(p->line_array.result[i], p->at_indicator_nosignal_string) == 0)) {
+ if (option_debug > 1)
+ ERRORA("|%s| at_indicator_nosignal_string\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ }
+
+ if ((strcmp(p->line_array.result[i], p->at_indicator_lowsignal_string) == 0)) {
+ if (option_debug > 1)
+ WARNINGA("|%s| at_indicator_lowsignal_string\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ }
+
+ if ((strcmp(p->line_array.result[i], p->at_indicator_lowbattchg_string) == 0)) {
+ if (option_debug > 1)
+ WARNINGA("|%s| at_indicator_lowbattchg_string\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ }
+
+ if ((strcmp(p->line_array.result[i], p->at_indicator_nobattchg_string) == 0)) {
+ if (option_debug > 1)
+ ERRORA("|%s| at_indicator_nobattchg_string\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ }
+
+ if ((strcmp(p->line_array.result[i], p->at_indicator_callactive_string) == 0)) {
+ if (option_debug > 1)
+ DEBUGA_AT("|%s| at_indicator_callactive_string\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ }
+
+ if ((strcmp(p->line_array.result[i], p->at_indicator_nocallactive_string) == 0)) {
+ if (option_debug > 1)
+ DEBUGA_AT("|%s| at_indicator_nocallactive_string\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ }
+
+ if ((strcmp(p->line_array.result[i], p->at_indicator_nocallsetup_string) == 0)) {
+ if (option_debug > 1)
+ DEBUGA_AT("|%s| at_indicator_nocallsetup_string\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ }
+
+ if ((strcmp(p->line_array.result[i], p->at_indicator_callsetupincoming_string) ==
+ 0)) {
+ if (option_debug > 1)
+ DEBUGA_AT("|%s| at_indicator_callsetupincoming_string\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ }
+
+ if ((strcmp(p->line_array.result[i], p->at_indicator_callsetupoutgoing_string) ==
+ 0)) {
+ if (option_debug > 1)
+ DEBUGA_AT("|%s| at_indicator_callsetupoutgoing_string\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ }
+
+ if ((strcmp(p->line_array.result[i], p->at_indicator_callsetupremoteringing_string)
+ == 0)) {
+ if (option_debug > 1)
+ DEBUGA_AT("|%s| at_indicator_callsetupremoteringing_string\n", CELLIAX_P_LOG,
+ p->line_array.result[i]);
+ }
+
+ }
+
+ /* let's look for OK, ERROR and EXPECTED_STRING in the complete lines read so far, without re-looking at the lines that has been yet looked at */
+ for (i = la_read; i < la_counter; i++) {
+ if (expected_string) {
+ if ((strncmp(p->line_array.result[i], expected_string, strlen(expected_string))
+ == 0)) {
+ if (option_debug > 1)
+ DEBUGA_AT("|%s| got what EXPECTED\n", CELLIAX_P_LOG, p->line_array.result[i]);
+ at_ack = AT_OK;
+ }
+ } else {
+ if ((strcmp(p->line_array.result[i], "OK") == 0)) {
+ if (option_debug > 1)
+ DEBUGA_AT("got OK\n", CELLIAX_P_LOG);
+ at_ack = AT_OK;
+ }
+ }
+ if ((strcmp(p->line_array.result[i], "ERROR") == 0)) {
+ if (option_debug > 1)
+ DEBUGA_AT("got ERROR\n", CELLIAX_P_LOG);
+ at_ack = AT_ERROR;
+ }
+
+ /* if we are reading an sms message from memory, put the line into the sms buffer if the line is not "OK" or "ERROR" */
+ if (p->reading_sms_msg > 1 && at_ack == -1) {
+ int c;
+ char sms_body[16000];
+ int err;
+
+ if (strncmp(p->line_array.result[i], "+CMGR", 5) == 0) { /* we are reading the "header" of an SMS */
+ char content[512];
+ char content2[512];
+
+ memset(content, '\0', sizeof(content));
+
+ int inside_comma = 0;
+ int inside_quote = 0;
+ int d = 0;
+
+ for (c = 0; c < strlen(p->line_array.result[i]); c++) {
+ if (p->line_array.result[i][c] == ','
+ && p->line_array.result[i][c - 1] != '\\' && inside_quote == 0) {
+ if (inside_comma) {
+ inside_comma = 0;
+ //NOTICA("inside_comma=%d, inside_quote=%d, we're at=%s\n", CELLIAX_P_LOG, inside_comma, inside_quote, &p->line_array.result[i][c]);
+ } else {
+ inside_comma = 1;
+ //NOTICA("inside_comma=%d, inside_quote=%d, we're at=%s\n", CELLIAX_P_LOG, inside_comma, inside_quote, &p->line_array.result[i][c]);
+ }
+ }
+ if (p->line_array.result[i][c] == '"'
+ && p->line_array.result[i][c - 1] != '\\') {
+ if (inside_quote) {
+ inside_quote = 0;
+ //ERRORA("END_CONTENT inside_comma=%d, inside_quote=%d, we're at=%s\n", CELLIAX_P_LOG, inside_comma, inside_quote, &p->line_array.result[i][c]);
+ DEBUGA_AT("content=%s\n", CELLIAX_P_LOG, content);
+
+ strncat(p->sms_message, "---",
+ ((sizeof(p->sms_message) - strlen(p->sms_message)) - 1));
+ strncat(p->sms_message, content,
+ ((sizeof(p->sms_message) - strlen(p->sms_message)) - 1));
+ strncat(p->sms_message, "|||",
+ ((sizeof(p->sms_message) - strlen(p->sms_message)) - 1));
+
+ memset(content2, '\0', sizeof(content2));
+ err = ucs2_to_utf8(p, content, content2, sizeof(content2));
+
+ strncat(p->sms_message, "---",
+ ((sizeof(p->sms_message) - strlen(p->sms_message)) - 1));
+ if (!err)
+ strncat(p->sms_message, content2,
+ ((sizeof(p->sms_message) - strlen(p->sms_message)) - 1));
+ strncat(p->sms_message, "|||",
+ ((sizeof(p->sms_message) - strlen(p->sms_message)) - 1));
+ memset(content, '\0', sizeof(content));
+ d = 0;
+ } else {
+ inside_quote = 1;
+ //WARNINGA("START_CONTENT inside_comma=%d, inside_quote=%d, we're at=%s\n", CELLIAX_P_LOG, inside_comma, inside_quote, &p->line_array.result[i][c]);
+ }
+ }
+ if (inside_quote && p->line_array.result[i][c] != '"') {
+
+ content[d] = p->line_array.result[i][c];
+ d++;
+
+ }
+
+ }
+ } //it was the +CMGR answer from the cellphone
+ else {
+ strncat(p->sms_message, "---",
+ ((sizeof(p->sms_message) - strlen(p->sms_message)) - 1));
+ strncat(p->sms_message, p->line_array.result[i],
+ ((sizeof(p->sms_message) - strlen(p->sms_message)) - 1));
+ strncat(p->sms_message, "|||",
+ ((sizeof(p->sms_message) - strlen(p->sms_message)) - 1));
+
+ memset(sms_body, '\0', sizeof(sms_body));
+ err = ucs2_to_utf8(p, p->line_array.result[i], sms_body, sizeof(sms_body));
+
+ strncat(p->sms_message, "---",
+ ((sizeof(p->sms_message) - strlen(p->sms_message)) - 1));
+ if (!err)
+ strncat(p->sms_message, sms_body,
+ ((sizeof(p->sms_message) - strlen(p->sms_message)) - 1));
+ strncat(p->sms_message, "|||",
+ ((sizeof(p->sms_message) - strlen(p->sms_message)) - 1));
+
+ DEBUGA_AT("sms_message=%s\n", CELLIAX_P_LOG, p->sms_message);
+
+ } //it was the UCS2 from cellphone
+
+ } //we were reading the SMS
+
+ }
+
+ la_read = la_counter;
+
+ if (look_for_ack && at_ack > -1)
+ break;
+
+ if (la_counter > AT_MESG_MAX_LINES) {
+ ERRORA("Too many lines in result (>%d). Stopping reader.\n", CELLIAX_P_LOG,
+ AT_MESG_MAX_LINES);
+ at_ack = AT_ERROR;
+ break;
+ }
+ }
+
+ UNLOCKA(&p->controldev_lock);
+ POPPA_UNLOCKA(&p->controldev_lock);
+ if (select_err == -1) {
+ ERRORA("select returned -1 on %s, setting controldev_dead, error was: %s\n",
+ CELLIAX_P_LOG, p->controldevice_name, strerror(errno));
+ p->controldev_dead = 1;
+ close(p->controldevfd);
+ if (p->owner)
+ celliax_queue_control(p->owner, AST_CONTROL_HANGUP);
+ return -1;
+ }
+
+ if (p->phone_callflow == CALLFLOW_CALL_INCOMING && p->call_incoming_time.tv_sec) { //after three sec of CALLFLOW_CALL_INCOMING, we assume the phone is incapable of notifying RING (eg: motorola c350), so we try to answer
+ char list_command[64];
+ struct timeval call_incoming_timeout;
+ gettimeofday(&call_incoming_timeout, NULL);
+ call_incoming_timeout.tv_sec -= 3;
+ DEBUGA_AT
+ ("CALLFLOW_CALL_INCOMING call_incoming_time.tv_sec=%ld, call_incoming_timeout.tv_sec=%ld\n",
+ CELLIAX_P_LOG, p->call_incoming_time.tv_sec, call_incoming_timeout.tv_sec);
+ if (call_incoming_timeout.tv_sec > p->call_incoming_time.tv_sec) {
+
+ p->call_incoming_time.tv_sec = 0;
+ p->call_incoming_time.tv_usec = 0;
+ DEBUGA_AT
+ ("CALLFLOW_CALL_INCOMING call_incoming_time.tv_sec=%ld, call_incoming_timeout.tv_sec=%ld\n",
+ CELLIAX_P_LOG, p->call_incoming_time.tv_sec, call_incoming_timeout.tv_sec);
+ res = celliax_serial_write_AT_ack(p, "AT+CPBS=RC");
+ if (res) {
+ ERRORA
+ ("AT+CPBS=RC (select memory of received calls) was not answered by the phone\n",
+ CELLIAX_P_LOG);
+ }
+ p->phonebook_querying = 1;
+ res = celliax_serial_write_AT_ack(p, "AT+CPBR=?");
+ if (res) {
+ ERRORA
+ ("AT+CPBS=RC (select memory of received calls) was not answered by the phone\n",
+ CELLIAX_P_LOG);
+ }
+ p->phonebook_querying = 0;
+ sprintf(list_command, "AT+CPBR=%d,%d", p->phonebook_first_entry,
+ p->phonebook_last_entry);
+ p->phonebook_listing_received_calls = 1;
+ res = celliax_serial_write_AT_expect_longtime(p, list_command, "OK");
+ if (res) {
+ WARNINGA("AT+CPBR=%d,%d failed, continue\n", CELLIAX_P_LOG,
+ p->phonebook_first_entry, p->phonebook_last_entry);
+ }
+ p->phonebook_listing_received_calls = 0;
+ }
+ }
+
+ if (p->phone_callflow == CALLFLOW_INCOMING_RING) {
+ struct timeval call_incoming_timeout;
+ gettimeofday(&call_incoming_timeout, NULL);
+ call_incoming_timeout.tv_sec -= 10;
+ DEBUGA_AT
+ ("CALLFLOW_CALL_INCOMING call_incoming_time.tv_sec=%ld, call_incoming_timeout.tv_sec=%ld\n",
+ CELLIAX_P_LOG, p->call_incoming_time.tv_sec, call_incoming_timeout.tv_sec);
+ if (call_incoming_timeout.tv_sec > p->ringtime.tv_sec) {
+ ERRORA("Ringing stopped and I have not answered. Why?\n", CELLIAX_P_LOG);
+ DEBUGA_AT
+ ("CALLFLOW_CALL_INCOMING call_incoming_time.tv_sec=%ld, call_incoming_timeout.tv_sec=%ld\n",
+ CELLIAX_P_LOG, p->call_incoming_time.tv_sec, call_incoming_timeout.tv_sec);
+ if (p->owner) {
+ celliax_queue_control(p->owner, AST_CONTROL_HANGUP);
+ p->owner->hangupcause = AST_CAUSE_FAILURE;
+ }
+ }
+ }
+ p->line_array.elemcount = la_counter;
+ //NOTICA (" OUTSIDE this celliax_serial_device %s \n", CELLIAX_P_LOG, p->controldevice_name);
+ if (look_for_ack)
+ return at_ack;
+ else
+ return 0;
+}
+
+int celliax_serial_write_AT(struct celliax_pvt *p, const char *data)
+{
+ int howmany;
+ int i;
+ int res;
+ int count;
+
+ howmany = strlen(data);
+
+ for (i = 0; i < howmany; i++) {
+ res = write(p->controldevfd, &data[i], 1);
+
+ if (res != 1) {
+ DEBUGA_AT("Error sending (%.1s): %d (%s)\n", CELLIAX_P_LOG, &data[i], res,
+ strerror(errno));
+ usleep(100000);
+ for (count = 0; count < 10; count++) {
+ res = write(p->controldevfd, &data[i], 1);
+ if (res == 1) {
+ DEBUGA_AT("Successfully RE-sent (%.1s): %d %d (%s)\n", CELLIAX_P_LOG, &data[i],
+ count, res, strerror(errno));
+ break;
+ } else
+ DEBUGA_AT("Error RE-sending (%.1s): %d %d (%s)\n", CELLIAX_P_LOG, &data[i],
+ count, res, strerror(errno));
+ usleep(100000);
+
+ }
+ if (res != 1) {
+ ERRORA("Error RE-sending (%.1s): %d %d (%s)\n", CELLIAX_P_LOG, &data[i], count,
+ res, strerror(errno));
+ return -1;
+ }
+ }
+ if (option_debug > 1)
+ DEBUGA_AT("sent data... (%.1s)\n", CELLIAX_P_LOG, &data[i]);
+ usleep(1000); /* release the cpu */
+ }
+
+ res = write(p->controldevfd, "\r", 1);
+
+ if (res != 1) {
+ DEBUGA_AT("Error sending (carriage return): %d (%s)\n", CELLIAX_P_LOG, res,
+ strerror(errno));
+ usleep(100000);
+ for (count = 0; count < 10; count++) {
+ res = write(p->controldevfd, "\r", 1);
+
+ if (res == 1) {
+ DEBUGA_AT("Successfully RE-sent carriage return: %d %d (%s)\n", CELLIAX_P_LOG,
+ count, res, strerror(errno));
+ break;
+ } else
+ DEBUGA_AT("Error RE-sending (carriage return): %d %d (%s)\n", CELLIAX_P_LOG,
+ count, res, strerror(errno));
+ usleep(100000);
+
+ }
+ if (res != 1) {
+ ERRORA("Error RE-sending (carriage return): %d %d (%s)\n", CELLIAX_P_LOG, count,
+ res, strerror(errno));
+ return -1;
+ }
+ }
+ if (option_debug > 1)
+ DEBUGA_AT("sent (carriage return)\n", CELLIAX_P_LOG);
+ usleep(1000); /* release the cpu */
+
+ return howmany;
+}
+
+int celliax_serial_write_AT_nocr(struct celliax_pvt *p, const char *data)
+{
+ int howmany;
+ int i;
+ int res;
+ int count;
+
+ howmany = strlen(data);
+
+ for (i = 0; i < howmany; i++) {
+ res = write(p->controldevfd, &data[i], 1);
+
+ if (res != 1) {
+ DEBUGA_AT("Error sending (%.1s): %d (%s)\n", CELLIAX_P_LOG, &data[i], res,
+ strerror(errno));
+ usleep(100000);
+ for (count = 0; count < 10; count++) {
+ res = write(p->controldevfd, &data[i], 1);
+ if (res == 1)
+ break;
+ else
+ DEBUGA_AT("Error RE-sending (%.1s): %d %d (%s)\n", CELLIAX_P_LOG, &data[i],
+ count, res, strerror(errno));
+ usleep(100000);
+
+ }
+ if (res != 1) {
+ ERRORA("Error RE-sending (%.1s): %d %d (%s)\n", CELLIAX_P_LOG, &data[i], count,
+ res, strerror(errno));
+ return -1;
+ }
+ }
+ if (option_debug > 1)
+ DEBUGA_AT("sent data... (%.1s)\n", CELLIAX_P_LOG, &data[i]);
+ usleep(1000); /* release the cpu */
+ }
+
+ usleep(1000); /* release the cpu */
+
+ return howmany;
+}
+
+int celliax_serial_write_AT_noack(struct celliax_pvt *p, const char *data)
+{
+
+ if (option_debug > 1)
+ DEBUGA_AT("celliax_serial_write_AT_noack: %s\n", CELLIAX_P_LOG, data);
+
+ PUSHA_UNLOCKA(&p->controldev_lock);
+ LOKKA(&p->controldev_lock);
+ if (celliax_serial_write_AT(p, data) != strlen(data)) {
+
+ ERRORA("Error sending data... (%s)\n", CELLIAX_P_LOG, strerror(errno));
+ UNLOCKA(&p->controldev_lock);
+ return -1;
+ }
+ UNLOCKA(&p->controldev_lock);
+ POPPA_UNLOCKA(&p->controldev_lock);
+
+ return 0;
+}
+
+int celliax_serial_write_AT_ack(struct celliax_pvt *p, const char *data)
+{
+ int at_result = AT_ERROR;
+
+ PUSHA_UNLOCKA(&p->controldev_lock);
+ LOKKA(&p->controldev_lock);
+ if (option_debug > 1)
+ DEBUGA_AT("sending: %s\n", CELLIAX_P_LOG, data);
+ if (celliax_serial_write_AT(p, data) != strlen(data)) {
+ ERRORA("Error sending data... (%s) \n", CELLIAX_P_LOG, strerror(errno));
+ UNLOCKA(&p->controldev_lock);
+ return -1;
+ }
+
+ at_result = celliax_serial_read_AT(p, 1, 500000, 2, NULL, 1); // 2.5 sec timeout
+ UNLOCKA(&p->controldev_lock);
+ POPPA_UNLOCKA(&p->controldev_lock);
+
+ return at_result;
+
+}
+
+int celliax_serial_write_AT_ack_nocr_longtime(struct celliax_pvt *p, const char *data)
+{
+ int at_result = AT_ERROR;
+
+ PUSHA_UNLOCKA(&p->controldev_lock);
+ LOKKA(&p->controldev_lock);
+ if (option_debug > 1)
+ DEBUGA_AT("sending: %s\n", CELLIAX_P_LOG, data);
+ if (celliax_serial_write_AT_nocr(p, data) != strlen(data)) {
+ ERRORA("Error sending data... (%s) \n", CELLIAX_P_LOG, strerror(errno));
+ UNLOCKA(&p->controldev_lock);
+ return -1;
+ }
+
+ at_result = celliax_serial_read_AT(p, 1, 500000, 20, NULL, 1); // 20.5 sec timeout
+ UNLOCKA(&p->controldev_lock);
+ POPPA_UNLOCKA(&p->controldev_lock);
+
+ return at_result;
+
+}
+
+int celliax_serial_write_AT_expect1(struct celliax_pvt *p, const char *data,
+ const char *expected_string, int expect_crlf,
+ int seconds)
+{
+ int at_result = AT_ERROR;
+
+ PUSHA_UNLOCKA(&p->controldev_lock);
+ LOKKA(&p->controldev_lock);
+ if (option_debug > 1)
+ DEBUGA_AT("sending: %s, expecting: %s\n", CELLIAX_P_LOG, data, expected_string);
+ if (celliax_serial_write_AT(p, data) != strlen(data)) {
+ ERRORA("Error sending data... (%s) \n", CELLIAX_P_LOG, strerror(errno));
+ UNLOCKA(&p->controldev_lock);
+ return -1;
+ }
+
+ at_result = celliax_serial_read_AT(p, 1, 500000, seconds, expected_string, expect_crlf); // 20.5 sec timeout, used for querying the SIM and sending SMSs
+ UNLOCKA(&p->controldev_lock);
+ POPPA_UNLOCKA(&p->controldev_lock);
+
+ return at_result;
+
+}
+
+int celliax_serial_AT_expect(struct celliax_pvt *p, const char *expected_string,
+ int expect_crlf, int seconds)
+{
+ int at_result = AT_ERROR;
+
+ PUSHA_UNLOCKA(&p->controldev_lock);
+ LOKKA(&p->controldev_lock);
+ if (option_debug > 1)
+ DEBUGA_AT("expecting: %s\n", CELLIAX_P_LOG, expected_string);
+
+ at_result = celliax_serial_read_AT(p, 1, 500000, seconds, expected_string, expect_crlf); // 20.5 sec timeout, used for querying the SIM and sending SMSs
+ UNLOCKA(&p->controldev_lock);
+ POPPA_UNLOCKA(&p->controldev_lock);
+
+ return at_result;
+
+}
+
+int celliax_serial_answer_AT(struct celliax_pvt *p)
+{
+ int res;
+
+ res = celliax_serial_write_AT_expect(p, p->at_answer, p->at_answer_expect);
+ if (res) {
+ DEBUGA_AT
+ ("at_answer command failed, command used: %s, expecting: %s, trying with AT+CKPD=\"S\"\n",
+ CELLIAX_P_LOG, p->at_answer, p->at_answer_expect);
+
+ res = celliax_serial_write_AT_ack(p, "AT+CKPD=\"S\"");
+ if (res) {
+ ERRORA("at_answer command failed, command used: 'AT+CKPD=\"S\"', giving up\n",
+ CELLIAX_P_LOG);
+ return -1;
+ }
+ }
+ //p->interface_state = AST_STATE_UP;
+ //p->phone_callflow = CALLFLOW_CALL_ACTIVE;
+ DEBUGA_AT("AT: call answered\n", CELLIAX_P_LOG);
+ return 0;
+}
+
+int celliax_serial_hangup_AT(struct celliax_pvt *p)
+{
+ int res;
+
+ if (p->interface_state != AST_STATE_DOWN) {
+ res = celliax_serial_write_AT_expect(p, p->at_hangup, p->at_hangup_expect);
+ if (res) {
+ DEBUGA_AT
+ ("at_hangup command failed, command used: %s, trying to use AT+CKPD=\"EEE\"\n",
+ CELLIAX_P_LOG, p->at_hangup);
+ res = celliax_serial_write_AT_ack(p, "AT+CKPD=\"EEE\"");
+ if (res) {
+ ERRORA("at_hangup command failed, command used: 'AT+CKPD=\"EEE\"'\n",
+ CELLIAX_P_LOG);
+ return -1;
+ }
+ }
+ }
+ p->interface_state = AST_STATE_DOWN;
+ p->phone_callflow = CALLFLOW_CALL_IDLE;
+ return 0;
+}
+
+int celliax_serial_config_AT(struct celliax_pvt *p)
+{
+ int res;
+
+/* initial_pause? */
+ if (p->at_initial_pause) {
+ DEBUGA_AT("sleeping for %d usec\n", CELLIAX_P_LOG, p->at_initial_pause);
+ usleep(p->at_initial_pause);
+ }
+
+/* go until first empty preinit string, or last preinit string */
+ while (1) {
+
+ if (strlen(p->at_preinit_1)) {
+ res = celliax_serial_write_AT_expect(p, p->at_preinit_1, p->at_preinit_1_expect);
+ if (res) {
+ DEBUGA_AT("%s does not get %s from the phone. Continuing.\n", CELLIAX_P_LOG,
+ p->at_preinit_1, p->at_preinit_1_expect);
+ }
+ } else {
+ break;
+ }
+
+ if (strlen(p->at_preinit_2)) {
+ res = celliax_serial_write_AT_expect(p, p->at_preinit_2, p->at_preinit_2_expect);
+ if (res) {
+ DEBUGA_AT("%s does not get %s from the phone. Continuing.\n", CELLIAX_P_LOG,
+ p->at_preinit_2, p->at_preinit_2_expect);
+ }
+ } else {
+ break;
+ }
+
+ if (strlen(p->at_preinit_3)) {
+ res = celliax_serial_write_AT_expect(p, p->at_preinit_3, p->at_preinit_3_expect);
+ if (res) {
+ DEBUGA_AT("%s does not get %s from the phone. Continuing.\n", CELLIAX_P_LOG,
+ p->at_preinit_3, p->at_preinit_3_expect);
+ }
+ } else {
+ break;
+ }
+
+ if (strlen(p->at_preinit_4)) {
+ res = celliax_serial_write_AT_expect(p, p->at_preinit_4, p->at_preinit_4_expect);
+ if (res) {
+ DEBUGA_AT("%s does not get %s from the phone. Continuing.\n", CELLIAX_P_LOG,
+ p->at_preinit_4, p->at_preinit_4_expect);
+ }
+ } else {
+ break;
+ }
+
+ if (strlen(p->at_preinit_5)) {
+ res = celliax_serial_write_AT_expect(p, p->at_preinit_5, p->at_preinit_5_expect);
+ if (res) {
+ DEBUGA_AT("%s does not get %s from the phone. Continuing.\n", CELLIAX_P_LOG,
+ p->at_preinit_5, p->at_preinit_5_expect);
+ }
+ } else {
+ break;
+ }
+
+ break;
+ }
+
+/* after_preinit_pause? */
+ if (p->at_after_preinit_pause) {
+ DEBUGA_AT("sleeping for %d usec\n", CELLIAX_P_LOG, p->at_after_preinit_pause);
+ usleep(p->at_after_preinit_pause);
+ }
+
+ /* phone, brother, art you alive? */
+ res = celliax_serial_write_AT_ack(p, "AT");
+ if (res) {
+ ERRORA("no response to AT\n", CELLIAX_P_LOG);
+ return -1;
+ }
+ /* for motorola, bring it back to "normal" mode if it happens to be in another mode */
+ res = celliax_serial_write_AT_ack(p, "AT+mode=0");
+ if (res) {
+ DEBUGA_AT("AT+mode=0 does not get OK from the phone. If it is NOT Motorola,"
+ " no problem.\n", CELLIAX_P_LOG);
+ }
+ usleep(50000);
+ /* for motorola end */
+
+ /* reset AT configuration to phone default */
+ res = celliax_serial_write_AT_ack(p, "ATZ");
+ if (res) {
+ DEBUGA_AT("ATZ failed\n", CELLIAX_P_LOG);
+ }
+
+ /* disable AT command echo */
+ res = celliax_serial_write_AT_ack(p, "ATE0");
+ if (res) {
+ DEBUGA_AT("ATE0 failed\n", CELLIAX_P_LOG);
+ }
+
+ /* disable extended error reporting */
+ res = celliax_serial_write_AT_ack(p, "AT+CMEE=0");
+ if (res) {
+ DEBUGA_AT("AT+CMEE failed\n", CELLIAX_P_LOG);
+ }
+
+ /* various phone manufacturer identifier */
+ char at_command[5];
+ int i;
+ for (i = 0; i < 10; i++) {
+ memset(at_command, 0, sizeof(at_command));
+ sprintf(at_command, "ATI%d", i);
+ res = celliax_serial_write_AT_ack(p, at_command);
+ if (res) {
+ DEBUGA_AT("ATI%d command failed, continue\n", CELLIAX_P_LOG, i);
+ }
+ }
+
+ /* phone manufacturer */
+ res = celliax_serial_write_AT_ack(p, "AT+CGMI");
+ if (res) {
+ DEBUGA_AT("AT+CGMI failed\n", CELLIAX_P_LOG);
+ }
+
+ /* phone model */
+ res = celliax_serial_write_AT_ack(p, "AT+CGMM");
+ if (res) {
+ DEBUGA_AT("AT+CGMM failed\n", CELLIAX_P_LOG);
+ }
+
+ res = celliax_serial_write_AT_ack(p, "AT+CGSN");
+ if (res) {
+ DEBUGA_AT("AT+CGSN failed\n", CELLIAX_P_LOG);
+ }
+
+/* this take a lot of time to complete on devices with slow serial link (eg.: 9600bps) */
+#if 0
+ /* ask for the list of supported AT commands, useful to implement new models and debugging */
+ res = celliax_serial_write_AT_ack(p, "AT+CLAC");
+ if (res) {
+ DEBUGA_AT("AT+CLAC failed, continue\n", CELLIAX_P_LOG);
+ }
+#endif
+ /* signal incoming SMS with a +CMTI unsolicited msg */
+ res = celliax_serial_write_AT_ack(p, "AT+CNMI=3,1,0,0,0");
+ if (res) {
+ DEBUGA_AT("AT+CNMI=3,1,0,0,0 failed, continue\n", CELLIAX_P_LOG);
+ p->sms_cnmi_not_supported = 1;
+ p->celliax_serial_sync_period = 30;
+ }
+ /* what is the Message Center address (number) to which the SMS has to be sent? */
+ res = celliax_serial_write_AT_ack(p, "AT+CSCA?");
+ if (res) {
+ DEBUGA_AT("AT+CSCA? failed, continue\n", CELLIAX_P_LOG);
+ }
+ /* what is the Message Format of SMSs? */
+ res = celliax_serial_write_AT_ack(p, "AT+CMGF?");
+ if (res) {
+ DEBUGA_AT("AT+CMGF? failed, continue\n", CELLIAX_P_LOG);
+ }
+ res = celliax_serial_write_AT_ack(p, "AT+CMGF=1"); //TODO: support phones that only accept pdu mode
+ if (res) {
+ ERRORA("Error setting SMS sending mode to TEXT on the cellphone\n", CELLIAX_P_LOG);
+ return RESULT_FAILURE;
+ }
+ /* what is the Charset of SMSs? */
+ res = celliax_serial_write_AT_ack(p, "AT+CSCS?");
+ if (res) {
+ DEBUGA_AT("AT+CSCS? failed, continue\n", CELLIAX_P_LOG);
+ }
+
+ p->no_ucs2 = 0;
+ res = celliax_serial_write_AT_ack(p, "AT+CSCS=\"UCS2\"");
+ if (res) {
+ WARNINGA
+ ("AT+CSCS=\"UCS2\" (set TE messages to ucs2) do not got OK from the phone, let's try with 'GSM'\n",
+ CELLIAX_P_LOG);
+ p->no_ucs2 = 1;
+ }
+
+ if (p->no_ucs2) {
+ res = celliax_serial_write_AT_ack(p, "AT+CSCS=\"GSM\"");
+ if (res) {
+ WARNINGA("AT+CSCS=\"GSM\" (set TE messages to GSM) do not got OK from the phone\n",
+ CELLIAX_P_LOG);
+ }
+ //res = celliax_serial_write_AT_ack(p, "AT+CSMP=17,167,0,16"); //"flash", class 0 sms 7 bit
+ res = celliax_serial_write_AT_ack(p, "AT+CSMP=17,167,0,0"); //normal, 7 bit message
+ if (res) {
+ WARNINGA("AT+CSMP do not got OK from the phone, continuing\n", CELLIAX_P_LOG);
+ }
+ } else {
+ //res = celliax_serial_write_AT_ack(p, "AT+CSMP=17,167,0,20"); //"flash", class 0 sms 16 bit unicode
+ res = celliax_serial_write_AT_ack(p, "AT+CSMP=17,167,0,8"); //unicode, 16 bit message
+ if (res) {
+ WARNINGA("AT+CSMP do not got OK from the phone, continuing\n", CELLIAX_P_LOG);
+ }
+ }
+
+ /* is the unsolicited reporting of mobile equipment event supported? */
+ res = celliax_serial_write_AT_ack(p, "AT+CMER=?");
+ if (res) {
+ DEBUGA_AT("AT+CMER=? failed, continue\n", CELLIAX_P_LOG);
+ }
+ /* request unsolicited reporting of mobile equipment indicators' events, to be screened by categories reported by +CIND=? */
+ res = celliax_serial_write_AT_ack(p, "AT+CMER=3,0,0,1");
+ if (res) {
+ DEBUGA_AT("AT+CMER=? failed, continue\n", CELLIAX_P_LOG);
+ }
+
+ /* is the solicited reporting of mobile equipment indications supported? */
+
+ res = celliax_serial_write_AT_ack(p, "AT+CIND=?");
+ if (res) {
+ DEBUGA_AT("AT+CIND=? failed, continue\n", CELLIAX_P_LOG);
+ }
+
+ /* is the unsolicited reporting of call monitoring supported? sony-ericsson specific */
+ res = celliax_serial_write_AT_ack(p, "AT*ECAM=?");
+ if (res) {
+ DEBUGA_AT("AT*ECAM=? failed, continue\n", CELLIAX_P_LOG);
+ }
+ /* enable the unsolicited reporting of call monitoring. sony-ericsson specific */
+ res = celliax_serial_write_AT_ack(p, "AT*ECAM=1");
+ if (res) {
+ DEBUGA_AT("AT*ECAM=1 failed, continue\n", CELLIAX_P_LOG);
+ p->at_has_ecam = 0;
+ } else {
+ p->at_has_ecam = 1;
+ }
+
+ /* disable unsolicited signaling of call list */
+ res = celliax_serial_write_AT_ack(p, "AT+CLCC=0");
+ if (res) {
+ DEBUGA_AT("AT+CLCC=0 failed, continue\n", CELLIAX_P_LOG);
+ p->at_has_clcc = 0;
+ } else {
+ p->at_has_clcc = 1;
+ }
+
+ /* give unsolicited caller id when incoming call */
+ res = celliax_serial_write_AT_ack(p, "AT+CLIP=1");
+ if (res) {
+ DEBUGA_AT("AT+CLIP failed, continue\n", CELLIAX_P_LOG);
+ }
+ /* for motorola */
+ res = celliax_serial_write_AT_ack(p, "AT+MCST=1"); /* motorola call control codes
+ (to know when call is disconnected (they
+ don't give you "no carrier") */
+ if (res) {
+ DEBUGA_AT("AT+MCST=1 does not get OK from the phone. If it is NOT Motorola,"
+ " no problem.\n", CELLIAX_P_LOG);
+ }
+ /* for motorola end */
+
+/* go until first empty postinit string, or last postinit string */
+ while (1) {
+
+ if (strlen(p->at_postinit_1)) {
+ res = celliax_serial_write_AT_expect(p, p->at_postinit_1, p->at_postinit_1_expect);
+ if (res) {
+ DEBUGA_AT("%s does not get %s from the phone. Continuing.\n", CELLIAX_P_LOG,
+ p->at_postinit_1, p->at_postinit_1_expect);
+ }
+ } else {
+ break;
+ }
+
+ if (strlen(p->at_postinit_2)) {
+ res = celliax_serial_write_AT_expect(p, p->at_postinit_2, p->at_postinit_2_expect);
+ if (res) {
+ DEBUGA_AT("%s does not get %s from the phone. Continuing.\n", CELLIAX_P_LOG,
+ p->at_postinit_2, p->at_postinit_2_expect);
+ }
+ } else {
+ break;
+ }
+
+ if (strlen(p->at_postinit_3)) {
+ res = celliax_serial_write_AT_expect(p, p->at_postinit_3, p->at_postinit_3_expect);
+ if (res) {
+ DEBUGA_AT("%s does not get %s from the phone. Continuing.\n", CELLIAX_P_LOG,
+ p->at_postinit_3, p->at_postinit_3_expect);
+ }
+ } else {
+ break;
+ }
+
+ if (strlen(p->at_postinit_4)) {
+ res = celliax_serial_write_AT_expect(p, p->at_postinit_4, p->at_postinit_4_expect);
+ if (res) {
+ DEBUGA_AT("%s does not get %s from the phone. Continuing.\n", CELLIAX_P_LOG,
+ p->at_postinit_4, p->at_postinit_4_expect);
+ }
+ } else {
+ break;
+ }
+
+ if (strlen(p->at_postinit_5)) {
+ res = celliax_serial_write_AT_expect(p, p->at_postinit_5, p->at_postinit_5_expect);
+ if (res) {
+ DEBUGA_AT("%s does not get %s from the phone. Continuing.\n", CELLIAX_P_LOG,
+ p->at_postinit_5, p->at_postinit_5_expect);
+ }
+ } else {
+ break;
+ }
+
+ break;
+ }
+
+ return 0;
+}
+
+int celliax_serial_call_AT(struct celliax_pvt *p, char *dstr)
+{
+ int res;
+ char at_command[256];
+
+ if (option_debug)
+ DEBUGA_PBX("Dialing %s\n", CELLIAX_P_LOG, dstr);
+ memset(at_command, 0, sizeof(at_command));
+ p->phone_callflow = CALLFLOW_CALL_DIALING;
+ p->interface_state = AST_STATE_DIALING;
+ ast_uri_decode(dstr);
+ size_t fixdstr = strspn(dstr, AST_DIGIT_ANYDIG);
+ if (fixdstr == 0) {
+ ERRORA("dial command failed because of invalid dial number. dial string was: %s\n",
+ CELLIAX_P_LOG, dstr);
+ return -1;
+ }
+ dstr[fixdstr] = '\0';
+ sprintf(at_command, "%s%s%s", p->at_dial_pre_number, dstr, p->at_dial_post_number);
+ res = celliax_serial_write_AT_expect(p, at_command, p->at_dial_expect);
+ if (res) {
+ ERRORA("dial command failed, dial string was: %s\n", CELLIAX_P_LOG, at_command);
+ return -1;
+ }
+ // jet - early audio
+ if (p->at_early_audio) {
+ ast_queue_control(p->owner, AST_CONTROL_ANSWER);
+ }
+
+ return 0;
+}
+
+int celliax_console_at(int fd, int argc, char *argv[])
+{
+ struct celliax_pvt *p = celliax_console_find_desc(celliax_console_active);
+ char at_cmd[1024];
+ int i, a, c;
+
+ if (argc == 1)
+ return RESULT_SHOWUSAGE;
+ if (!p) {
+ ast_cli(fd,
+ "No \"current\" console for celliax_at, please enter 'help celliax_console'\n");
+ return RESULT_SUCCESS;
+ }
+ if (p->controldevprotocol != PROTOCOL_AT) {
+ ast_cli(fd,
+ "The \"current\" console is not connected to an 'AT modem' (cellphone)\n");
+ return RESULT_SUCCESS;
+ }
+
+ memset(at_cmd, 0, sizeof(at_cmd));
+ c = 0;
+ for (i = 1; i < argc; i++) {
+ for (a = 0; a < strlen(argv[i]); a++) {
+ at_cmd[c] = argv[i][a];
+ c++;
+ if (c == 1022)
+ break;
+ }
+ if (i != argc - 1) {
+ at_cmd[c] = ' ';
+ c++;
+ }
+ if (c == 1023)
+ break;
+ }
+ celliax_serial_write_AT_noack(p, at_cmd);
+ return RESULT_SUCCESS;
+}
+
+#ifdef ASTERISK_VERSION_1_2
+int celliax_manager_sendsms(struct mansession *s, struct message *m)
+#endif //ASTERISK_VERSION_1_2
+#ifdef ASTERISK_VERSION_1_4
+int celliax_manager_sendsms(struct mansession *s, const struct message *m)
+#endif //ASTERISK_VERSION_1_4
+{
+ int ret;
+ char command[512];
+ const char *interfacename = astman_get_header(m, "Interface");
+ const char *destinationnumber = astman_get_header(m, "Number");
+ const char *text = astman_get_header(m, "Text");
+ const char *action_id = astman_get_header(m, "ActionID");
+
+ if (ast_strlen_zero(interfacename)) {
+ astman_send_error(s, m, "Interface: missing.\n");
+ return 0;
+ }
+ if (ast_strlen_zero(destinationnumber)) {
+ astman_send_error(s, m, "Number: missing.\n");
+ return 0;
+ }
+ if (ast_strlen_zero(text)) {
+ astman_send_error(s, m, "Text: missing.\n");
+ return 0;
+ }
+ if (ast_strlen_zero(action_id)) {
+ astman_send_error(s, m, "ActionID: missing.\n");
+ return 0;
+ }
+
+ memset(command, 0, sizeof(command));
+
+ sprintf(command, "%s/%s|%s|", interfacename, destinationnumber, text);
+
+ ret = celliax_sendsms(NULL, (void *) &command);
+
+#ifndef ASTERISK_VERSION_1_4
+ if (!ret) {
+ ast_cli(s->fd, "Response: Success\r\n");
+ if (!ast_strlen_zero(action_id))
+ ast_cli(s->fd, "ActionID: %s\r\n", action_id);
+ ast_cli(s->fd, "\r\n");
+ return RESULT_SUCCESS;
+ } else {
+ ast_cli(s->fd, "Response: Error\r\n");
+ if (!ast_strlen_zero(action_id))
+ ast_cli(s->fd, "ActionID: %s\r\n", action_id);
+ ast_cli(s->fd, "Message: celliax_manager_sendsms failed\r\n");
+ ast_cli(s->fd, "\r\n");
+ return 0;
+ }
+#else /* ASTERISK_VERSION_1_4 */
+ if (!ret) {
+ astman_append(s, "Response: Success\r\n");
+ if (!ast_strlen_zero(action_id))
+ astman_append(s, "ActionID: %s\r\n", action_id);
+ astman_append(s, "\r\n");
+ return RESULT_SUCCESS;
+ } else {
+ astman_append(s, "Response: Error\r\n");
+ if (!ast_strlen_zero(action_id))
+ astman_append(s, "ActionID: %s\r\n", action_id);
+ astman_append(s, "Message: celliax_manager_sendsms failed\r\n");
+ astman_append(s, "\r\n");
+ return 0;
+ }
+#endif /* ASTERISK_VERSION_1_4 */
+
+ return RESULT_SUCCESS; //never reached
+}
+
+int ucs2_to_utf8(struct celliax_pvt *p, char *ucs2_in, char *utf8_out,
+ size_t outbytesleft)
+{
+ char converted[16000];
+ iconv_t iconv_format;
+ int iconv_res;
+ char *outbuf;
+ char *inbuf;
+ size_t inbytesleft;
+ int c;
+ char stringa[5];
+ double hexnum;
+ int i = 0;
+
+ memset(converted, '\0', sizeof(converted));
+
+ DEBUGA_AT("ucs2_in=%s\n", CELLIAX_P_LOG, ucs2_in);
+ /* cicopet */
+ for (c = 0; c < strlen(ucs2_in); c++) {
+ sprintf(stringa, "0x%c%c", ucs2_in[c], ucs2_in[c + 1]);
+ c++;
+ hexnum = strtod(stringa, NULL);
+ converted[i] = hexnum;
+ i++;
+ }
+
+ outbuf = utf8_out;
+ inbuf = converted;
+
+ iconv_format = iconv_open("UTF8", "UCS-2BE");
+ if (iconv_format == (iconv_t) - 1) {
+ ERRORA("error: %s\n", CELLIAX_P_LOG, strerror(errno));
+ return -1;
+ }
+
+ inbytesleft = i;
+ iconv_res = iconv(iconv_format, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
+ if (iconv_res == (size_t) - 1) {
+ DEBUGA_AT("ciao in=%s, inleft=%d, out=%s, outleft=%d, converted=%s, utf8_out=%s\n",
+ CELLIAX_P_LOG, inbuf, inbytesleft, outbuf, outbytesleft, converted,
+ utf8_out);
+ DEBUGA_AT("error: %s %d\n", CELLIAX_P_LOG, strerror(errno), errno);
+ return -1;
+ }
+ DEBUGA_AT
+ ("iconv_res=%d, in=%s, inleft=%d, out=%s, outleft=%d, converted=%s, utf8_out=%s\n",
+ CELLIAX_P_LOG, iconv_res, inbuf, inbytesleft, outbuf, outbytesleft, converted,
+ utf8_out);
+ iconv_close(iconv_format);
+
+ return 0;
+}
+
+int utf_to_ucs2(struct celliax_pvt *p, char *utf_in, size_t inbytesleft, char *ucs2_out,
+ size_t outbytesleft)
+{
+ /* cicopet */
+ iconv_t iconv_format;
+ int iconv_res;
+ char *outbuf;
+ char *inbuf;
+ char converted[16000];
+ int i;
+ char stringa[16];
+ char stringa2[16];
+
+ memset(converted, '\0', sizeof(converted));
+
+ outbuf = converted;
+ inbuf = utf_in;
+
+ iconv_format = iconv_open("UCS-2BE", "UTF8");
+ if (iconv_format == (iconv_t) - 1) {
+ ERRORA("error: %s\n", CELLIAX_P_LOG, strerror(errno));
+ return -1;
+ }
+ outbytesleft = 16000;
+
+ DEBUGA_AT("in=%s, inleft=%d, out=%s, outleft=%d, utf_in=%s, converted=%s\n",
+ CELLIAX_P_LOG, inbuf, inbytesleft, outbuf, outbytesleft, utf_in, converted);
+ iconv_res = iconv(iconv_format, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
+ if (iconv_res == (size_t) - 1) {
+ ERRORA("error: %s %d\n", CELLIAX_P_LOG, strerror(errno), errno);
+ return -1;
+ }
+ DEBUGA_AT
+ ("iconv_res=%d, in=%s, inleft=%d, out=%s, outleft=%d, utf_in=%s, converted=%s\n",
+ CELLIAX_P_LOG, iconv_res, inbuf, inbytesleft, outbuf, outbytesleft, utf_in,
+ converted);
+ iconv_close(iconv_format);
+
+ for (i = 0; i < 16000 - outbytesleft; i++) {
+ memset(stringa, '\0', sizeof(stringa));
+ memset(stringa2, '\0', sizeof(stringa2));
+ sprintf(stringa, "%02X", converted[i]);
+ DEBUGA_AT("character is |%02X|\n", CELLIAX_P_LOG, converted[i]);
+ stringa2[0] = stringa[strlen(stringa) - 2];
+ stringa2[1] = stringa[strlen(stringa) - 1];
+ strncat(ucs2_out, stringa2, ((outbytesleft - strlen(ucs2_out)) - 1)); //add the received line to the buffer
+ DEBUGA_AT("stringa=%s, stringa2=%s, ucs2_out=%s\n", CELLIAX_P_LOG, stringa, stringa2,
+ ucs2_out);
+ }
+ return 0;
+}
+
+int celliax_sendsms(struct ast_channel *c, void *data)
+{
+ char *idest = data;
+ char rdest[256];
+ struct celliax_pvt *p = NULL;
+ char *device;
+ char *dest;
+ char *text;
+ char *stringp = NULL;
+ int found = 0;
+ int failed = 0;
+
+ strncpy(rdest, idest, sizeof(rdest) - 1);
+ ast_log(LOG_DEBUG, "CelliaxSendsms: %s\n", rdest);
+ ast_log(LOG_DEBUG, "START\n");
+ /* we can use celliax_request to get the channel, but celliax_request would look for onowned channels, and probably we can send SMSs while a call is ongoing
+ *
+ */
+
+ stringp = rdest;
+ device = strsep(&stringp, "/");
+ dest = strsep(&stringp, "|");
+ text = strsep(&stringp, "|");
+
+ if (!device) {
+ ast_log(LOG_ERROR,
+ "CelliaxSendsms app do not recognize '%s'. Requires a destination with slashes (interfacename/destinationnumber, TEXT)\n",
+ idest);
+ return -1;
+ }
+
+ if (!dest) {
+ ast_log(LOG_ERROR,
+ "CelliaxSendsms app do not recognize '%s'. Requires a destination with slashes (interfacename/destinationnumber, TEXT)\n",
+ idest);
+ return -1;
+ }
+
+ if (!text) {
+ ast_log(LOG_ERROR,
+ "CelliaxSendsms app do not recognize '%s'. Requires a destination with slashes (interfacename/destinationnumber, TEXT)\n",
+ idest);
+ return -1;
+ }
+
+ ast_log(LOG_DEBUG, "interfacename:%s, destinationnumber:%s, text:%s\n", device, dest,
+ text);
+
+ /* lock the interfaces' list */
+ LOKKA(&celliax_iflock);
+ /* make a pointer to the first interface in the interfaces list */
+ p = celliax_iflist;
+ /* Search for the requested interface and verify if is unowned */
+ //TODO implement groups a la chan_zap
+ while (p) {
+ size_t length = strlen(p->name);
+ /* is this the requested interface? */
+ if (strncmp(device, p->name, length) == 0) {
+ /* this is the requested interface! */
+ if (option_debug)
+ DEBUGA_AT("FOUND! interfacename:%s, destinationnumber:%s, text:%s, p->name=%s\n",
+ CELLIAX_P_LOG, device, dest, text, p->name);
+ found = 1;
+ break;
+
+ }
+ /* not yet found, next please */
+ p = p->next;
+ }
+ /* unlock the interfaces' list */
+ UNLOCKA(&celliax_iflock);
+
+ if (!found) {
+ ast_log(LOG_ERROR, "Interface '%s' requested by CelliaxSendsms NOT FOUND\n", device);
+ return RESULT_FAILURE;
+ }
+
+ if (p->controldevprotocol != PROTOCOL_AT) {
+ ERRORA("CelliaxSendsms supports only AT command cellphones at the moment :-( !\n",
+ CELLIAX_P_LOG);
+ return RESULT_FAILURE;
+ }
+
+ if (p->controldevprotocol == PROTOCOL_AT) {
+ int err = 0;
+ char smscommand[16000];
+ memset(smscommand, '\0', sizeof(smscommand));
+
+ PUSHA_UNLOCKA(&p->controldev_lock);
+ LOKKA(&p->controldev_lock);
+
+ if (p->no_ucs2) {
+ sprintf(smscommand, "AT+CMGS=\"%s\"", dest); //TODO: support phones that only accept pdu mode
+ } else {
+ char dest2[1048];
+
+ err = celliax_serial_write_AT_ack(p, "AT+CSCS=\"UCS2\"");
+ if (err) {
+ ERRORA
+ ("AT+CSCS=\"UCS2\" (set TE messages to ucs2) do not got OK from the phone\n",
+ CELLIAX_P_LOG);
+ }
+
+ memset(dest2, '\0', sizeof(dest2));
+ utf_to_ucs2(p, dest, strlen(dest), dest2, sizeof(dest2));
+ sprintf(smscommand, "AT+CMGS=\"%s\"", dest2); //TODO: support phones that only accept pdu mode
+ }
+ //TODO: support phones that only accept pdu mode
+ //TODO would be better to lock controldev here
+ err = celliax_serial_write_AT_noack(p, smscommand);
+ if (err) {
+ ERRORA("Error sending SMS\n", CELLIAX_P_LOG);
+ failed = 1;
+ goto uscita;
+ }
+ err = celliax_serial_AT_expect(p, "> ", 0, 1); // wait 1.5s for the prompt, no crlf
+#if 1
+ if (err) {
+ DEBUGA_AT
+ ("Error or timeout getting prompt '> ' for sending sms directly to the remote party. BTW, seems that we cannot do that with Motorola c350, so we'll write to cellphone memory, then send from memory\n",
+ CELLIAX_P_LOG);
+
+ err = celliax_serial_write_AT_ack(p, "ATE1"); //motorola (at least c350) do not echo the '>' prompt when in ATE0... go figure!!!!
+ if (err) {
+ ERRORA("Error activating echo from modem\n", CELLIAX_P_LOG);
+ }
+ p->at_cmgw[0] = '\0';
+ sprintf(smscommand, "AT+CMGW=\"%s\"", dest); //TODO: support phones that only accept pdu mode
+ err = celliax_serial_write_AT_noack(p, smscommand);
+ if (err) {
+ ERRORA("Error writing SMS destination to the cellphone memory\n", CELLIAX_P_LOG);
+ failed = 1;
+ goto uscita;
+ }
+ err = celliax_serial_AT_expect(p, "> ", 0, 1); // wait 1.5s for the prompt, no crlf
+ if (err) {
+ ERRORA
+ ("Error or timeout getting prompt '> ' for writing sms text in cellphone memory\n",
+ CELLIAX_P_LOG);
+ failed = 1;
+ goto uscita;
+ }
+ }
+#endif
+
+ //sprintf(text,"ciao 123 belè новости לק ראת ﺎﻠﺠﻤﻋﺓ 人大"); //let's test the beauty of utf
+ memset(smscommand, '\0', sizeof(smscommand));
+ if (p->no_ucs2) {
+ sprintf(smscommand, "%s", text);
+ } else {
+ utf_to_ucs2(p, text, strlen(text), smscommand, sizeof(smscommand));
+ }
+
+ smscommand[strlen(smscommand)] = 0x1A;
+ DEBUGA_AT("smscommand len is: %d, text is:|||%s|||\n", CELLIAX_P_LOG,
+ strlen(smscommand), smscommand);
+
+ err = celliax_serial_write_AT_ack_nocr_longtime(p, smscommand);
+ //TODO would be better to unlock controldev here
+ if (err) {
+ ERRORA("Error writing SMS text to the cellphone memory\n", CELLIAX_P_LOG);
+ //return RESULT_FAILURE;
+ failed = 1;
+ goto uscita;
+ }
+ if (p->at_cmgw[0]) {
+ sprintf(smscommand, "AT+CMSS=%s", p->at_cmgw);
+ err = celliax_serial_write_AT_expect_longtime(p, smscommand, "OK");
+ if (err) {
+ ERRORA("Error sending SMS from the cellphone memory\n", CELLIAX_P_LOG);
+ //return RESULT_FAILURE;
+ failed = 1;
+ goto uscita;
+ }
+
+ err = celliax_serial_write_AT_ack(p, "ATE0"); //motorola (at least c350) do not echo the '>' prompt when in ATE0... go figure!!!!
+ if (err) {
+ ERRORA("Error de-activating echo from modem\n", CELLIAX_P_LOG);
+ }
+ }
+ uscita:
+ usleep(1000);
+
+ if (p->at_cmgw[0]) {
+
+ /* let's see what we've sent, just for check TODO: Motorola it's not reliable! Motorola c350 tells that all was sent, but is not true! It just sends how much it fits into one SMS FIXME: need an algorithm to calculate how many ucs2 chars fits into an SMS. It make difference based, probably, on the GSM alphabet translation, or so */
+ sprintf(smscommand, "AT+CMGR=%s", p->at_cmgw);
+ err = celliax_serial_write_AT_ack(p, smscommand);
+ if (err) {
+ ERRORA("Error reading SMS back from the cellphone memory\n", CELLIAX_P_LOG);
+ }
+
+ /* let's delete from cellphone memory what we've sent */
+ sprintf(smscommand, "AT+CMGD=%s", p->at_cmgw);
+ err = celliax_serial_write_AT_ack(p, smscommand);
+ if (err) {
+ ERRORA("Error deleting SMS from the cellphone memory\n", CELLIAX_P_LOG);
+ }
+
+ p->at_cmgw[0] = '\0';
+ }
+ //usleep(500000); //.5 secs
+ UNLOCKA(&p->controldev_lock);
+ POPPA_UNLOCKA(&p->controldev_lock);
+ }
+
+ ast_log(LOG_DEBUG, "FINISH\n");
+ if (failed)
+ return -1;
+ else
+ return RESULT_SUCCESS;
+}
+
+#ifdef CELLIAX_DIR
+/* For simplicity, I'm keeping the format compatible with the voicemail config,
+ but i'm open to suggestions for isolating it */
+#define CELLIAX_DIR_CONFIG "directoriax.conf"
+
+/* How many digits to read in */
+#define CELLIAX_DIR_NUMDIGITS 3
+
+struct ast_config *celliax_dir_realtime(char *context)
+{
+ //TODO: all the realtime stuff has to be re-made
+ struct ast_config *cfg;
+ struct celliax_pvt *p = NULL;
+#ifdef ASTERISK_VERSION_1_6_0
+ struct ast_flags config_flags = { 0 };
+#endif /* ASTERISK_VERSION_1_6_0 */
+
+ /* Load flat file config. */
+#ifdef ASTERISK_VERSION_1_6_0
+ cfg = ast_config_load(CELLIAX_DIR_CONFIG, config_flags);
+#else
+ cfg = ast_config_load(CELLIAX_DIR_CONFIG);
+#endif /* ASTERISK_VERSION_1_6_0 */
+
+ if (!cfg) {
+ /* Loading config failed. */
+ WARNINGA
+ ("Loading directoriax.conf config file failed. It's not necessary, continuing.\n",
+ CELLIAX_P_LOG);
+ return NULL;
+ }
+ return cfg;
+}
+
+static char *celliax_dir_convert(char *lastname)
+{
+ char *tmp;
+ int lcount = 0;
+ tmp = malloc(CELLIAX_DIR_NUMDIGITS + 1);
+ if (tmp) {
+ while ((*lastname > 32) && lcount < CELLIAX_DIR_NUMDIGITS) {
+ switch (toupper(*lastname)) {
+ case '1':
+ tmp[lcount++] = '1';
+ break;
+ case '2':
+ case 'A':
+ case 'B':
+ case 'C':
+ tmp[lcount++] = '2';
+ break;
+ case '3':
+ case 'D':
+ case 'E':
+ case 'F':
+ tmp[lcount++] = '3';
+ break;
+ case '4':
+ case 'G':
+ case 'H':
+ case 'I':
+ tmp[lcount++] = '4';
+ break;
+ case '5':
+ case 'J':
+ case 'K':
+ case 'L':
+ tmp[lcount++] = '5';
+ break;
+ case '6':
+ case 'M':
+ case 'N':
+ case 'O':
+ tmp[lcount++] = '6';
+ break;
+ case '7':
+ case 'P':
+ case 'Q':
+ case 'R':
+ case 'S':
+ tmp[lcount++] = '7';
+ break;
+ case '8':
+ case 'T':
+ case 'U':
+ case 'V':
+ tmp[lcount++] = '8';
+ break;
+ case '9':
+ case 'W':
+ case 'X':
+ case 'Y':
+ case 'Z':
+ tmp[lcount++] = '9';
+ break;
+ }
+ lastname++;
+ }
+ tmp[lcount] = '\0';
+ }
+ return tmp;
+}
+
+int celliax_console_celliax_dir_export(int fd, int argc, char *argv[])
+{
+ struct ast_config *cfg;
+
+ struct ast_variable *v;
+ char *start, *pos, *stringp, *space, *options = NULL, *conv = NULL;
+ struct celliax_pvt *p = celliax_console_find_desc(celliax_console_active);
+ char *context = "default";
+ char *s;
+ char *var, *value;
+ int fromcell = 0;
+ int fromskype = 0;
+ char name[256] = "";
+ char phonebook_direct_calling_ext[7] = "";
+ char write_entry_command[256] = "";
+ char entry_number[256] = "";
+ char entry_text[256] = "";
+ char final_entry_text[256] = "";
+ int res;
+ int tocell = 0;
+#ifdef CELLIAX_LIBCSV
+ int tocsv = 0;
+ int tovcf = 0;
+#endif /* CELLIAX_LIBCSV */
+
+ if (argc < 3 || argc > 4)
+ return RESULT_SHOWUSAGE;
+ if (!p) {
+ ast_cli(fd, "No \"current\" console ???, please enter 'help celliax_console'\n");
+ return RESULT_SUCCESS;
+ }
+
+ if (!strcasecmp(argv[1], "tocell"))
+ tocell = 1;
+#ifdef CELLIAX_LIBCSV
+ else if (!strcasecmp(argv[1], "tocsv"))
+ tocsv = 1;
+ else if (!strcasecmp(argv[1], "tovcf"))
+ tovcf = 1;
+#endif /* CELLIAX_LIBCSV */
+ else {
+ ast_cli(fd,
+#ifdef CELLIAX_LIBCSV
+ "\n\nYou have neither specified 'tocell' nor 'tocsv'\n\n");
+#else /* CELLIAX_LIBCSV */
+ "\n\nYou have not specified 'tocell'\n\n");
+#endif /* CELLIAX_LIBCSV */
+ return RESULT_SHOWUSAGE;
+ }
+ if (tocell)
+ if (p->controldevprotocol != PROTOCOL_AT) {
+ ast_cli(fd,
+ "Exporting to the cellphone phonebook is currently supported only on \"AT\" cellphones :( !\n");
+ return RESULT_SUCCESS;
+ }
+#ifdef CELLIAX_LIBCSV
+ if (tocsv || tovcf)
+ if (argc != 4) {
+ ast_cli(fd, "\n\nYou have to specify a filename with 'tocsv'\n\n");
+ return RESULT_SHOWUSAGE;
+ }
+#endif /* CELLIAX_LIBCSV */
+
+ if (option_debug)
+ NOTICA("celliax_cellphonenumber is: %s\n", CELLIAX_P_LOG, argv[2]);
+
+#ifdef CELLIAX_LIBCSV
+ if (tocsv) {
+ if (option_debug)
+ NOTICA("filename is: %s\n", CELLIAX_P_LOG, argv[3]);
+ //ast_cli(fd, "\n\nnot yet implemented :P \n");
+ //return RESULT_SUCCESS;
+ }
+ if (tovcf) {
+ if (option_debug)
+ NOTICA("filename is: %s\n", CELLIAX_P_LOG, argv[3]);
+ ast_cli(fd, "\n\nnot yet implemented :P \n");
+ return RESULT_SUCCESS;
+ }
+#endif /* CELLIAX_LIBCSV */
+
+ cfg = celliax_dir_realtime(context);
+ if (!cfg) {
+ return -1;
+ }
+
+ if (tocell) {
+ /* which phonebook to use, use the SIM */
+ res = celliax_serial_write_AT_ack(p, "AT+CPBS=SM");
+ if (res) {
+ WARNINGA("AT+CPBS=SM failed, continue\n", CELLIAX_P_LOG);
+ }
+ /* which phonebook to use, trying to use phone, not SIM */
+ res = celliax_serial_write_AT_ack(p, "AT+CPBS=ME");
+ if (res) {
+ WARNINGA("AT+CPBS=ME failed, continue\n", CELLIAX_P_LOG);
+ }
+ /* retrieve the fields lenght in the selected phonebook */
+ p->phonebook_querying = 1;
+ res = celliax_serial_write_AT_ack(p, "AT+CPBR=?");
+ if (res) {
+ WARNINGA("AT+CPBR=? failed, continue\n", CELLIAX_P_LOG);
+ }
+ p->phonebook_querying = 0;
+
+ v = ast_variable_browse(cfg, context);
+ /* Find all candidate extensions */
+ while (v) {
+ /* Find a candidate extension */
+ start = strdup(v->value);
+ if (strcasestr(start, "fromcell=yes")) {
+ fromcell = 1;
+ fromskype = 0;
+
+ }
+ if (strcasestr(start, "fromskype=yes")) {
+ fromcell = 0;
+ fromskype = 1;
+
+ }
+
+ if (start && !strcasestr(start, "hidefromdir=yes")) {
+ memset(name, 0, sizeof(name));
+ memset(phonebook_direct_calling_ext, 0, sizeof(phonebook_direct_calling_ext));
+ memset(write_entry_command, 0, sizeof(write_entry_command));
+ memset(entry_number, 0, sizeof(entry_number));
+ memset(entry_text, 0, sizeof(entry_text));
+ memset(final_entry_text, 0, sizeof(final_entry_text));
+
+ DEBUGA_AT("v->name=%s\n", CELLIAX_P_LOG, v->name);
+ DEBUGA_AT("v->value=%s\n", CELLIAX_P_LOG, v->value);
+
+ stringp = start;
+ strsep(&stringp, ",");
+ pos = strsep(&stringp, ",");
+ if (pos) {
+ ast_copy_string(name, pos, sizeof(name));
+ if (strchr(pos, ' ')) {
+ space = strchr(pos, ' ');
+ *space = '\0';
+ }
+ if (pos) {
+ conv = celliax_dir_convert(pos);
+ DEBUGA_AT("<pos=>%s<conv=>%s<\n", CELLIAX_P_LOG, pos, conv);
+
+ options = strdup(v->value);
+ strsep(&options, ",");
+ strsep(&options, ",");
+ strsep(&options, ",");
+ strsep(&options, ",");
+ DEBUGA_AT("options=%s\n", CELLIAX_P_LOG, options);
+
+ while ((s = strsep(&options, "|"))) {
+ value = s;
+ if ((var = strsep(&value, "=")) && value) {
+ DEBUGA_AT("var=%s value=%s\n", CELLIAX_P_LOG, var, value);
+ if (!strcmp(var, "phonebook_direct_calling_ext"))
+ strncpy(phonebook_direct_calling_ext, value, 6);
+ }
+ }
+
+ res =
+ snprintf(entry_number, p->phonebook_number_lenght + 1, "%s%s%d%s%s",
+ argv[2], "p", p->celliax_dir_prefix, "p",
+ phonebook_direct_calling_ext);
+ if (res == (p->phonebook_number_lenght + 1)
+ || res > (p->phonebook_number_lenght + 1)) {
+ ERRORA("entry_number truncated, was: '%s%s%d%s%s', now is: '%s'\n",
+ CELLIAX_P_LOG, argv[2], "p", p->celliax_dir_prefix, "p",
+ phonebook_direct_calling_ext, entry_number);
+ //FIXME: abort ???
+
+ }
+
+ res = snprintf(final_entry_text, p->phonebook_text_lenght + 1, "%s", name); //FIXME result not checked
+
+ res =
+ snprintf(write_entry_command, sizeof(write_entry_command) - 1,
+ "AT+CPBW=,\"%s\",,\"%s\"", entry_number, final_entry_text);
+ if (res == (sizeof(write_entry_command) - 1)
+ || res > (sizeof(write_entry_command) - 1)) {
+ WARNINGA
+ ("write_entry_command truncated, was supposed: 'AT+CPBW=,\"%s\",,\"%s\"', now is: '%s'\n",
+ CELLIAX_P_LOG, entry_number, final_entry_text, write_entry_command);
+ }
+ //if (option_debug)
+ NOTICA("%s\n", CELLIAX_P_LOG, write_entry_command);
+ }
+ }
+ if (conv)
+ free(conv);
+ if (start)
+ free(start);
+ if (options)
+ free(options);
+ }
+ v = v->next;
+ }
+ }
+#ifdef CELLIAX_LIBCSV
+ if (tocsv) {
+
+ v = ast_variable_browse(cfg, context);
+ /* Find all candidate extensions */
+ while (v) {
+ /* Find a candidate extension */
+ start = strdup(v->value);
+ if (strcasestr(start, "fromcell=yes")) {
+ fromcell = 1;
+ fromskype = 0;
+
+ }
+ if (strcasestr(start, "fromskype=yes")) {
+ fromcell = 0;
+ fromskype = 1;
+
+ }
+
+ if (start && !strcasestr(start, "hidefromdir=yes")) {
+ memset(name, 0, sizeof(name));
+ memset(phonebook_direct_calling_ext, 0, sizeof(phonebook_direct_calling_ext));
+ memset(write_entry_command, 0, sizeof(write_entry_command));
+ memset(entry_number, 0, sizeof(entry_number));
+ memset(entry_text, 0, sizeof(entry_text));
+ memset(final_entry_text, 0, sizeof(final_entry_text));
+
+ DEBUGA_AT("v->name=%s\n", CELLIAX_P_LOG, v->name);
+ DEBUGA_AT("v->value=%s\n", CELLIAX_P_LOG, v->value);
+
+ stringp = start;
+ strsep(&stringp, ",");
+ pos = strsep(&stringp, ",");
+ if (pos) {
+ ast_copy_string(name, pos, sizeof(name));
+ if (strchr(pos, ' ')) {
+ space = strchr(pos, ' ');
+ *space = '\0';
+ }
+ if (pos) {
+ conv = celliax_dir_convert(pos);
+ DEBUGA_AT("<pos=>%s<conv=>%s<\n", CELLIAX_P_LOG, pos, conv);
+
+ options = strdup(v->value);
+ strsep(&options, ",");
+ strsep(&options, ",");
+ strsep(&options, ",");
+ strsep(&options, ",");
+ DEBUGA_AT("options=%s\n", CELLIAX_P_LOG, options);
+
+ while ((s = strsep(&options, "|"))) {
+ value = s;
+ if ((var = strsep(&value, "=")) && value) {
+ DEBUGA_AT("var=%s value=%s\n", CELLIAX_P_LOG, var, value);
+ if (!strcmp(var, "phonebook_direct_calling_ext"))
+ strncpy(phonebook_direct_calling_ext, value, 6);
+ }
+ }
+
+ //FIXME choose a logic for fields maximum lenght
+ res =
+ snprintf(entry_number, sizeof(entry_number) - 1, "%s%s%d%s%s", argv[2], "p",
+ p->celliax_dir_prefix, "p", phonebook_direct_calling_ext);
+ if (res == (sizeof(entry_number) - 1)
+ || res > (sizeof(entry_number) - 1)) {
+ ERRORA("entry_number truncated, was: '%s%s%d%s%s', now is: '%s'\n",
+ CELLIAX_P_LOG, argv[2], "p", p->celliax_dir_prefix, "p",
+ phonebook_direct_calling_ext, entry_number);
+ //FIXME: abort ???
+
+ }
+
+ res = snprintf(final_entry_text, sizeof(final_entry_text) - 1, "%s", name); //FIXME result not checked
+
+ int i, a;
+
+ a = 0;
+ for (i = 0; i < p->csv_complete_name_pos - 1; i++) {
+ if (p->csv_separator_is_semicolon)
+ write_entry_command[a] = ';';
+ else
+ write_entry_command[a] = ',';
+ a++;
+ }
+ //NOTICA("i=%d a=%d\n", CELLIAX_P_LOG, i, a);
+
+ write_entry_command[a] = '"';
+ a++;
+ //NOTICA("i=%d a=%d\n", CELLIAX_P_LOG, i, a);
+ for (i = 0; i < strlen(final_entry_text); i++) {
+ write_entry_command[a] = final_entry_text[i];
+ a++;
+ }
+ //NOTICA("i=%d a=%d\n", CELLIAX_P_LOG, i, a);
+ write_entry_command[a] = '"';
+ a++;
+ //NOTICA("i=%d a=%d\n", CELLIAX_P_LOG, i, a);
+ for (i = 0; i < (p->csv_business_phone_pos - p->csv_complete_name_pos); i++) {
+ if (p->csv_separator_is_semicolon)
+ write_entry_command[a] = ';';
+ else
+ write_entry_command[a] = ',';
+ a++;
+ }
+
+ //NOTICA("i=%d a=%d\n", CELLIAX_P_LOG, i, a);
+
+ write_entry_command[a] = '"';
+ a++;
+ //NOTICA("i=%d a=%d\n", CELLIAX_P_LOG, i, a);
+ for (i = 0; i < strlen(entry_number); i++) {
+ write_entry_command[a] = entry_number[i];
+ a++;
+ }
+ //NOTICA("i=%d a=%d\n", CELLIAX_P_LOG, i, a);
+ write_entry_command[a] = '"';
+ a++;
+ //NOTICA("i=%d a=%d\n", CELLIAX_P_LOG, i, a);
+
+ if (option_debug)
+ NOTICA("%s\n", CELLIAX_P_LOG, write_entry_command);
+ }
+ }
+ if (conv)
+ free(conv);
+ if (start)
+ free(start);
+ if (options)
+ free(options);
+ }
+ v = v->next;
+ }
+
+ }
+ if (tovcf) {
+//TODO implementation here
+ }
+#endif /* CELLIAX_LIBCSV */
+ ast_config_destroy(cfg);
+ return 0;
+}
+
+#ifdef CELLIAX_LIBCSV
+
+void celliax_cb1(char *s, size_t len, void *data)
+{
+ struct celliax_pvt *p = data;
+ char field_content[256];
+
+ p->csv_fields++;
+ memset(field_content, 0, sizeof(field_content));
+ strncpy(field_content, s,
+ sizeof(field_content) > (len + 1) ? len : (sizeof(field_content) - 1));
+ if (p->csv_fields == p->csv_complete_name_pos) {
+ strncpy(p->csv_complete_name, field_content, sizeof(p->csv_complete_name) - 1);
+ }
+ if (p->csv_fields == p->csv_email_pos) {
+ strncpy(p->csv_email, field_content, sizeof(p->csv_email) - 1);
+ }
+ if (p->csv_fields == p->csv_home_phone_pos) {
+ strncpy(p->csv_home_phone, field_content, sizeof(p->csv_home_phone) - 1);
+ }
+ if (p->csv_fields == p->csv_mobile_phone_pos) {
+ strncpy(p->csv_mobile_phone, field_content, sizeof(p->csv_mobile_phone) - 1);
+ }
+ if (p->csv_fields == p->csv_business_phone_pos) {
+ strncpy(p->csv_business_phone, field_content, sizeof(p->csv_business_phone) - 1);
+ }
+}
+
+void celliax_cb2(char c, void *data)
+{
+ struct celliax_pvt *p = data;
+
+ p->csv_rows++;
+ p->csv_fields = 0;
+
+ if (p->csv_first_row_is_title && p->csv_rows == 1) {
+ //do nothing
+ } else {
+ if (strlen(p->csv_complete_name)) {
+ if (option_debug)
+ NOTICA
+ ("ROW %d ENDED, complete_name=%s, email=%s, home_phone=%s, mobile_phone=%s, business_phone=%s\n",
+ CELLIAX_P_LOG, p->csv_rows,
+ strlen(p->csv_complete_name) ? p->csv_complete_name : "N/A",
+ strlen(p->csv_email) ? p->csv_email : "N/A",
+ strlen(p->csv_home_phone) ? p->csv_home_phone : "N/A",
+ strlen(p->csv_mobile_phone) ? p->csv_mobile_phone : "N/A",
+ strlen(p->csv_business_phone) ? p->csv_business_phone : "N/A");
+ }
+
+ /* write entries in phonebook file */
+ if (p->phonebook_writing_fp) {
+ celliax_dir_entry_extension++;
+
+ if (strlen(p->csv_complete_name)) {
+ /* let's start with home_phone */
+ if (strlen(p->csv_home_phone)) {
+ fprintf(p->phonebook_writing_fp,
+ "%s => ,%s %sSKO,,,hidefromdir=%s|phonebook_direct_calling_ext=%d%s%.4d|phonebook_entry_fromcsv=%s|phonebook_entry_owner=%s\n",
+ p->csv_home_phone, p->csv_complete_name, "HOME", "no",
+ p->celliax_dir_entry_extension_prefix, "2", celliax_dir_entry_extension,
+ "yes", "not_specified");
+ fprintf(p->phonebook_writing_fp,
+ "%s => ,%s %sDO,,,hidefromdir=%s|phonebook_direct_calling_ext=%d%s%.4d|phonebook_entry_fromcsv=%s|phonebook_entry_owner=%s\n",
+ p->csv_home_phone, p->csv_complete_name, "HOME", "no",
+ p->celliax_dir_entry_extension_prefix, "3", celliax_dir_entry_extension,
+ "yes", "not_specified");
+ }
+
+ /* now business_phone */
+ if (strlen(p->csv_business_phone)) {
+ fprintf(p->phonebook_writing_fp,
+ "%s => ,%s %sSKO,,,hidefromdir=%s|phonebook_direct_calling_ext=%d%s%.4d|phonebook_entry_fromcsv=%s|phonebook_entry_owner=%s\n",
+ p->csv_business_phone, p->csv_complete_name, "BIZ", "no",
+ p->celliax_dir_entry_extension_prefix, "2", celliax_dir_entry_extension,
+ "yes", "not_specified");
+ fprintf(p->phonebook_writing_fp,
+ "%s => ,%s %sDO,,,hidefromdir=%s|phonebook_direct_calling_ext=%d%s%.4d|phonebook_entry_fromcsv=%s|phonebook_entry_owner=%s\n",
+ p->csv_business_phone, p->csv_complete_name, "BIZ", "no",
+ p->celliax_dir_entry_extension_prefix, "3", celliax_dir_entry_extension,
+ "yes", "not_specified");
+ }
+
+ /* let's end with mobile_phone */
+ if (strlen(p->csv_mobile_phone)) {
+ fprintf(p->phonebook_writing_fp,
+ "%s => ,%s %sSKO,,,hidefromdir=%s|phonebook_direct_calling_ext=%d%s%.4d|phonebook_entry_fromcsv=%s|phonebook_entry_owner=%s\n",
+ p->csv_mobile_phone, p->csv_complete_name, "CELL", "no",
+ p->celliax_dir_entry_extension_prefix, "2", celliax_dir_entry_extension,
+ "yes", "not_specified");
+ fprintf(p->phonebook_writing_fp,
+ "%s => ,%s %sDO,,,hidefromdir=%s|phonebook_direct_calling_ext=%d%s%.4d|phonebook_entry_fromcsv=%s|phonebook_entry_owner=%s\n",
+ p->csv_mobile_phone, p->csv_complete_name, "CELL", "no",
+ p->celliax_dir_entry_extension_prefix, "3", celliax_dir_entry_extension,
+ "yes", "not_specified");
+ }
+ }
+
+ }
+
+ }
+}
+
+#endif /* CELLIAX_LIBCSV */
+
+int celliax_console_celliax_dir_import(int fd, int argc, char *argv[])
+{
+ int res;
+ struct celliax_pvt *p = celliax_console_find_desc(celliax_console_active);
+ char list_command[64];
+ char fn[256];
+ char date[256] = "";
+ time_t t;
+ char *configfile = CELLIAX_DIR_CONFIG;
+ int add_to_celliax_dir_conf = 1;
+ //int fromskype = 0;
+ int fromcell = 0;
+#ifdef CELLIAX_LIBCSV
+ int fromcsv = 0;
+ int fromvcf = 0;
+#endif /* CELLIAX_LIBCSV */
+
+ if (argc < 3 || argc > 4)
+ return RESULT_SHOWUSAGE;
+ if (!p) {
+ ast_cli(fd, "No \"current\" console ???, please enter 'help celliax_console'\n");
+ return RESULT_SUCCESS;
+ }
+
+ if (!strcasecmp(argv[1], "add"))
+ add_to_celliax_dir_conf = 1;
+ else if (!strcasecmp(argv[1], "replace"))
+ add_to_celliax_dir_conf = 0;
+ else {
+ ast_cli(fd, "\n\nYou have neither specified 'add' nor 'replace'\n\n");
+ return RESULT_SHOWUSAGE;
+ }
+
+ //if (!strcasecmp(argv[2], "fromskype"))
+ //fromskype = 1;
+ //else
+
+ if (!strcasecmp(argv[2], "fromcell"))
+ fromcell = 1;
+#ifdef CELLIAX_LIBCSV
+ else if (!strcasecmp(argv[2], "fromcsv"))
+ fromcsv = 1;
+ else if (!strcasecmp(argv[2], "fromvcf"))
+ fromvcf = 1;
+#endif /* CELLIAX_LIBCSV */
+ else {
+ ast_cli(fd, "\n\nYou have neither specified 'fromcell' neither 'fromcsv'\n\n");
+ return RESULT_SHOWUSAGE;
+ }
+
+#ifdef CELLIAX_LIBCSV
+ if (fromcsv || fromvcf)
+ if (argc != 4) {
+ ast_cli(fd,
+ "\n\nYou have to specify a filename with 'fromcsv' or with 'fromvcf'\n\n");
+ return RESULT_SHOWUSAGE;
+ }
+#endif /* CELLIAX_LIBCSV */
+ if (fromcell)
+ if (p->controldevprotocol != PROTOCOL_AT) {
+ ast_cli(fd,
+ "Importing from cellphone is currently supported only on \"AT\" cellphones :( !\n");
+ //fclose(p->phonebook_writing_fp);
+ //celliax_dir_create_extensions();
+ return RESULT_SUCCESS;
+ }
+
+ if (fromcell)
+ if (argc != 3) {
+ ast_cli(fd, "\n\nYou don't have to specify a filename with 'fromcell'\n\n");
+ return RESULT_SHOWUSAGE;
+ }
+#ifdef CELLIAX_LIBCSV
+ if (fromvcf) {
+ if (option_debug)
+ NOTICA("filename is: %s\n", CELLIAX_P_LOG, argv[3]);
+ ast_cli(fd, "\n\nnot yet implemented :P \n");
+ return RESULT_SUCCESS;
+ }
+#endif /* CELLIAX_LIBCSV */
+
+ /*******************************************************************************************/
+
+ if (configfile[0] == '/') {
+ ast_copy_string(fn, configfile, sizeof(fn));
+ } else {
+ snprintf(fn, sizeof(fn), "%s/%s", ast_config_AST_CONFIG_DIR, configfile);
+ }
+ if (option_debug)
+ NOTICA("Opening '%s'\n", CELLIAX_P_LOG, fn);
+ time(&t);
+ ast_copy_string(date, ctime(&t), sizeof(date));
+
+ if (add_to_celliax_dir_conf)
+ p->phonebook_writing_fp = fopen(fn, "a+");
+ else
+ p->phonebook_writing_fp = fopen(fn, "w+");
+
+ if (p->phonebook_writing_fp) {
+ if (add_to_celliax_dir_conf) {
+ if (option_debug)
+ NOTICA("Opened '%s' for appending \n", CELLIAX_P_LOG, fn);
+ fprintf(p->phonebook_writing_fp, ";!\n");
+ fprintf(p->phonebook_writing_fp, ";! Update Date: %s", date);
+ fprintf(p->phonebook_writing_fp, ";! Updated by: %s, %d\n", __FILE__, __LINE__);
+ fprintf(p->phonebook_writing_fp, ";!\n");
+ } else {
+ if (option_debug)
+ NOTICA("Opened '%s' for writing \n", CELLIAX_P_LOG, fn);
+ fprintf(p->phonebook_writing_fp, ";!\n");
+ fprintf(p->phonebook_writing_fp, ";! Automatically generated configuration file\n");
+ fprintf(p->phonebook_writing_fp, ";! Filename: %s (%s)\n", configfile, fn);
+ fprintf(p->phonebook_writing_fp, ";! Creation Date: %s", date);
+ fprintf(p->phonebook_writing_fp, ";! Generated by: %s, %d\n", __FILE__, __LINE__);
+ fprintf(p->phonebook_writing_fp, ";!\n");
+ fprintf(p->phonebook_writing_fp, "[general]\n\n");
+ fprintf(p->phonebook_writing_fp, "[default]\n");
+ }
+
+#ifdef CELLIAX_LIBCSV
+ //FIXME: if add_to_celliax_dir_conf parse the "old" config file, so to have the correct next entry id-exten
+ if (fromcsv) {
+ if (option_debug)
+ NOTICA("filename is: %s\n", CELLIAX_P_LOG, argv[3]);
+
+/************************/
+ FILE *fp;
+ struct csv_parser *csvp;
+ char buf[1024];
+ size_t bytes_read;
+ unsigned char options = 0;
+
+ p->csv_rows = 0;
+ p->csv_fields = 0;
+
+ if (p->csv_separator_is_semicolon) {
+ if (csv_init(&csvp, options | CSV_USE_SEMICOLON_SEPARATOR) != 0) {
+ ERRORA("Failed to initialize csv parser\n", CELLIAX_P_LOG);
+ return RESULT_SUCCESS;
+ }
+ } else {
+ if (csv_init(&csvp, options) != 0) {
+ ERRORA("Failed to initialize csv parser\n", CELLIAX_P_LOG);
+ return RESULT_SUCCESS;
+ }
+
+ }
+
+ fp = fopen(argv[3], "rb");
+ if (!fp) {
+ ERRORA("Failed to open %s: %s\n", CELLIAX_P_LOG, argv[3], strerror(errno));
+ return RESULT_SUCCESS;
+ }
+ while ((bytes_read = fread(buf, 1, 1024, fp)) > 0) {
+ if (csv_parse(csvp, buf, bytes_read, celliax_cb1, celliax_cb2, p) != bytes_read) {
+ ERRORA("Error while parsing file: %s\n", CELLIAX_P_LOG,
+ csv_strerror(csv_error(csvp)));
+ }
+ }
+
+ csv_fini(csvp, celliax_cb1, celliax_cb2, p);
+
+ if (ferror(fp)) {
+ ERRORA("Error while reading file %s\n", CELLIAX_P_LOG, argv[3]);
+ fclose(fp);
+ return RESULT_SUCCESS;
+ }
+
+ fclose(fp);
+ if (option_debug)
+ NOTICA("%s: %d fields, %d rows\n", CELLIAX_P_LOG, argv[3], p->csv_fields,
+ p->csv_rows);
+
+ csv_free(csvp);
+
+ /**************************/
+ }
+#endif /* CELLIAX_LIBCSV */
+
+ /*******************************************************************************************/
+ //if (fromskype) {
+ //ast_cli(fd,
+ //"Skype not supported in celliax_dir. Load chan_skypiax and use skypiax_dir!\n");
+ //}
+
+ /*******************************************************************************************/
+ if (fromcell) {
+ /* which phonebook to use, use the SIM */
+ res = celliax_serial_write_AT_ack(p, "AT+CPBS=SM");
+ if (res) {
+ WARNINGA("AT+CPBS=SM failed, continue\n", CELLIAX_P_LOG);
+ }
+ /* which phonebook to use, trying to use combined phone+SIM */
+ res = celliax_serial_write_AT_ack(p, "AT+CPBS=MT");
+ if (res) {
+ WARNINGA("AT+CPBS=MT failed, continue\n", CELLIAX_P_LOG);
+ }
+ /* How many entries in phonebook */
+ p->phonebook_querying = 1;
+ res = celliax_serial_write_AT_ack(p, "AT+CPBR=?");
+ if (res) {
+ WARNINGA("AT+CPBR=? failed, continue\n", CELLIAX_P_LOG);
+ }
+ p->phonebook_querying = 0;
+ /* list entries in phonebook, give the SIM the time to answer */
+ WARNINGA
+ ("About to querying the cellphone phonebook, if the SIM do not answer may stuck here for 20 seconds... Don't worry.\n",
+ CELLIAX_P_LOG);
+ sprintf(list_command, "AT+CPBR=%d,%d", p->phonebook_first_entry,
+ p->phonebook_last_entry);
+ p->phonebook_listing = 1;
+ res = celliax_serial_write_AT_expect_longtime(p, list_command, "OK");
+ if (res) {
+ WARNINGA("AT+CPBR=%d,%d failed, continue\n", CELLIAX_P_LOG,
+ p->phonebook_first_entry, p->phonebook_last_entry);
+ }
+ p->phonebook_listing = 0;
+ }
+ /*******************************************************************************************/
+#ifdef CELLIAX_LIBCSV
+ if (fromvcf) {
+ //TODO implementation here
+ }
+#endif /* CELLIAX_LIBCSV */
+
+ } else {
+ ast_cli(fd, "\n\nfailed to open the directoriax.conf configuration file: %s\n", fn);
+ ERRORA("failed to open the directoriax.conf configuration file: %s\n", CELLIAX_P_LOG,
+ fn);
+ return RESULT_FAILURE;
+ }
+
+ fclose(p->phonebook_writing_fp);
+ //celliax_dir_create_extensions();
+
+ return RESULT_SUCCESS;
+}
+
+#endif /* CELLIAX_DIR */
+
+#ifdef CELLIAX_FBUS2
+
+int celliax_serial_getstatus_FBUS2(struct celliax_pvt *p)
+{
+ unsigned char MsgBuffer[7];
+ int res;
+ int how_many_reads = 0;
+
+ PUSHA_UNLOCKA(&p->controldev_lock);
+ LOKKA(&p->controldev_lock);
+
+ MsgBuffer[0] = FBUS2_COMMAND_BYTE_1;
+ MsgBuffer[1] = FBUS2_COMMAND_BYTE_2;
+ MsgBuffer[2] = 0x00;
+ MsgBuffer[3] = 0x03;
+ MsgBuffer[4] = 0x00;
+ MsgBuffer[5] = FBUS2_IS_LAST_FRAME;
+ MsgBuffer[6] = celliax_serial_get_seqnum_FBUS2(p);
+
+ if (option_debug > 1)
+ DEBUGA_FBUS2("asking model, outseqnum %.2X \n", CELLIAX_P_LOG, MsgBuffer[6]);
+ celliax_serial_write_FBUS2(p, MsgBuffer, 7, FBUS2_TYPE_MODEL_ASK);
+ usleep(1000);
+ res = celliax_serial_read_FBUS2(p); //we don't have no monitor neither do_controldev_thread
+ if (res == -1) {
+ ERRORA("failed celliax_serial_read_FBUS2\n", CELLIAX_P_LOG);
+ UNLOCKA(&p->controldev_lock);
+ return -1;
+ }
+ while (res != MsgBuffer[6] && res != FBUS2_TYPE_MODEL_ANSWER) {
+ usleep(1000);
+ res = celliax_serial_read_FBUS2(p);
+ how_many_reads++;
+ if (res == -1) {
+ ERRORA("failed celliax_serial_read_FBUS2\n", CELLIAX_P_LOG);
+ UNLOCKA(&p->controldev_lock);
+ return -1;
+ }
+ if (how_many_reads > 10) {
+ ERRORA("no expected results in %d celliax_serial_read_FBUS2\n", CELLIAX_P_LOG,
+ how_many_reads);
+ UNLOCKA(&p->controldev_lock);
+ return -1;
+ }
+ }
+
+ UNLOCKA(&p->controldev_lock);
+ POPPA_UNLOCKA(&p->controldev_lock);
+ return 0;
+}
+
+int celliax_serial_sync_FBUS2(struct celliax_pvt *p)
+{
+ unsigned char initc = 0x55; /* FBUS2 initialization char */
+ int c, rt;
+ PUSHA_UNLOCKA(&p->controldev_lock);
+ LOKKA(&p->controldev_lock);
+ /* init the link (sync receive uart) */
+ for (c = 0; c < 55; c++) { /* 55 times */
+ usleep(10000);
+ rt = write(p->controldevfd, &initc, 1);
+ if (rt != 1) {
+ ERRORA("serial error: %s", CELLIAX_P_LOG, strerror(errno));
+ UNLOCKA(&p->controldev_lock);
+ return -1;
+ }
+ }
+ time(&p->celliax_serial_synced_timestamp);
+ UNLOCKA(&p->controldev_lock);
+ POPPA_UNLOCKA(&p->controldev_lock);
+ return 0;
+}
+
+int celliax_serial_answer_FBUS2(struct celliax_pvt *p)
+{
+ unsigned char MsgBuffer[6];
+
+ celliax_serial_security_command_FBUS2(p);
+
+ MsgBuffer[0] = FBUS2_COMMAND_BYTE_1;
+ MsgBuffer[1] = FBUS2_COMMAND_BYTE_2;
+ MsgBuffer[2] = FBUS2_SECURIY_CALL_COMMANDS;
+ MsgBuffer[3] = FBUS2_SECURIY_CALL_COMMAND_ANSWER;
+ MsgBuffer[4] = FBUS2_IS_LAST_FRAME;
+ MsgBuffer[5] = celliax_serial_get_seqnum_FBUS2(p);
+ if (option_debug > 1)
+ DEBUGA_FBUS2("celliax_serial_answer_FBUS2, outseqnum %.2X \n", CELLIAX_P_LOG,
+ MsgBuffer[5]);
+ celliax_serial_write_FBUS2(p, MsgBuffer, 6, FBUS2_TYPE_SECURITY);
+ DEBUGA_FBUS2("FBUS2: sent commands to answer the call\n", CELLIAX_P_LOG);
+ p->interface_state = AST_STATE_UP; //FIXME
+
+ return 0;
+}
+
+int celliax_serial_call_FBUS2(struct celliax_pvt *p, char *dstr)
+{
+ unsigned char MsgBufferNum[255];
+ int i;
+
+ celliax_serial_security_command_FBUS2(p);
+
+ MsgBufferNum[0] = FBUS2_COMMAND_BYTE_1;
+ MsgBufferNum[1] = FBUS2_COMMAND_BYTE_2;
+ MsgBufferNum[2] = FBUS2_SECURIY_CALL_COMMANDS;
+ MsgBufferNum[3] = FBUS2_SECURIY_CALL_COMMAND_CALL;
+ for (i = 0; i < strlen(dstr); i++) {
+ MsgBufferNum[4 + i] = dstr[i];
+ }
+ MsgBufferNum[4 + strlen(dstr)] = 0x00; /* required by FBUS2 prot */
+ MsgBufferNum[4 + strlen(dstr) + 1] = FBUS2_IS_LAST_FRAME;
+ MsgBufferNum[4 + strlen(dstr) + 2] = celliax_serial_get_seqnum_FBUS2(p);
+ if (option_debug > 1)
+ DEBUGA_FBUS2("celliax_serial_call_FBUS2, outseqnum %.2X \n", CELLIAX_P_LOG,
+ MsgBufferNum[4 + strlen(dstr) + 2]);
+ celliax_serial_write_FBUS2(p, MsgBufferNum, 5 + strlen(dstr) + 2, FBUS2_TYPE_SECURITY);
+
+ p->phone_callflow = CALLFLOW_CALL_DIALING;
+ p->interface_state = AST_STATE_DIALING;
+ if (option_debug)
+ DEBUGA_FBUS2("FBUS2: sent commands to call\n", CELLIAX_P_LOG);
+ return 0;
+}
+
+int celliax_serial_hangup_FBUS2(struct celliax_pvt *p)
+{
+ unsigned char MsgBuffer[6];
+
+ if (p->interface_state != AST_STATE_DOWN) {
+ celliax_serial_security_command_FBUS2(p);
+
+ MsgBuffer[0] = FBUS2_COMMAND_BYTE_1;
+ MsgBuffer[1] = FBUS2_COMMAND_BYTE_2;
+ MsgBuffer[2] = FBUS2_SECURIY_CALL_COMMANDS;
+ MsgBuffer[3] = FBUS2_SECURIY_CALL_COMMAND_RELEASE;
+ MsgBuffer[4] = FBUS2_IS_LAST_FRAME;
+ MsgBuffer[5] = celliax_serial_get_seqnum_FBUS2(p);
+
+ if (option_debug > 1)
+ DEBUGA_FBUS2("celliax_serial_hangup_FBUS2, outseqnum %.2X \n", CELLIAX_P_LOG,
+ MsgBuffer[5]);
+ celliax_serial_write_FBUS2(p, MsgBuffer, 6, FBUS2_TYPE_SECURITY);
+
+ DEBUGA_FBUS2("FBUS2: sent commands to hangup the call\n", CELLIAX_P_LOG);
+
+ }
+ p->interface_state = AST_STATE_DOWN; //FIXME
+ p->phone_callflow = CALLFLOW_CALL_IDLE; //FIXME
+ return 0;
+}
+
+int celliax_serial_config_FBUS2(struct celliax_pvt *p)
+{
+ unsigned char MsgBuffer[6];
+ int res;
+ int how_many_reads = 0;
+
+ MsgBuffer[0] = FBUS2_COMMAND_BYTE_1;
+ MsgBuffer[1] = FBUS2_COMMAND_BYTE_2;
+ MsgBuffer[2] = FBUS2_SECURIY_EXTENDED_COMMANDS;
+ MsgBuffer[3] = FBUS2_SECURIY_EXTENDED_COMMAND_ON;
+ MsgBuffer[4] = FBUS2_IS_LAST_FRAME;
+ MsgBuffer[5] = celliax_serial_get_seqnum_FBUS2(p);
+
+ if (option_debug > 1)
+ DEBUGA_FBUS2("activating security commands for getting IMEI, outseqnum %.2X \n",
+ CELLIAX_P_LOG, MsgBuffer[5]);
+ celliax_serial_write_FBUS2(p, MsgBuffer, 6, FBUS2_TYPE_SECURITY);
+ res = celliax_serial_read_FBUS2(p); //we don't have no monitor neither do_controldev_thread
+ if (res == -1) {
+ ERRORA("failed celliax_serial_read_FBUS2\n", CELLIAX_P_LOG);
+ return -1;
+ }
+ while (res != MsgBuffer[5] && res != FBUS2_SECURIY_EXTENDED_COMMAND_ON) {
+ usleep(1000);
+ res = celliax_serial_read_FBUS2(p);
+ how_many_reads++;
+ if (res == -1) {
+ ERRORA("failed celliax_serial_read_FBUS2\n", CELLIAX_P_LOG);
+ return -1;
+ }
+ if (how_many_reads > 10) {
+ ERRORA("no expected results in %d celliax_serial_read_FBUS2\n", CELLIAX_P_LOG,
+ how_many_reads);
+ return -1;
+ }
+ }
+
+ MsgBuffer[0] = FBUS2_COMMAND_BYTE_1;
+ MsgBuffer[1] = FBUS2_COMMAND_BYTE_2;
+ MsgBuffer[2] = FBUS2_SECURIY_IMEI_COMMANDS;
+ MsgBuffer[3] = FBUS2_SECURIY_IMEI_COMMAND_GET;
+ MsgBuffer[4] = FBUS2_IS_LAST_FRAME;
+ MsgBuffer[5] = celliax_serial_get_seqnum_FBUS2(p);
+ if (option_debug > 1)
+ DEBUGA_FBUS2("celliax_serial_get_IMEI_init_FBUS2, outseqnum %.2X \n", CELLIAX_P_LOG,
+ MsgBuffer[5]);
+ celliax_serial_write_FBUS2(p, MsgBuffer, 6, FBUS2_TYPE_SECURITY);
+ res = celliax_serial_read_FBUS2(p); //we don't have no monitor neither do_controldev_thread
+ if (res == -1) {
+ ERRORA("failed celliax_serial_read_FBUS2\n", CELLIAX_P_LOG);
+ return -1;
+ }
+ how_many_reads = 0;
+ while (res != MsgBuffer[5] && res != CALLFLOW_GOT_IMEI) {
+ usleep(1000);
+ res = celliax_serial_read_FBUS2(p);
+ how_many_reads++;
+ if (res == -1) {
+ ERRORA("failed celliax_serial_read_FBUS2\n", CELLIAX_P_LOG);
+ return -1;
+ }
+ if (how_many_reads > 10) {
+ ERRORA("no expected results in %d celliax_serial_read_FBUS2\n", CELLIAX_P_LOG,
+ how_many_reads);
+ //FIXME return -1;
+ return 0;
+ }
+ }
+
+ if (option_debug > 1)
+ DEBUGA_FBUS2("xxxxx GOT IMEI xxxxx res=%d %.2X \n", CELLIAX_P_LOG, res, res);
+
+ return 0;
+}
+
+int celliax_serial_get_seqnum_FBUS2(struct celliax_pvt *p)
+{
+ if (p->seqnumfbus > FBUS2_SEQNUM_MAX || p->seqnumfbus < FBUS2_SEQNUM_MIN) {
+ ERRORA("p->seqnumfbus: %2.X\n", CELLIAX_P_LOG, p->seqnumfbus);
+ p->seqnumfbus = FBUS2_SEQNUM_MIN;
+ }
+
+ if (p->seqnumfbus == FBUS2_SEQNUM_MAX) {
+ p->seqnumfbus = FBUS2_SEQNUM_MIN;
+ } else {
+ p->seqnumfbus++;
+ }
+ if (option_debug > 10)
+ DEBUGA_FBUS2("sqnum: %2.X\n", CELLIAX_P_LOG, p->seqnumfbus);
+ return p->seqnumfbus;
+}
+
+int celliax_serial_security_command_FBUS2(struct celliax_pvt *p)
+{
+ unsigned char MsgBuffer[6];
+
+ MsgBuffer[0] = FBUS2_COMMAND_BYTE_1;
+ MsgBuffer[1] = FBUS2_COMMAND_BYTE_2;
+ MsgBuffer[2] = FBUS2_SECURIY_EXTENDED_COMMANDS;
+ MsgBuffer[3] = FBUS2_SECURIY_EXTENDED_COMMAND_ON;
+ MsgBuffer[4] = FBUS2_IS_LAST_FRAME;
+ MsgBuffer[5] = celliax_serial_get_seqnum_FBUS2(p);
+
+ if (option_debug > 1)
+ DEBUGA_FBUS2("activating security commands, outseqnum %.2X \n", CELLIAX_P_LOG,
+ MsgBuffer[5]);
+ celliax_serial_write_FBUS2(p, MsgBuffer, 6, FBUS2_TYPE_SECURITY);
+ return 0;
+}
+
+/*!
+ * \brief Write on the serial port for all the FBUS2 (old Nokia) functions
+ * \param p celliax_pvt
+ * \param len lenght of buffer2
+ * \param buffer2 chars to be written
+ *
+ * Write on the serial port for all the FBUS2 (old Nokia) functions
+ *
+ * \return the number of chars written on the serial,
+ * that can be different from len (or negative) in case of errors.
+ */
+int celliax_serial_send_FBUS2(struct celliax_pvt *p, int len, unsigned char *mesg_ptr)
+{
+ int ret;
+ size_t actual = 0;
+ unsigned char *mesg_ptr2 = mesg_ptr;
+ PUSHA_UNLOCKA(&p->controldev_lock);
+ LOKKA(&p->controldev_lock);
+ do {
+ ret = write(p->controldevfd, mesg_ptr, len - actual);
+ if (ret < 0 && errno == EAGAIN)
+ continue;
+ if (ret < 0) {
+ if (actual != len)
+ ERRORA("celliax_serial_write error: %s", CELLIAX_P_LOG, strerror(errno));
+ UNLOCKA(&p->controldev_lock);
+ return -1;
+ }
+ actual += ret;
+ mesg_ptr += ret;
+ usleep(10000);
+ } while (actual < len);
+
+ UNLOCKA(&p->controldev_lock);
+ POPPA_UNLOCKA(&p->controldev_lock);
+ if (option_debug > 10) {
+ int i;
+ char debug_buf[1024];
+ char *debug_buf_pos;
+
+ memset(debug_buf, 0, 1024);
+ debug_buf_pos = debug_buf;
+
+ for (i = 0; i < len; i++) {
+ debug_buf_pos += sprintf(debug_buf_pos, "[%.2X] ", mesg_ptr2[i]);
+ if (debug_buf_pos > ((char *) &debug_buf + 1000))
+ break;
+ }
+ DEBUGA_FBUS2("%s was sent down the wire\n", CELLIAX_P_LOG, debug_buf);
+ }
+
+ return 0;
+}
+
+/*!
+ * \brief Flags as acknowledged an FBUS2 message previously sent
+ * \param p celliax_pvt
+ * \param seqnum identifier of the message to be acknowledged
+ *
+ * Called upon receiving an FBUS2 acknoledgement message, browse the fbus2_outgoing_list
+ * looking for the seqnum sent FBUS2 message, and flags it as acknowledged.
+ * (if an outgoing FBUS2 message is not aknowledged by the cellphone in a while,
+ * it will be retransmitted)
+ *
+ * \return 0 on error, 1 otherwise
+ */
+int celliax_serial_list_acknowledge_FBUS2(struct celliax_pvt *p, int seqnum)
+{
+ struct fbus2_msg *ptr;
+
+ ptr = p->fbus2_outgoing_list;
+ if (ptr == NULL) {
+ ERRORA("fbus2_outgoing_list is NULL ?\n", CELLIAX_P_LOG);
+ return -1;
+ }
+ PUSHA_UNLOCKA(&p->fbus2_outgoing_list_lock);
+ LOKKA(&p->fbus2_outgoing_list_lock);
+ while (ptr->next != NULL)
+ ptr = ptr->next;
+ while (ptr->acknowledged == 0) {
+ if (ptr->seqnum == seqnum) {
+ ptr->acknowledged = 1;
+ if (option_debug > 1)
+ DEBUGA_FBUS2("Acknowledgment to %.2X\n", CELLIAX_P_LOG, seqnum);
+
+ DEBUGA_FBUS2("PREFREE OUTGOING list:\n", CELLIAX_P_LOG);
+ celliax_serial_list_print_FBUS2(p, p->fbus2_outgoing_list);
+ if (ptr->previous) {
+ if (ptr->next) {
+ ptr->previous->next = ptr->next;
+ } else {
+ ptr->previous->next = NULL;
+ }
+ }
+ if (ptr->next) {
+ if (ptr->previous) {
+ ptr->next->previous = ptr->previous;
+ } else {
+ ptr->next->previous = NULL;
+ }
+ }
+
+ if ((NULL == ptr->next) && (NULL == ptr->previous)) { /* bug catched by Wojciech Andralojc */
+ if (option_debug > 1)
+ DEBUGA_FBUS2("FREEING LAST\n", CELLIAX_P_LOG);
+ p->fbus2_outgoing_list = NULL;
+ p->fbus2_outgoing_list = celliax_serial_list_init_FBUS2(p);
+ }
+
+ free(ptr);
+ DEBUGA_FBUS2("POSTFREE OUTGOING list:\n", CELLIAX_P_LOG);
+ celliax_serial_list_print_FBUS2(p, p->fbus2_outgoing_list);
+
+ break;
+ }
+ if (ptr->previous != NULL) {
+ ptr = ptr->previous;
+ } else {
+ ERRORA
+ ("The phone sent us an acknowledgement referring to a msg with a seqnum that is not in our sent list: %.2X\n",
+ CELLIAX_P_LOG, seqnum);
+ break;
+ }
+ }
+ UNLOCKA(&p->fbus2_outgoing_list_lock);
+ POPPA_UNLOCKA(&p->fbus2_outgoing_list_lock);
+ return 0;
+}
+
+/*!
+ * \brief Sends an FBUS2 message or resends it if it was not acknowledged
+ * \param p celliax_pvt
+ *
+ * Called by celliax_serial_read_FBUS2, browse the fbus2_outgoing_list looking for FBUS2 messages to be sent,
+ * or for FBUS2 messages previously sent but not yet acknoledged.
+ * (if an outgoing FBUS2 message is not aknowledged by the cellphone in a while,
+ * it will be retransmitted)
+ *
+ * \return 0 on error, 1 otherwise
+ */
+int celliax_serial_send_if_time_FBUS2(struct celliax_pvt *p)
+{
+ struct fbus2_msg *ptr;
+ struct timeval tv;
+ struct timezone tz;
+
+ gettimeofday(&tv, &tz);
+ ptr = p->fbus2_outgoing_list;
+ if (ptr == NULL) {
+ ERRORA("fbus2_outgoing_list is NULL ?\n", CELLIAX_P_LOG);
+ return -1;
+ }
+ while (ptr->next != NULL) {
+ WARNINGA("fbus2_outgoing_list->next is not null ?\n", CELLIAX_P_LOG);
+ ptr = ptr->next; //FIXME what to do?
+ }
+ while (ptr->sent == 0 && ptr->acknowledged == 0) {
+ if (ptr->previous != NULL) {
+ ptr = ptr->previous;
+ } else
+ break;
+ }
+ while (ptr->sent == 1 && ptr->acknowledged == 0) {
+ if (ptr->previous != NULL) {
+ ptr = ptr->previous;
+ } else
+ break;
+ }
+ if (ptr->sent == 1 && ptr->acknowledged == 1) {
+ if (ptr->next != NULL) {
+ ptr = ptr->next;
+ }
+ }
+ if (ptr->sent == 1 && ptr->acknowledged == 0 && ptr->msg > 0) {
+ if ((tv.tv_sec * 1000 + tv.tv_usec / 1000) >
+ ((ptr->tv_sec * 1000 + ptr->tv_usec / 1000) + 1000)) {
+
+ PUSHA_UNLOCKA(&p->fbus2_outgoing_list_lock);
+ LOKKA(&p->fbus2_outgoing_list_lock);
+
+ if (ptr->sent == 1 && ptr->acknowledged == 0 && ptr->msg > 0) { //retest, maybe has been changed?
+ if ((tv.tv_sec * 1000 + tv.tv_usec / 1000) > ((ptr->tv_sec * 1000 + ptr->tv_usec / 1000) + 1000)) { //retest, maybe has been changed?
+
+ if (option_debug > 1)
+ DEBUGA_FBUS2("RESEND %.2X, passed %ld ms, sent %d times\n", CELLIAX_P_LOG,
+ ptr->seqnum,
+ ((tv.tv_sec * 1000 + tv.tv_usec / 1000) -
+ (ptr->tv_sec * 1000 + ptr->tv_usec / 1000)),
+ ptr->how_many_sent);
+ if (ptr->how_many_sent > 9) {
+ ERRORA("RESEND %.2X, passed %ld ms, sent %d times\n", CELLIAX_P_LOG,
+ ptr->seqnum,
+ ((tv.tv_sec * 1000 + tv.tv_usec / 1000) -
+ (ptr->tv_sec * 1000 + ptr->tv_usec / 1000)), ptr->how_many_sent);
+
+ UNLOCKA(&p->fbus2_outgoing_list_lock);
+ return -1;
+ }
+
+ celliax_serial_send_FBUS2(p, ptr->len, ptr->buffer);
+ if (ptr->buffer[3] == FBUS2_ACK_BYTE) {
+ if (option_debug > 1)
+ DEBUGA_FBUS2("RESEND ACK, passed %ld ms, sent %d times\n", CELLIAX_P_LOG,
+ ((tv.tv_sec * 1000 + tv.tv_usec / 1000) -
+ (ptr->tv_sec * 1000 + ptr->tv_usec / 1000)),
+ ptr->how_many_sent);
+ ptr->acknowledged = 1;
+ ptr->msg = FBUS2_OUTGOING_ACK;
+ }
+ ptr->tv_sec = tv.tv_sec;
+ ptr->tv_usec = tv.tv_usec;
+ ptr->sent = 1;
+ ptr->how_many_sent++;
+ if (option_debug > 1) {
+ DEBUGA_FBUS2("OUTGOING list:\n", CELLIAX_P_LOG);
+ celliax_serial_list_print_FBUS2(p, p->fbus2_outgoing_list);
+ DEBUGA_FBUS2("OUTGOING list END\n", CELLIAX_P_LOG);
+ }
+
+ }
+ }
+
+ UNLOCKA(&p->fbus2_outgoing_list_lock);
+ POPPA_UNLOCKA(&p->fbus2_outgoing_list_lock);
+ }
+ }
+ if (ptr->sent == 0 && ptr->acknowledged == 0 && ptr->msg > 0) {
+
+ PUSHA_UNLOCKA(&p->fbus2_outgoing_list_lock);
+ LOKKA(&p->fbus2_outgoing_list_lock);
+
+ if (ptr->sent == 0 && ptr->acknowledged == 0 && ptr->msg > 0) { //retest, maybe has been changed?
+
+ if (option_debug > 1)
+ DEBUGA_FBUS2("SENDING 1st TIME %.2X\n", CELLIAX_P_LOG, ptr->seqnum);
+ celliax_serial_send_FBUS2(p, ptr->len, ptr->buffer);
+ if (ptr->buffer[3] == FBUS2_ACK_BYTE) {
+ if (option_debug > 1)
+ DEBUGA_FBUS2("SENDING 1st TIME ACK\n", CELLIAX_P_LOG);
+ ptr->acknowledged = 1;
+ ptr->msg = FBUS2_OUTGOING_ACK;
+ }
+ ptr->tv_sec = tv.tv_sec;
+ ptr->tv_usec = tv.tv_usec;
+ ptr->sent = 1;
+ ptr->how_many_sent++;
+ if (option_debug > 1) {
+ DEBUGA_FBUS2("OUTGOING list:\n", CELLIAX_P_LOG);
+ celliax_serial_list_print_FBUS2(p, p->fbus2_outgoing_list);
+ DEBUGA_FBUS2("OUTGOING list END\n", CELLIAX_P_LOG);
+ }
+
+ }
+
+ UNLOCKA(&p->fbus2_outgoing_list_lock);
+ POPPA_UNLOCKA(&p->fbus2_outgoing_list_lock);
+
+ }
+ return 0;
+}
+
+int celliax_serial_write_FBUS2(struct celliax_pvt *p, unsigned char *MsgBuffer,
+ int MsgLength, unsigned char MsgType)
+{
+ unsigned char buffer2[FBUS2_MAX_TRANSMIT_LENGTH + 10];
+ unsigned char checksum = 0;
+ int i, len;
+ struct timeval tv;
+ struct timezone tz;
+
+ buffer2[0] = FBUS2_SERIAL_FRAME_ID;
+ buffer2[1] = FBUS2_DEVICE_PHONE; /* destination */
+ buffer2[2] = FBUS2_DEVICE_PC; /* source */
+ buffer2[3] = MsgType;
+ buffer2[4] = 0x00; /* required by protocol */
+ buffer2[5] = MsgLength;
+
+ memcpy(buffer2 + 6, MsgBuffer, MsgLength);
+ len = MsgLength + 6;
+
+ /* Odd messages require additional padding 0x00 byte */
+ if (MsgLength % 2)
+ buffer2[len++] = 0x00; /* optional PaddingByte */
+
+ checksum = 0;
+ for (i = 0; i < len; i += 2)
+ checksum ^= buffer2[i];
+ buffer2[len++] = checksum; /* ChkSum1 */
+
+ checksum = 0;
+ for (i = 1; i < len; i += 2)
+ checksum ^= buffer2[i];
+ buffer2[len++] = checksum; /* ChkSum2 */
+
+ if (option_debug > 10) {
+ int i;
+ char debug_buf[1024];
+ char *debug_buf_pos;
+
+ memset(debug_buf, 0, 1024);
+ debug_buf_pos = debug_buf;
+
+ for (i = 0; i < len; i++) {
+ debug_buf_pos += sprintf(debug_buf_pos, "[%.2X] ", buffer2[i]);
+ if (debug_buf_pos > (char *) (&debug_buf + 1000))
+ break;
+ }
+ if (buffer2[3] == FBUS2_ACK_BYTE) {
+ DEBUGA_FBUS2("%s to be written, ACK\n", CELLIAX_P_LOG, debug_buf);
+ } else {
+ DEBUGA_FBUS2("%s to be written\n", CELLIAX_P_LOG, debug_buf);
+ }
+ }
+
+ gettimeofday(&tv, &tz);
+
+ if (buffer2[3] != FBUS2_ACK_BYTE) {
+ p->fbus2_outgoing_list = celliax_serial_list_init_FBUS2(p);
+ p->fbus2_outgoing_list->msg = 11;
+
+ p->fbus2_outgoing_list->len = len;
+ for (i = 0; i < len; i++) {
+ p->fbus2_outgoing_list->buffer[i] = buffer2[i];
+ }
+ p->fbus2_outgoing_list->seqnum = MsgBuffer[MsgLength - 1];
+ if (option_debug > 1) {
+ DEBUGA_FBUS2("OUTGOING LIST seqnum is %2.X\n", CELLIAX_P_LOG,
+ MsgBuffer[MsgLength - 1]);
+
+ DEBUGA_FBUS2("OUTGOING list:\n", CELLIAX_P_LOG);
+ celliax_serial_list_print_FBUS2(p, p->fbus2_outgoing_list);
+ DEBUGA_FBUS2("OUTGOING list END\n", CELLIAX_P_LOG);
+ }
+ } else {
+ usleep(100);
+ celliax_serial_send_FBUS2(p, len, buffer2);
+ }
+
+ return 0;
+}
+
+int celliax_serial_send_ack_FBUS2(struct celliax_pvt *p, unsigned char MsgType,
+ unsigned char MsgSequence)
+{
+ unsigned char buffer2[2];
+
+ buffer2[0] = MsgType;
+ buffer2[1] = (MsgSequence - FBUS2_SEQNUM_MIN);
+
+ if (option_debug > 1)
+ DEBUGA_FBUS2("SENDING ACK to %2.X, seqack %2.X \n", CELLIAX_P_LOG, MsgSequence,
+ (MsgSequence - FBUS2_SEQNUM_MIN));
+ /* Sending to phone */
+ return celliax_serial_write_FBUS2(p, buffer2, 2, FBUS2_ACK_BYTE);
+}
+
+struct fbus2_msg *celliax_serial_list_init_FBUS2(struct celliax_pvt *p)
+{
+ struct fbus2_msg *list;
+ list = p->fbus2_outgoing_list;
+
+ PUSHA_UNLOCKA(&p->fbus2_outgoing_list_lock);
+ LOKKA(&p->fbus2_outgoing_list_lock);
+ if (list == NULL) {
+ list = malloc(sizeof(*(list)));
+ list->msg = 0;
+ list->seqnum = 0;
+ list->len = 0;
+ list->acknowledged = 0;
+ list->how_many_sent = 0;
+ list->sent = 0;
+ list->tv_sec = 0;
+ list->tv_usec = 0;
+ list->next = NULL;
+ list->previous = NULL;
+ }
+ if (list->msg != 0) {
+ struct fbus2_msg *new;
+ new = malloc(sizeof(*new));
+ new->msg = 0;
+ new->seqnum = 0;
+ new->len = 0;
+ new->acknowledged = 0;
+ new->how_many_sent = 0;
+ new->sent = 0;
+ new->tv_sec = 0;
+ new->tv_usec = 0;
+ new->next = NULL;
+ new->previous = list;
+ list->next = new;
+ list = new;
+ }
+ UNLOCKA(&p->fbus2_outgoing_list_lock);
+ POPPA_UNLOCKA(&p->fbus2_outgoing_list_lock);
+ return list;
+}
+
+int celliax_serial_list_print_FBUS2(struct celliax_pvt *p, struct fbus2_msg *list)
+{
+ struct fbus2_msg *ptr;
+ ptr = list;
+ while (ptr) {
+ if (option_debug > 3)
+ DEBUGA_FBUS2
+ ("PTR msg is: %d, seqnum is %.2X, tv_sec is %d, tv_usec is %d, acknowledged is: %d,"
+ " sent is:%d, how_many_sent is: %d\n", CELLIAX_P_LOG, ptr->msg, ptr->seqnum,
+ ptr->tv_sec, ptr->tv_usec, ptr->acknowledged, ptr->sent, ptr->how_many_sent);
+ ptr = ptr->previous;
+ }
+ return 0;
+}
+
+int celliax_serial_read_FBUS2(struct celliax_pvt *p)
+{
+ int read_count;
+ int select_err;
+ fd_set read_fds;
+ struct timeval timeout;
+ int fbus_mesg = 0;
+ int i;
+
+ FD_ZERO(&read_fds);
+ FD_SET(p->controldevfd, &read_fds);
+ timeout.tv_sec = 0;
+ timeout.tv_usec = 50000;
+
+ if ((select_err = select(p->controldevfd + 1, &read_fds, NULL, NULL, &timeout)) > 0) {
+ timeout.tv_sec = 0; //reset the timeout, linux modify it
+ timeout.tv_usec = 50000; //reset the timeout, linux modify it
+ PUSHA_UNLOCKA(&p->controldev_lock);
+ LOKKA(&p->controldev_lock);
+ while ((select_err =
+ select(p->controldevfd + 1, &read_fds, NULL, NULL, &timeout)) > 0) {
+ gettimeofday(&p->fbus2_list_tv, &p->fbus2_list_tz);
+ read_count = read(p->controldevfd, p->rxm, 255);
+
+ if (read_count == 0) {
+ ERRORA
+ ("read 0 bytes!!! Nenormalno! Marking this celliax_serial_device %s as dead, andif it is owned by a channel, hanging up. Maybe the phone is stuck, switched off, power down or battery exhausted\n",
+ CELLIAX_P_LOG, p->controldevice_name);
+ p->controldev_dead = 1;
+ close(p->controldevfd);
+ UNLOCKA(&p->controldev_lock);
+ if (p->owner) {
+ celliax_queue_control(p->owner, AST_CONTROL_HANGUP);
+ p->owner->hangupcause = AST_CAUSE_FAILURE;
+ }
+ return -1;
+ }
+ if (option_debug > 10) {
+ int c;
+ char debug_buf[1024];
+ char *debug_buf_pos;
+
+ memset(debug_buf, 0, 1024);
+ debug_buf_pos = debug_buf;
+ for (c = 0; c < read_count; c++) {
+ debug_buf_pos += sprintf(debug_buf_pos, "[%.2X] ", p->rxm[c]);
+ if (debug_buf_pos > (char *) (&debug_buf + 1000))
+ break;
+ }
+ DEBUGA_FBUS2("%s READ AT seconds=%ld usec=%6ld read_count=%d\n", CELLIAX_P_LOG,
+ debug_buf, p->fbus2_list_tv.tv_sec, p->fbus2_list_tv.tv_usec,
+ read_count);
+ }
+
+ for (i = 0; i < read_count; i++) {
+ if (p->rxm[i] == FBUS2_DEVICE_PHONE && p->rxm[i - 1] == FBUS2_DEVICE_PC
+ && p->rxm[i - 2] == FBUS2_SERIAL_FRAME_ID) {
+ /* if we have identified the start of an fbus2 frame sent to us by the phone */
+ /* clean the array, copy into it the beginning of the frame, move the counter in the array after the last byte copied */
+ memset(p->array, 0, 255);
+ p->array[0] = FBUS2_SERIAL_FRAME_ID;
+ p->array[1] = FBUS2_DEVICE_PC;
+ p->arraycounter = 2;
+ }
+ if (p->rxm[i] == FBUS2_SERIAL_FRAME_ID && read_count == 1) { /* quick hack to try to identify the lone char
+ at the beginning a frame, often returned by
+ ark3116 based datacables */
+ /* if we have identified the start of an fbus2 frame sent to us by the phone */
+ /* clean the array, copy into it the beginning of the frame, move the counter in the array after the last byte copied */
+ memset(p->array, 0, 255);
+ p->arraycounter = 0;
+ }
+
+ /* continue copying into the array, until... */
+ p->array[p->arraycounter] = p->rxm[i];
+ /* we reach the end of the incoming frame, its lenght is in the p->array[5] byte, plus overhead */
+ if (p->arraycounter == p->array[5] + 7) {
+ /* start categorizing frames */
+ int seqnum;
+ int known = 0;
+
+ /* ACK frames are always of lenght 10, without padding */
+ seqnum = p->array[p->arraycounter - 2];
+ /* first step in categorizing frames, look at the general kind of frame, in p->array[3] */
+ switch (p->array[3]) {
+/****************************************************************/
+ case FBUS2_ACK_BYTE:
+ /* this is an ACKnowledgement frame sent to us in reply to an item we sent, take note we were ACKnowledged, no need to resend the item */
+ if (option_debug > 1)
+ DEBUGA_FBUS2("INCOMING ACK, seqack %.2X \n", CELLIAX_P_LOG, seqnum);
+ if (seqnum == 0x80) { /* reset */
+ seqnum = 0x00;
+ DEBUGA_FBUS2
+ ("seqack was 0x80, interpreting as 0x00, first acknowledgement (session begin?) of our first sent item 0x40\n",
+ CELLIAX_P_LOG);
+ }
+ /* an ACK frame has the same seqnum as the item it acknowledge, minus 0x40, so here we obtain the seqnum of the item that has been ACKnowledged */
+ fbus_mesg = seqnum + FBUS2_SEQNUM_MIN;
+ /* take note that the item sent was ACKnowledged, so no need to resend it */
+ celliax_serial_list_acknowledge_FBUS2(p, fbus_mesg);
+ /* this frame has been categorized, bail out from the loop */
+ known = 1;
+ break;
+/****************************************************************/
+ case FBUS2_TYPE_CALL_DIVERT:
+ if (option_debug > 1)
+ DEBUGA_FBUS2("CALL DIVERT SIGNALING seqnum %.2X \n", CELLIAX_P_LOG, seqnum);
+ fbus_mesg = FBUS2_TYPE_CALL_DIVERT;
+ /* this signal us that we have some settings in line divert, let's use it as activation of the line when we call */
+ if (p->interface_state == AST_STATE_DIALING) {
+ p->interface_state = AST_STATE_UP;
+ p->phone_callflow = CALLFLOW_CALL_ACTIVE;
+ ast_setstate(p->owner, AST_STATE_RINGING);
+ celliax_queue_control(p->owner, AST_CONTROL_ANSWER);
+ if (option_debug)
+ DEBUGA_FBUS2
+ ("call is active, I know it's not yet true, but 3310 do not give us remote answer signaling\n",
+ CELLIAX_P_LOG);
+ }
+ /* this frame has been categorized, bail out from the loop */
+ known = 1;
+ break;
+
+/****************************************************************/
+ /* this kind of frames is an answer to "ask model" actions */
+ case FBUS2_TYPE_MODEL_ANSWER:
+ if (1) {
+ int newline = 0;
+ int c = i = 0;
+ unsigned char model[10];
+ for (i = 10; i < p->arraycounter; i++) {
+ if (p->array[i] == '\n')
+ newline++;
+ if (newline == 2) {
+ if (p->array[i] != '\n') {
+ model[c] = p->array[i];
+ c++;
+ }
+ }
+ if (newline == 3) {
+ break;
+ }
+ if (c == 9)
+ break;
+ }
+ model[c] = '\0';
+ DEBUGA_FBUS2("FBUS2 PHONE MODEL is: %s, inseqnum %.2X \n", CELLIAX_P_LOG,
+ model, seqnum);
+ }
+ known = 1;
+ fbus_mesg = FBUS2_TYPE_MODEL_ANSWER;
+ break;
+/****************************************************************/
+ /* this kind of frames is an answer to "security enabled" actions */
+ case FBUS2_TYPE_SECURITY:
+ switch (p->array[8]) {
+ /* this subkind of frames is an answer to "security enabled" CALL actions */
+ case FBUS2_SECURIY_CALL_COMMANDS:
+ switch (p->array[9]) {
+ /* this sub-subkind of frames tell us that we answered the call */
+ case FBUS2_SECURIY_CALL_COMMAND_ANSWER:
+ p->interface_state = AST_STATE_UP;
+ p->phone_callflow = CALLFLOW_CALL_ACTIVE;
+
+ /* set the channel state to UP, we've answered */
+ if (ast_setstate(p->owner, AST_STATE_UP)) {
+ ERRORA("ast_setstate failed, BAD\n", CELLIAX_P_LOG);
+ }
+
+ if (option_debug > 1)
+ DEBUGA_FBUS2("ANSWERED CALL, inseqnum %.2X \n", CELLIAX_P_LOG, seqnum);
+ known = 1;
+ break;
+ /* this sub-subkind of frames tell us that we released the call */
+ case FBUS2_SECURIY_CALL_COMMAND_RELEASE:
+ p->interface_state = AST_STATE_DOWN;
+ p->phone_callflow = CALLFLOW_CALL_IDLE;
+ if (option_debug > 1)
+ DEBUGA_FBUS2("RELEASED CALL, inseqnum %.2X \n", CELLIAX_P_LOG, seqnum);
+ fbus_mesg = CALLFLOW_CALL_RELEASED;
+ known = 1;
+ break;
+ }
+ break;
+ /* this subkind of frames is an answer to "enable security commands" action */
+ case FBUS2_SECURIY_EXTENDED_COMMANDS:
+ if (option_debug > 1)
+ DEBUGA_FBUS2("SECURITY EXTENDED COMMANDS ON, inseqnum %.2X \n",
+ CELLIAX_P_LOG, seqnum);
+ fbus_mesg = FBUS2_SECURIY_EXTENDED_COMMAND_ON;
+ known = 1;
+ break;
+ /* this subkind of frames is an answer to "get IMEI" action */
+ case FBUS2_SECURIY_IMEI_COMMANDS:
+ if (option_debug > 1)
+ DEBUGA_FBUS2("CALLFLOW_GOT_IMEI, inseqnum %.2X \n", CELLIAX_P_LOG,
+ seqnum);
+ fbus_mesg = CALLFLOW_GOT_IMEI;
+ known = 1;
+ break;
+ }
+ break;
+/****************************************************************/
+ /* this kind of frames is about SMSs */
+ case FBUS2_TYPE_SMS:
+ switch (p->array[9]) {
+ /* this subkind of frames is about an INCOMING SMS */
+ case FBUS2_SMS_INCOMING:
+ if (option_debug > 1)
+ DEBUGA_FBUS2("SMS, inseqnum %.2X \n", CELLIAX_P_LOG, seqnum);
+ known = 1;
+ break;
+ }
+ break;
+/****************************************************************/
+ /* this kind of frames is about PHONE CALLs */
+ case FBUS2_TYPE_CALL:
+ switch (p->array[9]) {
+ int a;
+ /* this subkind of frame is about the CALL has been HUNGUP */
+ case FBUS2_CALL_HANGUP:
+ p->interface_state = AST_STATE_DOWN;
+ p->phone_callflow = CALLFLOW_CALL_IDLE;
+ if (option_debug > 1)
+ DEBUGA_FBUS2("REMOTE PARTY HANG UP, inseqnum %.2X \n", CELLIAX_P_LOG,
+ seqnum);
+ fbus_mesg = CALLFLOW_INCOMING_HANGUP;
+ known = 1;
+ break;
+ /* this subkind of frame is about the remote CALLID (not signaled by 3310) */
+ case FBUS2_CALL_CALLID:
+ if (option_debug > 1)
+ DEBUGA_FBUS2("CALLID, inseqnum %.2X \n", CELLIAX_P_LOG, seqnum);
+ memset(p->callid_name, 0, sizeof(p->callid_name));
+ memset(p->callid_number, 0, sizeof(p->callid_number));
+ for (a = 0; a < p->array[12]; a++) {
+ p->callid_number[a] = p->array[12 + a + 1];
+ }
+ for (a = 0; a < p->array[12 + 1 + p->array[12]] + 1; a++) {
+ p->callid_name[a] = p->array[12 + 1 + a + p->array[12] + 1];
+ }
+ if (option_debug > 1)
+ DEBUGA_FBUS2("CALLFLOW_INCOMING_CALLID: name is %s, number is %s\n",
+ CELLIAX_P_LOG,
+ p->callid_name[0] != 1 ? p->callid_name : "not available",
+ p->callid_number[0] ? p->callid_number : "not available");
+ fbus_mesg = CALLFLOW_INCOMING_CALLID;
+ p->phone_callflow = CALLFLOW_INCOMING_RING;
+ p->interface_state = AST_STATE_RING;
+ known = 1;
+ break;
+ }
+ break;
+/****************************************************************/
+ /* this kind of frames is about NETWORK STATUS */
+ case FBUS2_TYPE_NETWORK_STATUS:
+ switch (p->array[9]) {
+ /* this subkind of frames is NETWORK STATUS REGISTERED */
+ case FBUS2_NETWORK_STATUS_REGISTERED:
+ if (option_debug > 1)
+ DEBUGA_FBUS2("NETWORK STATUS REGISTERED, inseqnum %.2X \n", CELLIAX_P_LOG,
+ seqnum);
+ if (p->callid_name[0] == 0 && p->owner
+ && p->interface_state != AST_STATE_DOWN) {
+ p->interface_state = AST_STATE_DOWN;
+ p->phone_callflow = CALLFLOW_CALL_IDLE;
+ if (option_debug)
+ NOTICA("We think we are using a nokia3310, so NETWORK STATUS REGISTERED"
+ " is interpreted as REMOTE PARTY HANG UP during a call, because"
+ " Nokia 3310 give no hint about remote hangup. Nokia 3310"
+ " does not signal the CALLID, while other nokias at least put"
+ " callid_name[0]=1 (also if no callid was transmitted by remote"
+ " party), we use this lack of CALLID as a sign of 3310nness."
+ " Outside a call, or when CALLID has been signaled, NETWORK STATUS"
+ " REGISTERED is ignored.\n", CELLIAX_P_LOG);
+ fbus_mesg = CALLFLOW_INCOMING_HANGUP;
+ }
+ known = 1;
+ break;
+ }
+ break;
+/****************************************************************/
+ /* this kind of frames is about CALL STATUS */
+ case FBUS2_TYPE_CALL_STATUS:
+ switch (p->array[12]) {
+ /* this subkind of frames is about CALL STATUS OFF */
+ case FBUS2_CALL_STATUS_OFF:
+ p->interface_state = AST_STATE_DOWN;
+ p->phone_callflow = CALLFLOW_CALL_IDLE;
+ if (option_debug > 1)
+ DEBUGA_FBUS2("STATUS call in progress OFF, inseqnum %.2X \n",
+ CELLIAX_P_LOG, seqnum);
+ fbus_mesg = CALLFLOW_INCOMING_HANGUP;
+ known = 1;
+ break;
+ /* this subkind of frames is about CALL STATUS ON */
+ case FBUS2_CALL_STATUS_ON:
+ if (option_debug > 1)
+ DEBUGA_FBUS2("STATUS call in progress ON, inseqnum %.2X \n",
+ CELLIAX_P_LOG, seqnum);
+ known = 1;
+ break;
+ }
+/****************************************************************/
+ break;
+ }
+
+ /* categorization of frame is ended, if it has not been recognized, whine */
+ if (!known) {
+ WARNINGA("FBUS2 MSG UNKNOWN, inseqnum %.2X\n", CELLIAX_P_LOG, seqnum);
+ }
+
+ /* let's print our frame */
+ if (option_debug > 1) {
+ int i;
+ char debug_buf[1024];
+ char *debug_buf_pos;
+
+ memset(debug_buf, 0, 1024);
+ debug_buf_pos = debug_buf;
+ for (i = 0; i < p->arraycounter + 1; i++) {
+ debug_buf_pos += sprintf(debug_buf_pos, "[%.2X] ", p->array[i]);
+ if (debug_buf_pos > (char *) (&debug_buf + 1000))
+ break;
+ }
+ DEBUGA_FBUS2("%s is the RECEIVED FRAME inseqnum %.2X\n", CELLIAX_P_LOG,
+ debug_buf, seqnum);
+ }
+
+ /* if the frame we received is not an ACK frame, let's ACKnowledge it */
+ if (p->array[0] == FBUS2_SERIAL_FRAME_ID && p->array[3] != FBUS2_ACK_BYTE) {
+ celliax_serial_send_ack_FBUS2(p, p->array[3], seqnum);
+ }
+ }
+ p->arraycounter++;
+ }
+ }
+ UNLOCKA(&p->controldev_lock);
+ POPPA_UNLOCKA(&p->controldev_lock);
+ }
+ /* oooops, select returned error, got a kill/cancel or problems with the serial file descriptor */
+ if (select_err == -1) {
+ if (errno != EINTR) {
+ ERRORA
+ ("select returned -1 on %s, marking controldev as dead, errno was: %d, error was: %s\n",
+ CELLIAX_P_LOG, p->controldevice_name, errno, strerror(errno));
+ p->controldev_dead = 1;
+ close(p->controldevfd);
+ if (p->owner)
+ celliax_queue_control(p->owner, AST_CONTROL_HANGUP);
+ return -1;
+ } else {
+ WARNINGA("select returned -1 on %s, errno was: %d, EINTR, error was: %s\n",
+ CELLIAX_P_LOG, p->controldevice_name, errno, strerror(errno));
+ return 0;
+ }
+ }
+ /* OK, reading done, let's browse the list of pending frames to be sent, and act on it */
+ if (celliax_serial_send_if_time_FBUS2(p)) {
+ ERRORA("celliax_serial_send_if_time_FBUS2 failed!\n", CELLIAX_P_LOG);
+ return -1;
+ }
+
+ if (fbus_mesg == CALLFLOW_INCOMING_HANGUP) {
+ if (p->owner) {
+ celliax_queue_control(p->owner, AST_CONTROL_HANGUP);
+ DEBUGA_FBUS2("phone call ended\n", CELLIAX_P_LOG);
+ }
+ }
+
+ return fbus_mesg; //FIXME breaks the convention of returning 0 on success
+}
+
+#endif /* CELLIAX_FBUS2 */
+
+#ifdef CELLIAX_CVM
+
+int celliax_serial_sync_CVM_BUSMAIL(struct celliax_pvt *p)
+{
+ usleep(1000); /* 1msec */
+ time(&p->celliax_serial_synced_timestamp);
+ return 0;
+}
+
+int celliax_serial_answer_CVM_BUSMAIL(struct celliax_pvt *p)
+{
+ if (AST_STATE_RING == p->interface_state) {
+ DEBUGA_CVM("Sending commands to answer an incomming call...\n", CELLIAX_P_LOG);
+ celliax_serial_send_info_frame_CVM_BUSMAIL(p, API_PP_CONNECT_REQ, 0, NULL);
+
+ } else {
+ DEBUGA_CVM
+ ("SKIPPING Sending commands to answer an incomming call, because: !AST_STATE_RING\n",
+ CELLIAX_P_LOG);
+ }
+
+ return 0;
+}
+
+int celliax_serial_call_CVM_BUSMAIL(struct celliax_pvt *p, char *dstr)
+{
+ unsigned char bCallType = 0x01; /* INTERNAL */
+
+ unsigned char DialReqBuff[2];
+
+ celliax_serial_send_info_frame_CVM_BUSMAIL(p, API_PP_SETUP_REQ, sizeof(bCallType),
+ &bCallType);
+
+ while (AST_STATE_DOWN == p->interface_state) {
+ usleep(10000); //10msec
+ }
+
+ if (AST_STATE_DIALING == p->interface_state) {
+ /* as for now, we only support internal calls */
+ /* "0" - call speaker phone */
+ /* "1" - call handset #1 */
+ /* "2" - call handset #2 */
+ /* ... */
+
+ DialReqBuff[0] = 1; /* number of digits to send */
+ DialReqBuff[1] = dstr[0]; /* digit to send */
+
+ celliax_serial_send_info_frame_CVM_BUSMAIL(p, API_PP_KEYPAD_REQ, 2, DialReqBuff);
+ }
+
+ if (option_debug)
+ NOTICA("CVM_BUSMAIL: sent commands to call\n", CELLIAX_P_LOG);
+ return 0;
+}
+
+int celliax_serial_hangup_CVM_BUSMAIL(struct celliax_pvt *p)
+{
+ unsigned char bReason = 0x0; /* Normal hang-up */
+
+ if (p->interface_state != AST_STATE_DOWN) {
+ celliax_serial_send_info_frame_CVM_BUSMAIL(p, API_PP_RELEASE_REQ, sizeof(bReason),
+ &bReason);
+
+ DEBUGA_CVM("CVM_BUSMAIL: sent commands to hangup the call\n", CELLIAX_P_LOG);
+
+ } else {
+ DEBUGA_CVM("CVM_BUSMAIL: sent commands to hangup skipped because: AST_STATE_DOWN\n",
+ CELLIAX_P_LOG);
+ }
+
+ return 0;
+}
+
+int celliax_serial_config_CVM_BUSMAIL(struct celliax_pvt *p)
+{
+ int res;
+ int how_many_reads = 0;
+ unsigned char SubcriptionNo = p->cvm_subsc_no;
+ unsigned char RegistartionData[5];
+
+ p->cvm_lock_state = CVM_UNKNOWN_LOCK_STATE;
+ p->cvm_register_state = CVM_UNKNOWN_REGISTER_STATE;
+
+ PUSHA_UNLOCKA(&p->controldev_lock);
+ CVM_LOKKA(&p->controldev_lock);
+
+ if (option_debug > 1)
+ DEBUGA_CVM("Try to init communication with CVM...\n", CELLIAX_P_LOG);
+
+ /* CVM after reset sends SABM CTRL frame, let's assume that CVM already sent it, that's the reply... */
+ celliax_serial_send_ctrl_frame_CVM_BUSMAIL(p,
+ BUSMAIL_HEADER_CTRL_FRAME |
+ BUSMAIL_HEADER_CTRL_UN_FRAME |
+ BUSMAIL_HEADER_UNID_SABM);
+ /* usleep(10000); *//* 10ms */
+
+ /* Now we are sending SABM CTRL frame, if CVM is out there, it should reply... */
+ celliax_serial_send_ctrl_frame_CVM_BUSMAIL(p,
+ BUSMAIL_HEADER_CTRL_FRAME |
+ BUSMAIL_HEADER_CTRL_UN_FRAME |
+ BUSMAIL_HEADER_UNID_SABM |
+ (BUSMAIL_HEADER_PF_BIT_MASK & 0xFF));
+// usleep(1000);
+
+ res = celliax_serial_read_CVM_BUSMAIL(p); //we don't have no monitor neither do_controldev_thread
+
+ DEBUGA_CVM("celliax_serial_read_CVM_BUSMAIL res= %X, expected %X\n", CELLIAX_P_LOG, res,
+ (BUSMAIL_HEADER_CTRL_FRAME | BUSMAIL_HEADER_CTRL_UN_FRAME |
+ BUSMAIL_HEADER_SABM));
+
+ if (res == -1) {
+ ERRORA("failed celliax_serial_read_CVM_BUSMAIL\n", CELLIAX_P_LOG);
+ CVM_UNLOCKA(&p->controldev_lock);
+ return -1;
+ }
+
+ how_many_reads = 0;
+
+ while ((res & 0xF0) !=
+ (BUSMAIL_HEADER_CTRL_FRAME | BUSMAIL_HEADER_CTRL_UN_FRAME | BUSMAIL_HEADER_SABM))
+ {
+
+ usleep(1000);
+ res = celliax_serial_read_CVM_BUSMAIL(p);
+ how_many_reads++;
+
+ if (res == -1) {
+ ERRORA("failed celliax_serial_read_CVM_BUSMAIL\n", CELLIAX_P_LOG);
+ CVM_UNLOCKA(&p->controldev_lock);
+ return -1;
+ }
+
+ if (how_many_reads > 10) {
+ ERRORA("no expected results in %d celliax_serial_read_CVM_BUSMAIL\n", CELLIAX_P_LOG,
+ how_many_reads);
+
+ ERRORA("Unable to initialize cmmunication with CVM...\n", CELLIAX_P_LOG);
+
+ CVM_UNLOCKA(&p->controldev_lock);
+ return -1;
+ }
+ }
+
+ DEBUGA_CVM("Communication with CVM initialized successfully...\n", CELLIAX_P_LOG);
+
+ DEBUGA_CVM("Attempt to lock to FP...\n", CELLIAX_P_LOG);
+
+ /* Try to connect to FP, try to lock to FP, maybe we registered with it in the past... */
+ /* CVM can hold up to 2 subscriptions in its EEPROM, celliax.conf contains number we should try */
+ /* eg. cvm_subscription_no = 1 */
+
+ celliax_serial_send_info_frame_CVM_BUSMAIL(p, API_PP_LOCK_REQ, sizeof(SubcriptionNo),
+ &SubcriptionNo);
+
+ usleep(10000);
+
+ res = celliax_serial_read_CVM_BUSMAIL(p); //we don't have no monitor neither do_controldev_thread
+
+ if (res == -1) {
+ ERRORA("failed celliax_serial_read_CVM_BUSMAIL\n", CELLIAX_P_LOG);
+ CVM_UNLOCKA(&p->controldev_lock);
+ return -1;
+ }
+
+ how_many_reads = 0;
+
+ while (CVM_UNKNOWN_LOCK_STATE == p->cvm_lock_state) {
+
+/*
+ if (0 == (how_many_reads % 10))
+ {
+ DEBUGA_CVM("Attempt to lock to FP... %d\n", CELLIAX_P_LOG, how_many_reads/10 );
+ celliax_serial_send_info_frame_CVM_BUSMAIL(p, API_PP_LOCK_REQ, sizeof(SubcriptionNo) ,&SubcriptionNo);
+ }
+*/
+
+ usleep(100000);
+
+ res = celliax_serial_read_CVM_BUSMAIL(p);
+ how_many_reads++;
+
+ if (res == -1) {
+ ERRORA("failed celliax_serial_read_CVM_BUSMAIL\n", CELLIAX_P_LOG);
+ CVM_UNLOCKA(&p->controldev_lock);
+ return -1;
+ }
+
+ if (how_many_reads > 50) {
+ ERRORA("no expected results in %d celliax_serial_read_CVM_BUSMAIL\n", CELLIAX_P_LOG,
+ how_many_reads);
+
+ ERRORA("Unable to lock to FP...\n", CELLIAX_P_LOG);
+ break;
+ }
+ }
+
+ if (CVM_LOCKED_TO_FP == p->cvm_lock_state) {
+ DEBUGA_CVM("CVM locked to FP successfully...\n", CELLIAX_P_LOG);
+ } else {
+ DEBUGA_CVM("Lock to FP failed, Attempt to register to FP...\n", CELLIAX_P_LOG);
+
+ RegistartionData[0] = SubcriptionNo;
+ RegistartionData[1] = 0xFF;
+ RegistartionData[2] = 0xFF;
+
+ if (1 == SubcriptionNo) {
+ RegistartionData[3] =
+ (((p->cvm_subsc_1_pin[3] - 0x30) & 0x0F) << 4) | ((p->cvm_subsc_1_pin[2] -
+ 0x30) & 0x0F);
+ RegistartionData[4] =
+ (((p->cvm_subsc_1_pin[1] - 0x30) & 0x0F) << 4) | ((p->cvm_subsc_1_pin[0] -
+ 0x30) & 0x0F);
+ } else {
+ RegistartionData[3] =
+ (((p->cvm_subsc_2_pin[3] - 0x30) & 0x0F) << 4) | ((p->cvm_subsc_2_pin[2] -
+ 0x30) & 0x0F);
+ RegistartionData[4] =
+ (((p->cvm_subsc_2_pin[1] - 0x30) & 0x0F) << 4) | ((p->cvm_subsc_2_pin[0] -
+ 0x30) & 0x0F);
+ }
+
+ celliax_serial_send_info_frame_CVM_BUSMAIL(p, API_PP_ACCESS_RIGHTS_REQ,
+ sizeof(RegistartionData),
+ RegistartionData);
+
+ usleep(100000);
+
+ res = celliax_serial_read_CVM_BUSMAIL(p); //we don't have no monitor neither do_controldev_thread
+
+ if (res == -1) {
+ ERRORA("failed celliax_serial_read_CVM_BUSMAIL\n", CELLIAX_P_LOG);
+ CVM_UNLOCKA(&p->controldev_lock);
+ return -1;
+ }
+
+ how_many_reads = 0;
+
+ while (CVM_UNKNOWN_REGISTER_STATE == p->cvm_register_state) {
+
+ if (0 == (how_many_reads % 50)) {
+ DEBUGA_CVM("Attempt to register to FP... %d\n", CELLIAX_P_LOG,
+ how_many_reads / 10);
+ celliax_serial_send_info_frame_CVM_BUSMAIL(p, API_PP_ACCESS_RIGHTS_REQ,
+ sizeof(RegistartionData),
+ RegistartionData);
+ }
+
+ /* up to 5 minutes for registration.... */
+ usleep(1000000);
+ res = celliax_serial_read_CVM_BUSMAIL(p);
+ how_many_reads++;
+
+ if (res == -1) {
+ ERRORA("failed celliax_serial_read_CVM_BUSMAIL\n", CELLIAX_P_LOG);
+ CVM_UNLOCKA(&p->controldev_lock);
+ return -1;
+ }
+
+ if (how_many_reads > 300) {
+ ERRORA("no expected results in %d celliax_serial_read_CVM_BUSMAIL\n",
+ CELLIAX_P_LOG, how_many_reads);
+
+ ERRORA("Unable to communication with CVM...\n", CELLIAX_P_LOG);
+
+ CVM_UNLOCKA(&p->controldev_lock);
+ return -1;
+ }
+ }
+
+ if (CVM_REGISTERED_TO_FP != p->cvm_register_state) {
+ ERRORA("Unable to register to FP...\n", CELLIAX_P_LOG);
+
+ CVM_UNLOCKA(&p->controldev_lock);
+ return -1;
+
+ } else {
+ DEBUGA_CVM("CVM registered to FP successfully...\n", CELLIAX_P_LOG);
+ DEBUGA_CVM("Attempt to lock to FP...\n", CELLIAX_P_LOG);
+
+ /* Try to connect to FP, try to lock to FP, maybe we registered with it in the past... */
+ /* CVM can hold up to 2 subscriptions in its EEPROM, celliax.conf contains number we should try */
+ /* eg. cvm_subscription_no = 1 */
+
+ celliax_serial_send_info_frame_CVM_BUSMAIL(p, API_PP_LOCK_REQ,
+ sizeof(SubcriptionNo), &SubcriptionNo);
+
+ usleep(10000);
+
+ res = celliax_serial_read_CVM_BUSMAIL(p); //we don't have no monitor neither do_controldev_thread
+
+ if (res == -1) {
+ ERRORA("failed celliax_serial_read_CVM_BUSMAIL\n", CELLIAX_P_LOG);
+ CVM_UNLOCKA(&p->controldev_lock);
+ return -1;
+ }
+
+ how_many_reads = 0;
+
+ while (CVM_UNKNOWN_LOCK_STATE == p->cvm_lock_state) {
+
+ if (0 == (how_many_reads % 10)) {
+ DEBUGA_CVM("Attempt to lock to FP... %d\n", CELLIAX_P_LOG, how_many_reads / 10);
+ celliax_serial_send_info_frame_CVM_BUSMAIL(p, API_PP_ACCESS_RIGHTS_REQ,
+ sizeof(RegistartionData),
+ RegistartionData);
+ }
+
+ usleep(10000);
+ res = celliax_serial_read_CVM_BUSMAIL(p);
+ how_many_reads++;
+
+ if (res == -1) {
+ ERRORA("failed celliax_serial_read_CVM_BUSMAIL\n", CELLIAX_P_LOG);
+ CVM_UNLOCKA(&p->controldev_lock);
+ return -1;
+ }
+
+ if (how_many_reads > 100) {
+ ERRORA("no expected results in %d celliax_serial_read_CVM_BUSMAIL\n",
+ CELLIAX_P_LOG, how_many_reads);
+
+ ERRORA("Unable to communication with CVM...\n", CELLIAX_P_LOG);
+
+ CVM_UNLOCKA(&p->controldev_lock);
+ return -1;
+ }
+ }
+
+ if (CVM_LOCKED_TO_FP != p->cvm_lock_state) {
+ ERRORA("Unable to lock to FP...\n", CELLIAX_P_LOG);
+
+ CVM_UNLOCKA(&p->controldev_lock);
+ return -1;
+ } else {
+ DEBUGA_CVM("CVM locked to FP successfully...\n", CELLIAX_P_LOG);
+ }
+ }
+ }
+
+ usleep(100000);
+
+ CVM_UNLOCKA(&p->controldev_lock);
+ POPPA_UNLOCKA(&p->controldev_lock);
+ return 0;
+
+}
+
+int celliax_serial_read_CVM_BUSMAIL(struct celliax_pvt *p)
+{
+ int read_count;
+ int select_err;
+ fd_set read_fds;
+ struct timeval timeout;
+ int cvm_busmail_mesg = 0;
+ unsigned char busmail_crc = 0;
+ unsigned char MsgCrc = 0;
+ unsigned char MsgHeader = 0;
+ unsigned char MsgTxSeqNo = 0;
+ unsigned char MsgRxSeqNo = 0;
+ unsigned char MsgTaskId = 0;
+ unsigned char MsgProgId = 0;
+ unsigned char MsgPrimitiveLSB = 0;
+ unsigned char MsgPrimitiveMSB = 0;
+ unsigned int MsgPrimitive = 0;
+
+ int i = 0;
+
+ FD_ZERO(&read_fds);
+ FD_SET(p->controldevfd, &read_fds);
+ timeout.tv_sec = 0;
+ timeout.tv_usec = 10000;
+
+ if ((select_err = select(p->controldevfd + 1, &read_fds, NULL, NULL, &timeout)) > 0) {
+ timeout.tv_sec = 0; //reset the timeout, linux modify it
+ timeout.tv_usec = 10000; //reset the timeout, linux modify it
+ PUSHA_UNLOCKA(&p->controldev_lock);
+ CVM_LOKKA(&p->controldev_lock);
+
+ while ((select_err =
+ select(p->controldevfd + 1, &read_fds, NULL, NULL, &timeout)) > 0) {
+ gettimeofday(&p->cvm_busmail_list_tv, &p->cvm_busmail_list_tz);
+ read_count = read(p->controldevfd, p->rxm, 255);
+
+ if (read_count == 0) {
+ ERRORA
+ ("read 0 bytes!!! Nenormalno! Marking this celliax_serial_device %s as dead, andif it is owned by a channel, hanging up. Maybe the CVM is stuck, switched off or power down.\n",
+ CELLIAX_P_LOG, p->controldevice_name);
+
+ p->controldev_dead = 1;
+ close(p->controldevfd);
+ CVM_UNLOCKA(&p->controldev_lock);
+
+ if (p->owner)
+ celliax_queue_control(p->owner, AST_CONTROL_HANGUP);
+ return -1;
+ }
+
+ if (option_debug > 10) {
+ char debug_buf[1024];
+ char *debug_buf_pos;
+
+ memset(debug_buf, 0, 1024);
+ debug_buf_pos = debug_buf;
+ for (i = 0; i < read_count; i++) {
+ debug_buf_pos += sprintf(debug_buf_pos, "[%.2X] ", p->rxm[i]);
+ if (debug_buf_pos > (char *) (&debug_buf + 1000))
+ break;
+ }
+
+ DEBUGA_CVM("%s READ AT seconds=%ld usec=%6ld read_count=%d\n", CELLIAX_P_LOG,
+ debug_buf, p->cvm_busmail_list_tv.tv_sec,
+ p->cvm_busmail_list_tv.tv_usec, read_count);
+ }
+
+ for (i = 0; i < read_count; i++) {
+ if (p->rxm[i] == BUSMAIL_SOF) {
+ /* if we have identified the start of an busmail frame sent to us by the CVM */
+ /* clean the array, copy into it the beginning of the frame, move the counter in the array after the last byte copied */
+ memset(p->array, 0, 255);
+ p->array[0] = p->rxm[i];
+ p->arraycounter = 1;
+ }
+
+ /* buffer overload protection */
+ if (255 == p->arraycounter) {
+ p->arraycounter = 1;
+ }
+
+ /* continue copying into the array, until... */
+ p->array[p->arraycounter - 1] = p->rxm[i];
+
+ /* we reach the end of the incoming frame, its lenght is in the p->array[BUSMAIL_OFFSET_LEN_LSB] byte, plus overhead */
+ if (p->arraycounter == p->array[BUSMAIL_OFFSET_LEN_LSB] + 4) {
+
+ tcflush(p->controldevfd, TCIFLUSH); /* PL2303HX bug? */
+ /* start categorizing frames */
+
+ if (option_debug > 10) {
+ char debug_buf[1024];
+ char *debug_buf_pos;
+
+ memset(debug_buf, 0, 1024);
+ debug_buf_pos = debug_buf;
+
+ for (i = 0; i < p->arraycounter; i++) {
+ debug_buf_pos += sprintf(debug_buf_pos, "[%.2X] ", p->array[i]);
+ if (debug_buf_pos > (char *) (&debug_buf + 1000))
+ break;
+ }
+
+ DEBUGA_CVM("%s was received, Starting to categorize this frame\n",
+ CELLIAX_P_LOG, debug_buf);
+ }
+
+ int known = 0;
+ int j = 0;
+
+ busmail_crc = 0;
+ MsgCrc = p->array[p->arraycounter - 1];
+
+ busmail_crc = (unsigned char) (p->array[BUSMAIL_OFFSET_HEADER] + busmail_crc);
+
+ for (j = BUSMAIL_OFFSET_MAIL; j < (p->arraycounter - 1); j++) {
+ busmail_crc = (unsigned char) (p->array[j] + busmail_crc);
+ }
+
+ if (busmail_crc != MsgCrc) {
+ WARNINGA("BUSMAIL MSG CRC FAILED!, MsgCrc %.2X, calcd %.2X, dropping frame\n",
+ CELLIAX_P_LOG, MsgCrc, busmail_crc);
+ } else {
+ /* first step in categorizing frames, look at the general kind of frame, in p->array[BUSMAIL_OFFSET_HEADER] */
+ if (option_debug > 1)
+ DEBUGA_CVM("BUSMAIL MSG CRC, MsgCrc %.2X, calcd %.2X...\n", CELLIAX_P_LOG,
+ MsgCrc, busmail_crc);
+
+ MsgHeader = p->array[BUSMAIL_OFFSET_HEADER];
+ cvm_busmail_mesg = MsgHeader;
+
+ switch (MsgHeader & BUSMAIL_HEADER_IC_BIT_MASK) {
+ case BUSMAIL_HEADER_INFO_FRAME:
+ /* analyzis of frame header */
+ MsgTxSeqNo = ((MsgHeader & BUSMAIL_HEADER_TXSEQ_MASK) >> 4);
+ MsgRxSeqNo = ((MsgHeader & BUSMAIL_HEADER_RXSEQ_MASK));
+
+ if (option_debug > 1)
+ DEBUGA_CVM("BUSMAIL_HEADER_INFO_FRAME TxSeq %X, RxSeq %X\n",
+ CELLIAX_P_LOG, MsgTxSeqNo, MsgRxSeqNo);
+
+ if (((p->busmail_rxseq_cvm_last + 1) & 0x7) != MsgTxSeqNo) {
+ /* some CVM frames are missing, TxSeq of this frame is higher then expected */
+ /* reject, I expected p->busmail_rxseq_cvm_last + 1, resend it to me, please */
+
+ WARNINGA("CVM TxSeq %X, does not match expected value %X\n",
+ CELLIAX_P_LOG, MsgTxSeqNo,
+ (p->busmail_rxseq_cvm_last + 1) & 0x7);
+
+// celliax_serial_send_ctrl_frame_CVM_BUSMAIL(p, BUSMAIL_HEADER_CTRL_FRAME | BUSMAIL_HEADER_CTRL_SU_FRAME | BUSMAIL_HEADER_SUID_REJ);
+
+ if (((p->busmail_rxseq_cvm_last) & 0x7) == MsgTxSeqNo) {
+
+ WARNINGA
+ ("It looks like our ACK to this frame was MIA :), lets ACK the frame one more time...\n",
+ CELLIAX_P_LOG);
+
+ /* if the frame we received informs us that other side is waiting for ACK, let's ACK it */
+ /* even if it is unknown to us */
+ if (p->array[BUSMAIL_OFFSET_HEADER] & BUSMAIL_HEADER_PF_BIT_MASK) {
+ if (BUSMAIL_HEADER_SABM ==
+ (p->array[BUSMAIL_OFFSET_HEADER] & BUSMAIL_HEADER_SABM_MASK)) {
+ celliax_serial_send_ctrl_frame_CVM_BUSMAIL(p, (unsigned char)
+ (BUSMAIL_HEADER_CTRL_FRAME | BUSMAIL_HEADER_CTRL_UN_FRAME | BUSMAIL_HEADER_UNID_SABM));
+ } else {
+ celliax_serial_send_ctrl_frame_CVM_BUSMAIL(p, (unsigned char)
+ (BUSMAIL_HEADER_CTRL_FRAME | BUSMAIL_HEADER_CTRL_SU_FRAME | BUSMAIL_HEADER_SUID_RR));
+ }
+ }
+ }
+
+ break;
+ } else {
+ /* we expected packet with this seq no. */
+ /* CVM ACKed our frames with info frame */
+ celliax_serial_list_acknowledge_CVM_BUSMAIL(p, MsgRxSeqNo);
+
+ /* save it but limit it to 3 bits only (valid values: 0-7) */
+ p->busmail_rxseq_cvm_last = MsgTxSeqNo;
+ p->busmail_rxseq_cvm_last &= 0x7;
+
+ /* if the frame we received informs us that other side is waiting for ACK, let's ACK it */
+ /* even if it is unknown to us */
+ if (p->array[BUSMAIL_OFFSET_HEADER] & BUSMAIL_HEADER_PF_BIT_MASK) {
+ if (BUSMAIL_HEADER_SABM ==
+ (p->array[BUSMAIL_OFFSET_HEADER] & BUSMAIL_HEADER_SABM_MASK)) {
+ celliax_serial_send_ctrl_frame_CVM_BUSMAIL(p, (unsigned char)
+ (BUSMAIL_HEADER_CTRL_FRAME
+ |
+ BUSMAIL_HEADER_CTRL_UN_FRAME
+ |
+ BUSMAIL_HEADER_UNID_SABM));
+ } else {
+ celliax_serial_send_ctrl_frame_CVM_BUSMAIL(p, (unsigned char)
+ (BUSMAIL_HEADER_CTRL_FRAME
+ |
+ BUSMAIL_HEADER_CTRL_SU_FRAME
+ |
+ BUSMAIL_HEADER_SUID_RR));
+ }
+ }
+
+ }
+
+ /* frame header OK, let's see what's inside mail field */
+ MsgTaskId = p->array[BUSMAIL_OFFSET_MAIL_TASK_ID];
+ MsgProgId = p->array[BUSMAIL_OFFSET_MAIL_PROGRAM_ID];
+ MsgPrimitiveLSB = p->array[BUSMAIL_OFFSET_MAIL_PRIMITIVE_LSB];
+ MsgPrimitiveMSB = p->array[BUSMAIL_OFFSET_MAIL_PRIMITIVE_MSB];
+ MsgPrimitive = MsgPrimitiveMSB << 8 | MsgPrimitiveLSB;
+
+ if (option_debug > 1)
+ DEBUGA_CVM
+ ("BUSMAIL_HEADER_INFO_FRAME ProgId %X, TaskId %X, Primitive %X %X\n",
+ CELLIAX_P_LOG, MsgProgId, MsgTaskId, MsgPrimitiveMSB, MsgPrimitiveLSB);
+
+ switch (MsgPrimitive) {
+
+ case API_PP_ACCESS_RIGHTS_REJ:
+ /* FP rejected our registration... */
+ WARNINGA("API_PP_ACCESS_RIGHTS_REJ, FP rejected our registration...\n",
+ CELLIAX_P_LOG);
+
+ p->cvm_register_state = CVM_UNREGISTERED_TO_FP;
+ p->cvm_lock_state = CVM_UNKNOWN_LOCK_STATE;
+ known = 1;
+ break;
+
+ case API_PP_ACCESS_RIGHTS_CFM:
+ /* FP accepted our registration... */
+ if (option_debug > 1)
+ DEBUGA_CVM
+ ("API_PP_ACCESS_RIGHTS_CFM, FP accepted our registration...\n",
+ CELLIAX_P_LOG);
+
+ p->cvm_register_state = CVM_REGISTERED_TO_FP;
+ p->cvm_lock_state = CVM_UNKNOWN_LOCK_STATE;
+ p->cvm_handset_no = p->array[BUSMAIL_OFFSET_MAIL_PARAMS + 0];
+ p->cvm_fp_is_cvm = p->array[BUSMAIL_OFFSET_MAIL_PARAMS + 1];
+
+ if (option_debug > 1)
+ DEBUGA_CVM
+ ("API_PP_ACCESS_RIGHTS_CFM, FP accepted our registration, Our handset no. is %d, CVM? %X\n",
+ CELLIAX_P_LOG, p->cvm_handset_no, p->cvm_fp_is_cvm);
+
+ known = 1;
+ break;
+
+ case API_PP_LOCKED_IND:
+ /* CVM is connected to FP */
+ if (option_debug > 1)
+ DEBUGA_CVM("API_PP_LOCKED_IND, Connection to FP completed...\n",
+ CELLIAX_P_LOG);
+
+ p->cvm_register_state = CVM_REGISTERED_TO_FP;
+ p->cvm_lock_state = CVM_LOCKED_TO_FP;
+ known = 1;
+ break;
+
+ case API_PP_UNLOCKED_IND:
+ /* CVM is unlocked with FP, Out of service */
+ WARNINGA
+ ("API_PP_UNLOCKED_IND, CVM is unlocked with FP, Out of service !!!\n",
+ CELLIAX_P_LOG);
+
+ p->cvm_lock_state = CVM_UNLOCKED_TO_FP;
+ known = 1;
+ break;
+
+ case API_PP_SETUP_ACK_IND:
+ /* Outgoing call, connection to FP established, FP is waiting for a number to dial */
+ if (option_debug > 1)
+ DEBUGA_CVM
+ ("API_PP_SETUP_ACK_IND, connection to FP established, FP is waiting for a numer to dial...\n",
+ CELLIAX_P_LOG);
+
+ if (AST_STATE_DOWN == p->interface_state) {
+ p->interface_state = AST_STATE_DIALING;
+ }
+
+ known = 1;
+ break;
+
+ case API_PP_ALERT_IND:
+ /* Outgoing call, Remote end is ringing */
+ if (option_debug > 1)
+ DEBUGA_CVM("API_PP_ALERT_IND, remote end is ringing...\n",
+ CELLIAX_P_LOG);
+
+ if (AST_STATE_DIALING == p->interface_state) {
+ p->interface_state = AST_STATE_RINGING;
+ }
+
+ known = 1;
+ break;
+
+ case API_PP_CONNECT_IND:
+ /* Outgoing call, the remote end answered our call */
+ if (option_debug > 1)
+ DEBUGA_CVM("API_PP_CONNECT_IND, our call was answered...\n",
+ CELLIAX_P_LOG);
+
+ if (AST_STATE_RINGING == p->interface_state) {
+
+ /* let's open audio and have a chat */
+ celliax_serial_send_info_frame_CVM_BUSMAIL(p, CVM_PP_AUDIO_OPEN_REQ, 0,
+ NULL);
+
+ unsigned char volume = (unsigned char) p->cvm_volume_level;
+ celliax_serial_send_info_frame_CVM_BUSMAIL(p,
+ CVM_PP_AUDIO_SET_VOLUME_REQ,
+ sizeof(volume), &volume);
+
+ /* let's unmute mic and have a chat */
+ celliax_serial_send_info_frame_CVM_BUSMAIL(p,
+ CVM_PP_AUDIO_UNMUTE_MIC_REQ,
+ 0, NULL);
+
+ /* let's switch to headset, because we fried normal output.... */
+/* unsigned char headset_on = (unsigned char) 1;
+ celliax_serial_send_info_frame_CVM_BUSMAIL(p, CVM_PP_AUDIO_HS_PLUG_IND, sizeof(headset_on), &headset_on);
+*/
+ p->interface_state = AST_STATE_UP;
+ ast_setstate(p->owner, AST_STATE_RINGING);
+ celliax_queue_control(p->owner, AST_CONTROL_ANSWER);
+ }
+
+ known = 1;
+ break;
+
+ case API_PP_REJECT_IND:
+ /* Outgoing/Incoming call, FP rejected our connection... */
+ if (option_debug > 1)
+ DEBUGA_CVM
+ ("API_PP_REJECT_IND, FP or ther PP rejected our connection...\n",
+ CELLIAX_P_LOG);
+
+ if (AST_STATE_RING == p->interface_state && p->owner) {
+ /* Attempt to answer incoming call rejected by FP or PP */
+ if (option_debug > 1)
+ DEBUGA_CVM("Was it PAGE_ALL CALL, that we should not answered?\n",
+ CELLIAX_P_LOG);
+
+ p->interface_state = AST_STATE_DOWN;
+ celliax_queue_control(p->owner, AST_CONTROL_HANGUP);
+
+ } else if (AST_STATE_DOWN != p->interface_state && p->owner) {
+ /* Outgoing call rejected by other PP or FP */
+ p->interface_state = AST_STATE_BUSY;
+ ast_setstate(p->owner, AST_STATE_BUSY);
+ celliax_queue_control(p->owner, AST_CONTROL_BUSY);
+ }
+
+ known = 1;
+ break;
+
+ case API_PP_SIGNAL_ON_IND:
+ /* Ringback, ignore it... */
+ if (option_debug > 1)
+ DEBUGA_CVM("API_PP_SIGNAL_ON_IND, Ringback, ignore it...\n",
+ CELLIAX_P_LOG);
+
+ known = 1;
+ break;
+
+ case API_PP_SIGNAL_OFF_IND:
+ /* Ringback, ignore it... */
+ if (option_debug > 1)
+ DEBUGA_CVM("API_PP_SIGNAL_OFF_IND, Ringback, ignore it...\n",
+ CELLIAX_P_LOG);
+
+ known = 1;
+ break;
+
+ case API_PP_SETUP_IND:
+ /* Incoming call, Somebody is calling us */
+
+ if (option_debug > 1)
+ DEBUGA_CVM("API_PP_SETUP_IND, somebody is calling us...\n",
+ CELLIAX_P_LOG);
+
+ if (AST_STATE_DOWN == p->interface_state) {
+
+ if (API_PP_SETUP_IND_CALL_INT ==
+ p->array[BUSMAIL_OFFSET_MAIL_PARAMS +
+ API_PP_SETUP_IND_CALL_TYPE_OFFSET]) {
+ DEBUGA_CVM("INTERNAL CALL, receive it...\n", CELLIAX_P_LOG);
+
+ p->interface_state = AST_STATE_RING;
+
+ /* inform calling end, that we know about his call, and that we are alerting */
+ celliax_serial_send_info_frame_CVM_BUSMAIL(p, API_PP_ALERT_REQ, 0,
+ NULL);
+
+ /* let's open audio before valid mac, to remove noise... */
+ celliax_serial_send_info_frame_CVM_BUSMAIL(p,
+ CVM_PP_AUDIO_OPEN_ADPCM_OFF_REQ,
+ 0, NULL);
+
+ } else {
+ DEBUGA_CVM("NOT an INTERNAL CALL, CALL TYPE %X, just ignore it...\n",
+ CELLIAX_P_LOG,
+ p->array[BUSMAIL_OFFSET_MAIL_PARAMS +
+ API_PP_SETUP_IND_CALL_TYPE_OFFSET]);
+
+ /* inform calling end, that we know about his call, and that we are alerting OR not :) */
+ /* probably it is needed so FP does not remove us from PP list :) */
+ celliax_serial_send_info_frame_CVM_BUSMAIL(p, API_PP_ALERT_REQ, 0,
+ NULL);
+ }
+
+ } else {
+ WARNINGA
+ ("Ignore incoming call, Wrong interface state, current state %X\n",
+ CELLIAX_P_LOG, p->interface_state);
+ }
+
+ known = 1;
+ break;
+
+ case API_PP_ALERT_OFF_IND:
+ /* Incoming call, We should stop alerting about incoming call... */
+ if (option_debug > 1)
+ DEBUGA_CVM
+ ("API_PP_ALERT_OFF_IND, Ringback, stop alerting about incoming call...\n",
+ CELLIAX_P_LOG);
+
+ known = 1;
+ break;
+
+ case API_PP_ALERT_ON_IND:
+ /* Incoming call, We should stop alerting about incoming call... */
+ if (option_debug > 1)
+ DEBUGA_CVM
+ ("API_PP_ALERT_ON_IND, Ringback, start alerting about incoming call...\n",
+ CELLIAX_P_LOG);
+/*
+ if (AST_STATE_DOWN == p->interface_state) {
+ DEBUGA_CVM("Somebody is calling us, we see a PP_ALERT_ON_IND, receive it...\n", CELLIAX_P_LOG);
+ p->interface_state = AST_STATE_RING;
+ }
+*/
+ known = 1;
+ break;
+
+ case API_PP_CONNECT_CFM:
+ /* Incoming call, Confirmation for request to answer incoming call... */
+ if (option_debug > 1)
+ DEBUGA_CVM
+ ("API_PP_CONNECT_CFM, Confirmation for request to answer incoming call...\n",
+ CELLIAX_P_LOG);
+
+ if (AST_STATE_RING == p->interface_state && p->owner) {
+
+ p->interface_state = AST_STATE_UP;
+ ast_setstate(p->owner, AST_STATE_UP);
+
+ /* let's open audio and have a chat */
+// celliax_serial_send_info_frame_CVM_BUSMAIL(p, CVM_PP_AUDIO_OPEN_ADPCM_OFF_REQ, 0, NULL);
+
+ /* let's open audio and have a chat */
+ celliax_serial_send_info_frame_CVM_BUSMAIL(p, CVM_PP_AUDIO_OPEN_REQ, 0,
+ NULL);
+
+ unsigned char volume = (unsigned char) p->cvm_volume_level;
+ celliax_serial_send_info_frame_CVM_BUSMAIL(p,
+ CVM_PP_AUDIO_SET_VOLUME_REQ,
+ sizeof(volume), &volume);
+
+ /* let's unmute mic and have a chat */
+ celliax_serial_send_info_frame_CVM_BUSMAIL(p,
+ CVM_PP_AUDIO_UNMUTE_MIC_REQ,
+ 0, NULL);
+
+ /* let's switch to headset, because we fried normal output.... */
+/* unsigned char headset_on = (unsigned char) 1;
+ celliax_serial_send_info_frame_CVM_BUSMAIL(p, CVM_PP_AUDIO_HS_PLUG_IND, sizeof(headset_on), &headset_on);
+*/
+ } else {
+ WARNINGA
+ ("Ignore connection cfm, Wrong interface state, current state %X\n",
+ CELLIAX_P_LOG, p->interface_state);
+ }
+
+ known = 1;
+ break;
+
+ case API_PP_RELEASE_CFM:
+ /* Confirmation for request to hangup a call... */
+ if (option_debug > 1)
+ DEBUGA_CVM
+ ("API_PP_RELEASE_CFM, Confirmation for request to hangup a call..\n",
+ CELLIAX_P_LOG);
+
+ if (AST_STATE_UP == p->interface_state) {
+ /* let's close audio */
+ celliax_serial_send_info_frame_CVM_BUSMAIL(p, CVM_PP_AUDIO_CLOSE_REQ, 0,
+ NULL);
+
+ /* let's unmute mic and have a chat */
+ celliax_serial_send_info_frame_CVM_BUSMAIL(p, CVM_PP_AUDIO_MUTE_MIC_REQ,
+ 0, NULL);
+ }
+
+ p->interface_state = AST_STATE_DOWN;
+
+ known = 1;
+ break;
+
+ case API_PP_RELEASE_IND:
+ /* FP releases connection to CVM... */
+ if (option_debug > 1)
+ DEBUGA_CVM("API_PP_RELEASE_IND, FP releases connection to CVM...\n",
+ CELLIAX_P_LOG);
+
+ if (AST_STATE_UP == p->interface_state && p->owner) {
+ /* let's close audio */
+ celliax_serial_send_info_frame_CVM_BUSMAIL(p, CVM_PP_AUDIO_CLOSE_REQ, 0,
+ NULL);
+ p->interface_state = AST_STATE_DOWN;
+ celliax_queue_control(p->owner, AST_CONTROL_HANGUP);
+
+ } else if (AST_STATE_RING == p->interface_state && p->owner) {
+ /* workaround for PAGE ALL CALL, FIXME!!!! */
+ if (option_debug > 1)
+ DEBUGA_CVM("WAS IT A PAGE ALL ???...\n", CELLIAX_P_LOG);
+
+ p->interface_state = AST_STATE_UP;
+ usleep(100000);
+
+ p->interface_state = AST_STATE_DOWN;
+ celliax_queue_control(p->owner, AST_CONTROL_HANGUP);
+ }
+
+ /* we need to ACK release */
+ celliax_serial_send_info_frame_CVM_BUSMAIL(p, API_PP_RELEASE_RES, 0,
+ NULL);
+
+ known = 1;
+ break;
+
+ case API_PP_READ_RSSI_CFM:
+ if (option_debug > 1)
+ DEBUGA_CVM("API_PP_READ_RSSI_CFM, RSSI readout...\n", CELLIAX_P_LOG);
+
+ p->cvm_rssi = p->array[BUSMAIL_OFFSET_MAIL_PARAMS + 0];
+ int rssi_percent = p->cvm_rssi * 100 / 0x3F;
+ if (option_debug > 1)
+ DEBUGA_CVM("RSSI is %X, %d%%...\n", CELLIAX_P_LOG, p->cvm_rssi,
+ rssi_percent);
+
+ known = 1;
+ break;
+ default:
+ WARNINGA("UNKNOWN MsgPrimitive!!! %X\n", CELLIAX_P_LOG, MsgPrimitive);
+ break;
+ }
+
+ break;
+
+ case BUSMAIL_HEADER_CTRL_FRAME:
+ if (option_debug > 1)
+ DEBUGA_CVM("BUSMAIL_HEADER_CTRL_FRAME\n", CELLIAX_P_LOG);
+
+ switch (p->array[BUSMAIL_OFFSET_HEADER] & BUSMAIL_HEADER_SU_BIT_MASK) {
+ case BUSMAIL_HEADER_CTRL_SU_FRAME:
+ if (option_debug > 1)
+ DEBUGA_CVM("BUSMAIL_HEADER_CTRL_SU_FRAME\n", CELLIAX_P_LOG);
+
+ switch (p->array[BUSMAIL_OFFSET_HEADER] & BUSMAIL_HEADER_SUID_MASK) {
+ case BUSMAIL_HEADER_SUID_REJ:
+ /* CVM Reject, CVM missed one of our packets, it will be resend, do nothing */
+ MsgRxSeqNo =
+ ((p->array[BUSMAIL_OFFSET_HEADER] & BUSMAIL_HEADER_RXSEQ_MASK));
+
+ if (option_debug > 1)
+ DEBUGA_CVM("BUSMAIL_HEADER_SUID_REJ, RxSeq %X\n", CELLIAX_P_LOG,
+ MsgRxSeqNo);
+
+ /* Even that it is CVM Reject packet, it still ACKs some packets */
+ celliax_serial_list_acknowledge_CVM_BUSMAIL(p, MsgRxSeqNo);
+
+ known = 1;
+ break;
+ case BUSMAIL_HEADER_SUID_RNR:
+ /* CVM Receiver Not Ready, answer to packet that we sent, do nothing, it will be resend later */
+ MsgRxSeqNo =
+ ((p->array[BUSMAIL_OFFSET_HEADER] & BUSMAIL_HEADER_RXSEQ_MASK));
+
+ if (option_debug > 1)
+ DEBUGA_CVM("BUSMAIL_HEADER_SUID_RNR, RxSeq %X\n", CELLIAX_P_LOG,
+ MsgRxSeqNo);
+
+ known = 1;
+ break;
+ case BUSMAIL_HEADER_SUID_RR:
+ /* CVM ACKs our packets */
+ MsgRxSeqNo =
+ ((p->array[BUSMAIL_OFFSET_HEADER] & BUSMAIL_HEADER_RXSEQ_MASK));
+
+ if (option_debug > 1)
+ DEBUGA_CVM("BUSMAIL_HEADER_SUID_RR, RxSeq %X\n", CELLIAX_P_LOG,
+ MsgRxSeqNo);
+
+ /* CVM ACKed our frames with RR frame */
+ celliax_serial_list_acknowledge_CVM_BUSMAIL(p, MsgRxSeqNo);
+
+ known = 1;
+ break;
+
+ default:
+ WARNINGA("BUSMAIL_HEADER_SUID_UNKNOWN!!!\n", CELLIAX_P_LOG);
+ break;
+ }
+ break;
+
+ case BUSMAIL_HEADER_CTRL_UN_FRAME:
+ if (option_debug > 1)
+ DEBUGA_CVM("BUSMAIL_HEADER_CTRL_UN_FRAME\n", CELLIAX_P_LOG);
+
+ switch (p->array[BUSMAIL_OFFSET_HEADER] & BUSMAIL_HEADER_UNID_MASK) {
+
+ case BUSMAIL_HEADER_UNID_SABM:
+ if (option_debug > 1)
+ DEBUGA_CVM("BUSMAIL_HEADER_UNID_SABM\n", CELLIAX_P_LOG);
+ /* reset seq counters */
+ p->busmail_txseq_celliax_last = 0xFF;
+ p->busmail_rxseq_cvm_last = 0xFF;
+
+ celliax_serial_lists_free_CVM_BUSMAIL(p);
+ /* if needed, reply will be send by code at the end of switch statements */
+ known = 1;
+ break;
+
+ default:
+ WARNINGA("BUSMAIL_HEADER_UNID_UNKNOWN!!!\n", CELLIAX_P_LOG);
+ break;
+ }
+ break;
+
+ default:
+ WARNINGA("BUSMAIL_HEADER_CTRL_UNKNOWN!!!\n", CELLIAX_P_LOG);
+ break;
+ }
+ break;
+
+ default:
+ WARNINGA("BUSMAIL_HEADER_UNKNOWN!!!\n", CELLIAX_P_LOG);
+ break;
+ }
+
+ }
+
+ /* categorization of frame is ended, if it has not been recognized, whine */
+ if (!known) {
+ WARNINGA("BUSMAIL MSG UNKNOWN or REJECTED!\n", CELLIAX_P_LOG);
+ }
+ }
+ p->arraycounter++;
+ }
+ }
+ CVM_UNLOCKA(&p->controldev_lock);
+ POPPA_UNLOCKA(&p->controldev_lock);
+ }
+
+ /* oooops, select returned error, got a kill/cancel or problems with the serial file descriptor */
+ if (select_err == -1) {
+ if (errno != EINTR) {
+ ERRORA
+ ("select returned -1 on %s, marking controldev as dead, errno was: %d, error was: %s\n",
+ CELLIAX_P_LOG, p->controldevice_name, errno, strerror(errno));
+
+ p->controldev_dead = 1;
+ close(p->controldevfd);
+
+ if (p->owner)
+ celliax_queue_control(p->owner, AST_CONTROL_HANGUP);
+ return -1;
+
+ } else {
+ WARNINGA("select returned -1 on %s, errno was: %d, EINTR, error was: %s\n",
+ CELLIAX_P_LOG, p->controldevice_name, errno, strerror(errno));
+ return 0;
+ }
+ }
+ /* OK, reading done, let's browse the list of pending frames to be sent, and act on it */
+ if (celliax_serial_send_if_time_CVM_BUSMAIL(p)) {
+ ERRORA("celliax_serial_send_if_time_CVM_BUSMAIL failed!\n", CELLIAX_P_LOG);
+ return -1;
+ }
+
+ return cvm_busmail_mesg; //FIXME breaks the convention of returning 0 on success
+}
+
+int celliax_serial_getstatus_CVM_BUSMAIL(struct celliax_pvt *p)
+{
+ int res;
+ int how_many_reads = 0;
+
+ PUSHA_UNLOCKA(&p->controldev_lock);
+ CVM_LOKKA(&p->controldev_lock);
+
+ if (option_debug > 1)
+ DEBUGA_CVM("Sending RR CTRL frame wit PF bit set\n", CELLIAX_P_LOG);
+
+ /* this ctrl frame can be used as low level keep alive */
+ celliax_serial_send_ctrl_frame_CVM_BUSMAIL(p,
+ BUSMAIL_HEADER_CTRL_FRAME |
+ BUSMAIL_HEADER_CTRL_SU_FRAME |
+ BUSMAIL_HEADER_SUID_RR |
+ (BUSMAIL_HEADER_PF_BIT_MASK & 0xFF));
+
+ //usleep(1000);
+
+ res = celliax_serial_read_CVM_BUSMAIL(p); //we don't have no monitor neither do_controldev_thread
+
+ if (res == -1) {
+ ERRORA("failed celliax_serial_read_CVM_BUSMAIL\n", CELLIAX_P_LOG);
+ CVM_UNLOCKA(&p->controldev_lock);
+ return -1;
+ }
+
+ while ((res & 0xF0) !=
+ (BUSMAIL_HEADER_CTRL_FRAME | BUSMAIL_HEADER_CTRL_SU_FRAME |
+ BUSMAIL_HEADER_SUID_RR)) {
+
+ usleep(1000);
+ res = celliax_serial_read_CVM_BUSMAIL(p);
+ how_many_reads++;
+
+ if (res == -1) {
+ ERRORA("failed celliax_serial_read_CVM_BUSMAIL\n", CELLIAX_P_LOG);
+ CVM_UNLOCKA(&p->controldev_lock);
+ return -1;
+ }
+
+ if (how_many_reads > 10) {
+ ERRORA("no expected results in %d celliax_serial_read_CVM_BUSMAIL\n", CELLIAX_P_LOG,
+ how_many_reads);
+ CVM_UNLOCKA(&p->controldev_lock);
+ return -1;
+ }
+ }
+
+ //celliax_serial_send_info_frame_CVM_BUSMAIL(p, API_PP_READ_RSSI_REQ, 0, NULL);
+
+ CVM_UNLOCKA(&p->controldev_lock);
+ POPPA_UNLOCKA(&p->controldev_lock);
+
+ return 0;
+
+}
+
+/*!
+ * \brief Write on the serial port for all the CVM_BUSMAIL functions
+ * \param p celliax_pvt
+ * \param len lenght of buffer2
+ * \param buffer2 chars to be written
+ *
+ * Write on the serial port for all the CVM_BUSMAIL functions
+ *
+ * \return the number of chars written on the serial,
+ * that can be different from len (or negative) in case of errors.
+ */
+int celliax_serial_send_CVM_BUSMAIL(struct celliax_pvt *p, int len,
+ unsigned char *mesg_ptr)
+{
+ int ret;
+ size_t actual = 0;
+ unsigned char *mesg_ptr2 = mesg_ptr;
+ PUSHA_UNLOCKA(&p->controldev_lock);
+ CVM_LOKKA(&p->controldev_lock);
+ do {
+ ret = write(p->controldevfd, mesg_ptr, len - actual);
+ if (ret < 0 && errno == EAGAIN)
+ continue;
+ if (ret < 0) {
+ if (actual != len)
+ ERRORA("celliax_serial_write error: %s", CELLIAX_P_LOG, strerror(errno));
+ CVM_UNLOCKA(&p->controldev_lock);
+ return -1;
+ }
+ actual += ret;
+ mesg_ptr += ret;
+ usleep(10000);
+// usleep(p->cvm_celliax_serial_delay*1000);
+ } while (actual < len);
+
+ usleep(p->cvm_celliax_serial_delay * 1000);
+
+// tcdrain(p->controldevfd);
+
+ CVM_UNLOCKA(&p->controldev_lock);
+ POPPA_UNLOCKA(&p->controldev_lock);
+
+ if (option_debug > 10) {
+ int i;
+ char debug_buf[1024];
+ char *debug_buf_pos;
+
+ memset(debug_buf, 0, 1024);
+ debug_buf_pos = debug_buf;
+
+ for (i = 0; i < len; i++) {
+ debug_buf_pos += sprintf(debug_buf_pos, "[%.2X] ", mesg_ptr2[i]);
+ if (debug_buf_pos > ((char *) &debug_buf + 1000))
+ break;
+ }
+ DEBUGA_CVM("%s was sent down the wire\n", CELLIAX_P_LOG, debug_buf);
+ }
+
+ return 0;
+}
+
+/*!
+ * \brief Flags as acknowledged an BUSMAIL message previously sent
+ * \param p celliax_pvt
+ * \param seqnum identifier of the message to be acknowledged
+ *
+ * Called upon receiving an BUSMAIL acknoledgement message, browse the cvm_busmail_outgoing_list
+ * looking for the seqnum sent BUSMAIL message, and flags it as acknowledged.
+ * (if an outgoing BUSMAIL message is not aknowledged by the cellphone in a while,
+ * it will be retransmitted)
+ *
+ * \return 0 on error, 1 otherwise
+ */
+int celliax_serial_list_acknowledge_CVM_BUSMAIL(struct celliax_pvt *p,
+ unsigned char AckTxSeqNo)
+{
+ struct cvm_busmail_msg *ptr = NULL;
+ struct cvm_busmail_msg *old = NULL;
+
+ unsigned char MsgTxSeqNo;
+ unsigned char MsgRxSeqNo;
+
+ ptr = p->cvm_busmail_outgoing_list;
+
+ if (ptr == NULL) {
+ ERRORA("cvm_busmail_outgoing_list is NULL ?\n", CELLIAX_P_LOG);
+ return -1;
+ }
+
+ PUSHA_UNLOCKA(&p->cvm_busmail_outgoing_list_lock);
+ CVM_LOKKA(&p->cvm_busmail_outgoing_list_lock);
+/*
+ DEBUGA_CVM("PREFREE OUTGOING list:\n", CELLIAX_P_LOG);
+ celliax_serial_list_print_CVM_BUSMAIL(p, p->cvm_busmail_outgoing_list);
+*/
+ while (ptr->next != NULL)
+ ptr = ptr->next;
+
+ while (ptr) {
+
+ if ((1 == ptr->valid) && (0 == ptr->acknowledged) && (0 != ptr->sent)) {
+ MsgTxSeqNo =
+ ((ptr->busmail_msg_buffer[BUSMAIL_OFFSET_HEADER] & BUSMAIL_HEADER_TXSEQ_MASK) >>
+ 4);
+ MsgRxSeqNo =
+ ((ptr->busmail_msg_buffer[BUSMAIL_OFFSET_HEADER] & BUSMAIL_HEADER_RXSEQ_MASK));
+
+/*
+ if (option_debug > 1)
+ DEBUGA_CVM("OUTGOING LIST TxSeq is %X, RxSeq is %X\n", CELLIAX_P_LOG, MsgTxSeqNo, MsgRxSeqNo);
+*/
+ unsigned char TxToAck = 0;
+
+ if (0 == AckTxSeqNo) {
+ TxToAck = 7;
+ } else {
+ TxToAck = AckTxSeqNo - 1;
+ }
+
+ if (MsgTxSeqNo <= TxToAck) {
+
+ if (option_debug > 1)
+ DEBUGA_CVM("Msg with TxSeq=%X ACKed with CvmRxSeq=%X\n", CELLIAX_P_LOG,
+ MsgTxSeqNo, AckTxSeqNo);
+
+ old = ptr;
+ old->acknowledged = 1;
+ old->valid = 0;
+ ptr = old->previous;
+
+ if (old->previous) {
+ if (old->next) {
+ old->previous->next = old->next;
+ } else {
+ old->previous->next = NULL;
+ }
+ }
+
+ if (old->next) {
+ if (old->previous) {
+ old->next->previous = old->previous;
+ } else {
+ old->next->previous = NULL;
+ }
+ }
+
+ if ((NULL == old->next) && (NULL == old->previous)) {
+ if (option_debug > 1) {
+ DEBUGA_CVM("FREEING LAST\n", CELLIAX_P_LOG);
+ }
+
+ p->cvm_busmail_outgoing_list = NULL;
+ p->cvm_busmail_outgoing_list = celliax_serial_list_init_CVM_BUSMAIL(p);
+ }
+
+/*
+ if (option_debug > 1)
+ DEBUGA_CVM("FREEING TxSeq is %X, RxSeq is %X\n", CELLIAX_P_LOG, MsgTxSeqNo, MsgRxSeqNo);
+*/
+
+ free(old);
+
+ } else {
+ ptr = ptr->previous;
+ }
+
+ } else {
+ ptr = ptr->previous;
+ }
+ }
+
+/*
+ DEBUGA_CVM("POSTFREE OUTGOING list:\n", CELLIAX_P_LOG);
+ celliax_serial_list_print_CVM_BUSMAIL(p, p->cvm_busmail_outgoing_list);
+*/
+
+ CVM_UNLOCKA(&p->cvm_busmail_outgoing_list_lock);
+ POPPA_UNLOCKA(&p->cvm_busmail_outgoing_list_lock);
+ return 0;
+}
+
+/*!
+ * \brief Sends an FBUS2 message or resends it if it was not acknowledged
+ * \param p celliax_pvt
+ *
+ * Called by celliax_serial_read_CVM_BUSMAIL, browse the fbus2_outgoing_list looking for FBUS2 messages to be sent,
+ * or for FBUS2 messages previously sent but not yet acknoledged.
+ * (if an outgoing FBUS2 message is not aknowledged by the cellphone in a while,
+ * it will be retransmitted)
+ *
+ * \return 0 on error, 1 otherwise
+ */
+int celliax_serial_send_if_time_CVM_BUSMAIL(struct celliax_pvt *p)
+{
+ struct cvm_busmail_msg *ptr;
+ struct timeval tv;
+ struct timezone tz;
+
+ gettimeofday(&tv, &tz);
+ ptr = p->cvm_busmail_outgoing_list;
+
+ if (ptr == NULL) {
+/* ERRORA("cvm_busmail_outgoing_list is NULL ?\n", CELLIAX_P_LOG); */
+ WARNINGA("cvm_busmail_outgoing_list is NULL, nothing to send...\n", CELLIAX_P_LOG);
+
+/* return -1; */
+ return 0;
+
+ }
+
+ while (ptr->next != NULL) {
+ WARNINGA("cvm_busmail_outgoing_list->next is not null ?\n", CELLIAX_P_LOG);
+ ptr = ptr->next; //FIXME what to do?
+ }
+
+ while (ptr->sent == 0 && ptr->acknowledged == 0) {
+ if (ptr->previous != NULL) {
+ ptr = ptr->previous;
+ } else
+ break;
+ }
+
+ while (ptr->sent == 1 && ptr->acknowledged == 0) {
+ if (ptr->previous != NULL) {
+ ptr = ptr->previous;
+ } else
+ break;
+ }
+
+ if (ptr->sent == 1 && ptr->acknowledged == 1) {
+ if (ptr->next != NULL) {
+ ptr = ptr->next;
+ }
+ }
+
+ if (ptr->sent == 1 && ptr->acknowledged == 0 && ptr->valid == 1) {
+ if ((tv.tv_sec * 1000 + tv.tv_usec / 1000) >
+ ((ptr->tv_sec * 1000 + ptr->tv_usec / 1000) + 1000)) {
+
+ PUSHA_UNLOCKA(&p->cvm_busmail_outgoing_list_lock);
+ CVM_LOKKA(&p->cvm_busmail_outgoing_list_lock);
+
+ if (ptr->sent == 1 && ptr->acknowledged == 0 && ptr->valid == 1) { //retest, maybe has been changed?
+ if ((tv.tv_sec * 1000 + tv.tv_usec / 1000) > ((ptr->tv_sec * 1000 + ptr->tv_usec / 1000) + 1000)) { //retest, maybe has been changed?
+
+ if (option_debug > 1)
+ DEBUGA_CVM("RESEND TxSeq=%X, passed %ld ms, sent %d times\n", CELLIAX_P_LOG,
+ ptr->txseqno,
+ ((tv.tv_sec * 1000 + tv.tv_usec / 1000) -
+ (ptr->tv_sec * 1000 + ptr->tv_usec / 1000)), ptr->how_many_sent);
+
+ if (ptr->how_many_sent > 9) {
+ ERRORA("RESEND TxSeq=%X, passed %ld ms, sent %d times\n", CELLIAX_P_LOG,
+ ptr->txseqno,
+ ((tv.tv_sec * 1000 + tv.tv_usec / 1000) -
+ (ptr->tv_sec * 1000 + ptr->tv_usec / 1000)), ptr->how_many_sent);
+
+ CVM_UNLOCKA(&p->cvm_busmail_outgoing_list_lock);
+ return -1;
+ }
+
+ celliax_serial_send_CVM_BUSMAIL(p, ptr->busmail_msg_len,
+ ptr->busmail_msg_buffer);
+
+ ptr->tv_sec = tv.tv_sec;
+ ptr->tv_usec = tv.tv_usec;
+ ptr->sent = 1;
+ ptr->how_many_sent++;
+/*
+ if (option_debug > 1) {
+ DEBUGA_CVM("OUTGOING list:\n", CELLIAX_P_LOG);
+ celliax_serial_list_print_CVM_BUSMAIL(p, p->cvm_busmail_outgoing_list);
+ DEBUGA_CVM("OUTGOING list END\n", CELLIAX_P_LOG);
+ }
+*/
+ }
+ }
+
+ CVM_UNLOCKA(&p->cvm_busmail_outgoing_list_lock);
+ POPPA_UNLOCKA(&p->cvm_busmail_outgoing_list_lock);
+ }
+ }
+
+ if (ptr->sent == 0 && ptr->acknowledged == 0 && ptr->valid == 1) {
+
+ PUSHA_UNLOCKA(&p->cvm_busmail_outgoing_list_lock);
+ CVM_LOKKA(&p->cvm_busmail_outgoing_list_lock);
+
+ if (ptr->sent == 0 && ptr->acknowledged == 0 && ptr->valid == 1) { //retest, maybe has been changed?
+
+ if (option_debug > 1)
+ DEBUGA_CVM("SENDING 1st TIME TxSeq=%X\n", CELLIAX_P_LOG, ptr->txseqno);
+
+ celliax_serial_send_CVM_BUSMAIL(p, ptr->busmail_msg_len, ptr->busmail_msg_buffer);
+
+ ptr->tv_sec = tv.tv_sec;
+ ptr->tv_usec = tv.tv_usec;
+ ptr->sent = 1;
+ ptr->how_many_sent++;
+/*
+ if (option_debug > 1) {
+ DEBUGA_CVM("OUTGOING list:\n", CELLIAX_P_LOG);
+ celliax_serial_list_print_CVM_BUSMAIL(p, p->cvm_busmail_outgoing_list);
+ DEBUGA_CVM("OUTGOING list END\n", CELLIAX_P_LOG);
+ }
+*/
+ }
+
+ CVM_UNLOCKA(&p->cvm_busmail_outgoing_list_lock);
+ POPPA_UNLOCKA(&p->cvm_busmail_outgoing_list_lock);
+
+ }
+ return 0;
+}
+
+int celliax_serial_write_CVM_BUSMAIL(struct celliax_pvt *p,
+ struct cvm_busmail_frame *busmail_frame)
+{
+ unsigned char buffer2[BUSMAIL_MAX_FRAME_LENGTH];
+ int i = 0;
+ int len = 0;
+ unsigned int busmail_len_total = 0;
+
+ busmail_frame->busmail_sof = BUSMAIL_SOF;
+ busmail_frame->busmail_crc = 0;
+
+/* because of Rx Tx SEQ HEADER fields problem, update when these fields are filled with correct data
+ busmail_frame->busmail_crc = (unsigned char)(busmail_frame->busmail_header + busmail_frame->busmail_crc);
+*/
+
+ buffer2[BUSMAIL_OFFSET_SOF] = busmail_frame->busmail_sof;
+ buffer2[BUSMAIL_OFFSET_HEADER] = busmail_frame->busmail_header;
+
+ if ((buffer2[BUSMAIL_OFFSET_HEADER] & BUSMAIL_HEADER_IC_BIT_MASK) ==
+ BUSMAIL_HEADER_INFO_FRAME) {
+ len =
+ BUSMAIL_OFFSET_MAIL_PARAMS + busmail_frame->busmail_mail_params_buffer_len +
+ sizeof(busmail_frame->busmail_crc);
+ busmail_len_total =
+ busmail_frame->busmail_mail_params_buffer_len +
+ sizeof(busmail_frame->busmail_header)
+ + sizeof(busmail_frame->busmail_mail_program_id) +
+ sizeof(busmail_frame->busmail_mail_task_id) + 2;
+
+ if (option_debug > 1)
+ DEBUGA_CVM("INFO frame to send\n", CELLIAX_P_LOG);
+
+ buffer2[BUSMAIL_OFFSET_MAIL_PROGRAM_ID] = busmail_frame->busmail_mail_program_id;
+ buffer2[BUSMAIL_OFFSET_MAIL_TASK_ID] = busmail_frame->busmail_mail_task_id;
+ buffer2[BUSMAIL_OFFSET_MAIL_PRIMITIVE_LSB] =
+ busmail_frame->busmail_mail_primitive[BUSMAIL_MAIL_PRIMITIVE_LSB];
+ buffer2[BUSMAIL_OFFSET_MAIL_PRIMITIVE_MSB] =
+ busmail_frame->busmail_mail_primitive[BUSMAIL_MAIL_PRIMITIVE_MSB];
+
+ if (busmail_frame->busmail_mail_params_buffer_len) {
+ memcpy(buffer2 + BUSMAIL_OFFSET_MAIL_PARAMS,
+ busmail_frame->busmail_mail_params_buffer,
+ busmail_frame->busmail_mail_params_buffer_len);
+ }
+
+ for (i = 0; i < busmail_frame->busmail_mail_params_buffer_len; i++) {
+ busmail_frame->busmail_crc =
+ (unsigned char) (busmail_frame->busmail_mail_params_buffer[i] +
+ busmail_frame->busmail_crc);
+ }
+
+ busmail_frame->busmail_crc += busmail_frame->busmail_mail_program_id;
+ busmail_frame->busmail_crc += busmail_frame->busmail_mail_task_id;
+ busmail_frame->busmail_crc +=
+ busmail_frame->busmail_mail_primitive[BUSMAIL_MAIL_PRIMITIVE_LSB];
+ busmail_frame->busmail_crc +=
+ busmail_frame->busmail_mail_primitive[BUSMAIL_MAIL_PRIMITIVE_MSB];
+ } else {
+ busmail_len_total = sizeof(busmail_frame->busmail_header);
+ len = BUSMAIL_OFFSET_MAIL + sizeof(busmail_frame->busmail_crc);
+
+ if (option_debug > 1)
+ DEBUGA_CVM("CTRL frame to send\n", CELLIAX_P_LOG);
+ }
+
+/*
+ DEBUGA_CVM("Its len=%d\n", CELLIAX_P_LOG, len);
+*/
+
+ busmail_frame->busmail_len[BUSMAIL_LEN_LSB] =
+ (unsigned char) (busmail_len_total & 0xFF);
+ busmail_frame->busmail_len[BUSMAIL_LEN_MSB] = (unsigned char) (busmail_len_total >> 8);
+ buffer2[BUSMAIL_OFFSET_LEN_MSB] = busmail_frame->busmail_len[BUSMAIL_LEN_MSB];
+ buffer2[BUSMAIL_OFFSET_LEN_LSB] = busmail_frame->busmail_len[BUSMAIL_LEN_LSB];
+
+/*
+ buffer2[len-1] = busmail_frame->busmail_crc;
+*/
+ buffer2[len - 1] = 0xFF;
+
+ if ((buffer2[BUSMAIL_OFFSET_HEADER] & BUSMAIL_HEADER_IC_BIT_MASK) ==
+ BUSMAIL_HEADER_INFO_FRAME) {
+ /* if it is INFO frame, queue it */
+
+ /* update TxSeq and RxSeq bits */
+ /* clear TxSeq and RxSeq bits */
+ buffer2[BUSMAIL_OFFSET_HEADER] &=
+ ~(BUSMAIL_HEADER_RXSEQ_MASK | BUSMAIL_HEADER_TXSEQ_MASK);
+
+ buffer2[BUSMAIL_OFFSET_HEADER] |=
+ (p->busmail_rxseq_cvm_last + 1) & BUSMAIL_HEADER_RXSEQ_MASK;
+
+ p->busmail_txseq_celliax_last++;
+ p->busmail_txseq_celliax_last &= 0x07;
+
+ buffer2[BUSMAIL_OFFSET_HEADER] |=
+ ((p->busmail_txseq_celliax_last) << 4) & BUSMAIL_HEADER_TXSEQ_MASK;
+
+ /* update CRC */
+ busmail_frame->busmail_crc += buffer2[BUSMAIL_OFFSET_HEADER];
+ buffer2[len - 1] = busmail_frame->busmail_crc;
+
+ p->cvm_busmail_outgoing_list = celliax_serial_list_init_CVM_BUSMAIL(p);
+ p->cvm_busmail_outgoing_list->busmail_msg_len = len;
+
+ for (i = 0; i < len; i++) {
+ p->cvm_busmail_outgoing_list->busmail_msg_buffer[i] = buffer2[i];
+ }
+
+ if (option_debug > 10) {
+ char debug_buf[1024];
+ char *debug_buf_pos;
+
+ memset(debug_buf, 0, 1024);
+ debug_buf_pos = debug_buf;
+
+ for (i = 0; i < len; i++) {
+ debug_buf_pos += sprintf(debug_buf_pos, "[%.2X] ", buffer2[i]);
+ if (debug_buf_pos > (char *) (&debug_buf + 1000))
+ break;
+ }
+
+ if (option_debug > 1)
+ DEBUGA_CVM("INFO: %s was prepared to send\n", CELLIAX_P_LOG, debug_buf);
+ }
+
+ if (option_debug > 1) {
+ DEBUGA_CVM("OUTGOING INFO Frame TxSeq is %X, RxSeq is %X\n", CELLIAX_P_LOG,
+ (buffer2[BUSMAIL_OFFSET_HEADER] & BUSMAIL_HEADER_TXSEQ_MASK) >> 4,
+ buffer2[BUSMAIL_OFFSET_HEADER] & BUSMAIL_HEADER_RXSEQ_MASK);
+/*
+ DEBUGA_CVM("OUTGOING list:\n", CELLIAX_P_LOG);
+ celliax_serial_list_print_CVM_BUSMAIL(p, p->cvm_busmail_outgoing_list);
+ DEBUGA_CVM("OUTGOING list END\n", CELLIAX_P_LOG); */
+ }
+ p->cvm_busmail_outgoing_list->txseqno =
+ (unsigned char) (buffer2[BUSMAIL_OFFSET_HEADER] & BUSMAIL_HEADER_TXSEQ_MASK) >> 4;
+ p->cvm_busmail_outgoing_list->valid = 1; /* ready to send (?) */
+
+ } else {
+ /* if it is CTRL frame, send it straight to the wire */
+ if (BUSMAIL_HEADER_SABM !=
+ (buffer2[BUSMAIL_OFFSET_HEADER] & BUSMAIL_HEADER_SABM_MASK)) {
+ /*SABM ctrl frames have no RxSeq bits */
+
+ buffer2[BUSMAIL_OFFSET_HEADER] &= ~BUSMAIL_HEADER_RXSEQ_MASK;
+
+ if (BUSMAIL_HEADER_REJ ==
+ (buffer2[BUSMAIL_OFFSET_HEADER] & BUSMAIL_HEADER_REJ_MASK)) {
+
+ if (option_debug > 1)
+ DEBUGA_CVM("CTRL REJ frame...\n", CELLIAX_P_LOG);
+
+ if (0xFF != p->busmail_rxseq_cvm_last) {
+ buffer2[BUSMAIL_OFFSET_HEADER] |=
+ (p->busmail_rxseq_cvm_last + 1) & BUSMAIL_HEADER_RXSEQ_MASK;
+ } else {
+ if (option_debug > 1)
+ DEBUGA_CVM
+ ("Skipping sending REJ, because we just cleared RxSeq counter, and probably it was a packet that is invalid now...\n",
+ CELLIAX_P_LOG);
+ return 0;
+ }
+
+ } else {
+ buffer2[BUSMAIL_OFFSET_HEADER] |=
+ (p->busmail_rxseq_cvm_last + 1) & BUSMAIL_HEADER_RXSEQ_MASK;
+ }
+ }
+
+ /* update CRC */
+ busmail_frame->busmail_crc += buffer2[BUSMAIL_OFFSET_HEADER];
+ buffer2[len - 1] = busmail_frame->busmail_crc;
+
+ if (option_debug > 10) {
+ char debug_buf[1024];
+ char *debug_buf_pos;
+
+ memset(debug_buf, 0, 1024);
+ debug_buf_pos = debug_buf;
+
+ for (i = 0; i < len; i++) {
+ debug_buf_pos += sprintf(debug_buf_pos, "[%.2X] ", buffer2[i]);
+ if (debug_buf_pos > (char *) (&debug_buf + 1000))
+ break;
+ }
+
+ if (option_debug > 1)
+ DEBUGA_CVM("CTRL: %s was prepared to send\n", CELLIAX_P_LOG, debug_buf);
+ }
+// usleep(100);
+ celliax_serial_send_CVM_BUSMAIL(p, len, buffer2);
+ }
+
+ return 0;
+}
+
+int celliax_serial_send_ctrl_frame_CVM_BUSMAIL(struct celliax_pvt *p,
+ unsigned char FrameType)
+{
+ /*FrameType parameter is really a busmail header with info neeeded to tell the frame type to send */
+ struct cvm_busmail_frame busmail_frame;
+
+ switch (FrameType & 0xF0) {
+ /* only higher nibble is important for us, do not take PF bit into considration */
+
+ case BUSMAIL_HEADER_CTRL_FRAME | BUSMAIL_HEADER_CTRL_SU_FRAME | BUSMAIL_HEADER_SUID_RR:
+ case BUSMAIL_HEADER_CTRL_FRAME | BUSMAIL_HEADER_CTRL_SU_FRAME | BUSMAIL_HEADER_SUID_REJ:
+ case BUSMAIL_HEADER_CTRL_FRAME | BUSMAIL_HEADER_CTRL_SU_FRAME | BUSMAIL_HEADER_SUID_RNR:
+ case BUSMAIL_HEADER_CTRL_FRAME | BUSMAIL_HEADER_CTRL_UN_FRAME | BUSMAIL_HEADER_UNID_SABM:
+
+ busmail_frame.busmail_header =
+ (FrameType & 0xF8);
+
+ break;
+
+ default:
+ WARNINGA("UNKNOWN CTRL TYPE specified, sending nothing!!!\n", CELLIAX_P_LOG);
+ return -1;
+ break;
+ }
+
+ busmail_frame.busmail_mail_params_buffer_len = 0;
+
+ /* Sending to CVM */
+ return celliax_serial_write_CVM_BUSMAIL(p, &busmail_frame);
+}
+
+int celliax_serial_send_info_frame_CVM_BUSMAIL(struct celliax_pvt *p, int FrameType,
+ unsigned char ParamsLen,
+ unsigned char *Params)
+{
+ /*FrameType parameter is really a Primitive ID */
+ struct cvm_busmail_frame busmail_frame;
+ int i = 0;
+ busmail_frame.busmail_header =
+ (BUSMAIL_HEADER_PF_BIT_MASK & 0xFF) | BUSMAIL_HEADER_INFO_FRAME;
+
+ busmail_frame.busmail_mail_primitive[BUSMAIL_MAIL_PRIMITIVE_LSB] = FrameType & 0xFF;
+ busmail_frame.busmail_mail_primitive[BUSMAIL_MAIL_PRIMITIVE_MSB] =
+ (FrameType >> 8) & 0xFF;
+
+ busmail_frame.busmail_mail_program_id = BUSMAIL_MAIL_PROGRAM_ID;
+ busmail_frame.busmail_mail_task_id = BUSMAIL_MAIL_TASK_ID;
+
+ for (i = 0; i < ParamsLen; i++) {
+ busmail_frame.busmail_mail_params_buffer[i] = Params[i];
+ }
+
+ busmail_frame.busmail_mail_params_buffer_len = ParamsLen;
+
+ /* Sending to CVM */
+ return celliax_serial_write_CVM_BUSMAIL(p, &busmail_frame);
+}
+
+int celliax_serial_lists_free_CVM_BUSMAIL(struct celliax_pvt *p)
+{
+ struct cvm_busmail_msg *ptr, *prev;
+/*
+ if (option_debug > 1) {
+ DEBUGA_CVM("START FREEING OUTGOING\n", CELLIAX_P_LOG);
+ DEBUGA_CVM("OUTGOING list:\n", CELLIAX_P_LOG);
+ celliax_serial_list_print_CVM_BUSMAIL(p, p->cvm_busmail_outgoing_list);
+ DEBUGA_CVM("OUTGOING list END\n", CELLIAX_P_LOG);
+ }
+*/
+ ptr = p->cvm_busmail_outgoing_list;
+
+ if (ptr) {
+ while (ptr->next != NULL)
+ ptr = ptr->next;
+
+ while (ptr->previous != NULL) {
+
+ if (option_debug > 1)
+ DEBUGA_CVM("FREED \n", CELLIAX_P_LOG);
+
+ prev = ptr->previous;
+ free(ptr);
+ ptr = prev;
+ }
+
+ free(ptr);
+ }
+
+ if (option_debug > 1)
+ DEBUGA_CVM("LAST FREED \n", CELLIAX_P_LOG);
+
+ p->cvm_busmail_outgoing_list = NULL;
+ p->cvm_busmail_outgoing_list = celliax_serial_list_init_CVM_BUSMAIL(p);
+
+ if (option_debug > 1) {
+ DEBUGA_CVM("OUTGOING list:\n", CELLIAX_P_LOG);
+ celliax_serial_list_print_CVM_BUSMAIL(p, p->cvm_busmail_outgoing_list);
+ DEBUGA_CVM("OUTGOING list END\n", CELLIAX_P_LOG);
+ DEBUGA_CVM("STARTING FREE INGOING\n", CELLIAX_P_LOG);
+ }
+
+ return 0;
+}
+
+struct cvm_busmail_msg *celliax_serial_list_init_CVM_BUSMAIL(struct celliax_pvt *p)
+{
+ struct cvm_busmail_msg *list;
+ list = p->cvm_busmail_outgoing_list;
+
+ PUSHA_UNLOCKA(&p->cvm_busmail_outgoing_list_lock);
+ CVM_LOKKA(&p->cvm_busmail_outgoing_list_lock);
+
+ if (list == NULL) {
+ list = malloc(sizeof(*(list)));
+ list->valid = 0;
+ list->busmail_msg_len = 0;
+ list->acknowledged = 0;
+ list->how_many_sent = 0;
+ list->sent = 0;
+ list->tv_sec = 0;
+ list->tv_usec = 0;
+ list->next = NULL;
+ list->previous = NULL;
+ }
+
+ if (list->valid != 0) {
+ struct cvm_busmail_msg *new;
+ new = malloc(sizeof(*new));
+ new->valid = 0;
+ new->busmail_msg_len = 0;
+ new->acknowledged = 0;
+ new->how_many_sent = 0;
+ new->sent = 0;
+ new->tv_sec = 0;
+ new->tv_usec = 0;
+ new->next = NULL;
+ new->previous = list;
+ list->next = new;
+ list = new;
+ }
+
+ CVM_UNLOCKA(&p->cvm_busmail_outgoing_list_lock);
+ POPPA_UNLOCKA(&p->cvm_busmail_outgoing_list_lock);
+
+ return list;
+}
+
+int celliax_serial_list_print_CVM_BUSMAIL(struct celliax_pvt *p,
+ struct cvm_busmail_msg *list)
+{
+ struct cvm_busmail_msg *ptr;
+ ptr = list;
+
+ if (ptr) {
+ while (ptr->next != NULL)
+ ptr = ptr->next;
+
+ while (ptr) {
+
+ if (option_debug > 3)
+ DEBUGA_CVM
+ ("PTR msg is: %d, seqnum is %.2X, tv_sec is %d, tv_usec is %d, acknowledged is: %d,"
+ " sent is:%d, how_many_sent is: %d\n", CELLIAX_P_LOG, ptr->valid,
+ /*ptr->seqnum */ 44,
+ ptr->tv_sec, ptr->tv_usec, ptr->acknowledged, ptr->sent, ptr->how_many_sent);
+
+ ptr = ptr->previous;
+ }
+ }
+
+ return 0;
+}
+
+#endif /* CELLIAX_CVM */
</ins></span></pre></div>
<a id="freeswitchbranchesgmaruzzmod_celliaxcelliax_protocolc"></a>
<div class="modfile"><h4>Modified: freeswitch/branches/gmaruzz/mod_celliax/celliax_protocol.c (14550 => 14551)</h4>
<pre class="diff"><span>
<span class="info">--- freeswitch/branches/gmaruzz/mod_celliax/celliax_protocol.c 2009-08-18 05:33:42 UTC (rev 14550)
+++ freeswitch/branches/gmaruzz/mod_celliax/celliax_protocol.c 2009-08-18 09:37:23 UTC (rev 14551)
</span><span class="lines">@@ -1406,6 +1406,7 @@
</span><span class="cx"> {
</span><span class="cx">
</span><span class="cx"> private_t *tech_pvt = obj;
</span><ins>+#if 0
</ins><span class="cx"> struct SkypiaxHandles *SkypiaxHandles;
</span><span class="cx"> char buf[512];
</span><span class="cx"> Display *disp = NULL;
</span><span class="lines">@@ -1441,7 +1442,10 @@
</span><span class="cx">
</span><span class="cx"> SkypiaxHandles->disp = disp;
</span><span class="cx">
</span><del>- if (celliax_present(SkypiaxHandles)) {
</del><ins>+#endif// 0
+ //if (celliax_present(SkypiaxHandles))
+ if (1) {
+#if 0
</ins><span class="cx"> root = DefaultRootWindow(disp);
</span><span class="cx"> win = XCreateSimpleWindow(disp, root, 0, 0, 1, 1, 0, BlackPixel(disp, DefaultScreen(disp)), BlackPixel(disp, DefaultScreen(disp)));
</span><span class="cx">
</span><span class="lines">@@ -1474,7 +1478,11 @@
</span><span class="cx">
</span><span class="cx"> b = buffer;
</span><span class="cx">
</span><ins>+#endif // 0
</ins><span class="cx"> while (1) {
</span><ins>+ celliax_sleep(1000000); //1 sec
+ DEBUGA_SKYPE("ciao!\n", SKYPIAX_P_LOG);
+#if 0
</ins><span class="cx"> XNextEvent(disp, &an_event);
</span><span class="cx"> if (!(running && tech_pvt->running))
</span><span class="cx"> break;
</span><span class="lines">@@ -1535,6 +1543,7 @@
</span><span class="cx"> default:
</span><span class="cx"> break;
</span><span class="cx"> }
</span><ins>+#endif //0
</ins><span class="cx"> }
</span><span class="cx"> } else {
</span><span class="cx"> ERRORA("Skype is not running, maybe crashed. Please run/restart Skype and relaunch Skypiax\n", SKYPIAX_P_LOG);
</span></span></pre></div>
<a id="freeswitchbranchesgmaruzzmod_celliaxchan_celliaxc"></a>
<div class="addfile"><h4>Added: freeswitch/branches/gmaruzz/mod_celliax/chan_celliax.c (0 => 14551)</h4>
<pre class="diff"><span>
<span class="info">--- freeswitch/branches/gmaruzz/mod_celliax/chan_celliax.c (rev 0)
+++ freeswitch/branches/gmaruzz/mod_celliax/chan_celliax.c 2009-08-18 09:37:23 UTC (rev 14551)
</span><span class="lines">@@ -0,0 +1,3064 @@
</span><ins>+//indent -gnu -ts4 -br -brs -cdw -lp -ce -nbfda -npcs -nprs -npsl -nbbo -saf -sai -saw -cs -bbo -nhnl -nut -sob -l90
+#include "celliax.h"
+
+/* GLOBAL VARIABLES */
+char celliax_console_active_array[50] = "";
+char *celliax_console_active = celliax_console_active_array;
+/*! \brief Count of active channels for this module */
+int celliax_usecnt = 0;
+int celliax_debug = 0;
+/*! \brief This is the thread for the monitor which checks for input on the channels
+ * which are not currently in use. */
+pthread_t celliax_monitor_thread = AST_PTHREADT_NULL;
+pthread_t celliax_monitor_audio_thread = AST_PTHREADT_NULL;
+int celliax_dir_entry_extension = 0;
+
+/* CONSTANTS */
+/*! \brief Name of configuration file for this module */
+const char celliax_config[] = "celliax.conf";
+
+/*! \brief Textual description for this module */
+const char celliax_desc[] = "Celliax, Audio-Serial Driver";
+/*! \brief Textual type for this module */
+const char celliax_type[] = "Celliax";
+
+/*! \brief Definition of this channel for PBX channel registration */
+const struct ast_channel_tech celliax_tech = {
+ .type = celliax_type,
+ .description = celliax_desc,
+ .capabilities = AST_FORMAT_SLINEAR,
+ .requester = celliax_request,
+ .hangup = celliax_hangup,
+ .answer = celliax_answer,
+ .read = celliax_read,
+ .call = celliax_call,
+ .write = celliax_write,
+ .indicate = celliax_indicate,
+ .fixup = celliax_fixup,
+ .devicestate = celliax_devicestate,
+#ifdef ASTERISK_VERSION_1_4
+ .send_digit_begin = celliax_senddigit_begin,
+ .send_digit_end = celliax_senddigit_end,
+#else /* ASTERISK_VERSION_1_4 */
+ .send_digit = celliax_senddigit,
+#endif /* ASTERISK_VERSION_1_4 */
+};
+
+#ifdef ASTERISK_VERSION_1_4
+#include "asterisk/abstract_jb.h"
+/*! Global jitterbuffer configuration - by default, jb is disabled */
+static struct ast_jb_conf default_jbconf = {
+ .flags = 0,
+ .max_size = -1,
+ .resync_threshold = -1,
+ .impl = ""
+};
+static struct ast_jb_conf global_jbconf;
+#endif /* ASTERISK_VERSION_1_4 */
+
+
+#ifdef CELLIAX_ALSA
+char celliax_console_alsa_period_usage[] =
+ "Usage: celliax_alsa_period [alsa_period_size, in bytes] [alsa_periods_in_buffer, how many]\n"
+ " Shows or set the values of the period and the buffer used by the ALSA subsistem. Standard values are 160 for alsa_period_size and 4 for alsa_periods_in_buffer. Without specifying a value, it just shows the current values. The values are for the \"current\" console (Celliax) channel.\n"
+ " Enter 'help console' on how to change the \"current\" console\n";
+#endif /* CELLIAX_ALSA */
+
+char mandescr_celliax_sendsms[] =
+ "Description: Send an SMS through the designated Celliax interface.\n" "Variables: \n"
+ " Interface: <name> The Celliax interface name you want to use.\n"
+ " Number: <number> The recipient number you want to send the SMS to.\n"
+ " Text: <text> The text of the SMS to be sent.\n"
+ " ActionID: <id> The Action ID for this AMI transaction.\n";
+
+char celliax_console_celliax_usage[] =
+ " \n" "chan_celliax commands info\n" " \n"
+ " chan_celliax adds to Asterisk the following CLI commands and DIALPLAN applications:\n"
+ " \n" " CLI COMMANDS:\n" " celliax_hangup\n"
+ " celliax_dial\n" " celliax_console\n"
+#ifdef CELLIAX_DIR
+ " celliax_dir_import\n" " celliax_dir_export\n"
+#endif /* CELLIAX_DIR */
+ " celliax_playback_boost\n" " celliax_capture_boost\n"
+ " celliax_sendsms\n" " celliax_echo\n" " celliax_at\n"
+ " \n" " DIALPLAN APPLICATIONS:\n" " CelliaxSendsms\n" " \n"
+ " You can type 'help [command]' or 'show application [application]' to obtain more specific info on usage.\n"
+ " \n";
+char celliax_console_hangup_usage[] =
+ "Usage: celliax_hangup\n"
+ " Hangs up any call currently placed on the \"current\" celliax_console (Celliax) channel.\n"
+ " Enter 'help celliax_console' on how to change the \"current\" celliax_console\n";
+char celliax_console_playback_boost_usage[] =
+ "Usage: celliax_playback_boost [value]\n"
+ " Shows or set the value of boost applied to the outgoing sound (voice). Possible values are: 0 (no boost applied), -40 to 40 (negative to positive range, in db). Without specifying a value, it just shows the current value. The value is for the \"current\" celliax_console (Celliax) channel.\n"
+ " Enter 'help celliax_console' on how to change the \"current\" celliax_console\n";
+char celliax_console_capture_boost_usage[] =
+ "Usage: celliax_capture_boost [value]\n"
+ " Shows or set the value of boost applied to the incoming sound (voice). Possible values are: 0 (no boost applied), -40 to 40 (negative to positive range, in db). Without specifying a value, it just shows the current value. The value is for the \"current\" celliax_console (Celliax) channel.\n"
+ " Enter 'help celliax_console' on how to change the \"current\" celliax_console\n";
+
+#ifdef CELLIAX_DIR
+char celliax_console_celliax_dir_import_usage[] =
+ "Usage: celliax_dir_import [add | replace] fromcell\n"
+ " Write in the celliax_dir.conf config file all the entries found in the phonebook of the cellphone connected on the \"current\" celliax_console (Celliax) channel or in the 'Contacts' list of the Skype client.\n"
+ " Enter 'help celliax_console' on how to change the \"current\" celliax_console\n";
+char celliax_console_celliax_dir_export_usage[] =
+#ifdef CELLIAX_LIBCSV
+ "Usage: celliax_dir_export tocell|tocsv celliax_cellphonenumber [csv_filename]\n"
+#else /* CELLIAX_LIBCSV */
+ "Usage: celliax_dir_export tocell celliax_cellphonenumber\n"
+#endif /* CELLIAX_LIBCSV */
+ " With 'tocell' modifier, write in the cellphone connected on the \"current\" celliax_console (Celliax) all the entries found in directoriax.conf, in the form: [celliax_cellphonenumber]wait_for_answer celliax_dir_prefix celliax_dir_entry. So, you can choose the new entry from the cellphone phonebook, dial it, and be directly connected to celliax_dir extension chosen, without having to pass through the voice menu.\n"
+#ifdef CELLIAX_LIBCSV
+ " With 'tocsv' modifier, write in a file (Comma Separated Values, suitable to be imported by various software (eg Outlook) and smartphones) all the entries found in directoriax.conf, in the form: [celliax_cellphonenumber]wait_for_answer celliax_dir_prefix celliax_dir_entry. So, you can choose the new entry from the imported phonebook, dial it, and be directly connected to celliax_dir extension chosen, without having to pass through the voice menu.\n"
+#endif /* CELLIAX_LIBCSV */
+ " Enter 'help celliax_console' on how to change the \"current\" celliax_console\n";
+
+#endif /* CELLIAX_DIR */
+
+char celliax_console_dial_usage[] =
+ "Usage: celliax_dial [DTMFs]\n"
+ " Dials a given DTMF string in the call currently placed on the\n"
+ " \"current\" celliax_console (Celliax) channel.\n"
+ " Enter 'help celliax_console' on how to change the \"current\" celliax_console\n";
+char celliax_console_sendsms_usage[] =
+ "Usage: celliax_sendsms interfacename/number_to_send_sms_to SMS_TEXT\n"
+ " This CLI command will use the specified Celliax interface to send an SMS with content SMS_TEXT to the number_to_send_sms_to\n"
+ " Eg:\n" " celliax_sendsms nicephone/3472665618 \"ciao bello\"\n";
+
+char celliax_console_celliax_console_usage[] =
+ "Usage: celliax_console [interface] | show\n"
+ " If used without a parameter, displays which interface is the \"current\"\n"
+ " celliax_console. If a device is specified, the \"current\" celliax_console is changed to\n"
+ " the interface specified.\n"
+ " If the parameter is \"show\", the available interfaces are listed\n";
+char *celliax_sendsmsapp = "CelliaxSendsms";
+
+char *celliax_sendsmssynopsis = "CelliaxSendsms sends an SMS through the cellphone";
+char *celliax_sendsmsdescrip =
+ " CelliaxSendsms(interface_name / number_to_send_sms_to , SMS_TEXT):\n"
+ " This application will use the specified Celliax interface to send an SMS with content SMS_TEXT to the number_to_send_sms_to\n"
+ " Eg:\n" " CelliaxSendsms(nicephone/3472665618,\"ciao bello\")\n" " or\n"
+ " CelliaxSendsms(nicephone/3472665618,${DATETIME}\"ciao bello\")\n" "\n";
+char celliax_console_echo_usage[] =
+ "Usage: celliax_echo [0|1] [0|1]\n"
+ " Shows or set the values (0 meaning OFF and 1 meaning ON) of the echo suppression options: speexecho and speexpreprocess. Without specifying a value, it just shows the current values. The values are for the \"current\" celliax_console (Celliax) channel.\n"
+ " Enter 'help celliax_console' on how to change the \"current\" celliax_console\n";
+char celliax_console_at_usage[] =
+ "Usage: celliax_at [command string]\n"
+ " Send the 'command string' to the 'AT modem' (cellphone) connected to the \"current\" celliax_console (Celliax) channel.\n"
+ " Enter 'help celliax_console' on how to change the \"current\" celliax_console\n";
+/*! \brief fake celliax_pvt structure values,
+ * just for logging purposes */
+struct celliax_pvt celliax_log_struct = {
+ .name = "none",
+};
+
+/*! \brief Default celliax_pvt structure values,
+ * used by celliax_mkif to initialize the interfaces */
+struct celliax_pvt celliax_default = {
+ .readpos = AST_FRIENDLY_OFFSET, /* start here on reads */
+ .oss_write_dst = 0, /* start here on reads */
+ .interface_state = AST_STATE_DOWN,
+ .phone_callflow = CALLFLOW_CALL_IDLE,
+ .dsp_silence_threshold = 512,
+ .context = "default",
+ .language = "en",
+ .exten = "s",
+ .controldevice_name = "none",
+ .controldevfd = 0,
+ .next = NULL,
+ .owner = NULL,
+ .dsp = NULL,
+ .fbus2_outgoing_list = NULL,
+ .seqnumfbus = FBUS2_SEQNUM_MAX,
+ .controldev_thread = AST_PTHREADT_NULL,
+ .arraycounter = 0,
+#ifndef GIOVA48
+ .celliax_sound_rate = 8000,
+#else // GIOVA48
+ .celliax_sound_rate = 48000,
+#endif // GIOVA48
+ .celliax_sound_capt_fd = -1,
+ .need_acoustic_ring = 0,
+ .celliax_serial_synced_timestamp = 0,
+ .celliax_serial_sync_period = 300,
+ .audio_play_reset_timestamp = 0,
+ .audio_capture_reset_timestamp = 0,
+ .controldevice_speed = B38400,
+ .capture_boost = 0,
+ .playback_boost = 0,
+ .stripmsd = 0,
+ .controldev_dead = 0,
+ .dtmf_inited = 0,
+ .at_dial_pre_number = "AT+CKPD=\"",
+ //.at_dial_post_number = "S\"",
+ .at_dial_post_number = ";",
+ .at_dial_expect = "OK",
+ .at_early_audio = 0,
+ .at_hangup = "AT+CKPD=\"E\"",
+ .at_hangup_expect = "OK",
+ .at_answer = "ATA",
+ .at_answer_expect = "OK",
+ .at_send_dtmf = "AT+CKPD",
+ .at_initial_pause = 0,
+ .at_preinit_1 = "",
+ .at_preinit_1_expect = "",
+ .at_preinit_2 = "",
+ .at_preinit_2_expect = "",
+ .at_preinit_3 = "",
+ .at_preinit_3_expect = "",
+ .at_preinit_4 = "",
+ .at_preinit_4_expect = "",
+ .at_preinit_5 = "",
+ .at_preinit_5_expect = "",
+ .at_after_preinit_pause = 0,
+ .at_postinit_1 = "",
+ .at_postinit_1_expect = "",
+ .at_postinit_2 = "",
+ .at_postinit_2_expect = "",
+ .at_postinit_3 = "",
+ .at_postinit_3_expect = "",
+ .at_postinit_4 = "",
+ .at_postinit_4_expect = "",
+ .at_postinit_5 = "",
+ .at_postinit_5_expect = "",
+ .at_query_battchg = "",
+ .at_query_battchg_expect = "",
+ .at_query_signal = "",
+ .at_query_signal_expect = "",
+ .at_call_idle = "",
+ .at_call_incoming = "",
+ .at_call_active = "",
+ .at_call_failed = "",
+ .at_call_calling = "",
+ .at_indicator_noservice_string = "CIEV: 2,0",
+ .at_indicator_nosignal_string = "CIEV: 5,0",
+ .at_indicator_lowsignal_string = "CIEV: 5,1",
+ .at_indicator_lowbattchg_string = "CIEV: 0,1",
+ .at_indicator_nobattchg_string = "CIEV: 0,0",
+ .at_indicator_callactive_string = "CIEV: 3,1",
+ .at_indicator_nocallactive_string = "CIEV: 3,0",
+ .at_indicator_nocallsetup_string = "CIEV: 6,0",
+ .at_indicator_callsetupincoming_string = "CIEV: 6,1",
+ .at_indicator_callsetupoutgoing_string = "CIEV: 6,2",
+ .at_indicator_callsetupremoteringing_string = "CIEV: 6,3",
+ .at_has_clcc = 0,
+ .at_has_ecam = 0,
+
+ .skype = 0,
+ .celliax_dir_entry_extension_prefix = 5,
+
+#ifdef CELLIAX_CVM
+ .cvm_subsc_1_pin = "0000",
+ .cvm_subsc_2_pin = "0000",
+ .cvm_subsc_no = 1,
+ .cvm_lock_state = CVM_UNKNOWN_LOCK_STATE,
+ .cvm_register_state = CVM_UNKNOWN_REGISTER_STATE,
+ .cvm_busmail_outgoing_list = NULL,
+ .busmail_rxseq_cvm_last = 0xFF, /*!< \brief sequential number of BUSMAIL messages, (0-7) */
+ .busmail_txseq_celliax_last = 0xFF, /*!< \brief sequential number of BUSMAIL messages, (0-7) */
+ .cvm_volume_level = 5,
+ .cvm_celliax_serial_delay = 200, /* 200ms delay after sending down the wire, fix for a bug ? */
+ .cvm_handset_no = 0,
+ .cvm_fp_is_cvm = 0,
+ .cvm_rssi = 0,
+
+#endif /* CELLIAX_CVM */
+#ifdef CELLIAX_LIBCSV
+ .csv_separator_is_semicolon = 0, //FIXME as option
+ .csv_complete_name_pos = 4, //FIXME as option was 4 for outlook express and some outlook, other outlook 2
+ .csv_email_pos = 6, //FIXME as option for outlook express
+ .csv_home_phone_pos = 32, //FIXME as option was 12 for outlook express
+ .csv_mobile_phone_pos = 33, //FIXME as option was 14 for outlook express
+ .csv_business_phone_pos = 41, //FIXME as option was 22 for outlook express
+ .csv_first_row_is_title = 1, //FIXME as option
+#endif /* CELLIAX_LIBCSV */
+
+ .audio_play_reset_period = 0, //do not reset
+
+ .isInputInterleaved = 1,
+ .isOutputInterleaved = 1,
+ .numInputChannels = 1,
+ .numOutputChannels = 1,
+#ifndef GIOVA48
+ .framesPerCallback = 160,
+#else // GIOVA48
+ .framesPerCallback = 960,
+#endif // GIOVA48
+ .speexecho = 1,
+ .speexpreprocess = 1,
+ .portaudiocindex = -1,
+ .portaudiopindex = -1,
+#ifdef CELLIAX_ALSA
+ .alsa_period_size = 160,
+ .alsa_periods_in_buffer = 4,
+ .alsac = NULL,
+ .alsap = NULL,
+ .alsawrite_filled = 0,
+#endif /* CELLIAX_ALSA */
+
+};
+
+/*!
+ * \brief PVT structure for a celliax interface (channel), created by celliax_mkif
+ */
+struct celliax_pvt *celliax_iflist = NULL;
+
+#ifdef ASTERISK_VERSION_1_6_0
+struct ast_cli_entry myclis[] = {
+ AST_CLI_DEFINE(celliax_console_hangup, "Hangup a call on the console"),
+ //AST_CLI_DEFINE(celliax_console_dial, "Dial an extension on the console"),
+ //AST_CLI_DEFINE(celliax_console_playback_boost, "Sets/displays spk boost in dB"),
+ //AST_CLI_DEFINE(celliax_console_capture_boost, "Sets/displays mic boost in dB"),
+ //AST_CLI_DEFINE(celliax_console_set_active, "Sets/displays active console"),
+ //AST_CLI_DEFINE(celliax_console_at, "Sends an AT command"),
+ //AST_CLI_DEFINE(celliax_console_echo, "Echo suppression"),
+#ifdef CELLIAX_DIR
+ //AST_CLI_DEFINE(celliax_console_celliax_dir_import, "imports entries from cellphone"),
+ //AST_CLI_DEFINE(celliax_console_celliax_dir_export, "exports entries to cellphone"),
+#endif /* CELLIAX_DIR */
+ //AST_CLI_DEFINE(celliax_console_celliax, "all things celliax"),
+ //AST_CLI_DEFINE(celliax_console_sendsms, "Send an SMS from a Celliax interface"),
+};
+#else
+struct ast_cli_entry myclis[] = {
+ {{"celliax_hangup", NULL}, celliax_console_hangup,
+ "Hangup a call on the celliax_console",
+ celliax_console_hangup_usage},
+ {{"celliax_playback_boost", NULL}, celliax_console_playback_boost, "playback boost",
+ celliax_console_playback_boost_usage},
+ {{"celliax_capture_boost", NULL}, celliax_console_capture_boost, "capture boost",
+ celliax_console_capture_boost_usage},
+ {{"celliax_usage", NULL}, celliax_console_celliax, "chan_celliax commands info",
+ celliax_console_celliax_usage},
+
+ {{"celliax_at", NULL}, celliax_console_at, "AT command",
+ celliax_console_at_usage},
+ {{"celliax_echo", NULL}, celliax_console_echo, "echo suppression",
+ celliax_console_echo_usage},
+#ifdef CELLIAX_DIR
+ {{"celliax_dir_import", NULL}, celliax_console_celliax_dir_import,
+ "Write the celliax_dir.conf file, used by celliax_dir app",
+ celliax_console_celliax_dir_import_usage},
+ {{"celliax_dir_export", NULL}, celliax_console_celliax_dir_export,
+ "Write in the cellphone the contents of the celliax_dir.conf file, used by celliax_dir app",
+ celliax_console_celliax_dir_export_usage},
+#endif /* CELLIAX_DIR */
+#ifdef CELLIAX_ALSA
+ {{"celliax_alsa_period", NULL}, console_alsa_period, "alsa_period",
+ celliax_console_alsa_period_usage},
+#endif /* CELLIAX_ALSA */
+
+ {{"celliax_dial", NULL}, celliax_console_dial,
+ "Dial an extension on the celliax_console",
+ celliax_console_dial_usage},
+ {{"celliax_sendsms", NULL}, celliax_console_sendsms,
+ "Send an SMS from a Celliax interface",
+ celliax_console_sendsms_usage},
+ {{"celliax_console", NULL}, celliax_console_set_active,
+ "Sets/displays active celliax_console",
+ celliax_console_celliax_console_usage},
+};
+#endif /* ASTERISK_VERSION_1_6_0 */
+
+/* IMPLEMENTATION */
+
+#ifdef CELLIAX_ALSA
+int console_alsa_period(int fd, int argc, char *argv[])
+{
+ struct celliax_pvt *p = celliax_console_find_desc(celliax_console_active);
+
+ if (argc > 3 || argc == 2)
+ return RESULT_SHOWUSAGE;
+ if (!p) {
+ ast_cli(fd,
+ "No \"current\" console for alsa_period_size, please enter 'help console'\n");
+ return RESULT_SUCCESS;
+ }
+
+ if (argc == 1) {
+ ast_cli(fd,
+ "On the active console, that is [%s], alsa_period_size and alsa_periods_in_buffer are: %d and %d\n",
+ celliax_console_active, p->alsa_period_size, p->alsa_periods_in_buffer);
+ } else if (argc == 3) {
+
+ if (p->owner) {
+ ast_cli(fd,
+ "CANNOT SET alsa_period_size and alsa_periods_in_buffer on the active console, that is [%s], because there is a call ongoing\n",
+ celliax_console_active);
+ return RESULT_SUCCESS;
+ }
+ sscanf(argv[1], "%d", &p->alsa_period_size);
+ sscanf(argv[2], "%d", &p->alsa_periods_in_buffer);
+ ast_cli(fd,
+ "alsa_period_size and alsa_periods_in_buffer on the active console, that is [%s], are now: %d and %d\n",
+ celliax_console_active, p->alsa_period_size, p->alsa_periods_in_buffer);
+
+ if (celliax_monitor_audio_thread
+ && (celliax_monitor_audio_thread != AST_PTHREADT_NULL)
+ && (celliax_monitor_audio_thread != AST_PTHREADT_STOP)) {
+
+ if (pthread_cancel(celliax_monitor_audio_thread)) {
+ ERRORA("pthread_cancel celliax_monitor_audio_thread failed, BAD\n",
+ CELLIAX_P_LOG);
+ }
+ if (pthread_kill(celliax_monitor_audio_thread, SIGURG)) {
+ DEBUGA_PBX("pthread_kill celliax_monitor_audio_thread failed, no problem\n", CELLIAX_P_LOG); //maybe it just died
+ }
+
+ if (pthread_join(celliax_monitor_audio_thread, NULL)) {
+ ERRORA("pthread_join failed, BAD\n", CELLIAX_P_LOG);
+ }
+ }
+
+ alsa_shutdown(p);
+ //sleep(5);
+ alsa_init(p);
+
+ if (ast_pthread_create
+ (&celliax_monitor_audio_thread, NULL, celliax_do_audio_monitor, NULL) < 0) {
+ ERRORA("Unable to start audio_monitor thread.\n", CELLIAX_P_LOG);
+ return -1;
+ }
+
+ ast_cli(fd,
+ "ACTIVATED alsa_period_size and alsa_periods_in_buffer on the active console\n");
+ }
+
+ return RESULT_SUCCESS;
+}
+#endif /* CELLIAX_ALSA */
+
+void celliax_unlocka_log(void *x)
+{
+ ast_mutex_t *y;
+ y = x;
+ int i;
+
+ for (i = 0; i < 5; i++) { //let's be generous
+
+ ast_log(LOG_DEBUG,
+ CELLIAX_SVN_VERSION
+ "[%-7lx] I'm a dying thread, and I'm to go unlocking mutex %p for the %dth time\n",
+ (unsigned long int) pthread_self(), y, i);
+
+ ast_mutex_unlock(y);
+ }
+ ast_log(LOG_DEBUG,
+ CELLIAX_SVN_VERSION
+ "[%-7lx] I'm a dying thread, I've finished unlocking mutex %p\n",
+ (unsigned long int) pthread_self(), y);
+}
+
+int celliax_queue_control(struct ast_channel *c, int control)
+{
+ struct celliax_pvt *p = c->tech_pvt;
+
+/* queue the frame */
+ if (p)
+ p->control_to_send = control;
+ else
+ return 0;
+ DEBUGA_PBX("Queued CONTROL FRAME %d\n", CELLIAX_P_LOG, control);
+
+/* wait for the frame to be sent */
+ while (p->control_to_send)
+ usleep(1);
+
+ return 0;
+}
+
+int celliax_devicestate(void *data)
+{
+ struct celliax_pvt *p = NULL;
+ char *name = data;
+ int res = AST_DEVICE_INVALID;
+
+ if (!data) {
+ ERRORA("Devicestate requested with no data\n", CELLIAX_P_LOG);
+ return res;
+ }
+
+ /* lock the interfaces' list */
+ LOKKA(&celliax_iflock);
+ /* make a pointer to the first interface in the interfaces list */
+ p = celliax_iflist;
+ /* Search for the requested interface and verify if is unowned */
+ while (p) {
+ size_t length = strlen(p->name);
+ /* is this the requested interface? */
+ if (strncmp(name, p->name, length) == 0) {
+ /* is this interface unowned? */
+ if (!p->owner) {
+ res = AST_DEVICE_NOT_INUSE;
+ DEBUGA_PBX("Interface is NOT OWNED by a channel\n", CELLIAX_P_LOG);
+ } else {
+ /* interface owned by a channel */
+ res = AST_DEVICE_INUSE;
+ DEBUGA_PBX("Interface is OWNED by a channel\n", CELLIAX_P_LOG);
+ }
+
+ /* we found the requested interface, bail out from the while loop */
+ break;
+ }
+ /* not yet found, next please */
+ p = p->next;
+ }
+ /* unlock the interfaces' list */
+ UNLOCKA(&celliax_iflock);
+
+ if (res == AST_DEVICE_INVALID) {
+ ERRORA("Checking device state for interface [%s] returning AST_DEVICE_INVALID\n",
+ CELLIAX_P_LOG, name);
+ }
+ return res;
+}
+
+#ifndef ASTERISK_VERSION_1_4
+int celliax_indicate(struct ast_channel *c, int cond)
+#else
+int celliax_indicate(struct ast_channel *c, int cond, const void *data, size_t datalen)
+#endif
+{
+ struct celliax_pvt *p = c->tech_pvt;
+ int res = 0;
+
+ switch (cond) {
+ case AST_CONTROL_BUSY:
+ case AST_CONTROL_CONGESTION:
+ case AST_CONTROL_RINGING:
+ case -1:
+ NOTICA("Let's INDICATE %d\n", CELLIAX_P_LOG, cond);
+ res = -1; /* Ask for inband indications */
+ break;
+ case AST_CONTROL_PROGRESS:
+ case AST_CONTROL_PROCEEDING:
+ case AST_CONTROL_VIDUPDATE:
+ case AST_CONTROL_HOLD:
+ case AST_CONTROL_UNHOLD:
+#ifdef ASTERISK_VERSION_1_4
+ //FIXME case AST_CONTROL_SRCUPDATE:
+#endif /* ASTERISK_VERSION_1_4 */
+ NOTICA("Let's NOT INDICATE %d\n", CELLIAX_P_LOG, cond);
+ break;
+ default:
+ WARNINGA("Don't know how to display condition %d on %s\n", CELLIAX_P_LOG, cond,
+ c->name);
+ /* The core will play inband indications for us if appropriate */
+ res = -1;
+ }
+
+ return res;
+}
+
+/*! \brief PBX interface function -build celliax pvt structure
+ * celliax calls initiated by the PBX arrive here */
+struct ast_channel *celliax_request(const char *type, int format, void *data, int *cause)
+{
+ struct celliax_pvt *p = NULL;
+ struct ast_channel *tmp = NULL;
+ char *name = data;
+
+ if (option_debug) {
+ DEBUGA_PBX("ENTERING FUNC\n", CELLIAX_P_LOG);
+ }
+
+ DEBUGA_PBX("Try to request type: %s, name: %s, cause: %d," " format: %d\n",
+ CELLIAX_P_LOG, type, name, *cause, format);
+
+ if (!data) {
+ ERRORA("Channel requested with no data\n", CELLIAX_P_LOG);
+ if (option_debug) {
+ DEBUGA_PBX("EXITING FUNC\n", CELLIAX_P_LOG);
+ }
+ return NULL;
+ }
+
+ /* lock the interfaces' list */
+ LOKKA(&celliax_iflock);
+ /* make a pointer to the first interface in the interfaces list */
+ p = celliax_iflist;
+ /* Search for the requested interface and verify if is unowned and format compatible */
+ //TODO implement groups a la chan_zap
+ while (p) {
+ size_t length = strlen(p->name);
+ /* is this the requested interface? */
+ if (strncmp(name, p->name, length) == 0) {
+ /* is the requested format supported by this interface? */
+ if ((format & AST_FORMAT_SLINEAR) != 0) {
+ /* is this interface unowned? */
+ if (!p->owner) {
+ DEBUGA_PBX("Requesting: %s, name: %s, format: %d\n", CELLIAX_P_LOG, type, name,
+ format);
+ /* create a new channel owning this interface */
+ tmp = celliax_new(p, AST_STATE_DOWN, p->context);
+ if (!tmp) {
+ /* the channel was not created, probable memory allocation error */
+ *cause = AST_CAUSE_SWITCH_CONGESTION;
+ }
+ } else {
+ /* interface owned by another channel */
+ WARNINGA("owned by another channel\n", CELLIAX_P_LOG);
+ *cause = AST_CAUSE_REQUESTED_CHAN_UNAVAIL;
+ }
+ } else {
+ /* requested format not supported */
+ WARNINGA("format %d not supported\n", CELLIAX_P_LOG, format);
+ *cause = AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
+ }
+ /* we found the requested interface, bail out from the while loop */
+ break;
+ }
+ /* not yet found, next please */
+ p = p->next;
+ }
+ /* unlock the interfaces' list */
+ UNLOCKA(&celliax_iflock);
+ /* restart the monitor so it will watch only the remaining unowned interfaces */
+ celliax_restart_monitor();
+ if (tmp == NULL) {
+ /* new channel was not created */
+ WARNINGA("Unable to create new Celliax channel %s\n", CELLIAX_P_LOG, name);
+ }
+ if (option_debug) {
+ DEBUGA_PBX("EXITING FUNC\n", CELLIAX_P_LOG);
+ }
+ /* return the newly created channel */
+ return tmp;
+}
+
+/*! \brief Hangup celliax call
+ * Part of PBX interface, called from ast_hangup */
+
+int celliax_hangup(struct ast_channel *c)
+{
+ struct celliax_pvt *p;
+
+ /* get our celliax pvt interface from channel */
+ p = c->tech_pvt;
+ /* if there is not celliax pvt why we are here ? */
+ if (!p) {
+ ERRORA("Asked to hangup channel not connected\n", CELLIAX_P_LOG);
+ return 0;
+ }
+
+ if (option_debug) {
+ DEBUGA_PBX("ENTERING FUNC\n", CELLIAX_P_LOG);
+ }
+
+ /* shutdown the serial monitoring thread */
+ if (p->controldev_thread && (p->controldev_thread != AST_PTHREADT_NULL)
+ && (p->controldev_thread != AST_PTHREADT_STOP)) {
+ if (pthread_cancel(p->controldev_thread)) {
+ ERRORA("controldev_thread pthread_cancel failed, maybe he killed himself?\n",
+ CELLIAX_P_LOG);
+ }
+ /* push it, maybe is stuck in a select or so */
+ if (pthread_kill(p->controldev_thread, SIGURG)) {
+ DEBUGA_SERIAL("controldev_thread pthread_kill failed, no problem\n", CELLIAX_P_LOG);
+ }
+#ifndef __CYGWIN__ /* under cygwin, this seems to be not reliable, get stuck at times */
+ /* wait for it to die */
+ if (pthread_join(p->controldev_thread, NULL)) {
+ ERRORA("controldev_thread pthread_join failed, BAD\n", CELLIAX_P_LOG);
+ }
+#else /* __CYGWIN__ */
+/* allow the serial thread to die */
+ usleep(300000); //300msecs
+#endif /* __CYGWIN__ */
+ }
+ p->controldev_thread = AST_PTHREADT_NULL;
+
+ if (p->controldevprotocol != PROTOCOL_NO_SERIAL) {
+ if (p->interface_state != AST_STATE_DOWN) {
+ /* actually hangup through the serial port */
+ if (p->controldevprotocol != PROTOCOL_NO_SERIAL) {
+ int res;
+ res = celliax_serial_hangup(p);
+ if (res) {
+ ERRORA("celliax_serial_hangup error: %d\n", CELLIAX_P_LOG, res);
+ if (option_debug) {
+ DEBUGA_PBX("EXITING FUNC\n", CELLIAX_P_LOG);
+ }
+ return -1;
+ }
+ }
+
+ while (p->interface_state != AST_STATE_DOWN) {
+ usleep(10000); //10msec
+ }
+ if (p->interface_state != AST_STATE_DOWN) {
+ ERRORA("call hangup failed\n", CELLIAX_P_LOG);
+ return -1;
+ } else {
+ DEBUGA_SERIAL("call hungup\n", CELLIAX_P_LOG);
+ }
+ }
+ } else {
+ p->interface_state = AST_STATE_DOWN;
+ p->phone_callflow = CALLFLOW_CALL_IDLE;
+ }
+ /* if there is a dsp struct alloced, free it */
+ if (p->dsp) {
+ ast_dsp_free(p->dsp);
+ p->dsp = NULL;
+ }
+#ifndef __CYGWIN__
+#ifdef CELLIAX_ALSA
+/* restart alsa */
+ snd_pcm_drop(p->alsap);
+ snd_pcm_prepare(p->alsap);
+
+ snd_pcm_prepare(p->alsac);
+ snd_pcm_start(p->alsac);
+#endif /* CELLIAX_ALSA */
+
+#endif /* __CYGWIN__ */
+#ifdef CELLIAX_PORTAUDIO
+ speex_echo_state_reset(p->stream->echo_state);
+#endif // CELLIAX_PORTAUDIO
+
+ /* re-init the serial port, be paranoid */
+ if (p->controldevprotocol != PROTOCOL_NO_SERIAL) {
+ p->controldevfd = celliax_serial_init(p, p->controldevice_speed);
+ if (p->controldevfd < 1) {
+ ERRORA("bad, bad, bad\n", CELLIAX_P_LOG);
+ if (option_debug) {
+ DEBUGA_PBX("EXITING FUNC\n", CELLIAX_P_LOG);
+ }
+ return -1;
+ }
+ }
+#ifndef ASTERISK_VERSION_1_4
+ /* subtract one to the usage count of Celliax-type channels */
+ LOKKA(&celliax_usecnt_lock);
+ celliax_usecnt--;
+ if (celliax_usecnt < 0)
+ ERRORA("Usecnt < 0???\n", CELLIAX_P_LOG);
+ UNLOCKA(&celliax_usecnt_lock);
+ ast_update_use_count();
+#else /* ASTERISK_VERSION_1_4 */
+ ast_module_unref(ast_module_info->self);
+#endif /* ASTERISK_VERSION_1_4 */
+
+ /* our celliax pvt interface is no more part of a channel */
+ p->owner = NULL;
+ /* our channel has no more this celliax pvt interface to manage */
+ c->tech_pvt = NULL;
+ /* set the channel state to DOWN, eg. available, not in active use */
+ if (ast_setstate(c, AST_STATE_DOWN)) {
+ ERRORA("ast_setstate failed, BAD\n", CELLIAX_P_LOG);
+ if (option_debug) {
+ DEBUGA_PBX("EXITING FUNC\n", CELLIAX_P_LOG);
+ }
+ return -1;
+ }
+
+ if (option_debug)
+ DEBUGA_PBX("Hanged Up\n", CELLIAX_P_LOG);
+ /* restart the monitor thread, so it can recheck which interfaces it have to watch during its loop (the interfaces that are not owned by channels) */
+ if (celliax_restart_monitor()) {
+ ERRORA("celliax_restart_monitor failed, BAD\n", CELLIAX_P_LOG);
+ if (option_debug) {
+ DEBUGA_PBX("EXITING FUNC\n", CELLIAX_P_LOG);
+ }
+ return -1;
+ }
+
+ if (option_debug) {
+ DEBUGA_PBX("EXITING FUNC\n", CELLIAX_P_LOG);
+ }
+ return 0;
+}
+
+/*! \brief Answer incoming call,
+ * Part of PBX interface */
+int celliax_answer(struct ast_channel *c)
+{
+ struct celliax_pvt *p = c->tech_pvt;
+ int res;
+
+ if (option_debug) {
+ DEBUGA_PBX("ENTERING FUNC\n", CELLIAX_P_LOG);
+ }
+ /* do something to actually answer the call, if needed (eg. pick up the phone) */
+ if (p->controldevprotocol != PROTOCOL_NO_SERIAL) {
+ if (celliax_serial_answer(p)) {
+ ERRORA("celliax_answer FAILED\n", CELLIAX_P_LOG);
+ if (option_debug) {
+ DEBUGA_PBX("EXITING FUNC\n", CELLIAX_P_LOG);
+ }
+ return -1;
+ }
+ }
+ p->interface_state = AST_STATE_UP;
+ p->phone_callflow = CALLFLOW_CALL_ACTIVE;
+
+ while (p->interface_state == AST_STATE_RING) {
+ usleep(10000); //10msec
+ }
+ if (p->interface_state != AST_STATE_UP) {
+ ERRORA("call answering failed\n", CELLIAX_P_LOG);
+ res = -1;
+ } else {
+ if (option_debug)
+ DEBUGA_PBX("call answered\n", CELLIAX_P_LOG);
+ res = 0;
+#ifdef CELLIAX_PORTAUDIO
+ speex_echo_state_reset(p->stream->echo_state);
+#endif // CELLIAX_PORTAUDIO
+
+ if (p->owner) {
+ DEBUGA_PBX("going to send AST_STATE_UP\n", CELLIAX_P_LOG);
+ ast_setstate(p->owner, AST_STATE_UP);
+ //ast_queue_control(p->owner, AST_CONTROL_ANSWER);
+ //celliax_queue_control(p->owner, AST_CONTROL_ANSWER);
+ DEBUGA_PBX("just sent AST_STATE_UP\n", CELLIAX_P_LOG);
+ }
+ }
+ if (option_debug) {
+ DEBUGA_PBX("EXITING FUNC\n", CELLIAX_P_LOG);
+ }
+ return res;
+}
+
+#ifdef ASTERISK_VERSION_1_4
+int celliax_senddigit_begin(struct ast_channel *c, char digit)
+{
+ struct celliax_pvt *p = c->tech_pvt;
+
+ DEBUGA_PBX("DIGIT BEGIN received: %c\n", CELLIAX_P_LOG, digit);
+
+ return 0;
+}
+
+int celliax_senddigit_end(struct ast_channel *c, char digit, unsigned int duration)
+{
+ struct celliax_pvt *p = c->tech_pvt;
+
+ NOTICA("DIGIT END received: %c %d\n", CELLIAX_P_LOG, digit, duration);
+
+ if (p->controldevprotocol == PROTOCOL_AT && p->at_send_dtmf[0]) {
+ int res = 0;
+ char at_command[256];
+
+ memset(at_command, '\0', 256);
+ sprintf(at_command, "%s=\"%c\"", p->at_send_dtmf, digit);
+ res = celliax_serial_write_AT_ack(p, at_command);
+ if (res) {
+ ERRORA("senddigit command failed, command used: '%s=\"%c\"', giving up\n",
+ CELLIAX_P_LOG, p->at_send_dtmf, digit);
+ }
+ }
+ return 0;
+}
+#else /* ASTERISK_VERSION_1_4 */
+int celliax_senddigit(struct ast_channel *c, char digit)
+{
+ struct celliax_pvt *p = c->tech_pvt;
+
+ NOTICA("DIGIT received: %c\n", CELLIAX_P_LOG, digit);
+
+ if (p->controldevprotocol == PROTOCOL_AT && p->at_send_dtmf[0]) {
+ int res = 0;
+ char at_command[256];
+
+ memset(at_command, '\0', 256);
+ sprintf(at_command, "%s=\"%c\"", p->at_send_dtmf, digit);
+ res = celliax_serial_write_AT_ack(p, at_command);
+ if (res) {
+ ERRORA("senddigit command failed, command used: '%s=\"%c\"', giving up\n",
+ CELLIAX_P_LOG, p->at_send_dtmf, digit);
+ }
+ }
+ return 0;
+}
+
+#endif /* ASTERISK_VERSION_1_4 */
+
+/*! \brief Read audio frames from channel */
+struct ast_frame *celliax_read(struct ast_channel *c)
+{
+ struct ast_frame *f;
+ struct celliax_pvt *p = c->tech_pvt;
+ int actual;
+ char buf[128 + 1];
+
+ if (p->dtmf_inited == 0) {
+ dtmf_rx_init(&p->dtmf_state, NULL, NULL);
+ p->dtmf_inited = 1;
+ dtmf_rx_parms(&p->dtmf_state, 0, 10, 10);
+ p->dtmf_timestamp.tv_sec=0;
+ p->dtmf_timestamp.tv_usec=0;
+ DEBUGA_SOUND("DTMF recognition inited\n", CELLIAX_P_LOG);
+ }
+
+/* if there are control frames queued to be sent by celliax_queue_control, send it the first */
+//FIXME maybe better a real queue?
+ if (p && p->owner && p->control_to_send) {
+ ast_queue_control(p->owner, p->control_to_send);
+ DEBUGA_PBX("Sent CONTROL FRAME %d\n", CELLIAX_P_LOG, p->control_to_send);
+ p->control_to_send = 0;
+ }
+
+#ifdef CELLIAX_PORTAUDIO
+/* if the call is not active (ie: answered), do not send audio frames, they would pile up in a lag queue */
+ if (!p->owner || p->owner->_state != AST_STATE_UP)
+#else /* CELLIAX_PORTAUDIO */
+ if (!p->owner )
+#endif /* CELLIAX_PORTAUDIO */
+ {
+ static struct ast_frame f;
+#ifdef CELLIAX_PORTAUDIO
+ char c;
+#endif /* CELLIAX_PORTAUDIO */
+
+ f.frametype = AST_FRAME_NULL;
+ f.subclass = 0;
+ f.samples = 0;
+ f.datalen = 0;
+#ifdef ASTERISK_VERSION_1_6_0_1
+ f.data.ptr = NULL;
+#else
+ f.data = NULL;
+#endif /* ASTERISK_VERSION_1_6_0_1 */
+ f.offset = 0;
+ f.src = celliax_type;
+ f.mallocd = 0;
+ f.delivery.tv_sec = 0;
+ f.delivery.tv_usec = 0;
+/* read the char that was written by the audio thread in this pipe, this pipe is the fd monitored by asterisk, asterisk then has called the function we are inside) */
+#ifdef CELLIAX_PORTAUDIO
+ read(p->audiopipe[0], &c, 1);
+#endif /* CELLIAX_PORTAUDIO */
+
+ return &f;
+ }
+
+ /* read one asterisk frame of audio from sound interface */
+ f = celliax_sound_read(p);
+ if (f) {
+ struct timeval now_timestamp;
+#ifndef __CYGWIN__
+#ifdef CELLIAX_PORTAUDIO
+ char c[1000];
+ int letti = 2;
+
+ while (letti > 1) {
+ letti = read(p->audiopipe[0], &c, 1000);
+ if (letti > 0)
+ DEBUGA_SOUND("READ from audiopipe: %d\n", CELLIAX_P_LOG, letti);
+ //usleep(1);
+ }
+ //if(letti == -1)
+ //ERRORA("error: %s\n", CELLIAX_P_LOG, strerror(errno));
+#endif /* CELLIAX_PORTAUDIO */
+#endif /* __CYGWIN__ */
+
+ /* scale sound samples volume up or down */
+ celliax_sound_boost(f, p->capture_boost);
+
+ gettimeofday(&now_timestamp, NULL);
+
+ if( (((now_timestamp.tv_sec - p->dtmf_timestamp.tv_sec) * 1000000) < 0) || ( ((now_timestamp.tv_sec - p->dtmf_timestamp.tv_sec) * 1000000) + (now_timestamp.tv_usec - p->dtmf_timestamp.tv_usec) ) > 300000) { // if more than 0.3 seconds from last DTMF, or never got DTMFs before
+
+#ifdef ASTERISK_VERSION_1_6_0_1
+ dtmf_rx(&p->dtmf_state, f->data.ptr, f->samples);
+#else
+ dtmf_rx(&p->dtmf_state, f->data, f->samples);
+#endif /* ASTERISK_VERSION_1_6_0_1 */
+ actual = dtmf_rx_get(&p->dtmf_state, buf, 128);
+ if (actual) {
+ //if (option_debug)
+ NOTICA("delta_usec=%ld, inband audio DTMF: %s\n", CELLIAX_P_LOG, ( (now_timestamp.tv_sec - p->dtmf_timestamp.tv_sec) * 1000000) + (now_timestamp.tv_usec - p->dtmf_timestamp.tv_usec), buf);
+ struct ast_frame f2 = { AST_FRAME_DTMF, buf[0], };
+ ast_queue_frame(p->owner, &f2);
+ gettimeofday(&p->dtmf_timestamp, NULL);
+ }
+ }
+ return f;
+ }
+ return NULL;
+}
+
+/*! \brief Initiate celliax call from PBX
+ * used from the dial() application
+ */
+int celliax_call(struct ast_channel *c, char *idest, int timeout)
+{
+ struct celliax_pvt *p = NULL;
+ p = c->tech_pvt;
+ char rdest[80], *where, dstr[100] = "";
+ char *stringp = NULL;
+ int status;
+
+ if (option_debug) {
+ DEBUGA_PBX("ENTERING FUNC\n", CELLIAX_P_LOG);
+ }
+ if ((c->_state != AST_STATE_DOWN)
+ && (c->_state != AST_STATE_RESERVED)) {
+ ERRORA("celliax_call called on %s, neither down nor reserved\n", CELLIAX_P_LOG,
+ c->name);
+ if (option_debug) {
+ DEBUGA_PBX("EXITING FUNC\n", CELLIAX_P_LOG);
+ }
+ return -1;
+ }
+
+ if (option_debug > 1)
+ DEBUGA_PBX("celliax_call to call idest: %s, timeout: %d!\n", CELLIAX_P_LOG, idest,
+ timeout);
+
+ strncpy(rdest, idest, sizeof(rdest) - 1);
+ // try '/' as separator
+ stringp = rdest;
+ strsep(&stringp, "/");
+ where = strsep(&stringp, "/");
+
+ if (!where) {
+ ERRORA
+ ("Destination %s is not recognized. Chan_celliax requires a standard destination with slashes (Celliax/device/destination, eg: 'Celliax/nicephone/3472665618')\n",
+ CELLIAX_P_LOG, idest);
+ if (option_debug) {
+ DEBUGA_PBX("EXITING FUNC\n", CELLIAX_P_LOG);
+ }
+ return -1;
+ }
+
+ strncpy(dstr, where + p->stripmsd, sizeof(dstr) - 1);
+ if (option_debug > 1)
+ DEBUGA_PBX("celliax_call dialing idest: %s, timeout: %d, dstr: %s!\n", CELLIAX_P_LOG,
+ idest, timeout, dstr);
+
+ if (p->controldev_dead) {
+ WARNINGA("celliax_call: device is dead, cannot call!\n", CELLIAX_P_LOG);
+ status = -1;
+ } else {
+ ast_setstate(c, AST_STATE_DIALING);
+ status = celliax_serial_call(p, dstr);
+ }
+
+ if (status) {
+ WARNINGA("celliax_call dialing failed: %d!\n", CELLIAX_P_LOG, status);
+ if (option_debug) {
+ DEBUGA_PBX("EXITING FUNC\n", CELLIAX_P_LOG);
+ }
+ return -1;
+ } else {
+ if (option_debug)
+ DEBUGA_PBX("call ongoing\n", CELLIAX_P_LOG);
+ ast_queue_control(p->owner, AST_CONTROL_RINGING);
+ }
+
+ if (option_debug > 1)
+ DEBUGA_PBX("celliax_call dialed idest: %s, timeout: %d, dstr: %s!\n", CELLIAX_P_LOG,
+ idest, timeout, dstr);
+
+ if (option_debug) {
+ DEBUGA_PBX("EXITING FUNC\n", CELLIAX_P_LOG);
+ }
+#ifdef CELLIAX_PORTAUDIO
+ speex_echo_state_reset(p->stream->echo_state);
+#endif // CELLIAX_PORTAUDIO
+ return 0;
+}
+
+/*! \brief Send audio frame to channel */
+int celliax_write(struct ast_channel *c, struct ast_frame *f)
+{
+ struct celliax_pvt *p = c->tech_pvt;
+ if (p->owner && p->owner->_state != AST_STATE_UP) {
+ return 0;
+ }
+
+ celliax_sound_boost(f, p->playback_boost);
+
+ return celliax_sound_write(p, f);
+}
+
+/*! \brief Fix up a channel: If a channel is consumed, this is called.
+ * Basically update any ->owner links */
+int celliax_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
+{
+ struct celliax_pvt *p = newchan->tech_pvt;
+
+ if (!p) {
+ ERRORA("No pvt after masquerade. Strange things may happen\n", CELLIAX_P_LOG);
+ return -1;
+ }
+
+ if (p->owner != oldchan) {
+ ERRORA("old channel wasn't %p but was %p\n", CELLIAX_P_LOG, oldchan, p->owner);
+ return -1;
+ }
+
+ p->owner = newchan;
+ return 0;
+}
+
+int celliax_sound_boost(struct ast_frame *f, double boost)
+{
+/* LUIGI RIZZO's magic */
+ if (boost != 0) { /* scale and clip values */
+ int i, x;
+
+#ifdef ASTERISK_VERSION_1_6_0_1
+ int16_t *ptr = (int16_t *) f->data.ptr;
+#else
+ int16_t *ptr = (int16_t *) f->data;
+#endif /* ASTERISK_VERSION_1_6_0_1 */
+ for (i = 0; i < f->samples; i++) {
+ x = (ptr[i] * boost) / BOOST_SCALE;
+ if (x > 32767) {
+ x = 32767;
+ } else if (x < -32768) {
+ x = -32768;
+ }
+ ptr[i] = x;
+ }
+ }
+ return 0;
+}
+
+struct ast_channel *celliax_new(struct celliax_pvt *p, int state, char *context)
+{
+ struct ast_channel *tmp;
+
+ if (option_debug) {
+ DEBUGA_PBX("ENTERING FUNC\n", CELLIAX_P_LOG);
+ }
+ /* alloc a generic channel struct */
+#ifndef ASTERISK_VERSION_1_4
+ tmp = ast_channel_alloc(1);
+#else
+ //tmp = ast_channel_alloc(1, state, 0, 0, "", p->exten, p->context, 0, "");
+ tmp =
+ ast_channel_alloc(1, state, 0, 0, "", p->exten, p->context, 0, "Celliax/%s", p->name);
+
+#endif /* ASTERISK_VERSION_1_4 */
+ if (tmp) {
+
+ /* give a name to the newly created channel */
+#ifndef ASTERISK_VERSION_1_4
+ snprintf(tmp->name, sizeof(tmp->name), "Celliax/%s", p->name);
+ tmp->type = celliax_type;
+#else /* ASTERISK_VERSION_1_4 */
+ ast_string_field_build(tmp, name, "Celliax/%s", p->name);
+#endif /* ASTERISK_VERSION_1_4 */
+
+ DEBUGA_PBX("new channel: name=%s requested_state=%d\n", CELLIAX_P_LOG, tmp->name,
+ state);
+
+ /* fd for the channel to poll for incoming audio */
+ tmp->fds[0] = p->celliax_sound_capt_fd;
+
+ /* audio formats managed */
+ tmp->nativeformats = AST_FORMAT_SLINEAR;
+ tmp->readformat = AST_FORMAT_SLINEAR;
+ tmp->writeformat = AST_FORMAT_SLINEAR;
+ /* the technology description (eg. the interface type) of the newly created channel is the Celliax's one */
+ tmp->tech = &celliax_tech;
+ /* the technology pvt (eg. the interface) of the newly created channel is this interface pvt */
+ tmp->tech_pvt = p;
+
+ /* copy this interface default context, extension, language to the newly created channel */
+ if (strlen(p->context))
+ strncpy(tmp->context, p->context, sizeof(tmp->context) - 1);
+ if (strlen(p->exten))
+ strncpy(tmp->exten, p->exten, sizeof(tmp->exten) - 1);
+#ifndef ASTERISK_VERSION_1_4
+ if (strlen(p->language))
+ strncpy(tmp->language, p->language, sizeof(tmp->language) - 1);
+#else
+ if (strlen(p->language))
+ ast_string_field_set(tmp, language, p->language);
+#endif /* ASTERISK_VERSION_1_4 */
+ /* copy the requested context (not necessarily the interface default) to the newly created channel */
+ if (strlen(context))
+ strncpy(tmp->context, context, sizeof(tmp->context) - 1);
+
+ /* copy this interface default callerid in the newly created channel */
+ ast_set_callerid(tmp, !ast_strlen_zero(p->callid_number) ? p->callid_number : NULL,
+ !ast_strlen_zero(p->callid_name) ? p->callid_name : NULL,
+ !ast_strlen_zero(p->callid_number) ? p->callid_number : NULL);
+
+ /* the owner of this interface pvt is the newly created channel */
+ p->owner = tmp;
+ /* if this interface pvt has an initialized dsp struct, free it */
+ if (p->dsp) {
+ DEBUGA_SOUND("freeing dsp\n", CELLIAX_P_LOG);
+ ast_dsp_free(p->dsp);
+ p->dsp = NULL;
+ }
+#ifndef ASTERISK_VERSION_1_4
+ /* set the newly created channel state to the requested state */
+ if (ast_setstate(tmp, state)) {
+ ERRORA("ast_setstate failed, BAD\n", CELLIAX_P_LOG);
+ ast_dsp_free(p->dsp);
+ ast_channel_free(tmp);
+ if (option_debug) {
+ DEBUGA_PBX("EXITING FUNC\n", CELLIAX_P_LOG);
+ }
+ return NULL;
+ }
+#endif /* ASTERISK_VERSION_1_4 */
+
+#ifdef AST_VERION_1_4
+ ast_module_ref(ast_module_info->self);
+ ast_jb_configure(tmp, &global_jbconf);
+#endif /* AST_VERION_1_4 */
+
+ /* if the requested state is different from DOWN, let the pbx manage this interface (now part of the newly created channel) */
+ if (state != AST_STATE_DOWN) {
+ DEBUGA_PBX("Try to start PBX on %s, state=%d\n", CELLIAX_P_LOG, tmp->name, state);
+ if (ast_pbx_start(tmp)) {
+ ERRORA("Unable to start PBX on %s\n", CELLIAX_P_LOG, tmp->name);
+ ast_dsp_free(p->dsp);
+ ast_channel_free(tmp);
+ if (option_debug) {
+ DEBUGA_PBX("EXITING FUNC\n", CELLIAX_P_LOG);
+ }
+ return NULL;
+ }
+ }
+ /* let's start the serial monitoring thread too, so we can have serial signaling */
+ if (ast_pthread_create(&p->controldev_thread, NULL, celliax_do_controldev_thread, p) <
+ 0) {
+ ERRORA("Unable to start controldev thread.\n", CELLIAX_P_LOG);
+ ast_dsp_free(p->dsp);
+ ast_channel_free(tmp);
+ tmp = NULL;
+ }
+ DEBUGA_SERIAL("STARTED controldev_thread=%lu STOP=%lu NULL=%lu\n", CELLIAX_P_LOG,
+ (unsigned long) p->controldev_thread, (unsigned long) AST_PTHREADT_STOP,
+ (unsigned long) AST_PTHREADT_NULL);
+
+#ifndef ASTERISK_VERSION_1_4
+ /* add one to the usage count of Celliax-type channels */
+ LOKKA(&celliax_usecnt_lock);
+ celliax_usecnt++;
+ UNLOCKA(&celliax_usecnt_lock);
+ ast_update_use_count();
+#endif /* ASTERISK_VERSION_1_4 */
+
+ /* return the newly created channel */
+ if (option_debug) {
+ DEBUGA_PBX("EXITING FUNC\n", CELLIAX_P_LOG);
+ }
+ return tmp;
+ }
+ ERRORA("failed memory allocation for Celliax channel\n", CELLIAX_P_LOG);
+ if (option_debug) {
+ DEBUGA_PBX("EXITING FUNC\n", CELLIAX_P_LOG);
+ }
+ return NULL;
+}
+
+/*!
+ * \brief Load the module into Asterisk and start its threads
+ *
+ * This function register the module into Asterisk,
+ * create the interfaces for the channels,
+ * start the auxiliary threads for the interfaces,
+ * then start a monitor thread. The monitor thread
+ * will signal Asterisk when an interface receive a call.
+ *
+ *
+ * \return zero on success, -1 on error.
+ */
+int load_module(void)
+{
+ int i;
+ struct ast_config *cfg;
+ struct celliax_pvt *tmp;
+ struct celliax_pvt *p = NULL;
+#ifdef ASTERISK_VERSION_1_6_0
+ struct ast_flags config_flags = { 0 };
+#endif /* ASTERISK_VERSION_1_6_0 */
+
+
+
+#ifdef ASTERISK_VERSION_1_4
+ /* Copy the default jb config over global_jbconf */
+ memcpy(&global_jbconf, &default_jbconf, sizeof(struct ast_jb_conf));
+#endif /* ASTERISK_VERSION_1_4 */
+
+ if (option_debug) {
+ DEBUGA_PBX("ENTERING FUNC\n", CELLIAX_P_LOG);
+ }
+ ast_register_application(celliax_sendsmsapp, celliax_sendsms, celliax_sendsmssynopsis,
+ celliax_sendsmsdescrip);
+
+ ast_manager_register2("CELLIAXsendsms", EVENT_FLAG_SYSTEM, celliax_manager_sendsms,
+ "Send an SMS", mandescr_celliax_sendsms);
+ /* make sure we can register our channel type with Asterisk */
+ i = ast_channel_register(&celliax_tech);
+ if (i < 0) {
+ ERRORA("Unable to register channel type '%s'\n", CELLIAX_P_LOG, celliax_type);
+ if (option_debug) {
+ DEBUGA_PBX("EXITING FUNC\n", CELLIAX_P_LOG);
+ }
+ return -1;
+ }
+ /* load celliax.conf config file */
+#ifdef ASTERISK_VERSION_1_6_0
+ cfg = ast_config_load(celliax_config, config_flags);
+#else
+ cfg = ast_config_load(celliax_config);
+#endif /* ASTERISK_VERSION_1_6_0 */
+ if (cfg != NULL) {
+ char *ctg = NULL;
+ int is_first_category = 1;
+ while ((ctg = ast_category_browse(cfg, ctg)) != NULL) {
+ /* create one interface for each category in celliax.conf config file, first one set the defaults */
+ tmp = celliax_mkif(cfg, ctg, is_first_category);
+ if (tmp) {
+ NOTICA("Created channel Celliax: celliax.conf category '[%s]', channel name '%s'"
+ " control_device_name '%s'\n", CELLIAX_P_LOG, ctg, tmp->name,
+ tmp->controldevice_name);
+ /* add interface to celliax_iflist */
+ tmp->next = celliax_iflist;
+ celliax_iflist = tmp;
+ /* next one will not be the first ;) */
+ if (is_first_category == 1) {
+ is_first_category = 0;
+ celliax_console_active = tmp->name;
+ }
+ } else {
+ ERRORA("Unable to create channel Celliax from celliax.conf category '[%s]'\n",
+ CELLIAX_P_LOG, ctg);
+ /* if error, unload config from memory and return */
+ ast_config_destroy(cfg);
+ ast_channel_unregister(&celliax_tech);
+ if (option_debug) {
+ DEBUGA_PBX("EXITING FUNC\n", CELLIAX_P_LOG);
+ }
+ return -1;
+ }
+ /* do it for each category described in config */
+ }
+
+ /* we finished, unload config from memory */
+ ast_config_destroy(cfg);
+ } else {
+ ERRORA("Unable to load celliax_config celliax.conf\n", CELLIAX_P_LOG);
+ ast_channel_unregister(&celliax_tech);
+ if (option_debug) {
+ DEBUGA_PBX("EXITING FUNC\n", CELLIAX_P_LOG);
+ }
+ return -1;
+ }
+#ifndef ASTERISK_VERSION_1_6_0
+ ast_cli_register_multiple(myclis, sizeof(myclis) / sizeof(struct ast_cli_entry));
+#endif /* ASTERISK_VERSION_1_6_0 */
+ /* start to monitor the interfaces (celliax_iflist) for the first time */
+ if (celliax_restart_monitor()) {
+ ERRORA("celliax_restart_monitor failed, BAD\n", CELLIAX_P_LOG);
+ if (option_debug) {
+ DEBUGA_PBX("EXITING FUNC\n", CELLIAX_P_LOG);
+ }
+ return -1;
+ }
+#ifdef CELLIAX_DIR
+ //celliax_dir_create_extensions();
+#endif /* CELLIAX_DIR */
+ if (option_debug) {
+ DEBUGA_PBX("EXITING FUNC\n", CELLIAX_P_LOG);
+ }
+ return 0;
+}
+
+/*!
+ * \brief Unload the module from Asterisk and shutdown its threads
+ *
+ * This function unregister the module from Asterisk,
+ * destroy the interfaces for the channels,
+ * shutdown the auxiliary threads for the interfaces,
+ * then shutdown its monitor thread.
+ *
+ * \return zero on success, -1 on error.
+ */
+int unload_module(void)
+{
+ struct celliax_pvt *p = NULL, *p2 = NULL;
+ int res;
+
+ if (option_debug) {
+ DEBUGA_PBX("ENTERING FUNC\n", CELLIAX_P_LOG);
+ }
+
+ /* unregister our channel type with Asterisk */
+ ast_channel_unregister(&celliax_tech);
+ ast_cli_unregister_multiple(myclis, sizeof(myclis) / sizeof(struct ast_cli_entry));
+
+ ast_unregister_application(celliax_sendsmsapp);
+
+ /* lock the celliax_monlock, kill the monitor thread, unlock the celliax_monlock */
+ LOKKA(&celliax_monlock);
+ if (celliax_monitor_thread && (celliax_monitor_thread != AST_PTHREADT_NULL)
+ && (celliax_monitor_thread != AST_PTHREADT_STOP)) {
+ if (pthread_cancel(celliax_monitor_thread)) {
+ ERRORA("pthread_cancel failed, BAD\n", CELLIAX_P_LOG);
+ if (option_debug) {
+ DEBUGA_PBX("EXITING FUNC\n", CELLIAX_P_LOG);
+ }
+ return -1;
+ }
+ if (pthread_kill(celliax_monitor_thread, SIGURG)) {
+ DEBUGA_PBX("pthread_kill failed\n", CELLIAX_P_LOG); //maybe it just died
+ }
+#ifndef __CYGWIN__ /* under cygwin, this seems to be not reliable, get stuck at times */
+ if (pthread_join(celliax_monitor_thread, NULL)) {
+ ERRORA("pthread_join failed, BAD\n", CELLIAX_P_LOG);
+ if (option_debug) {
+ DEBUGA_PBX("EXITING FUNC\n", CELLIAX_P_LOG);
+ }
+ return -1;
+ }
+#endif /* __CYGWIN__ */
+ }
+ celliax_monitor_thread = AST_PTHREADT_STOP;
+ UNLOCKA(&celliax_monlock);
+
+ if (celliax_monitor_audio_thread && (celliax_monitor_audio_thread != AST_PTHREADT_NULL)
+ && (celliax_monitor_audio_thread != AST_PTHREADT_STOP)) {
+
+ if (pthread_cancel(celliax_monitor_audio_thread)) {
+ ERRORA("pthread_cancel celliax_monitor_audio_thread failed, BAD\n", CELLIAX_P_LOG);
+ }
+ if (pthread_kill(celliax_monitor_audio_thread, SIGURG)) {
+ DEBUGA_PBX("pthread_kill celliax_monitor_audio_thread failed, no problem\n", CELLIAX_P_LOG); //maybe it just died
+ }
+
+ if (pthread_join(celliax_monitor_audio_thread, NULL)) {
+ ERRORA("pthread_join failed, BAD\n", CELLIAX_P_LOG);
+ }
+ }
+ /* lock the celliax_iflock, and go through the interfaces list (celliax_iflist) */
+ LOKKA(&celliax_iflock);
+ p = celliax_iflist;
+ while (p) {
+ /* for each interface in list */
+ p2 = p->next;
+ /* shutdown the sound system, close sound fds, and if exist shutdown the sound managing threads */
+ DEBUGA_SOUND("shutting down sound\n", CELLIAX_P_LOG);
+ res = celliax_sound_shutdown(p);
+ if (res == -1) {
+ ERRORA("Failed to shutdown sound\n", CELLIAX_P_LOG);
+ }
+
+ /* if a serial port has been opened, close it */
+ if (p->controldevprotocol != PROTOCOL_NO_SERIAL)
+ if (p->controldevfd)
+ close(p->controldevfd);
+
+ /* if a dsp struct has been allocated, free it */
+ if (p->dsp) {
+ ast_dsp_free(p->dsp);
+ p->dsp = NULL;
+ }
+ DEBUGA_PBX("freeing PVT\n", CELLIAX_P_LOG);
+ /* free the pvt allocated memory */
+ free(p);
+ /* next one, please */
+ p = p2;
+ }
+ /* finished with the interfaces list, unlock the celliax_iflock */
+ UNLOCKA(&celliax_iflock);
+
+#ifdef __CYGWIN__
+ NOTICA("Sleping 5 secs, please wait...\n", CELLIAX_P_LOG);
+ sleep(5); /* without this pause, for some unknown (to me) reason it crashes on cygwin */
+#endif /* __CYGWIN__ */
+ NOTICA("Unloaded Celliax Module\n", CELLIAX_P_LOG);
+ if (option_debug) {
+ DEBUGA_PBX("EXITING FUNC\n", CELLIAX_P_LOG);
+ }
+ return 0;
+}
+
+/*!
+ * \brief Return the count of active channels for this module
+ *
+ * \return the count of active channels for this module
+ */
+int usecount()
+{
+ int res;
+ static struct celliax_pvt *p = &celliax_log_struct;
+/* lock the celliax_usecnt lock */
+ LOKKA(&celliax_usecnt_lock);
+ /* retrieve the celliax_usecnt */
+ res = celliax_usecnt;
+/* unlock the celliax_usecnt lock */
+ UNLOCKA(&celliax_usecnt_lock);
+ /* return the celliax_usecnt */
+ return res;
+}
+
+/*!
+ * \brief Return the textual description of the module
+ *
+ * \return the textual description of the module
+ */
+char *description()
+{
+ return (char *) celliax_desc;
+}
+
+/*!
+ * \brief Return the ASTERISK_GPL_KEY
+ *
+ * \return the ASTERISK_GPL_KEY
+ */
+char *key()
+{
+ struct celliax_pvt *p = NULL;
+
+ if (option_debug)
+ NOTICA("Returning Key\n", CELLIAX_P_LOG);
+
+ return ASTERISK_GPL_KEY;
+}
+
+/*!
+ * \brief Create and initialize one interface for the module
+ * \param cfg pointer to configuration data from celliax.conf
+ * \param ctg pointer to a category name to be found in cfg
+ * \param is_first_category is this the first category in cfg
+ *
+ * This function create and initialize one interface for the module
+ *
+ * \return a pointer to the PVT structure of interface on success, NULL on error.
+ */
+struct celliax_pvt *celliax_mkif(struct ast_config *cfg, char *ctg, int is_first_category)
+{
+ struct celliax_pvt *tmp;
+ struct ast_variable *v;
+ int res;
+
+ int debug_all = 0;
+ int debug_at = 0;
+ int debug_fbus2 = 0;
+ int debug_serial = 0;
+ int debug_sound = 0;
+ int debug_pbx = 0;
+ int debug_skype = 0;
+ int debug_call = 0;
+ int debug_locks = 0;
+ int debug_monitorlocks = 0;
+#ifdef CELLIAX_CVM
+ int debug_cvm = 0;
+#endif /* CELLIAX_CVM */
+
+ /* alloc memory for PVT */
+ tmp = malloc(sizeof(struct celliax_pvt));
+ if (tmp == NULL) /* fail */
+ return NULL;
+ /* clear memory for PVT */
+ memset(tmp, 0, sizeof(struct celliax_pvt));
+
+ //NOTICA("malloced %d bytes\n", CELLIAX_TMP_LOG, sizeof(struct celliax_pvt));
+
+ /* if we are reading the "first" category of the config file, take SELECTED values as defaults, overriding the values in celliax_default */
+ if (is_first_category == 1) {
+ /* for each variable in category, copy it in the celliax_default struct */
+ for (v = ast_variable_browse(cfg, ctg); v; v = v->next) {
+ M_START(v->name, v->value);
+
+ M_STR("control_device_protocol", celliax_default.controldevprotocolname)
+ M_STR("context", celliax_default.context)
+ M_STR("language", celliax_default.language)
+ M_STR("extension", celliax_default.exten)
+ M_UINT("dsp_silence_threshold", celliax_default.dsp_silence_threshold)
+ M_UINT("audio_play_reset_period", celliax_default.audio_play_reset_period)
+#ifdef CELLIAX_ALSA
+ M_UINT("alsa_period_size", celliax_default.alsa_period_size)
+ M_UINT("alsa_periods_in_buffer", celliax_default.alsa_periods_in_buffer)
+#endif /* CELLIAX_ALSA */
+ M_F("playback_boost",
+ celliax_store_boost(v->value, &celliax_default.playback_boost))
+ M_F("capture_boost",
+ celliax_store_boost(v->value, &celliax_default.capture_boost))
+ M_UINT("celliax_dir_entry_extension_prefix",
+ celliax_default.celliax_dir_entry_extension_prefix)
+ M_UINT("celliax_dir_prefix", celliax_default.celliax_dir_prefix)
+ M_STR("sms_receiving_program", tmp->sms_receiving_program)
+ M_END(;
+ );
+ }
+ }
+
+ /* initialize the newly created PVT from the celliax_default values */
+ *tmp = celliax_default;
+
+ /* initialize the mutexes */
+ ast_mutex_init(&tmp->controldev_lock);
+ ast_mutex_init(&tmp->fbus2_outgoing_list_lock);
+#ifdef CELLIAX_CVM
+ ast_mutex_init(&tmp->cvm_busmail_outgoing_list_lock);
+#endif /* CELLIAX_CVM */
+
+ /* the category name becomes the interface name */
+ tmp->name = strdup(ctg);
+
+ /* for each category in config file, "first" included, read in ALL the values */
+ for (v = ast_variable_browse(cfg, ctg); v; v = v->next) {
+ M_START(v->name, v->value);
+
+ M_BOOL("debug_all", debug_all)
+ M_BOOL("debug_at", debug_at)
+ M_BOOL("debug_fbus2", debug_fbus2)
+ M_BOOL("debug_serial", debug_serial)
+ M_BOOL("debug_sound", debug_sound)
+ M_BOOL("debug_pbx", debug_pbx)
+ M_BOOL("debug_skype", debug_skype)
+ M_BOOL("debug_call", debug_call)
+ M_BOOL("debug_locks", debug_locks)
+ M_BOOL("debug_monitorlocks", debug_monitorlocks)
+#ifdef CELLIAX_CVM
+ M_BOOL("debug_cvm", debug_cvm)
+ M_STR("cvm_subscription_1_pin", tmp->cvm_subsc_1_pin)
+ M_STR("cvm_subscription_2_pin", tmp->cvm_subsc_2_pin)
+ M_UINT("cvm_subscription_no", tmp->cvm_subsc_no)
+ M_UINT("cvm_volume_level", tmp->cvm_volume_level)
+ M_UINT("cvm_celliax_serial_delay", tmp->cvm_celliax_serial_delay)
+#endif /* CELLIAX_CVM */
+ M_BOOL("skype", tmp->skype)
+ M_BOOL("need_acoustic_ring", tmp->need_acoustic_ring)
+ M_STR("control_device_name", tmp->controldevice_name)
+ M_UINT("control_device_speed", tmp->controldevice_speed)
+ M_STR("control_device_protocol", tmp->controldevprotocolname)
+ M_STR("context", tmp->context)
+ M_STR("language", tmp->language)
+ M_STR("extension", tmp->exten)
+ M_UINT("dsp_silence_threshold", tmp->dsp_silence_threshold)
+ M_UINT("audio_play_reset_period", tmp->audio_play_reset_period)
+ M_UINT("portaudio_capture_device_id", tmp->portaudiocindex)
+ M_UINT("portaudio_playback_device_id", tmp->portaudiopindex)
+ M_F("playback_boost", celliax_store_boost(v->value, &tmp->playback_boost))
+ M_F("capture_boost", celliax_store_boost(v->value, &tmp->capture_boost))
+#ifdef CELLIAX_ALSA
+ M_STR("alsa_capture_device_name", tmp->alsacname)
+ M_STR("alsa_playback_device_name", tmp->alsapname)
+ M_UINT("alsa_period_size", tmp->alsa_period_size)
+ M_UINT("alsa_periods_in_buffer", tmp->alsa_periods_in_buffer)
+#endif /* CELLIAX_WINMM */
+ M_STR("at_dial_pre_number", tmp->at_dial_pre_number)
+ M_STR("at_dial_post_number", tmp->at_dial_post_number)
+
+ M_STR("at_dial_expect", tmp->at_dial_expect)
+ M_UINT("at_early_audio", tmp->at_early_audio)
+ M_STR("at_hangup", tmp->at_hangup)
+ M_STR("at_hangup_expect", tmp->at_hangup_expect)
+ M_STR("at_answer", tmp->at_answer)
+ M_STR("at_answer_expect", tmp->at_answer_expect)
+ M_STR("at_send_dtmf", tmp->at_send_dtmf)
+
+ M_UINT("at_initial_pause", tmp->at_initial_pause)
+ M_STR("at_preinit_1", tmp->at_preinit_1)
+ M_STR("at_preinit_1_expect", tmp->at_preinit_1_expect)
+ M_STR("at_preinit_2", tmp->at_preinit_2)
+ M_STR("at_preinit_2_expect", tmp->at_preinit_2_expect)
+ M_STR("at_preinit_3", tmp->at_preinit_3)
+ M_STR("at_preinit_3_expect", tmp->at_preinit_3_expect)
+ M_STR("at_preinit_4", tmp->at_preinit_4)
+ M_STR("at_preinit_4_expect", tmp->at_preinit_4_expect)
+ M_STR("at_preinit_5", tmp->at_preinit_5)
+ M_STR("at_preinit_5_expect", tmp->at_preinit_5_expect)
+ M_UINT("at_after_preinit_pause", tmp->at_after_preinit_pause)
+
+ M_STR("at_postinit_1", tmp->at_postinit_1)
+ M_STR("at_postinit_1_expect", tmp->at_postinit_1_expect)
+ M_STR("at_postinit_2", tmp->at_postinit_2)
+ M_STR("at_postinit_2_expect", tmp->at_postinit_2_expect)
+ M_STR("at_postinit_3", tmp->at_postinit_3)
+ M_STR("at_postinit_3_expect", tmp->at_postinit_3_expect)
+ M_STR("at_postinit_4", tmp->at_postinit_4)
+ M_STR("at_postinit_4_expect", tmp->at_postinit_4_expect)
+ M_STR("at_postinit_5", tmp->at_postinit_5)
+ M_STR("at_postinit_5_expect", tmp->at_postinit_5_expect)
+
+ M_STR("at_query_battchg", tmp->at_query_battchg)
+ M_STR("at_query_battchg_expect", tmp->at_query_battchg_expect)
+ M_STR("at_query_signal", tmp->at_query_signal)
+ M_STR("at_query_signal_expect", tmp->at_query_signal_expect)
+ M_STR("at_call_idle", tmp->at_call_idle)
+ M_STR("at_call_incoming", tmp->at_call_incoming)
+ M_STR("at_call_active", tmp->at_call_active)
+ M_STR("at_call_failed", tmp->at_call_failed)
+ M_STR("at_call_calling", tmp->at_call_calling)
+ M_STR("at_indicator_noservice_string", tmp->at_indicator_noservice_string)
+ M_STR("at_indicator_nosignal_string", tmp->at_indicator_nosignal_string)
+ M_STR("at_indicator_lowsignal_string", tmp->at_indicator_lowsignal_string)
+ M_STR("at_indicator_lowbattchg_string", tmp->at_indicator_lowbattchg_string)
+ M_STR("at_indicator_nobattchg_string", tmp->at_indicator_nobattchg_string)
+ M_STR("at_indicator_callactive_string", tmp->at_indicator_callactive_string)
+ M_STR("at_indicator_nocallactive_string", tmp->at_indicator_nocallactive_string)
+ M_STR("at_indicator_nocallsetup_string", tmp->at_indicator_nocallsetup_string)
+ M_STR("at_indicator_callsetupincoming_string",
+ tmp->at_indicator_callsetupincoming_string)
+ M_STR("at_indicator_callsetupoutgoing_string",
+ tmp->at_indicator_callsetupoutgoing_string)
+ M_STR("at_indicator_callsetupremoteringing_string",
+ tmp->at_indicator_callsetupremoteringing_string)
+ M_UINT("celliax_dir_entry_extension_prefix",
+ tmp->celliax_dir_entry_extension_prefix)
+ M_UINT("celliax_dir_prefix", tmp->celliax_dir_prefix)
+#ifdef CELLIAX_LIBCSV
+ M_UINT("csv_separator_is_semicolon", tmp->csv_separator_is_semicolon)
+ M_UINT("csv_complete_name_pos", tmp->csv_complete_name_pos)
+ M_UINT("csv_email_pos", tmp->csv_email_pos)
+ M_UINT("csv_home_phone_pos", tmp->csv_home_phone_pos)
+ M_UINT("csv_mobile_phone_pos", tmp->csv_mobile_phone_pos)
+ M_UINT("csv_business_phone_pos", tmp->csv_business_phone_pos)
+ M_UINT("csv_first_row_is_title", tmp->csv_first_row_is_title)
+#endif /* CELLIAX_LIBCSV */
+ M_STR("sms_receiving_program", tmp->sms_receiving_program)
+ M_BOOL("speexecho", tmp->speexecho)
+ M_BOOL("speexpreprocess", tmp->speexpreprocess)
+ M_END(;
+ );
+ }
+
+ if (debug_all) {
+ celliax_debug = celliax_debug | DEBUG_ALL;
+ if (!option_debug) {
+ WARNINGA
+ ("DEBUG_ALL activated, but option_debug is 0. You have to set debug level higher than zero to see some debugging output. Please use the command \"set debug 10\" or start Asterisk with \"-dddddddddd\" option for full DEBUG_ALL debugging output.\n",
+ CELLIAX_TMP_LOG);
+ } else {
+ NOTICA("DEBUG_ALL activated. \n", CELLIAX_TMP_LOG);
+ }
+ }
+ if (debug_at) {
+ celliax_debug = celliax_debug | DEBUG_AT;
+ if (!option_debug) {
+ WARNINGA
+ ("DEBUG_AT activated, but option_debug is 0. You have to set debug level higher than zero to see some debugging output. Please use the command \"set debug 10\" or start Asterisk with \"-dddddddddd\" option for full DEBUG_AT debugging output.\n",
+ CELLIAX_TMP_LOG);
+ } else {
+ NOTICA("DEBUG_AT activated. \n", CELLIAX_TMP_LOG);
+ }
+ }
+
+ if (debug_fbus2) {
+ celliax_debug = celliax_debug | DEBUG_FBUS2;
+ if (!option_debug) {
+ WARNINGA
+ ("DEBUG_FBUS2 activated, but option_debug is 0. You have to set debug level higher than zero to see some debugging output. Please use the command \"set debug 10\" or start Asterisk with \"-dddddddddd\" option for full DEBUG_FBUS2 debugging output.\n",
+ CELLIAX_TMP_LOG);
+ } else {
+ NOTICA("DEBUG_FBUS2 activated. \n", CELLIAX_TMP_LOG);
+ }
+ }
+
+ if (debug_serial) {
+ celliax_debug = celliax_debug | DEBUG_SERIAL;
+ if (!option_debug) {
+ WARNINGA
+ ("DEBUG_SERIAL activated, but option_debug is 0. You have to set debug level higher than zero to see some debugging output. Please use the command \"set debug 10\" or start Asterisk with \"-dddddddddd\" option for full DEBUG_SERIAL debugging output.\n",
+ CELLIAX_TMP_LOG);
+ } else {
+ NOTICA("DEBUG_SERIAL activated. \n", CELLIAX_TMP_LOG);
+ }
+ }
+
+ if (debug_sound) {
+ celliax_debug = celliax_debug | DEBUG_SOUND;
+ if (!option_debug) {
+ WARNINGA
+ ("DEBUG_SOUND activated, but option_debug is 0. You have to set debug level higher than zero to see some debugging output. Please use the command \"set debug 10\" or start Asterisk with \"-dddddddddd\" option for full DEBUG_SOUND debugging output.\n",
+ CELLIAX_TMP_LOG);
+ } else {
+ NOTICA("DEBUG_SOUND activated. \n", CELLIAX_TMP_LOG);
+ }
+ }
+
+ if (debug_pbx) {
+ celliax_debug = celliax_debug | DEBUG_PBX;
+ if (!option_debug) {
+ WARNINGA
+ ("DEBUG_PBX activated, but option_debug is 0. You have to set debug level higher than zero to see some debugging output. Please use the command \"set debug 10\" or start Asterisk with \"-dddddddddd\" option for full DEBUG_PBX debugging output.\n",
+ CELLIAX_TMP_LOG);
+ } else {
+ NOTICA("DEBUG_PBX activated. \n", CELLIAX_TMP_LOG);
+ }
+ }
+
+ if (debug_call) {
+ celliax_debug = celliax_debug | DEBUG_CALL;
+ if (!option_debug) {
+ WARNINGA
+ ("DEBUG_CALL activated, but option_debug is 0. You have to set debug level higher than zero to see some debugging output. Please use the command \"set debug 10\" or start Asterisk with \"-dddddddddd\" option for full DEBUG_CALL debugging output.\n",
+ CELLIAX_TMP_LOG);
+ } else {
+ NOTICA("DEBUG_CALL activated. \n", CELLIAX_TMP_LOG);
+ }
+ }
+
+ if (debug_locks) {
+ celliax_debug = celliax_debug | DEBUG_LOCKS;
+ if (!option_debug) {
+ WARNINGA
+ ("DEBUG_LOCKS activated, but option_debug is 0. You have to set debug level higher than zero to see some debugging output. Please use the command \"set debug 10\" or start Asterisk with \"-dddddddddd\" option for full DEBUG_LOCKS debugging output.\n",
+ CELLIAX_TMP_LOG);
+ } else {
+ NOTICA("DEBUG_LOCKS activated. \n", CELLIAX_TMP_LOG);
+ }
+ }
+
+ if (debug_monitorlocks) {
+ celliax_debug = celliax_debug | DEBUG_MONITORLOCKS;
+ if (!option_debug) {
+ WARNINGA
+ ("DEBUG_MONITORLOCKS activated, but option_debug is 0. You have to set debug level higher than zero to see some debugging output. Please use the command \"set debug 10\" or start Asterisk with \"-dddddddddd\" option for full DEBUG_MONITORLOCKS debugging output.\n",
+ CELLIAX_TMP_LOG);
+ } else {
+ NOTICA("DEBUG_MONITORLOCKS activated. \n", CELLIAX_TMP_LOG);
+ }
+ }
+#ifdef CELLIAX_CVM
+ if (debug_cvm) {
+ celliax_debug = celliax_debug | DEBUG_CVM;
+ if (!option_debug) {
+ WARNINGA
+ ("DEBUG_CVM activated, but option_debug is 0. You have to set debug level higher than zero to see some debugging output. Please use the command \"set debug 10\" or start Asterisk with \"-dddddddddd\" option for full DEBUG_CVM debugging output.\n",
+ CELLIAX_TMP_LOG);
+ } else {
+ NOTICA("DEBUG_CVM activated. \n", CELLIAX_TMP_LOG);
+ }
+ }
+#endif /* CELLIAX_CVM */
+
+ if (option_debug > 1) {
+ DEBUGA_SOUND("playback_boost is %f\n", CELLIAX_TMP_LOG, tmp->playback_boost);
+ DEBUGA_SOUND("capture_boost is %f\n", CELLIAX_TMP_LOG, tmp->capture_boost);
+ }
+
+ /* serial protocols are named in config with a string, but as int in this software */
+ if (strcasecmp(tmp->controldevprotocolname, "fbus2") == 0)
+ tmp->controldevprotocol = PROTOCOL_FBUS2;
+ else if (strcasecmp(tmp->controldevprotocolname, "at") == 0)
+ tmp->controldevprotocol = PROTOCOL_AT;
+ else if (strcasecmp(tmp->controldevprotocolname, "no_serial") == 0)
+ tmp->controldevprotocol = PROTOCOL_NO_SERIAL;
+ else if (strcasecmp(tmp->controldevprotocolname, "alsa_voicemodem") == 0)
+ tmp->controldevprotocol = PROTOCOL_ALSA_VOICEMODEM;
+#ifdef CELLIAX_CVM
+ else if (strcasecmp(tmp->controldevprotocolname, "cvm_busmail") == 0)
+ tmp->controldevprotocol = PROTOCOL_CVM_BUSMAIL;
+#endif /* CELLIAX_CVM */
+ else {
+#ifndef CELLIAX_CVM
+ ERRORA
+ ("control_device_protocol in celliax.conf MUST be = fbus2|at|no_serial|alsa_voicemodem, but is = '%s'\n",
+ CELLIAX_TMP_LOG,
+ tmp->controldevprotocolname ? tmp->controldevprotocolname : "NULL");
+#else
+ ERRORA
+ ("control_device_protocol in celliax.conf MUST be = fbus2|at|no_serial|alsa_voicemodem|cvm_busmail, but is = '%s'\n",
+ CELLIAX_TMP_LOG,
+ tmp->controldevprotocolname ? tmp->controldevprotocolname : "NULL");
+#endif /* CELLIAX_CVM */
+
+ /* we failed, free the PVT */
+ free(tmp);
+ return NULL;
+ }
+
+ if (tmp->controldevice_speed != celliax_default.controldevice_speed) {
+ /* serial speeds are numbers in config file, but we needs definitions in this software */
+ if (tmp->controldevice_speed == 9600)
+ tmp->controldevice_speed = B9600;
+ else if (tmp->controldevice_speed == 19200)
+ tmp->controldevice_speed = B19200;
+ else if (tmp->controldevice_speed == 38400)
+ tmp->controldevice_speed = B38400;
+ else if (tmp->controldevice_speed == 57600)
+ tmp->controldevice_speed = B57600;
+ else if (tmp->controldevice_speed == 115200)
+ tmp->controldevice_speed = B115200;
+ else {
+ ERRORA
+ ("controldevice_speed has to be given one of the following values: 9600|19200|38400|57600|115200. In the config file, was given: %d\n",
+ CELLIAX_TMP_LOG, tmp->controldevice_speed);
+ free(tmp);
+ return NULL;
+ }
+ }
+
+/* CVM PP DECT modules supports registration to two DECT FPs (bases), but CVM can be only connected to one DECT FP at the time, so we need two PINs (for registration) and info to which DECT FP connect*/
+#ifdef CELLIAX_CVM
+ if (tmp->cvm_subsc_no != celliax_default.cvm_subsc_no) {
+ if ((tmp->cvm_subsc_no != 1) && (tmp->cvm_subsc_no != 2)) {
+ ERRORA
+ ("cvm_subscription_no has to be given one of the following values: 1|2. In the config file, was given: %d\n",
+ CELLIAX_TMP_LOG, tmp->cvm_subsc_no);
+ free(tmp);
+ return NULL;
+ }
+ }
+
+ if (tmp->cvm_subsc_1_pin != celliax_default.cvm_subsc_1_pin) {
+ if (4 != strlen(tmp->cvm_subsc_1_pin)) {
+ ERRORA
+ ("cvm_subscription_1_pin has to be 4 digits long. In the config file, was given: %s\n",
+ CELLIAX_TMP_LOG, tmp->cvm_subsc_1_pin);
+ free(tmp);
+ return NULL;
+ }
+ }
+
+ if (tmp->cvm_subsc_2_pin != celliax_default.cvm_subsc_2_pin) {
+ if (4 != strlen(tmp->cvm_subsc_2_pin)) {
+ ERRORA
+ ("cvm_subscription_2_pin has to be 4 digits long. In the config file, was given: %s\n",
+ CELLIAX_TMP_LOG, tmp->cvm_subsc_2_pin);
+ free(tmp);
+ return NULL;
+ }
+ }
+
+ if (tmp->cvm_volume_level != celliax_default.cvm_volume_level) {
+ if ((0 > tmp->cvm_volume_level) && (9 < tmp->cvm_volume_level)) {
+ ERRORA("cvm_volume_level has to be 0-9. In the config file, was given: %d\n",
+ CELLIAX_TMP_LOG, tmp->cvm_volume_level);
+ free(tmp);
+ return NULL;
+ }
+ }
+
+ if (tmp->cvm_celliax_serial_delay != celliax_default.cvm_celliax_serial_delay) {
+ if ((0 > tmp->cvm_celliax_serial_delay) && (65535 < tmp->cvm_celliax_serial_delay)) {
+ ERRORA
+ ("cvm_celliax_serial_dealy has to be 0-65535. In the config file, was given: %d\n",
+ CELLIAX_TMP_LOG, tmp->cvm_celliax_serial_delay);
+ free(tmp);
+ return NULL;
+ }
+ }
+#endif /* CELLIAX_CVM */
+
+/* initialize the soundcard channels (input and output) used by this interface (a multichannel soundcard can be used by multiple interfaces), optionally starting the sound managing threads */
+ res = celliax_sound_init(tmp);
+ if (res == -1) {
+ ERRORA("Failed initializing sound device\n", CELLIAX_TMP_LOG);
+ /* we failed, free the PVT */
+ if (tmp)
+ free(tmp);
+ return NULL;
+ }
+ if (tmp->need_acoustic_ring) {
+ /* alloc and initialize a new dsp struct for this interface pvt, WITH silence suppression */
+ if (celliax_sound_dsp_set(tmp, tmp->dsp_silence_threshold, 1)) {
+ ERRORA("celliax_sound_dsp_set failed\n", CELLIAX_TMP_LOG);
+ celliax_sound_shutdown(tmp);
+ if (tmp)
+ free(tmp);
+ return NULL;
+ }
+ }
+
+ /* init the serial port */
+ if (tmp->controldevprotocol != PROTOCOL_NO_SERIAL) {
+ tmp->controldevfd = celliax_serial_init(tmp, tmp->controldevice_speed);
+ if (tmp->controldevfd < 1) {
+ ERRORA("celliax_serial_init failed\n", CELLIAX_TMP_LOG);
+ celliax_sound_shutdown(tmp);
+ if (tmp)
+ free(tmp);
+ return NULL;
+ }
+ }
+
+ /* config the phone/modem on the serial port */
+ if (tmp->controldevprotocol != PROTOCOL_NO_SERIAL) {
+ //int res;
+ res = celliax_serial_config(tmp);
+ if (res) {
+ ERRORA("celliax_serial_config failed\n", CELLIAX_TMP_LOG);
+ celliax_sound_shutdown(tmp);
+ if (tmp)
+ free(tmp);
+ return NULL;
+ }
+ }
+
+ /* return the newly created celliax_pvt */
+ return tmp;
+}
+
+/*! \brief (Re)Start the module main monitor thread, watching for incoming calls on the interfaces */
+int celliax_restart_monitor(void)
+{
+ static struct celliax_pvt *p = &celliax_log_struct;
+ /* If we're supposed to be stopped -- stay stopped */
+ if (celliax_monitor_thread == AST_PTHREADT_STOP)
+ return 0;
+ LOKKA(&celliax_monlock);
+ /* Do not seems possible to me that this function can be called by the very same monitor thread, but let's be paranoid */
+ if (celliax_monitor_thread == pthread_self()) {
+ UNLOCKA(&celliax_monlock);
+ ERRORA("Cannot kill myself\n", CELLIAX_P_LOG);
+ return -1;
+ }
+ /* if the monitor thread exists */
+ if (celliax_monitor_thread != AST_PTHREADT_NULL) {
+ /* Wake up the thread, it can be stuck waiting in a select or so */
+ pthread_kill(celliax_monitor_thread, SIGURG);
+ pthread_kill(celliax_monitor_audio_thread, SIGURG);
+ } else {
+ /* the monitor thread does not exists, start a new monitor */
+ if (ast_pthread_create(&celliax_monitor_thread, NULL, celliax_do_monitor, NULL) < 0) {
+ UNLOCKA(&celliax_monlock);
+ ERRORA("Unable to start monitor thread.\n", CELLIAX_P_LOG);
+ return -1;
+ }
+
+ if (ast_pthread_create
+ (&celliax_monitor_audio_thread, NULL, celliax_do_audio_monitor, NULL) < 0) {
+ ERRORA("Unable to start audio_monitor thread.\n", CELLIAX_P_LOG);
+ return -1;
+ }
+
+ }
+ UNLOCKA(&celliax_monlock);
+ return 0;
+}
+
+/*! \brief The celliax monitoring thread
+ * \note This thread monitors all the celliax interfaces that are not in a call
+ * (and thus do not have a separate thread) indefinitely
+ * */
+void *celliax_do_monitor(void *data)
+{
+ fd_set rfds;
+ int res;
+ struct celliax_pvt *p = NULL;
+ int max = -1;
+ struct timeval to;
+ time_t now_timestamp;
+
+ if (pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL)) {
+ ERRORA("Unable to set cancel type to deferred\n", CELLIAX_P_LOG);
+ return NULL;
+ }
+
+ for (;;) {
+ pthread_testcancel();
+ /* Don't let anybody kill us right away. Nobody should lock the interface list
+ and wait for the monitor list, but the other way around is okay. */
+ PUSHA_UNLOCKA(&celliax_monlock);
+ MONITORLOKKA(&celliax_monlock);
+ /* Lock the interface list */
+ PUSHA_UNLOCKA(&celliax_iflock);
+ MONITORLOKKA(&celliax_iflock);
+ /* Build the stuff we're going to select on, that is the celliax_serial_fd of every
+ celliax_pvt that does not have an associated owner channel. In the case of FBUS2 3310
+ and in the case of PROTOCOL_NO_SERIAL we add the audio_fd as well, because there is not serial signaling of incoming calls */
+ FD_ZERO(&rfds);
+
+ time(&now_timestamp);
+ p = celliax_iflist;
+ while (p) {
+ if (!p->owner) {
+ /* This interface needs to be watched, as it lacks an owner */
+
+ if (p->controldevprotocol != PROTOCOL_NO_SERIAL && !p->controldev_dead) {
+ /* This interface needs its serial connection to be watched, nokia 3310 and compatibles needs sounds as well */
+ if (FD_ISSET(p->controldevfd, &rfds)) {
+ ERRORA("Bizarre! Descriptor %d (controldevfd) appears twice ?\n",
+ CELLIAX_P_LOG, p->controldevfd);
+ }
+ if (p->controldevfd > 0) {
+
+ //time(&now_timestamp);
+ if ((now_timestamp - p->celliax_serial_synced_timestamp) > p->celliax_serial_sync_period) { //TODO find a sensible period. 5min? in config?
+ int rt;
+ if (option_debug > 1)
+ DEBUGA_SERIAL("Syncing Serial\n", CELLIAX_P_LOG);
+ rt = celliax_serial_sync(p);
+ if (rt) {
+ p->controldev_dead = 1;
+ close(p->controldevfd);
+ ERRORA("serial sync failed, declaring %s dead\n", CELLIAX_P_LOG,
+ p->controldevice_name);
+ }
+ rt = celliax_serial_getstatus(p);
+ if (rt) {
+ p->controldev_dead = 1;
+ close(p->controldevfd);
+ ERRORA("serial getstatus failed, declaring %s dead\n", CELLIAX_P_LOG,
+ p->controldevice_name);
+ }
+
+ }
+
+ if (!p->controldev_dead) {
+ /* add this file descriptor to the set watched by the select */
+ FD_SET(p->controldevfd, &rfds);
+ if (p->controldevfd > max) {
+ /* adjust the maximum file descriptor value the select has to watch for */
+ max = p->controldevfd;
+ }
+ }
+ }
+ }
+
+ }
+ /* next interface, please */
+ p = p->next;
+ }
+ /* Okay, now that we know what to do, release the interface lock */
+ MONITORUNLOCKA(&celliax_iflock);
+ POPPA_UNLOCKA(&celliax_iflock);
+ /* And from now on, we're okay to be killed, so release the monitor lock as well */
+ MONITORUNLOCKA(&celliax_monlock);
+ POPPA_UNLOCKA(&celliax_monlock);
+
+ /* you want me to die? */
+ pthread_testcancel();
+
+ /* Wait for something to happen */
+ to.tv_sec = 0;
+ to.tv_usec = 500000; /* we select with this timeout because under cygwin we avoid the signal usage, so there is no way to end the thread if it is stuck waiting for select */
+ res = ast_select(max + 1, &rfds, NULL, NULL, &to);
+
+ /* you want me to die? */
+ pthread_testcancel();
+
+ /* Okay, select has finished. Let's see what happened. */
+
+ /* If there are errors... */
+ if (res < 0) {
+ if (errno == EINTR) /* EINTR is just the select
+ being interrupted by a SIGURG, or so */
+ continue;
+ else {
+ ERRORA("select returned %d: %s\n", CELLIAX_P_LOG, res, strerror(errno));
+//FIXME what to do here? is the interface that failed signaled? which interface we have to disable?
+ return NULL;
+ }
+ }
+
+ /* must not be killed while celliax_iflist is locked */
+ PUSHA_UNLOCKA(&celliax_monlock);
+ MONITORLOKKA(&celliax_monlock);
+ /* Alright, lock the interface list again, and let's look and see what has
+ happened */
+ PUSHA_UNLOCKA(&celliax_iflock);
+ MONITORLOKKA(&celliax_iflock);
+
+ p = celliax_iflist;
+ for (; p; p = p->next) {
+
+ if (p->controldevprotocol != PROTOCOL_NO_SERIAL && !p->controldev_dead) {
+ if (!p->owner) { //give all the serial channels that have no owner a read, so we can have the timers clicking
+
+ if (!p->celliax_serial_monitoring) {
+ p->celliax_serial_monitoring = 1;
+ res = celliax_serial_monitor(p);
+ if (res == -1) { //manage the graceful interface shutdown
+ p->controldev_dead = 1;
+ close(p->controldevfd);
+ ERRORA("celliax_serial_monitor failed, declaring %s dead\n", CELLIAX_P_LOG,
+ p->controldevice_name);
+ } else if (!p->need_acoustic_ring
+ && p->controldevprotocol != PROTOCOL_NO_SERIAL
+ && p->interface_state == AST_STATE_RING) {
+ if (option_debug)
+ DEBUGA_PBX("INCOMING RING\n", CELLIAX_P_LOG);
+ if (!celliax_new(p, AST_STATE_RING, p->context)) {
+ //FIXME what to do here?
+ ERRORA("celliax_new failed! BAD BAD BAD\n", CELLIAX_P_LOG);
+ }
+ }
+ p->celliax_serial_monitoring = 0;
+ }
+ }
+ }
+
+ if (p->controldevprotocol != PROTOCOL_NO_SERIAL && p->controldev_dead) {
+
+ /* init the serial port */
+ p->controldevfd = celliax_serial_init(p, p->controldevice_speed);
+ if (p->controldevfd < 1) {
+ DEBUGA_SERIAL("celliax_serial_init failed\n", CELLIAX_P_LOG);
+ } else {
+
+ /* config the phone/modem on the serial port */
+ res = celliax_serial_config(p);
+ if (res) {
+ DEBUGA_SERIAL("celliax_serial_config failed\n", CELLIAX_P_LOG);
+ close(p->controldevfd);
+ } else {
+
+ NOTICA("Wow, the serial port has come back! Let's see if it will work\n",
+ CELLIAX_P_LOG);
+ p->controldev_dead = 0;
+ }
+
+ }
+
+ }
+
+ }
+ MONITORUNLOCKA(&celliax_iflock);
+ POPPA_UNLOCKA(&celliax_iflock);
+ MONITORUNLOCKA(&celliax_monlock);
+ POPPA_UNLOCKA(&celliax_monlock);
+ pthread_testcancel();
+ }
+/* Never reached */
+ return NULL;
+
+}
+
+void *celliax_do_audio_monitor(void *data)
+{
+ fd_set rfds;
+ int res;
+ struct celliax_pvt *p = NULL;
+ int max = -1;
+ struct timeval to;
+
+ if (pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL)) {
+ ERRORA("Unable to set cancel type to deferred\n", CELLIAX_P_LOG);
+ return NULL;
+ }
+
+ for (;;) {
+ pthread_testcancel();
+ /* Lock the interface list */
+ PUSHA_UNLOCKA(&celliax_iflock);
+ MONITORLOKKA(&celliax_iflock);
+
+ FD_ZERO(&rfds);
+
+ p = celliax_iflist;
+ while (p) {
+ if (!p->owner) {
+ /* This interface needs to be watched, as it lacks an owner */
+
+ if (p->controldevprotocol == PROTOCOL_NO_SERIAL || p->need_acoustic_ring) {
+ /* This interface needs its incoming sound to be watched, because it cannot signal incoming ring from serial (eg nokia 3310 and compatibles) */
+ if (p->celliax_sound_capt_fd > 0) {
+ /* if fd exist */
+ if (FD_ISSET(p->celliax_sound_capt_fd, &rfds)) {
+ ERRORA("Bizarre! Descriptor %d (celliax_sound_capt_fd) appears twice ?\n",
+ CELLIAX_P_LOG, p->celliax_sound_capt_fd);
+ }
+ /* add this file descriptor to the set watched by the select */
+ FD_SET(p->celliax_sound_capt_fd, &rfds);
+ if (p->celliax_sound_capt_fd > max) {
+ /* adjust the maximum file descriptor value the select has to watch for */
+ max = p->celliax_sound_capt_fd;
+ }
+ }
+ }
+
+ }
+ /* next interface, please */
+ p = p->next;
+ }
+ /* Okay, now that we know what to do, release the interface lock */
+
+ MONITORUNLOCKA(&celliax_iflock);
+ POPPA_UNLOCKA(&celliax_iflock);
+ /* you want me to die? */
+ pthread_testcancel();
+
+ /* Wait for something to happen */
+ to.tv_sec = 0;
+ to.tv_usec = 500000; /* we select with this timeout because under cygwin we avoid the signal usage, so there is no way to end the thread if it is stuck waiting for select */
+ res = ast_select(max + 1, &rfds, NULL, NULL, &to);
+
+ /* you want me to die? */
+ pthread_testcancel();
+
+ /* Okay, select has finished. Let's see what happened. */
+
+ /* If there are errors... */
+ if (res < 0) {
+ if (errno == EINTR) { /* EINTR is just the select
+ being interrupted by a SIGURG, or so */
+ usleep(100);
+ continue;
+ } else {
+ ERRORA("select returned %d: %s\n", CELLIAX_P_LOG, res, strerror(errno));
+//FIXME what to do here? is the interface that failed signaled? which interface we have to disable?
+ return NULL;
+ }
+ }
+ /* If there are no file descriptors changed, just continue */
+
+ if (res == 0) {
+ usleep(100); //let's breath
+ continue;
+ }
+//usleep(10); //let's breath
+
+ /* Lock the interface list */
+ PUSHA_UNLOCKA(&celliax_iflock);
+ MONITORLOKKA(&celliax_iflock);
+
+ p = celliax_iflist;
+ for (; p; p = p->next) {
+
+ if (FD_ISSET(p->celliax_sound_capt_fd, &rfds)) {
+ res = celliax_sound_monitor(p);
+ if (res < 0) {
+ ERRORA("celliax_sound_monitor ERROR %d\n", CELLIAX_P_LOG, res);
+ } else if (res == CALLFLOW_INCOMING_RING) {
+ p->phone_callflow = CALLFLOW_INCOMING_RING;
+ p->interface_state = AST_STATE_RING;
+ if (option_debug)
+ DEBUGA_PBX("INCOMING RING\n", CELLIAX_P_LOG);
+ if (!celliax_new(p, AST_STATE_RING, p->context))
+ ERRORA("celliax_new failed! BAD BAD BAD\n", CELLIAX_P_LOG);
+ } else {
+ }
+
+ }
+
+ }
+/* Okay, now that we know what to do, release the interface lock */
+
+ MONITORUNLOCKA(&celliax_iflock);
+ POPPA_UNLOCKA(&celliax_iflock);
+
+ pthread_testcancel();
+ }
+/* Never reached */
+ return NULL;
+}
+
+/*!
+ * \brief Initialize the soundcard channels (input and output) used by one interface (a multichannel soundcard can be used by multiple interfaces)
+ * \param p the celliax_pvt of the interface
+ *
+ * This function initialize the soundcard channels (input and output) used by one interface (a multichannel soundcard can be used by multiple interfaces). It simply pass its parameters to the right function for the sound system for which has been compiled, eg. alsa_init for ALSA, oss_init for OSS, winmm_init for Windows Multimedia, etc and return the result
+ *
+ * \return zero on success, -1 on error.
+ */
+
+int celliax_sound_init(struct celliax_pvt *p)
+{
+#ifdef CELLIAX_ALSA
+ return alsa_init(p);
+#endif /* CELLIAX_ALSA */
+#ifdef CELLIAX_PORTAUDIO
+ return celliax_portaudio_init(p);
+#endif /* CELLIAX_PORTAUDIO */
+
+ return -1;
+}
+
+/*!
+ * \brief Shutdown the soundcard channels (input and output) used by one interface (a multichannel soundcard can be used by multiple interfaces)
+ * \param p the celliax_pvt of the interface
+ *
+ * This function shutdown the soundcard channels (input and output) used by one interface (a multichannel soundcard can be used by multiple interfaces). It simply pass its parameters to the right function for the sound system for which has been compiled, eg. alsa_shutdown for ALSA, oss_shutdown for OSS, winmm_shutdown for Windows Multimedia, etc and return the result
+ *
+ * \return zero on success, -1 on error.
+ */
+
+int celliax_sound_shutdown(struct celliax_pvt *p)
+{
+
+#ifdef CELLIAX_ALSA
+ return alsa_shutdown(p);
+#endif /* CELLIAX_ALSA */
+#ifdef CELLIAX_PORTAUDIO
+ return celliax_portaudio_shutdown(p);
+#endif /* CELLIAX_PORTAUDIO */
+
+ return -1;
+}
+
+/*! \brief returns an asterisk frame categorized by dsp algorithms */
+struct ast_frame *celliax_sound_dsp_analize(struct celliax_pvt *p, struct ast_frame *f,
+ int dsp_silence_threshold)
+{
+ if (!p->dsp) {
+ DEBUGA_SOUND("no dsp, initializing it \n", CELLIAX_P_LOG);
+ if (celliax_sound_dsp_set(p, dsp_silence_threshold, 1)) {
+ ERRORA("celliax_sound_dsp_set failed\n", CELLIAX_P_LOG);
+ return NULL;
+ }
+ }
+
+ /* process with dsp */
+ if (p->dsp) {
+ if (f->frametype == AST_FRAME_VOICE) {
+ f = ast_dsp_process(p->owner, p->dsp, f);
+ } else {
+ //WARNINGA("not a VOICE frame ! \n", CELLIAX_P_LOG);
+ }
+ }
+ return f;
+}
+
+/*! \brief initialize the dsp algorithms and structures */
+int celliax_sound_dsp_set(struct celliax_pvt *p, int dsp_silence_threshold,
+ int silence_suppression)
+{
+
+/* let asterisk dsp algorithms detect dtmf */
+ if (p->dsp) {
+ return 0;
+ }
+ if (option_debug > 1)
+ DEBUGA_SOUND("alloc dsp \n", CELLIAX_P_LOG);
+ p->dsp = ast_dsp_new();
+ if (p->dsp) {
+ if (silence_suppression) {
+ ast_dsp_set_threshold(p->dsp, dsp_silence_threshold);
+ DEBUGA_SOUND("set dsp_silence_threshold=%d\n", CELLIAX_P_LOG,
+ dsp_silence_threshold);
+ if (option_debug > 1)
+ DEBUGA_SOUND("Detecting silence, I mean, voice\n", CELLIAX_P_LOG);
+ ast_dsp_set_features(p->dsp, 0 | DSP_FEATURE_SILENCE_SUPPRESS);
+ } else {
+ if (option_debug > 1)
+ DEBUGA_SOUND("WITHOUT SILENCE_SUPPRESS, Detecting inband dtmf with sw DSP\n",
+ CELLIAX_P_LOG);
+
+#ifdef ASTERISK_VERSION_1_6_0_1
+ ast_dsp_set_features(p->dsp, 0 | DSP_FEATURE_DIGIT_DETECT);
+#else
+ ast_dsp_set_features(p->dsp, 0 | DSP_FEATURE_DTMF_DETECT);
+#endif /* ASTERISK_VERSION_1_6_0_1 */
+ }
+
+ /*
+ if (ast_dsp_digitmode(p->dsp, DSP_DIGITMODE_DTMF | DSP_DIGITMODE_RELAXDTMF)) {
+ ERRORA("ast_dsp_digitmode failed\n", CELLIAX_P_LOG);
+ return -1;
+ }
+ */
+ } else {
+ ERRORA("ast_dsp_new failed\n", CELLIAX_P_LOG);
+ return -1;
+ }
+ return 0;
+}
+
+/*! \brief Read audio frames from interface */
+struct ast_frame *celliax_sound_read(struct celliax_pvt *p)
+{
+ struct ast_frame *f = NULL;
+#ifdef CELLIAX_ALSA
+ f = alsa_read(p);
+#endif /* CELLIAX_ALSA */
+#ifdef CELLIAX_PORTAUDIO
+ f = celliax_portaudio_read(p);
+#endif /* CELLIAX_PORTAUDIO */
+
+ return f;
+}
+
+/*! \brief Send audio frame to interface */
+int celliax_sound_write(struct celliax_pvt *p, struct ast_frame *f)
+{
+ int ret = -1;
+
+#ifdef CELLIAX_ALSA
+ ret = alsa_write(p, f);
+#endif /* CELLIAX_ALSA */
+#ifdef CELLIAX_PORTAUDIO
+ ret = celliax_portaudio_write(p, f);
+#endif /* CELLIAX_PORTAUDIO */
+
+ return ret;
+}
+
+/*! \brief read an audio frame and tell if is "voice" (interpreted as incoming RING) */
+int celliax_sound_monitor(struct celliax_pvt *p)
+{
+ struct ast_frame *f;
+ f = celliax_sound_read(p);
+ if (f) {
+ f = celliax_sound_dsp_analize(p, f, p->dsp_silence_threshold);
+ if (f) {
+ if (f->frametype == AST_FRAME_VOICE) {
+ DEBUGA_SOUND("VOICE\n", CELLIAX_P_LOG);
+ return CALLFLOW_INCOMING_RING;
+ } else {
+ return AST_STATE_DOWN;
+ }
+ }
+ }
+ return -1;
+}
+
+/*!
+ * \brief This thread runs during a call, and monitor the interface serial port for signaling, like hangup, caller id, etc
+ *
+ */
+void *celliax_do_controldev_thread(void *data)
+{
+ struct celliax_pvt *p = data;
+ int res;
+
+ DEBUGA_SERIAL("In celliax_do_controldev_thread: started, p=%p\n", CELLIAX_P_LOG, p);
+
+ if (pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL)) {
+ ERRORA("Unable to set cancel type to deferred\n", CELLIAX_P_LOG);
+ return NULL;
+ }
+
+ while (1) {
+ int rt;
+ time_t now_timestamp;
+
+ if (p->controldevprotocol == PROTOCOL_NO_SERIAL) {
+ while (1) {
+ usleep(10000);
+ pthread_testcancel();
+ }
+ }
+#ifdef CELLIAX_CVM
+ if (p->controldevprotocol == PROTOCOL_CVM_BUSMAIL) {
+ usleep(p->cvm_celliax_serial_delay * 1000); //to get msecs
+ } else {
+ usleep(1000);
+ }
+
+#else
+ usleep(1000);
+#endif /* CELLIAX_CVM */
+
+ pthread_testcancel();
+ /* do not read from a dead controldev */
+ if (p->controldev_dead) {
+ DEBUGA_SERIAL("celliax_do_controldev_thread: device %s is dead\n", CELLIAX_P_LOG,
+ p->controldevice_name);
+ if (p->owner)
+ celliax_queue_control(p->owner, AST_CONTROL_HANGUP);
+ return NULL;
+ } else {
+ pthread_testcancel();
+ res = celliax_serial_read(p);
+ pthread_testcancel();
+ if (res == -1) {
+ p->controldev_dead = 1;
+ close(p->controldevfd);
+ ERRORA("serial read failed, declaring %s dead\n", CELLIAX_P_LOG,
+ p->controldevice_name);
+ }
+ }
+
+ pthread_testcancel();
+ time(&now_timestamp);
+ if ((now_timestamp - p->celliax_serial_synced_timestamp) > p->celliax_serial_synced_timestamp && !p->controldev_dead) { //TODO find a sensible period. 5min? in config?
+ DEBUGA_SERIAL("Syncing Serial\n", CELLIAX_P_LOG);
+ pthread_testcancel();
+ rt = celliax_serial_sync(p);
+ pthread_testcancel();
+ if (rt) {
+ p->controldev_dead = 1;
+ close(p->controldevfd);
+ ERRORA("serial sync failed, declaring %s dead\n", CELLIAX_P_LOG,
+ p->controldevice_name);
+ }
+ pthread_testcancel();
+ rt = celliax_serial_getstatus(p);
+ pthread_testcancel();
+ if (rt) {
+ p->controldev_dead = 1;
+ close(p->controldevfd);
+ ERRORA("serial getstatus failed, declaring %s dead\n", CELLIAX_P_LOG,
+ p->controldevice_name);
+ }
+
+ }
+ pthread_testcancel();
+ }
+ return NULL;
+
+}
+
+int celliax_serial_init(struct celliax_pvt *p, speed_t controldevice_speed)
+{
+ int fd;
+ int rt;
+ struct termios tp;
+
+/* if there is a file descriptor, close it. But it is probably just an old value, so don't check for close success*/
+ fd = p->controldevfd;
+ if (fd) {
+ close(fd);
+ }
+/* open the serial port */
+#ifdef __CYGWIN__
+ fd = open(p->controldevice_name, O_RDWR | O_NOCTTY | O_NONBLOCK);
+ sleep(1);
+ close(fd);
+#endif /* __CYGWIN__ */
+ fd = open(p->controldevice_name, O_RDWR | O_NOCTTY | O_NONBLOCK);
+ if (fd == -1) {
+ DEBUGA_SERIAL("serial error: %s\n", CELLIAX_P_LOG, strerror(errno));
+ p->controldevfd = fd;
+ return -1;
+ }
+/* flush it */
+ rt = tcflush(fd, TCIFLUSH);
+ if (rt == -1) {
+ ERRORA("serial error: %s", CELLIAX_P_LOG, strerror(errno));
+ }
+/* attributes */
+ tp.c_cflag = B0 | CS8 | CLOCAL | CREAD | HUPCL;
+ tp.c_iflag = IGNPAR;
+ tp.c_cflag &= ~CRTSCTS;
+ tp.c_oflag = 0;
+ tp.c_lflag = 0;
+ tp.c_cc[VMIN] = 1;
+ tp.c_cc[VTIME] = 0;
+/* set controldevice_speed */
+ rt = cfsetispeed(&tp, p->controldevice_speed);
+ if (rt == -1) {
+ ERRORA("serial error: %s", CELLIAX_P_LOG, strerror(errno));
+ }
+ rt = cfsetospeed(&tp, p->controldevice_speed);
+ if (rt == -1) {
+ ERRORA("serial error: %s", CELLIAX_P_LOG, strerror(errno));
+ }
+/* set port attributes */
+ if (tcsetattr(fd, TCSADRAIN, &tp) == -1) {
+ ERRORA("serial error: %s", CELLIAX_P_LOG, strerror(errno));
+ }
+ rt = tcsetattr(fd, TCSANOW, &tp);
+ if (rt == -1) {
+ ERRORA("serial error: %s", CELLIAX_P_LOG, strerror(errno));
+ }
+ unsigned int status = 0;
+#ifndef __CYGWIN__
+ ioctl(fd, TIOCMGET, &status);
+ status |= TIOCM_DTR; /* Set DTR high */
+ status &= ~TIOCM_RTS; /* Set RTS low */
+ ioctl(fd, TIOCMSET, &status);
+ ioctl(fd, TIOCMGET, &status);
+ unsigned int flags = TIOCM_DTR;
+ ioctl(fd, TIOCMBIS, &flags);
+ flags = TIOCM_RTS;
+ ioctl(fd, TIOCMBIC, &flags);
+ ioctl(fd, TIOCMGET, &status);
+#else /* __CYGWIN__ */
+ ioctl(fd, TIOCMGET, &status);
+ status |= TIOCM_DTR; /* Set DTR high */
+ status &= ~TIOCM_RTS; /* Set RTS low */
+ ioctl(fd, TIOCMSET, &status);
+#endif /* __CYGWIN__ */
+ p->controldevfd = fd;
+ DEBUGA_SERIAL("Syncing Serial\n", CELLIAX_P_LOG);
+ rt = celliax_serial_sync(p);
+ if (rt == -1) {
+ ERRORA("Serial init error\n", CELLIAX_P_LOG);
+ return -1;
+ }
+ return (fd);
+}
+
+int celliax_serial_sync(struct celliax_pvt *p)
+{
+ if (p->controldevprotocol == PROTOCOL_AT)
+ return celliax_serial_sync_AT(p);
+#ifdef CELLIAX_FBUS2
+ if (p->controldevprotocol == PROTOCOL_FBUS2)
+ return celliax_serial_sync_FBUS2(p);
+#endif /* CELLIAX_FBUS2 */
+#ifdef CELLIAX_CVM
+ if (p->controldevprotocol == PROTOCOL_CVM_BUSMAIL)
+ return celliax_serial_sync_CVM_BUSMAIL(p);
+#endif /* CELLIAX_CVM */
+
+ return -1;
+}
+
+int celliax_serial_getstatus(struct celliax_pvt *p)
+{
+ if (p->controldevprotocol == PROTOCOL_AT)
+ return celliax_serial_getstatus_AT(p);
+#ifdef CELLIAX_FBUS2
+ if (p->controldevprotocol == PROTOCOL_FBUS2)
+ return celliax_serial_getstatus_FBUS2(p);
+#endif /* CELLIAX_FBUS2 */
+
+#ifdef CELLIAX_CVM
+ if (p->controldevprotocol == PROTOCOL_CVM_BUSMAIL)
+ return celliax_serial_getstatus_CVM_BUSMAIL(p);
+#endif /* CELLIAX_CVM */
+ return -1;
+}
+
+int celliax_serial_read(struct celliax_pvt *p)
+{
+ if (p->controldevprotocol == PROTOCOL_AT)
+ return celliax_serial_read_AT(p, 0, 100000, 0, NULL, 1); // a 10th of a second timeout
+#ifdef CELLIAX_FBUS2
+ if (p->controldevprotocol == PROTOCOL_FBUS2)
+ return celliax_serial_read_FBUS2(p);
+#endif /* CELLIAX_FBUS2 */
+#ifdef CELLIAX_CVM
+ if (p->controldevprotocol == PROTOCOL_CVM_BUSMAIL)
+ return celliax_serial_read_CVM_BUSMAIL(p);
+#endif /* CELLIAX_CVM */
+ return -1;
+}
+
+int celliax_serial_hangup(struct celliax_pvt *p)
+{
+ if (p->controldevprotocol == PROTOCOL_AT)
+ return celliax_serial_hangup_AT(p);
+#ifdef CELLIAX_FBUS2
+ if (p->controldevprotocol == PROTOCOL_FBUS2)
+ return celliax_serial_hangup_FBUS2(p);
+#endif /* CELLIAX_FBUS2 */
+#ifdef CELLIAX_CVM
+ if (p->controldevprotocol == PROTOCOL_CVM_BUSMAIL)
+ return celliax_serial_hangup_CVM_BUSMAIL(p);
+#endif /* CELLIAX_CVM */
+ return -1;
+}
+
+int celliax_serial_answer(struct celliax_pvt *p)
+{
+ if (p->controldevprotocol == PROTOCOL_AT)
+ return celliax_serial_answer_AT(p);
+#ifdef CELLIAX_FBUS2
+ if (p->controldevprotocol == PROTOCOL_FBUS2)
+ return celliax_serial_answer_FBUS2(p);
+#endif /* CELLIAX_FBUS2 */
+#ifdef CELLIAX_CVM
+ if (p->controldevprotocol == PROTOCOL_CVM_BUSMAIL)
+ return celliax_serial_answer_CVM_BUSMAIL(p);
+#endif /* CELLIAX_CVM */
+ return -1;
+}
+
+int celliax_serial_config(struct celliax_pvt *p)
+{
+ if (p->controldevprotocol == PROTOCOL_AT)
+ return celliax_serial_config_AT(p);
+#ifdef CELLIAX_FBUS2
+ if (p->controldevprotocol == PROTOCOL_FBUS2)
+ return celliax_serial_config_FBUS2(p);
+#endif /* CELLIAX_FBUS2 */
+#ifdef CELLIAX_CVM
+ if (p->controldevprotocol == PROTOCOL_CVM_BUSMAIL)
+ return celliax_serial_config_CVM_BUSMAIL(p);
+#endif /* CELLIAX_CVM */
+ return -1;
+}
+
+int celliax_serial_monitor(struct celliax_pvt *p)
+{
+ if (p->controldevprotocol == PROTOCOL_AT)
+ return celliax_serial_read_AT(p, 0, 100000, 0, NULL, 1); // a 10th of a second timeout
+#ifdef CELLIAX_FBUS2
+ if (p->controldevprotocol == PROTOCOL_FBUS2)
+ return celliax_serial_read_FBUS2(p);
+#endif /* CELLIAX_FBUS2 */
+#ifdef CELLIAX_CVM
+ if (p->controldevprotocol == PROTOCOL_CVM_BUSMAIL)
+ return celliax_serial_read_CVM_BUSMAIL(p);
+#endif /* CELLIAX_CVM */
+ return -1;
+}
+
+/************************************************/
+
+/* LUIGI RIZZO's magic */
+/*
+ * store the boost factor
+ */
+#ifdef ASTERISK_VERSION_1_6_0
+void celliax_store_boost(const char *s, double *boost)
+#else
+void celliax_store_boost(char *s, double *boost)
+#endif /* ASTERISK_VERSION_1_6_0 */
+{
+ struct celliax_pvt *p = NULL;
+
+ if (sscanf(s, "%lf", boost) != 1) {
+ ERRORA("invalid boost <%s>\n", CELLIAX_P_LOG, s);
+ return;
+ }
+ if (*boost < -BOOST_MAX) {
+ WARNINGA("boost %s too small, using %d\n", CELLIAX_P_LOG, s, -BOOST_MAX);
+ *boost = -BOOST_MAX;
+ } else if (*boost > BOOST_MAX) {
+ WARNINGA("boost %s too large, using %d\n", CELLIAX_P_LOG, s, BOOST_MAX);
+ *boost = BOOST_MAX;
+ }
+ *boost = exp(log(10) * *boost / 20) * BOOST_SCALE;
+ if (option_debug > 1)
+ DEBUGA_SOUND("setting boost %s to %f\n", CELLIAX_P_LOG, s, *boost);
+}
+
+int celliax_serial_call(struct celliax_pvt *p, char *dstr)
+{
+ if (p->controldevprotocol == PROTOCOL_AT)
+ return celliax_serial_call_AT(p, dstr);
+#ifdef CELLIAX_FBUS2
+ if (p->controldevprotocol == PROTOCOL_FBUS2)
+ return celliax_serial_call_FBUS2(p, dstr);
+#endif /* CELLIAX_FBUS2 */
+ if (p->controldevprotocol == PROTOCOL_NO_SERIAL)
+ return 0;
+#ifdef CELLIAX_CVM
+ if (p->controldevprotocol == PROTOCOL_CVM_BUSMAIL)
+ return celliax_serial_call_CVM_BUSMAIL(p, dstr);
+#endif /* CELLIAX_CVM */
+ return -1;
+}
+
+/*
+ * returns a pointer to the descriptor with the given name
+ */
+struct celliax_pvt *celliax_console_find_desc(char *dev)
+{
+ struct celliax_pvt *p;
+
+ for (p = celliax_iflist; p && strcmp(p->name, dev) != 0; p = p->next);
+ if (p == NULL)
+ WARNINGA("could not find <%s>\n", CELLIAX_P_LOG, dev);
+
+ return p;
+}
+
+int celliax_console_playback_boost(int fd, int argc, char *argv[])
+{
+ struct celliax_pvt *p = celliax_console_find_desc(celliax_console_active);
+
+ if (argc > 2)
+ return RESULT_SHOWUSAGE;
+ if (!p) {
+ ast_cli(fd,
+ "No \"current\" celliax_console for playback_boost, please enter 'help celliax_console'\n");
+ return RESULT_SUCCESS;
+ }
+
+ if (argc == 1) {
+ ast_cli(fd, "playback_boost on the active celliax_console, that is [%s], is: %5.1f\n",
+ celliax_console_active,
+ 20 * log10(((double) p->playback_boost / (double) BOOST_SCALE)));
+ } else if (argc == 2) {
+ celliax_store_boost(argv[1], &p->playback_boost);
+
+ ast_cli(fd,
+ "playback_boost on the active celliax_console, that is [%s], is now: %5.1f\n",
+ celliax_console_active,
+ 20 * log10(((double) p->playback_boost / (double) BOOST_SCALE)));
+ }
+
+ return RESULT_SUCCESS;
+}
+
+int celliax_console_capture_boost(int fd, int argc, char *argv[])
+{
+ struct celliax_pvt *p = celliax_console_find_desc(celliax_console_active);
+
+ if (argc > 2)
+ return RESULT_SHOWUSAGE;
+ if (!p) {
+ ast_cli(fd,
+ "No \"current\" celliax_console for capture_boost, please enter 'help celliax_console'\n");
+ return RESULT_SUCCESS;
+ }
+
+ if (argc == 1) {
+ ast_cli(fd, "capture_boost on the active celliax_console, that is [%s], is: %5.1f\n",
+ celliax_console_active,
+ 20 * log10(((double) p->capture_boost / (double) BOOST_SCALE)));
+ } else if (argc == 2) {
+ celliax_store_boost(argv[1], &p->capture_boost);
+
+ ast_cli(fd,
+ "capture_boost on the active celliax_console, that is [%s], is now: %5.1f\n",
+ celliax_console_active,
+ 20 * log10(((double) p->capture_boost / (double) BOOST_SCALE)));
+ }
+
+ return RESULT_SUCCESS;
+}
+
+int celliax_console_echo(int fd, int argc, char *argv[])
+{
+ struct celliax_pvt *p = celliax_console_find_desc(celliax_console_active);
+
+ if (argc != 3 && argc != 1)
+ return RESULT_SHOWUSAGE;
+ if (!p) {
+ ast_cli(fd,
+ "No \"current\" celliax_console for celliax_echo, please enter 'help celliax_console'\n");
+ return RESULT_SUCCESS;
+ }
+
+ if (argc == 1) {
+ ast_cli(fd,
+ "On the active celliax_console, that is [%s], speexecho and speexpreprocess are: %d and %d\n",
+ celliax_console_active, p->speexecho, p->speexpreprocess);
+ } else if (argc == 3) {
+ sscanf(argv[1], "%d", &p->speexecho);
+ sscanf(argv[2], "%d", &p->speexpreprocess);
+ ast_cli(fd,
+ "On the active celliax_console, that is [%s], speexecho and speexpreprocess are NOW: %d and %d\n",
+ celliax_console_active, p->speexecho, p->speexpreprocess);
+ }
+
+ return RESULT_SUCCESS;
+}
+
+#ifndef ASTERISK_VERSION_1_6_0
+int celliax_console_hangup(int fd, int argc, char *argv[])
+{
+ struct celliax_pvt *p = celliax_console_find_desc(celliax_console_active);
+
+ if (argc != 1)
+ return RESULT_SHOWUSAGE;
+ if (!p) {
+ ast_cli(fd,
+ "No \"current\" celliax_console for hanging up, please enter 'help celliax_console'\n");
+ return RESULT_SUCCESS;
+ }
+ if (!p->owner) {
+ ast_cli(fd, "No call to hangup on the active celliax_console, that is [%s]\n",
+ celliax_console_active);
+ return RESULT_FAILURE;
+ }
+ if (p->owner)
+ ast_queue_hangup(p->owner);
+ return RESULT_SUCCESS;
+}
+#else /* ASTERISK_VERSION_1_6_0 */
+char *celliax_console_hangup(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+{
+ struct celliax_pvt *p = celliax_console_find_desc(celliax_console_active);
+
+
+ switch (cmd) {
+ case CLI_INIT:
+ e->command = "celliax hangup";
+ e->usage =
+ "Usage: celliax hangup\n"
+ " Hangup a call on the celliax channel.\n";
+
+ return NULL;
+ case CLI_GENERATE:
+ return NULL;
+ }
+
+ if (a->argc != 2)
+ return CLI_SHOWUSAGE;
+ if (!p) {
+ ast_cli(a->fd,
+ "No \"current\" celliax_console for hanging up, please enter 'help celliax_console'\n");
+ return CLI_SUCCESS;
+ }
+ if (!p->owner) {
+ ast_cli(a->fd, "No call to hangup on the active celliax_console, that is [%s]\n",
+ celliax_console_active);
+ return CLI_FAILURE;
+ }
+ if (p->owner)
+ ast_queue_hangup(p->owner);
+ return CLI_SUCCESS;
+}
+
+#endif /* ASTERISK_VERSION_1_6_0 */
+int celliax_console_sendsms(int fd, int argc, char *argv[])
+{
+ char *s = NULL;
+ char *s1 = NULL;
+ char command[512];
+
+ if (argc != 3)
+ return RESULT_SHOWUSAGE;
+
+ s = argv[1];
+ s1 = argv[2];
+
+ memset(command, 0, sizeof(command));
+
+ sprintf(command, "%s|%s|", s, s1);
+
+ celliax_sendsms(NULL, (void *) &command);
+
+ return RESULT_SUCCESS;
+}
+
+int celliax_console_dial(int fd, int argc, char *argv[])
+{
+ char *s = NULL;
+ struct celliax_pvt *p = celliax_console_find_desc(celliax_console_active);
+
+ if (argc != 2)
+ return RESULT_SHOWUSAGE;
+ if (!p) {
+ ast_cli(fd,
+ "No \"current\" celliax_console for dialing, please enter 'help celliax_console'\n");
+ return RESULT_SUCCESS;
+ }
+
+ if (p->owner) { /* already in a call */
+ int i;
+ struct ast_frame f = { AST_FRAME_DTMF, 0 };
+
+ s = argv[1];
+ /* send the string one char at a time */
+ for (i = 0; i < strlen(s); i++) {
+ f.subclass = s[i];
+ ast_queue_frame(p->owner, &f);
+ }
+ return RESULT_SUCCESS;
+ } else
+ ast_cli(fd,
+ "No call in which to dial on the \"current\" celliax_console, that is [%s]\n",
+ celliax_console_active);
+ if (s)
+ free(s);
+ return RESULT_SUCCESS;
+}
+
+int celliax_console_set_active(int fd, int argc, char *argv[])
+{
+ if (argc == 1)
+ ast_cli(fd,
+ "\"current\" celliax_console is [%s]\n Enter 'celliax_console show' to see the available interfaces.\n Enter 'celliax_console interfacename' to change the \"current\" celliax_console.\n",
+ celliax_console_active);
+ else if (argc != 2)
+ return RESULT_SHOWUSAGE;
+ else {
+ struct celliax_pvt *p;
+ if (strcmp(argv[1], "show") == 0) {
+ ast_cli(fd, "Available interfaces:\n");
+ for (p = celliax_iflist; p; p = p->next)
+ ast_cli(fd, " [%s]\n", p->name);
+ return RESULT_SUCCESS;
+ }
+ p = celliax_console_find_desc(argv[1]);
+ if (p == NULL)
+ ast_cli(fd, "Interface [%s] do not exists!\n", argv[1]);
+ else {
+ celliax_console_active = p->name;
+ ast_cli(fd, "\"current\" celliax_console is now: [%s]\n", argv[1]);
+ }
+ }
+ return RESULT_SUCCESS;
+}
+
+int celliax_console_celliax(int fd, int argc, char *argv[])
+{
+ return RESULT_SHOWUSAGE;
+}
+
+#ifdef ASTERISK_VERSION_1_4
+#ifndef AST_MODULE
+#define AST_MODULE "chan_celliax"
+#endif
+AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Celliax, Audio-Serial Driver");
+#endif /* ASTERISK_VERSION_1_4 */
</ins></span></pre></div>
<a id="freeswitchbranchesgmaruzzmod_celliaxmod_celliaxc"></a>
<div class="modfile"><h4>Modified: freeswitch/branches/gmaruzz/mod_celliax/mod_celliax.c (14550 => 14551)</h4>
<pre class="diff"><span>
<span class="info">--- freeswitch/branches/gmaruzz/mod_celliax/mod_celliax.c 2009-08-18 05:33:42 UTC (rev 14550)
+++ freeswitch/branches/gmaruzz/mod_celliax/mod_celliax.c 2009-08-18 09:37:23 UTC (rev 14551)
</span><span class="lines">@@ -1269,16 +1269,13 @@
</span><span class="cx">
</span><span class="cx"> switch_threadattr_create(&celliax_api_thread_attr, celliax_module_pool);
</span><span class="cx"> switch_threadattr_stacksize_set(celliax_api_thread_attr, SWITCH_THREAD_STACKSIZE);
</span><del>- switch_thread_create(&globals.SKYPIAX_INTERFACES[interface_id].celliax_api_thread,
- celliax_api_thread_attr, celliax_do_skypeapi_thread, &globals.SKYPIAX_INTERFACES[interface_id], celliax_module_pool);
</del><ins>+ switch_thread_create(&globals.SKYPIAX_INTERFACES[interface_id].celliax_api_thread, celliax_api_thread_attr, celliax_do_skypeapi_thread, &globals.SKYPIAX_INTERFACES[interface_id], celliax_module_pool);
</ins><span class="cx">
</span><span class="cx"> switch_sleep(100000);
</span><span class="cx">
</span><span class="cx"> switch_threadattr_create(&celliax_signaling_thread_attr, celliax_module_pool);
</span><span class="cx"> switch_threadattr_stacksize_set(celliax_signaling_thread_attr, SWITCH_THREAD_STACKSIZE);
</span><del>- switch_thread_create(&globals.SKYPIAX_INTERFACES[interface_id].
- celliax_signaling_thread, celliax_signaling_thread_attr,
- celliax_signaling_thread_func, &globals.SKYPIAX_INTERFACES[interface_id], celliax_module_pool);
</del><ins>+ switch_thread_create(&globals.SKYPIAX_INTERFACES[interface_id].celliax_signaling_thread, celliax_signaling_thread_attr, celliax_signaling_thread_func, &globals.SKYPIAX_INTERFACES[interface_id], celliax_module_pool);
</ins><span class="cx">
</span><span class="cx"> switch_sleep(100000);
</span><span class="cx">
</span></span></pre>
</div>
</div>
<div id="footer">See you at ClueCon</div>
</body>
</html>