use a macro instead of an inline function, so that backtraces will report the caller...
[asterisk-bristuff.git] / res / res_adsi.c
blob950e4f8651e211eadaba82fecf6e1faef8313b5e
1 /*
2 * Asterisk -- An open source telephony toolkit.
4 * Copyright (C) 1999 - 2005, Digium, Inc.
6 * Mark Spencer <markster@digium.com>
8 * Includes code and algorithms from the Zapata library.
10 * See http://www.asterisk.org for more information about
11 * the Asterisk project. Please do not directly contact
12 * any of the maintainers of this project for assistance;
13 * the project provides a web site, mailing lists and IRC
14 * channels for your use.
16 * This program is free software, distributed under the terms of
17 * the GNU General Public License Version 2. See the LICENSE file
18 * at the top of the source tree.
21 /*! \file
23 * \brief ADSI support
25 * \author Mark Spencer <markster@digium.com>
27 * \note this module is required by app_voicemail and app_getcpeid
28 * \todo Move app_getcpeid into this module
29 * \todo Create a core layer so that app_voicemail does not require
30 * res_adsi to load
33 #include "asterisk.h"
35 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
37 #include <time.h>
38 #include <string.h>
39 #include <stdio.h>
40 #include <stdlib.h>
41 #include <unistd.h>
42 #include <math.h>
43 #include <errno.h>
45 #include "asterisk/ulaw.h"
46 #include "asterisk/alaw.h"
47 #include "asterisk/callerid.h"
48 #include "asterisk/logger.h"
49 #include "asterisk/fskmodem.h"
50 #include "asterisk/channel.h"
51 #include "asterisk/adsi.h"
52 #include "asterisk/module.h"
53 #include "asterisk/config.h"
54 #include "asterisk/file.h"
56 #define DEFAULT_ADSI_MAX_RETRIES 3
58 #define ADSI_MAX_INTRO 20
59 #define ADSI_MAX_SPEED_DIAL 6
61 #define ADSI_FLAG_DATAMODE (1 << 8)
63 static int maxretries = DEFAULT_ADSI_MAX_RETRIES;
65 /* Asterisk ADSI button definitions */
66 #define ADSI_SPEED_DIAL 10 /* 10-15 are reserved for speed dial */
68 static char intro[ADSI_MAX_INTRO][20];
69 static int aligns[ADSI_MAX_INTRO];
71 static char speeddial[ADSI_MAX_SPEED_DIAL][3][20];
73 static int alignment = 0;
75 static int adsi_generate(unsigned char *buf, int msgtype, unsigned char *msg, int msglen, int msgnum, int last, int codec)
77 int sum;
78 int x;
79 int bytes=0;
80 /* Initial carrier (imaginary) */
81 float cr = 1.0;
82 float ci = 0.0;
83 float scont = 0.0;
85 if (msglen > 255)
86 msglen = 255;
88 /* If first message, Send 150ms of MARK's */
89 if (msgnum == 1) {
90 for (x=0;x<150;x++) /* was 150 */
91 PUT_CLID_MARKMS;
93 /* Put message type */
94 PUT_CLID(msgtype);
95 sum = msgtype;
97 /* Put message length (plus one for the message number) */
98 PUT_CLID(msglen + 1);
99 sum += msglen + 1;
101 /* Put message number */
102 PUT_CLID(msgnum);
103 sum += msgnum;
105 /* Put actual message */
106 for (x=0;x<msglen;x++) {
107 PUT_CLID(msg[x]);
108 sum += msg[x];
111 /* Put 2's compliment of sum */
112 PUT_CLID(256-(sum & 0xff));
114 #if 0
115 if (last) {
116 /* Put trailing marks */
117 for (x=0;x<50;x++)
118 PUT_CLID_MARKMS;
120 #endif
121 return bytes;
125 static int adsi_careful_send(struct ast_channel *chan, unsigned char *buf, int len, int *remainder)
127 /* Sends carefully on a full duplex channel by using reading for
128 timing */
129 struct ast_frame *inf, outf;
130 int amt;
132 /* Zero out our outgoing frame */
133 memset(&outf, 0, sizeof(outf));
135 if (remainder && *remainder) {
136 amt = len;
138 /* Send remainder if provided */
139 if (amt > *remainder)
140 amt = *remainder;
141 else
142 *remainder = *remainder - amt;
143 outf.frametype = AST_FRAME_VOICE;
144 outf.subclass = AST_FORMAT_ULAW;
145 outf.data = buf;
146 outf.datalen = amt;
147 outf.samples = amt;
148 if (ast_write(chan, &outf)) {
149 ast_log(LOG_WARNING, "Failed to carefully write frame\n");
150 return -1;
152 /* Update pointers and lengths */
153 buf += amt;
154 len -= amt;
157 while(len) {
158 amt = len;
159 /* If we don't get anything at all back in a second, forget
160 about it */
161 if (ast_waitfor(chan, 1000) < 1)
162 return -1;
163 inf = ast_read(chan);
164 /* Detect hangup */
165 if (!inf)
166 return -1;
167 if (inf->frametype == AST_FRAME_VOICE) {
168 /* Read a voice frame */
169 if (inf->subclass != AST_FORMAT_ULAW) {
170 ast_log(LOG_WARNING, "Channel not in ulaw?\n");
171 return -1;
173 /* Send no more than they sent us */
174 if (amt > inf->datalen)
175 amt = inf->datalen;
176 else if (remainder)
177 *remainder = inf->datalen - amt;
178 outf.frametype = AST_FRAME_VOICE;
179 outf.subclass = AST_FORMAT_ULAW;
180 outf.data = buf;
181 outf.datalen = amt;
182 outf.samples = amt;
183 if (ast_write(chan, &outf)) {
184 ast_log(LOG_WARNING, "Failed to carefully write frame\n");
185 return -1;
187 /* Update pointers and lengths */
188 buf += amt;
189 len -= amt;
191 ast_frfree(inf);
193 return 0;
196 static int __adsi_transmit_messages(struct ast_channel *chan, unsigned char **msg, int *msglen, int *msgtype)
198 /* msglen must be no more than 256 bits, each */
199 unsigned char buf[24000 * 5];
200 int pos = 0, res;
201 int x;
202 int start=0;
203 int retries = 0;
205 char ack[3];
207 /* Wait up to 500 ms for initial ACK */
208 int waittime;
209 struct ast_frame *f;
210 int rem = 0;
211 int def;
213 if (chan->adsicpe == AST_ADSI_UNAVAILABLE) {
214 /* Don't bother if we know they don't support ADSI */
215 errno = ENOSYS;
216 return -1;
219 while(retries < maxretries) {
220 if (!(chan->adsicpe & ADSI_FLAG_DATAMODE)) {
221 /* Generate CAS (no SAS) */
222 ast_gen_cas(buf, 0, 680, AST_FORMAT_ULAW);
224 /* Send CAS */
225 if (adsi_careful_send(chan, buf, 680, NULL)) {
226 ast_log(LOG_WARNING, "Unable to send CAS\n");
228 /* Wait For DTMF result */
229 waittime = 500;
230 for(;;) {
231 if (((res = ast_waitfor(chan, waittime)) < 1)) {
232 /* Didn't get back DTMF A in time */
233 ast_log(LOG_DEBUG, "No ADSI CPE detected (%d)\n", res);
234 if (!chan->adsicpe)
235 chan->adsicpe = AST_ADSI_UNAVAILABLE;
236 errno = ENOSYS;
237 return -1;
239 waittime = res;
240 f = ast_read(chan);
241 if (!f) {
242 ast_log(LOG_DEBUG, "Hangup in ADSI\n");
243 return -1;
245 if (f->frametype == AST_FRAME_DTMF) {
246 if (f->subclass == 'A') {
247 /* Okay, this is an ADSI CPE. Note this for future reference, too */
248 if (!chan->adsicpe)
249 chan->adsicpe = AST_ADSI_AVAILABLE;
250 break;
251 } else {
252 if (f->subclass == 'D') {
253 ast_log(LOG_DEBUG, "Off-hook capable CPE only, not ADSI\n");
254 } else
255 ast_log(LOG_WARNING, "Unknown ADSI response '%c'\n", f->subclass);
256 if (!chan->adsicpe)
257 chan->adsicpe = AST_ADSI_UNAVAILABLE;
258 errno = ENOSYS;
259 return -1;
262 ast_frfree(f);
265 ast_log(LOG_DEBUG, "ADSI Compatible CPE Detected\n");
266 } else
267 ast_log(LOG_DEBUG, "Already in data mode\n");
269 x = 0;
270 pos = 0;
271 #if 1
272 def= ast_channel_defer_dtmf(chan);
273 #endif
274 while((x < 6) && msg[x]) {
275 res = adsi_generate(buf + pos, msgtype[x], msg[x], msglen[x], x+1 - start, (x == 5) || !msg[x+1], AST_FORMAT_ULAW);
276 if (res < 0) {
277 ast_log(LOG_WARNING, "Failed to generate ADSI message %d on channel %s\n", x + 1, chan->name);
278 return -1;
280 ast_log(LOG_DEBUG, "Message %d, of %d input bytes, %d output bytes\n",
281 x + 1, msglen[x], res);
282 pos += res;
283 x++;
287 rem = 0;
288 res = adsi_careful_send(chan, buf, pos, &rem);
289 if (!def)
290 ast_channel_undefer_dtmf(chan);
291 if (res)
292 return -1;
294 ast_log(LOG_DEBUG, "Sent total spill of %d bytes\n", pos);
296 memset(ack, 0, sizeof(ack));
297 /* Get real result */
298 res = ast_readstring(chan, ack, 2, 1000, 1000, "");
299 /* Check for hangup */
300 if (res < 0)
301 return -1;
302 if (ack[0] == 'D') {
303 ast_log(LOG_DEBUG, "Acked up to message %d\n", atoi(ack + 1));
304 start += atoi(ack + 1);
305 if (start >= x)
306 break;
307 else {
308 retries++;
309 ast_log(LOG_DEBUG, "Retransmitting (%d), from %d\n", retries, start + 1);
311 } else {
312 retries++;
313 ast_log(LOG_WARNING, "Unexpected response to ack: %s (retry %d)\n", ack, retries);
316 if (retries >= maxretries) {
317 ast_log(LOG_WARNING, "Maximum ADSI Retries (%d) exceeded\n", maxretries);
318 errno = ETIMEDOUT;
319 return -1;
321 return 0;
325 int ast_adsi_begin_download(struct ast_channel *chan, char *service, unsigned char *fdn, unsigned char *sec, int version)
327 int bytes;
328 unsigned char buf[256];
329 char ack[2];
330 bytes = 0;
331 /* Setup the resident soft key stuff, a piece at a time */
332 /* Upload what scripts we can for voicemail ahead of time */
333 bytes += ast_adsi_download_connect(buf + bytes, service, fdn, sec, version);
334 if (ast_adsi_transmit_message_full(chan, buf, bytes, ADSI_MSG_DOWNLOAD, 0))
335 return -1;
336 if (ast_readstring(chan, ack, 1, 10000, 10000, ""))
337 return -1;
338 if (ack[0] == 'B')
339 return 0;
340 ast_log(LOG_DEBUG, "Download was denied by CPE\n");
341 return -1;
344 int ast_adsi_end_download(struct ast_channel *chan)
346 int bytes;
347 unsigned char buf[256];
348 bytes = 0;
349 /* Setup the resident soft key stuff, a piece at a time */
350 /* Upload what scripts we can for voicemail ahead of time */
351 bytes += ast_adsi_download_disconnect(buf + bytes);
352 if (ast_adsi_transmit_message_full(chan, buf, bytes, ADSI_MSG_DOWNLOAD, 0))
353 return -1;
354 return 0;
357 int ast_adsi_transmit_message_full(struct ast_channel *chan, unsigned char *msg, int msglen, int msgtype, int dowait)
359 unsigned char *msgs[5] = { NULL, NULL, NULL, NULL, NULL };
360 int msglens[5];
361 int msgtypes[5];
362 int newdatamode;
363 int res;
364 int x;
365 int writeformat, readformat;
366 int waitforswitch = 0;
368 writeformat = chan->writeformat;
369 readformat = chan->readformat;
371 newdatamode = chan->adsicpe & ADSI_FLAG_DATAMODE;
373 for (x=0;x<msglen;x+=(msg[x+1]+2)) {
374 if (msg[x] == ADSI_SWITCH_TO_DATA) {
375 ast_log(LOG_DEBUG, "Switch to data is sent!\n");
376 waitforswitch++;
377 newdatamode = ADSI_FLAG_DATAMODE;
380 if (msg[x] == ADSI_SWITCH_TO_VOICE) {
381 ast_log(LOG_DEBUG, "Switch to voice is sent!\n");
382 waitforswitch++;
383 newdatamode = 0;
386 msgs[0] = msg;
388 msglens[0] = msglen;
389 msgtypes[0] = msgtype;
391 if (msglen > 253) {
392 ast_log(LOG_WARNING, "Can't send ADSI message of %d bytes, too large\n", msglen);
393 return -1;
396 ast_stopstream(chan);
398 if (ast_set_write_format(chan, AST_FORMAT_ULAW)) {
399 ast_log(LOG_WARNING, "Unable to set write format to ULAW\n");
400 return -1;
403 if (ast_set_read_format(chan, AST_FORMAT_ULAW)) {
404 ast_log(LOG_WARNING, "Unable to set read format to ULAW\n");
405 if (writeformat) {
406 if (ast_set_write_format(chan, writeformat))
407 ast_log(LOG_WARNING, "Unable to restore write format to %d\n", writeformat);
409 return -1;
411 res = __adsi_transmit_messages(chan, msgs, msglens, msgtypes);
413 if (dowait) {
414 ast_log(LOG_DEBUG, "Wait for switch is '%d'\n", waitforswitch);
415 while(waitforswitch-- && ((res = ast_waitfordigit(chan, 1000)) > 0)) { res = 0; ast_log(LOG_DEBUG, "Waiting for 'B'...\n"); }
418 if (!res)
419 chan->adsicpe = (chan->adsicpe & ~ADSI_FLAG_DATAMODE) | newdatamode;
421 if (writeformat)
422 ast_set_write_format(chan, writeformat);
423 if (readformat)
424 ast_set_read_format(chan, readformat);
426 if (!res)
427 res = ast_safe_sleep(chan, 100 );
428 return res;
431 int ast_adsi_transmit_message(struct ast_channel *chan, unsigned char *msg, int msglen, int msgtype)
433 return ast_adsi_transmit_message_full(chan, msg, msglen, msgtype, 1);
436 static inline int ccopy(unsigned char *dst, const unsigned char *src, int max)
438 int x=0;
439 /* Carefully copy the requested data */
440 while ((x < max) && src[x] && (src[x] != 0xff)) {
441 dst[x] = src[x];
442 x++;
444 return x;
447 int ast_adsi_load_soft_key(unsigned char *buf, int key, const char *llabel, const char *slabel, const char *ret, int data)
449 int bytes=0;
451 /* Abort if invalid key specified */
452 if ((key < 2) || (key > 33))
453 return -1;
454 buf[bytes++] = ADSI_LOAD_SOFTKEY;
455 /* Reserve for length */
456 bytes++;
457 /* Which key */
458 buf[bytes++] = key;
460 /* Carefully copy long label */
461 bytes += ccopy(buf + bytes, (const unsigned char *)llabel, 18);
463 /* Place delimiter */
464 buf[bytes++] = 0xff;
466 /* Short label */
467 bytes += ccopy(buf + bytes, (const unsigned char *)slabel, 7);
470 /* If specified, copy return string */
471 if (ret) {
472 /* Place delimiter */
473 buf[bytes++] = 0xff;
474 if (data)
475 buf[bytes++] = ADSI_SWITCH_TO_DATA2;
476 /* Carefully copy return string */
477 bytes += ccopy(buf + bytes, (const unsigned char *)ret, 20);
480 /* Replace parameter length */
481 buf[1] = bytes - 2;
482 return bytes;
486 int ast_adsi_connect_session(unsigned char *buf, unsigned char *fdn, int ver)
488 int bytes=0;
489 int x;
491 /* Message type */
492 buf[bytes++] = ADSI_CONNECT_SESSION;
494 /* Reserve space for length */
495 bytes++;
497 if (fdn) {
498 for (x=0;x<4;x++)
499 buf[bytes++] = fdn[x];
500 if (ver > -1)
501 buf[bytes++] = ver & 0xff;
504 buf[1] = bytes - 2;
505 return bytes;
509 int ast_adsi_download_connect(unsigned char *buf, char *service, unsigned char *fdn, unsigned char *sec, int ver)
511 int bytes=0;
512 int x;
514 /* Message type */
515 buf[bytes++] = ADSI_DOWNLOAD_CONNECT;
517 /* Reserve space for length */
518 bytes++;
520 /* Primary column */
521 bytes+= ccopy(buf + bytes, (unsigned char *)service, 18);
523 /* Delimiter */
524 buf[bytes++] = 0xff;
526 for (x=0;x<4;x++) {
527 buf[bytes++] = fdn[x];
529 for (x=0;x<4;x++)
530 buf[bytes++] = sec[x];
531 buf[bytes++] = ver & 0xff;
533 buf[1] = bytes - 2;
535 return bytes;
539 int ast_adsi_disconnect_session(unsigned char *buf)
541 int bytes=0;
543 /* Message type */
544 buf[bytes++] = ADSI_DISC_SESSION;
546 /* Reserve space for length */
547 bytes++;
549 buf[1] = bytes - 2;
550 return bytes;
554 int ast_adsi_query_cpeid(unsigned char *buf)
556 int bytes = 0;
557 buf[bytes++] = ADSI_QUERY_CPEID;
558 /* Reserve space for length */
559 bytes++;
560 buf[1] = bytes - 2;
561 return bytes;
564 int ast_adsi_query_cpeinfo(unsigned char *buf)
566 int bytes = 0;
567 buf[bytes++] = ADSI_QUERY_CONFIG;
568 /* Reserve space for length */
569 bytes++;
570 buf[1] = bytes - 2;
571 return bytes;
574 int ast_adsi_read_encoded_dtmf(struct ast_channel *chan, unsigned char *buf, int maxlen)
576 int bytes = 0;
577 int res;
578 unsigned char current = 0;
579 int gotstar = 0;
580 int pos = 0;
581 memset(buf, 0, sizeof(buf));
582 while(bytes <= maxlen) {
583 /* Wait up to a second for a digit */
584 res = ast_waitfordigit(chan, 1000);
585 if (!res)
586 break;
587 if (res == '*') {
588 gotstar = 1;
589 continue;
591 /* Ignore anything other than a digit */
592 if ((res < '0') || (res > '9'))
593 continue;
594 res -= '0';
595 if (gotstar)
596 res += 9;
597 if (pos) {
598 pos = 0;
599 buf[bytes++] = (res << 4) | current;
600 } else {
601 pos = 1;
602 current = res;
604 gotstar = 0;
606 return bytes;
609 int ast_adsi_get_cpeid(struct ast_channel *chan, unsigned char *cpeid, int voice)
611 unsigned char buf[256];
612 int bytes = 0;
613 int res;
614 bytes += ast_adsi_data_mode(buf);
615 ast_adsi_transmit_message_full(chan, buf, bytes, ADSI_MSG_DISPLAY, 0);
617 bytes = 0;
618 bytes += ast_adsi_query_cpeid(buf);
619 ast_adsi_transmit_message_full(chan, buf, bytes, ADSI_MSG_DISPLAY, 0);
621 /* Get response */
622 memset(buf, 0, sizeof(buf));
623 res = ast_adsi_read_encoded_dtmf(chan, cpeid, 4);
624 if (res != 4) {
625 ast_log(LOG_WARNING, "Got %d bytes back of encoded DTMF, expecting 4\n", res);
626 res = 0;
627 } else {
628 res = 1;
631 if (voice) {
632 bytes = 0;
633 bytes += ast_adsi_voice_mode(buf, 0);
634 ast_adsi_transmit_message_full(chan, buf, bytes, ADSI_MSG_DISPLAY, 0);
635 /* Ignore the resulting DTMF B announcing it's in voice mode */
636 ast_waitfordigit(chan, 1000);
638 return res;
641 int ast_adsi_get_cpeinfo(struct ast_channel *chan, int *width, int *height, int *buttons, int voice)
643 unsigned char buf[256];
644 int bytes = 0;
645 int res;
646 bytes += ast_adsi_data_mode(buf);
647 ast_adsi_transmit_message_full(chan, buf, bytes, ADSI_MSG_DISPLAY, 0);
649 bytes = 0;
650 bytes += ast_adsi_query_cpeinfo(buf);
651 ast_adsi_transmit_message_full(chan, buf, bytes, ADSI_MSG_DISPLAY, 0);
653 /* Get width */
654 memset(buf, 0, sizeof(buf));
655 res = ast_readstring(chan, (char *)buf, 2, 1000, 500, "");
656 if (res < 0)
657 return res;
658 if (strlen((char *)buf) != 2) {
659 ast_log(LOG_WARNING, "Got %d bytes of width, expecting 2\n", res);
660 res = 0;
661 } else {
662 res = 1;
664 if (width)
665 *width = atoi((char *)buf);
666 /* Get height */
667 memset(buf, 0, sizeof(buf));
668 if (res) {
669 res = ast_readstring(chan, (char *)buf, 2, 1000, 500, "");
670 if (res < 0)
671 return res;
672 if (strlen((char *)buf) != 2) {
673 ast_log(LOG_WARNING, "Got %d bytes of height, expecting 2\n", res);
674 res = 0;
675 } else {
676 res = 1;
678 if (height)
679 *height= atoi((char *)buf);
681 /* Get buttons */
682 memset(buf, 0, sizeof(buf));
683 if (res) {
684 res = ast_readstring(chan, (char *)buf, 1, 1000, 500, "");
685 if (res < 0)
686 return res;
687 if (strlen((char *)buf) != 1) {
688 ast_log(LOG_WARNING, "Got %d bytes of buttons, expecting 1\n", res);
689 res = 0;
690 } else {
691 res = 1;
693 if (buttons)
694 *buttons = atoi((char *)buf);
696 if (voice) {
697 bytes = 0;
698 bytes += ast_adsi_voice_mode(buf, 0);
699 ast_adsi_transmit_message_full(chan, buf, bytes, ADSI_MSG_DISPLAY, 0);
700 /* Ignore the resulting DTMF B announcing it's in voice mode */
701 ast_waitfordigit(chan, 1000);
703 return res;
706 int ast_adsi_data_mode(unsigned char *buf)
708 int bytes=0;
710 /* Message type */
711 buf[bytes++] = ADSI_SWITCH_TO_DATA;
713 /* Reserve space for length */
714 bytes++;
716 buf[1] = bytes - 2;
717 return bytes;
721 int ast_adsi_clear_soft_keys(unsigned char *buf)
723 int bytes=0;
725 /* Message type */
726 buf[bytes++] = ADSI_CLEAR_SOFTKEY;
728 /* Reserve space for length */
729 bytes++;
731 buf[1] = bytes - 2;
732 return bytes;
736 int ast_adsi_clear_screen(unsigned char *buf)
738 int bytes=0;
740 /* Message type */
741 buf[bytes++] = ADSI_CLEAR_SCREEN;
743 /* Reserve space for length */
744 bytes++;
746 buf[1] = bytes - 2;
747 return bytes;
751 int ast_adsi_voice_mode(unsigned char *buf, int when)
753 int bytes=0;
755 /* Message type */
756 buf[bytes++] = ADSI_SWITCH_TO_VOICE;
758 /* Reserve space for length */
759 bytes++;
761 buf[bytes++] = when & 0x7f;
763 buf[1] = bytes - 2;
764 return bytes;
768 int ast_adsi_available(struct ast_channel *chan)
770 int cpe = chan->adsicpe & 0xff;
771 if ((cpe == AST_ADSI_AVAILABLE) ||
772 (cpe == AST_ADSI_UNKNOWN))
773 return 1;
774 return 0;
777 int ast_adsi_download_disconnect(unsigned char *buf)
779 int bytes=0;
781 /* Message type */
782 buf[bytes++] = ADSI_DOWNLOAD_DISC;
784 /* Reserve space for length */
785 bytes++;
787 buf[1] = bytes - 2;
788 return bytes;
792 int ast_adsi_display(unsigned char *buf, int page, int line, int just, int wrap,
793 char *col1, char *col2)
795 int bytes=0;
797 /* Sanity check line number */
799 if (page) {
800 if (line > 4) return -1;
801 } else {
802 if (line > 33) return -1;
805 if (line < 1)
806 return -1;
807 /* Parameter type */
808 buf[bytes++] = ADSI_LOAD_VIRTUAL_DISP;
810 /* Reserve space for size */
811 bytes++;
813 /* Page and wrap indicator */
814 buf[bytes++] = ((page & 0x1) << 7) | ((wrap & 0x1) << 6) | (line & 0x3f);
816 /* Justification */
817 buf[bytes++] = (just & 0x3) << 5;
819 /* Omit highlight mode definition */
820 buf[bytes++] = 0xff;
822 /* Primary column */
823 bytes+= ccopy(buf + bytes, (unsigned char *)col1, 20);
825 /* Delimiter */
826 buf[bytes++] = 0xff;
828 /* Secondary column */
829 bytes += ccopy(buf + bytes, (unsigned char *)col2, 20);
831 /* Update length */
832 buf[1] = bytes - 2;
834 return bytes;
838 int ast_adsi_input_control(unsigned char *buf, int page, int line, int display, int format, int just)
840 int bytes=0;
842 if (page) {
843 if (line > 4) return -1;
844 } else {
845 if (line > 33) return -1;
848 if (line < 1)
849 return -1;
851 buf[bytes++] = ADSI_INPUT_CONTROL;
852 bytes++;
853 buf[bytes++] = ((page & 1) << 7) | (line & 0x3f);
854 buf[bytes++] = ((display & 1) << 7) | ((just & 0x3) << 4) | (format & 0x7);
856 buf[1] = bytes - 2;
857 return bytes;
861 int ast_adsi_input_format(unsigned char *buf, int num, int dir, int wrap, char *format1, char *format2)
863 int bytes = 0;
865 if (!strlen((char *)format1))
866 return -1;
868 buf[bytes++] = ADSI_INPUT_FORMAT;
869 bytes++;
870 buf[bytes++] = ((dir & 1) << 7) | ((wrap & 1) << 6) | (num & 0x7);
871 bytes += ccopy(buf + bytes, (unsigned char *)format1, 20);
872 buf[bytes++] = 0xff;
873 if (format2 && strlen((char *)format2)) {
874 bytes += ccopy(buf + bytes, (unsigned char *)format2, 20);
876 buf[1] = bytes - 2;
877 return bytes;
880 int ast_adsi_set_keys(unsigned char *buf, unsigned char *keys)
882 int bytes=0;
883 int x;
884 /* Message type */
885 buf[bytes++] = ADSI_INIT_SOFTKEY_LINE;
886 /* Space for size */
887 bytes++;
888 /* Key definitions */
889 for (x=0;x<6;x++)
890 buf[bytes++] = (keys[x] & 0x3f) ? keys[x] : (keys[x] | 0x1);
891 buf[1] = bytes - 2;
892 return bytes;
895 int ast_adsi_set_line(unsigned char *buf, int page, int line)
897 int bytes=0;
899 /* Sanity check line number */
901 if (page) {
902 if (line > 4) return -1;
903 } else {
904 if (line > 33) return -1;
907 if (line < 1)
908 return -1;
909 /* Parameter type */
910 buf[bytes++] = ADSI_LINE_CONTROL;
912 /* Reserve space for size */
913 bytes++;
915 /* Page and line */
916 buf[bytes++] = ((page & 0x1) << 7) | (line & 0x3f);
918 buf[1] = bytes - 2;
919 return bytes;
923 static int total = 0;
924 static int speeds = 0;
926 int ast_adsi_channel_restore(struct ast_channel *chan)
928 unsigned char dsp[256];
929 int bytes;
930 int x;
931 unsigned char keyd[6];
933 memset(dsp, 0, sizeof(dsp));
935 /* Start with initial display setup */
936 bytes = 0;
937 bytes += ast_adsi_set_line(dsp + bytes, ADSI_INFO_PAGE, 1);
939 /* Prepare key setup messages */
941 if (speeds) {
942 memset(keyd, 0, sizeof(keyd));
943 for (x=0;x<speeds;x++) {
944 keyd[x] = ADSI_SPEED_DIAL + x;
946 bytes += ast_adsi_set_keys(dsp + bytes, keyd);
948 ast_adsi_transmit_message_full(chan, dsp, bytes, ADSI_MSG_DISPLAY, 0);
949 return 0;
953 int ast_adsi_print(struct ast_channel *chan, char **lines, int *aligns, int voice)
955 unsigned char buf[4096];
956 int bytes=0;
957 int res;
958 int x;
959 for(x=0;lines[x];x++)
960 bytes += ast_adsi_display(buf + bytes, ADSI_INFO_PAGE, x+1, aligns[x], 0, lines[x], "");
961 bytes += ast_adsi_set_line(buf + bytes, ADSI_INFO_PAGE, 1);
962 if (voice) {
963 bytes += ast_adsi_voice_mode(buf + bytes, 0);
965 res = ast_adsi_transmit_message_full(chan, buf, bytes, ADSI_MSG_DISPLAY, 0);
966 if (voice) {
967 /* Ignore the resulting DTMF B announcing it's in voice mode */
968 ast_waitfordigit(chan, 1000);
970 return res;
973 int ast_adsi_load_session(struct ast_channel *chan, unsigned char *app, int ver, int data)
975 unsigned char dsp[256];
976 int bytes;
977 int res;
978 char resp[2];
980 memset(dsp, 0, sizeof(dsp));
982 /* Connect to session */
983 bytes = 0;
984 bytes += ast_adsi_connect_session(dsp + bytes, app, ver);
986 if (data)
987 bytes += ast_adsi_data_mode(dsp + bytes);
989 /* Prepare key setup messages */
990 if (ast_adsi_transmit_message_full(chan, dsp, bytes, ADSI_MSG_DISPLAY, 0))
991 return -1;
992 if (app) {
993 res = ast_readstring(chan, resp, 1, 1200, 1200, "");
994 if (res < 0)
995 return -1;
996 if (res) {
997 ast_log(LOG_DEBUG, "No response from CPE about version. Assuming not there.\n");
998 return 0;
1000 if (!strcmp(resp, "B")) {
1001 ast_log(LOG_DEBUG, "CPE has script '%s' version %d already loaded\n", app, ver);
1002 return 1;
1003 } else if (!strcmp(resp, "A")) {
1004 ast_log(LOG_DEBUG, "CPE hasn't script '%s' version %d already loaded\n", app, ver);
1005 } else {
1006 ast_log(LOG_WARNING, "Unexpected CPE response to script query: %s\n", resp);
1008 } else
1009 return 1;
1010 return 0;
1014 int ast_adsi_unload_session(struct ast_channel *chan)
1016 unsigned char dsp[256];
1017 int bytes;
1019 memset(dsp, 0, sizeof(dsp));
1021 /* Connect to session */
1022 bytes = 0;
1023 bytes += ast_adsi_disconnect_session(dsp + bytes);
1024 bytes += ast_adsi_voice_mode(dsp + bytes, 0);
1026 /* Prepare key setup messages */
1027 if (ast_adsi_transmit_message_full(chan, dsp, bytes, ADSI_MSG_DISPLAY, 0))
1028 return -1;
1029 return 0;
1032 static int str2align(char *s)
1034 if (!strncasecmp(s, "l", 1))
1035 return ADSI_JUST_LEFT;
1036 else if (!strncasecmp(s, "r", 1))
1037 return ADSI_JUST_RIGHT;
1038 else if (!strncasecmp(s, "i", 1))
1039 return ADSI_JUST_IND;
1040 else
1041 return ADSI_JUST_CENT;
1044 static void init_state(void)
1046 int x;
1048 for (x=0;x<ADSI_MAX_INTRO;x++)
1049 aligns[x] = ADSI_JUST_CENT;
1050 ast_copy_string(intro[0], "Welcome to the", sizeof(intro[0]));
1051 ast_copy_string(intro[1], "Asterisk", sizeof(intro[1]));
1052 ast_copy_string(intro[2], "Open Source PBX", sizeof(intro[2]));
1053 total = 3;
1054 speeds = 0;
1055 for (x=3;x<ADSI_MAX_INTRO;x++)
1056 intro[x][0] = '\0';
1057 memset(speeddial, 0, sizeof(speeddial));
1058 alignment = ADSI_JUST_CENT;
1061 static void adsi_load(void)
1063 int x;
1064 struct ast_config *conf;
1065 struct ast_variable *v;
1066 char *name, *sname;
1067 init_state();
1068 conf = ast_config_load("adsi.conf");
1069 if (conf) {
1070 x=0;
1071 for (v = ast_variable_browse(conf, "intro"); v; v = v->next) {
1072 if (!strcasecmp(v->name, "alignment"))
1073 alignment = str2align(v->value);
1074 else if (!strcasecmp(v->name, "greeting")) {
1075 if (x < ADSI_MAX_INTRO) {
1076 aligns[x] = alignment;
1077 ast_copy_string(intro[x], v->value, sizeof(intro[x]));
1078 x++;
1080 } else if (!strcasecmp(v->name, "maxretries")) {
1081 if (atoi(v->value) > 0)
1082 maxretries = atoi(v->value);
1085 if (x)
1086 total = x;
1087 x = 0;
1088 for (v = ast_variable_browse(conf, "speeddial"); v; v = v->next) {
1089 char *stringp = v->value;
1090 name = strsep(&stringp, ",");
1091 sname = strsep(&stringp, ",");
1092 if (!sname)
1093 sname = name;
1094 if (x < ADSI_MAX_SPEED_DIAL) {
1095 ast_copy_string(speeddial[x][0], v->name, sizeof(speeddial[x][0]));
1096 ast_copy_string(speeddial[x][1], name, 18);
1097 ast_copy_string(speeddial[x][2], sname, 7);
1098 x++;
1101 if (x)
1102 speeds = x;
1103 ast_config_destroy(conf);
1107 static int reload(void)
1109 adsi_load();
1110 return 0;
1113 static int load_module(void)
1115 adsi_load();
1116 return 0;
1119 static int unload_module(void)
1121 /* Can't unload this once we're loaded */
1122 return -1;
1125 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS, "ADSI Resource",
1126 .load = load_module,
1127 .unload = unload_module,
1128 .reload = reload,