"show application <foo>" changes for clarity.
[asterisk/asterisk.git] / res / res_adsi.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2005, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * Includes code and algorithms from the Zapata library.
9  *
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.
15  *
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.
19  */
20
21 /*! \file
22  *
23  * \brief ADSI support 
24  *
25  * \author Mark Spencer <markster@digium.com> 
26  *
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
31  */
32
33 #include "asterisk.h"
34
35 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
36
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>
44
45 #include "asterisk/adsi.h"
46 #include "asterisk/ulaw.h"
47 #include "asterisk/alaw.h"
48 #include "asterisk/callerid.h"
49 #include "asterisk/logger.h"
50 #include "asterisk/fskmodem.h"
51 #include "asterisk/channel.h"
52 #include "asterisk/adsi.h"
53 #include "asterisk/module.h"
54 #include "asterisk/config.h"
55 #include "asterisk/file.h"
56 #include "asterisk/options.h"
57
58 #define DEFAULT_ADSI_MAX_RETRIES 3
59
60 #define ADSI_MAX_INTRO 20
61 #define ADSI_MAX_SPEED_DIAL 6
62
63 #define ADSI_FLAG_DATAMODE      (1 << 8)
64
65 static int maxretries = DEFAULT_ADSI_MAX_RETRIES;
66
67 /* Asterisk ADSI button definitions */
68 #define ADSI_SPEED_DIAL         10      /* 10-15 are reserved for speed dial */
69
70 static char intro[ADSI_MAX_INTRO][20];
71 static int aligns[ADSI_MAX_INTRO];
72
73 static char speeddial[ADSI_MAX_SPEED_DIAL][3][20];
74
75 static int alignment = 0;
76
77 static int adsi_generate(unsigned char *buf, int msgtype, unsigned char *msg, int msglen, int msgnum, int last, int codec)
78 {
79         int sum, x, bytes = 0;
80         /* Initial carrier (imaginary) */
81         float cr = 1.0, ci = 0.0, scont = 0.0;
82
83         if (msglen > 255)
84                 msglen = 255;
85
86         /* If first message, Send 150ms of MARK's */
87         if (msgnum == 1) {
88                 for (x = 0; x < 150; x++)       /* was 150 */
89                         PUT_CLID_MARKMS;
90         }
91
92         /* Put message type */
93         PUT_CLID(msgtype);
94         sum = msgtype;
95
96         /* Put message length (plus one  for the message number) */
97         PUT_CLID(msglen + 1);
98         sum += msglen + 1;
99
100         /* Put message number */
101         PUT_CLID(msgnum);
102         sum += msgnum;
103
104         /* Put actual message */
105         for (x = 0; x < msglen; x++) {
106                 PUT_CLID(msg[x]);
107                 sum += msg[x];
108         }
109
110         /* Put 2's compliment of sum */
111         PUT_CLID(256-(sum & 0xff));
112
113 #if 0
114         if (last) {
115                 /* Put trailing marks */
116                 for (x = 0; x < 50; x++)
117                         PUT_CLID_MARKMS;
118         }
119 #endif
120         return bytes;
121
122 }
123
124 static int adsi_careful_send(struct ast_channel *chan, unsigned char *buf, int len, int *remainder)
125 {
126         /* Sends carefully on a full duplex channel by using reading for
127            timing */
128         struct ast_frame *inf, outf;
129         int amt;
130
131         /* Zero out our outgoing frame */
132         memset(&outf, 0, sizeof(outf));
133
134         if (remainder && *remainder) {
135                 amt = len;
136
137                 /* Send remainder if provided */
138                 if (amt > *remainder)
139                         amt = *remainder;
140                 else
141                         *remainder = *remainder - amt;
142                 outf.frametype = AST_FRAME_VOICE;
143                 outf.subclass = AST_FORMAT_ULAW;
144                 outf.data = buf;
145                 outf.datalen = amt;
146                 outf.samples = amt;
147                 if (ast_write(chan, &outf)) {
148                         ast_log(LOG_WARNING, "Failed to carefully write frame\n");
149                         return -1;
150                 }
151                 /* Update pointers and lengths */
152                 buf += amt;
153                 len -= amt;
154         }
155
156         while(len) {
157                 amt = len;
158                 /* If we don't get anything at all back in a second, forget
159                    about it */
160                 if (ast_waitfor(chan, 1000) < 1)
161                         return -1;
162                 /* Detect hangup */
163                 if (!(inf = ast_read(chan)))
164                         return -1;
165
166                 /* Drop any frames that are not voice */
167                 if (inf->frametype != AST_FRAME_VOICE) {
168                         ast_frfree(inf);
169                         continue;
170                 }
171                 
172                 if (inf->subclass != AST_FORMAT_ULAW) {
173                         ast_log(LOG_WARNING, "Channel not in ulaw?\n");
174                         ast_frfree(inf);
175                         return -1;
176                 }
177                 /* Send no more than they sent us */
178                 if (amt > inf->datalen)
179                         amt = inf->datalen;
180                 else if (remainder)
181                         *remainder = inf->datalen - amt;
182                 outf.frametype = AST_FRAME_VOICE;
183                 outf.subclass = AST_FORMAT_ULAW;
184                 outf.data = buf;
185                 outf.datalen = amt;
186                 outf.samples = amt;
187                 if (ast_write(chan, &outf)) {
188                         ast_log(LOG_WARNING, "Failed to carefully write frame\n");
189                         return -1;
190                 }
191                 /* Update pointers and lengths */
192                 buf += amt;
193                 len -= amt;
194                 ast_frfree(inf);
195         }
196         return 0;
197 }
198
199 static int __adsi_transmit_messages(struct ast_channel *chan, unsigned char **msg, int *msglen, int *msgtype)
200 {
201         /* msglen must be no more than 256 bits, each */
202         unsigned char buf[24000 * 5];
203         int pos = 0, res, x, start = 0, retries = 0, waittime, rem = 0, def;
204         char ack[3];
205         struct ast_frame *f;
206
207         if (chan->adsicpe == AST_ADSI_UNAVAILABLE) {
208                 /* Don't bother if we know they don't support ADSI */
209                 errno = ENOSYS;
210                 return -1;
211         }
212
213         while(retries < maxretries) {
214                 if (!(chan->adsicpe & ADSI_FLAG_DATAMODE)) {
215                         /* Generate CAS (no SAS) */
216                         ast_gen_cas(buf, 0, 680, AST_FORMAT_ULAW);
217                 
218                         /* Send CAS */
219                         if (adsi_careful_send(chan, buf, 680, NULL))
220                                 ast_log(LOG_WARNING, "Unable to send CAS\n");
221
222                         /* Wait For DTMF result */
223                         waittime = 500;
224                         for(;;) {
225                                 if (((res = ast_waitfor(chan, waittime)) < 1)) {
226                                         /* Didn't get back DTMF A in time */
227                                         ast_debug(1, "No ADSI CPE detected (%d)\n", res);
228                                         if (!chan->adsicpe)
229                                                 chan->adsicpe = AST_ADSI_UNAVAILABLE;
230                                         errno = ENOSYS;
231                                         return -1;
232                                 }
233                                 waittime = res;
234                                 if (!(f = ast_read(chan))) {
235                                         ast_debug(1, "Hangup in ADSI\n");
236                                         return -1;
237                                 }
238                                 if (f->frametype == AST_FRAME_DTMF) {
239                                         if (f->subclass == 'A') {
240                                                 /* Okay, this is an ADSI CPE.  Note this for future reference, too */
241                                                 if (!chan->adsicpe)
242                                                         chan->adsicpe = AST_ADSI_AVAILABLE;
243                                                 break;
244                                         } else {
245                                                 if (f->subclass == 'D')
246                                                         ast_debug(1, "Off-hook capable CPE only, not ADSI\n");
247                                                 else
248                                                         ast_log(LOG_WARNING, "Unknown ADSI response '%c'\n", f->subclass);
249                                                 if (!chan->adsicpe)
250                                                         chan->adsicpe = AST_ADSI_UNAVAILABLE;
251                                                 errno = ENOSYS;
252                                                 return -1;
253                                         }
254                                 }
255                                 ast_frfree(f);
256                         }
257
258                         ast_debug(1, "ADSI Compatible CPE Detected\n");
259                 } else {
260                         ast_debug(1, "Already in data mode\n");
261                 }
262
263                 x = 0;
264                 pos = 0;
265 #if 1
266                 def= ast_channel_defer_dtmf(chan);
267 #endif
268                 while ((x < 6) && msg[x]) {
269                         if ((res = adsi_generate(buf + pos, msgtype[x], msg[x], msglen[x], x+1 - start, (x == 5) || !msg[x+1], AST_FORMAT_ULAW)) < 0) {
270                                 ast_log(LOG_WARNING, "Failed to generate ADSI message %d on channel %s\n", x + 1, chan->name);
271                                 return -1;
272                         }
273                         ast_debug(1, "Message %d, of %d input bytes, %d output bytes\n", x + 1, msglen[x], res);
274                         pos += res; 
275                         x++;
276                 }
277
278
279                 rem = 0;
280                 res = adsi_careful_send(chan, buf, pos, &rem); 
281                 if (!def)
282                         ast_channel_undefer_dtmf(chan);
283                 if (res)
284                         return -1;
285
286                 ast_debug(1, "Sent total spill of %d bytes\n", pos);
287
288                 memset(ack, 0, sizeof(ack));
289                 /* Get real result and check for hangup */
290                 if ((res = ast_readstring(chan, ack, 2, 1000, 1000, "")) < 0)
291                         return -1;
292                 if (ack[0] == 'D') {
293                         ast_debug(1, "Acked up to message %d\n", atoi(ack + 1)); start += atoi(ack + 1);
294                         if (start >= x)
295                                 break;
296                         else {
297                                 retries++;
298                                 ast_debug(1, "Retransmitting (%d), from %d\n", retries, start + 1);
299                         }
300                 } else {
301                         retries++;
302                         ast_log(LOG_WARNING, "Unexpected response to ack: %s (retry %d)\n", ack, retries);
303                 } 
304         }
305         if (retries >= maxretries) {
306                 ast_log(LOG_WARNING, "Maximum ADSI Retries (%d) exceeded\n", maxretries);
307                 errno = ETIMEDOUT;
308                 return -1;
309         }
310         return 0;
311         
312 }
313
314 static int _ast_adsi_begin_download(struct ast_channel *chan, char *service, unsigned char *fdn, unsigned char *sec, int version)
315 {
316         int bytes = 0;
317         unsigned char buf[256];
318         char ack[2];
319
320         /* Setup the resident soft key stuff, a piece at a time */
321         /* Upload what scripts we can for voicemail ahead of time */
322         bytes += ast_adsi_download_connect(buf + bytes, service, fdn, sec, version);
323         if (ast_adsi_transmit_message_full(chan, buf, bytes, ADSI_MSG_DOWNLOAD, 0))
324                 return -1;
325         if (ast_readstring(chan, ack, 1, 10000, 10000, ""))
326                 return -1;
327         if (ack[0] == 'B')
328                 return 0;
329         ast_debug(1, "Download was denied by CPE\n");
330         return -1;
331 }
332
333 static int _ast_adsi_end_download(struct ast_channel *chan)
334 {
335         int bytes = 0;
336         unsigned char buf[256];
337
338         /* Setup the resident soft key stuff, a piece at a time */
339         /* Upload what scripts we can for voicemail ahead of time */
340         bytes += ast_adsi_download_disconnect(buf + bytes);
341         if (ast_adsi_transmit_message_full(chan, buf, bytes, ADSI_MSG_DOWNLOAD, 0))
342                 return -1;
343         return 0;
344 }
345
346 static int _ast_adsi_transmit_message_full(struct ast_channel *chan, unsigned char *msg, int msglen, int msgtype, int dowait)
347 {
348         unsigned char *msgs[5] = { NULL, NULL, NULL, NULL, NULL };
349         int msglens[5], msgtypes[5], newdatamode = (chan->adsicpe & ADSI_FLAG_DATAMODE), res, x, writeformat = chan->writeformat, readformat = chan->readformat, waitforswitch = 0;
350
351         for (x = 0; x < msglen; x += (msg[x+1]+2)) {
352                 if (msg[x] == ADSI_SWITCH_TO_DATA) {
353                         ast_debug(1, "Switch to data is sent!\n");
354                         waitforswitch++;
355                         newdatamode = ADSI_FLAG_DATAMODE;
356                 }
357                 
358                 if (msg[x] == ADSI_SWITCH_TO_VOICE) {
359                         ast_debug(1, "Switch to voice is sent!\n");
360                         waitforswitch++;
361                         newdatamode = 0;
362                 }
363         }
364         msgs[0] = msg;
365
366         msglens[0] = msglen;
367         msgtypes[0] = msgtype;
368
369         if (msglen > 253) {
370                 ast_log(LOG_WARNING, "Can't send ADSI message of %d bytes, too large\n", msglen);
371                 return -1;
372         }
373
374         ast_stopstream(chan);
375
376         if (ast_set_write_format(chan, AST_FORMAT_ULAW)) {
377                 ast_log(LOG_WARNING, "Unable to set write format to ULAW\n");
378                 return -1;
379         }
380
381         if (ast_set_read_format(chan, AST_FORMAT_ULAW)) {
382                 ast_log(LOG_WARNING, "Unable to set read format to ULAW\n");
383                 if (writeformat) {
384                         if (ast_set_write_format(chan, writeformat)) 
385                                 ast_log(LOG_WARNING, "Unable to restore write format to %d\n", writeformat);
386                 }
387                 return -1;
388         }
389         res = __adsi_transmit_messages(chan, msgs, msglens, msgtypes);
390
391         if (dowait) {
392                 ast_debug(1, "Wait for switch is '%d'\n", waitforswitch);
393                 while (waitforswitch-- && ((res = ast_waitfordigit(chan, 1000)) > 0)) { 
394                         res = 0; 
395                         ast_debug(1, "Waiting for 'B'...\n");
396                 }
397         }
398         
399         if (!res)
400                 chan->adsicpe = (chan->adsicpe & ~ADSI_FLAG_DATAMODE) | newdatamode;
401
402         if (writeformat)
403                 ast_set_write_format(chan, writeformat);
404         if (readformat)
405                 ast_set_read_format(chan, readformat);
406
407         if (!res)
408                 res = ast_safe_sleep(chan, 100 );
409         return res;
410 }
411
412 static int _ast_adsi_transmit_message(struct ast_channel *chan, unsigned char *msg, int msglen, int msgtype)
413 {
414         return ast_adsi_transmit_message_full(chan, msg, msglen, msgtype, 1);
415 }
416
417 static inline int ccopy(unsigned char *dst, const unsigned char *src, int max)
418 {
419         int x = 0;
420         /* Carefully copy the requested data */
421         while ((x < max) && src[x] && (src[x] != 0xff)) {
422                 dst[x] = src[x];
423                 x++;
424         }
425         return x;
426 }
427
428 static int _ast_adsi_load_soft_key(unsigned char *buf, int key, const char *llabel, const char *slabel, char *ret, int data)
429 {
430         int bytes = 0;
431
432         /* Abort if invalid key specified */
433         if ((key < 2) || (key > 33))
434                 return -1;
435
436         buf[bytes++] = ADSI_LOAD_SOFTKEY;
437         /* Reserve for length */
438         bytes++;
439         /* Which key */
440         buf[bytes++] = key;
441
442         /* Carefully copy long label */
443         bytes += ccopy(buf + bytes, (const unsigned char *)llabel, 18);
444
445         /* Place delimiter */
446         buf[bytes++] = 0xff;
447
448         /* Short label */
449         bytes += ccopy(buf + bytes, (const unsigned char *)slabel, 7);
450
451
452         /* If specified, copy return string */
453         if (ret) {
454                 /* Place delimiter */
455                 buf[bytes++] = 0xff;
456                 if (data)
457                         buf[bytes++] = ADSI_SWITCH_TO_DATA2;
458                 /* Carefully copy return string */
459                 bytes += ccopy(buf + bytes, (const unsigned char *)ret, 20);
460
461         }
462         /* Replace parameter length */
463         buf[1] = bytes - 2;
464         return bytes;
465         
466 }
467
468 static int _ast_adsi_connect_session(unsigned char *buf, unsigned char *fdn, int ver)
469 {
470         int bytes = 0, x;
471
472         /* Message type */
473         buf[bytes++] = ADSI_CONNECT_SESSION;
474
475         /* Reserve space for length */
476         bytes++;
477
478         if (fdn) {
479                 for (x = 0; x < 4; x++)
480                         buf[bytes++] = fdn[x];
481                 if (ver > -1)
482                         buf[bytes++] = ver & 0xff;
483         }
484
485         buf[1] = bytes - 2;
486         return bytes;
487
488 }
489
490 static int _ast_adsi_download_connect(unsigned char *buf, char *service,  unsigned char *fdn, unsigned char *sec, int ver)
491 {
492         int bytes = 0, x;
493
494         /* Message type */
495         buf[bytes++] = ADSI_DOWNLOAD_CONNECT;
496
497         /* Reserve space for length */
498         bytes++;
499
500         /* Primary column */
501         bytes+= ccopy(buf + bytes, (unsigned char *)service, 18);
502
503         /* Delimiter */
504         buf[bytes++] = 0xff;
505         
506         for (x = 0; x < 4; x++)
507                 buf[bytes++] = fdn[x];
508
509         for (x = 0; x < 4; x++)
510                 buf[bytes++] = sec[x];
511
512         buf[bytes++] = ver & 0xff;
513
514         buf[1] = bytes - 2;
515
516         return bytes;
517
518 }
519
520 static int _ast_adsi_disconnect_session(unsigned char *buf)
521 {
522         int bytes = 0;
523
524         /* Message type */
525         buf[bytes++] = ADSI_DISC_SESSION;
526
527         /* Reserve space for length */
528         bytes++;
529
530         buf[1] = bytes - 2;
531         return bytes;
532
533 }
534
535 static int _ast_adsi_query_cpeid(unsigned char *buf)
536 {
537         int bytes = 0;
538         buf[bytes++] = ADSI_QUERY_CPEID;
539         /* Reserve space for length */
540         bytes++;
541         buf[1] = bytes - 2;
542         return bytes;
543 }
544
545 static int _ast_adsi_query_cpeinfo(unsigned char *buf)
546 {
547         int bytes = 0;
548         buf[bytes++] = ADSI_QUERY_CONFIG;
549         /* Reserve space for length */
550         bytes++;
551         buf[1] = bytes - 2;
552         return bytes;
553 }
554
555 static int _ast_adsi_read_encoded_dtmf(struct ast_channel *chan, unsigned char *buf, int maxlen)
556 {
557         int bytes = 0, res, gotstar = 0, pos = 0;
558         unsigned char current = 0;
559
560         memset(buf, 0, sizeof(buf));
561
562         while(bytes <= maxlen) {
563                 /* Wait up to a second for a digit */
564                 if (!(res = ast_waitfordigit(chan, 1000)))
565                         break;
566                 if (res == '*') {
567                         gotstar = 1;    
568                         continue;
569                 }
570                 /* Ignore anything other than a digit */
571                 if ((res < '0') || (res > '9'))
572                         continue;
573                 res -= '0';
574                 if (gotstar)
575                         res += 9;
576                 if (pos)  {
577                         pos = 0;
578                         buf[bytes++] = (res << 4) | current;
579                 } else {
580                         pos = 1;
581                         current = res;
582                 }
583                 gotstar = 0;
584         }
585
586         return bytes;
587 }
588
589 static int _ast_adsi_get_cpeid(struct ast_channel *chan, unsigned char *cpeid, int voice)
590 {
591         unsigned char buf[256] = "";
592         int bytes = 0, res;
593
594         bytes += ast_adsi_data_mode(buf);
595         ast_adsi_transmit_message_full(chan, buf, bytes, ADSI_MSG_DISPLAY, 0);
596
597         bytes = 0;
598         bytes += ast_adsi_query_cpeid(buf);
599         ast_adsi_transmit_message_full(chan, buf, bytes, ADSI_MSG_DISPLAY, 0);
600
601         /* Get response */
602         res = ast_adsi_read_encoded_dtmf(chan, cpeid, 4);
603         if (res != 4) {
604                 ast_log(LOG_WARNING, "Got %d bytes back of encoded DTMF, expecting 4\n", res);
605                 res = 0;
606         } else {
607                 res = 1;
608         }
609
610         if (voice) {
611                 bytes = 0;
612                 bytes += ast_adsi_voice_mode(buf, 0);
613                 ast_adsi_transmit_message_full(chan, buf, bytes, ADSI_MSG_DISPLAY, 0);
614                 /* Ignore the resulting DTMF B announcing it's in voice mode */
615                 ast_waitfordigit(chan, 1000);
616         }
617         return res;
618 }
619
620 static int _ast_adsi_get_cpeinfo(struct ast_channel *chan, int *width, int *height, int *buttons, int voice)
621 {
622         unsigned char buf[256] = "";
623         int bytes = 0, res;
624
625         bytes += ast_adsi_data_mode(buf);
626         ast_adsi_transmit_message_full(chan, buf, bytes, ADSI_MSG_DISPLAY, 0);
627
628         bytes = 0;
629         bytes += ast_adsi_query_cpeinfo(buf);
630         ast_adsi_transmit_message_full(chan, buf, bytes, ADSI_MSG_DISPLAY, 0);
631
632         /* Get width */
633         if ((res = ast_readstring(chan, (char *)buf, 2, 1000, 500, "")) < 0)
634                 return res;
635         if (strlen((char *)buf) != 2) {
636                 ast_log(LOG_WARNING, "Got %d bytes of width, expecting 2\n", res);
637                 res = 0;
638         } else {
639                 res = 1;
640         }
641         if (width)
642                 *width = atoi((char *)buf);
643         /* Get height */
644         memset(buf, 0, sizeof(buf));
645         if (res) {
646                 if ((res = ast_readstring(chan, (char *)buf, 2, 1000, 500, "")) < 0)
647                         return res;
648                 if (strlen((char *)buf) != 2) {
649                         ast_log(LOG_WARNING, "Got %d bytes of height, expecting 2\n", res);
650                         res = 0;
651                 } else {
652                         res = 1;
653                 }       
654                 if (height)
655                         *height= atoi((char *)buf);
656         }
657         /* Get buttons */
658         memset(buf, 0, sizeof(buf));
659         if (res) {
660                 if ((res = ast_readstring(chan, (char *)buf, 1, 1000, 500, "")) < 0)
661                         return res;
662                 if (strlen((char *)buf) != 1) {
663                         ast_log(LOG_WARNING, "Got %d bytes of buttons, expecting 1\n", res);
664                         res = 0;
665                 } else {
666                         res = 1;
667                 }       
668                 if (buttons)
669                         *buttons = atoi((char *)buf);
670         }
671         if (voice) {
672                 bytes = 0;
673                 bytes += ast_adsi_voice_mode(buf, 0);
674                 ast_adsi_transmit_message_full(chan, buf, bytes, ADSI_MSG_DISPLAY, 0);
675                 /* Ignore the resulting DTMF B announcing it's in voice mode */
676                 ast_waitfordigit(chan, 1000);
677         }
678         return res;
679 }
680
681 static int _ast_adsi_data_mode(unsigned char *buf)
682 {
683         int bytes = 0;
684
685         /* Message type */
686         buf[bytes++] = ADSI_SWITCH_TO_DATA;
687
688         /* Reserve space for length */
689         bytes++;
690
691         buf[1] = bytes - 2;
692         return bytes;
693
694 }
695
696 static int _ast_adsi_clear_soft_keys(unsigned char *buf)
697 {
698         int bytes = 0;
699
700         /* Message type */
701         buf[bytes++] = ADSI_CLEAR_SOFTKEY;
702
703         /* Reserve space for length */
704         bytes++;
705
706         buf[1] = bytes - 2;
707         return bytes;
708
709 }
710
711 static int _ast_adsi_clear_screen(unsigned char *buf)
712 {
713         int bytes = 0;
714
715         /* Message type */
716         buf[bytes++] = ADSI_CLEAR_SCREEN;
717
718         /* Reserve space for length */
719         bytes++;
720
721         buf[1] = bytes - 2;
722         return bytes;
723
724 }
725
726 static int _ast_adsi_voice_mode(unsigned char *buf, int when)
727 {
728         int bytes = 0;
729
730         /* Message type */
731         buf[bytes++] = ADSI_SWITCH_TO_VOICE;
732
733         /* Reserve space for length */
734         bytes++;
735
736         buf[bytes++] = when & 0x7f;
737
738         buf[1] = bytes - 2;
739         return bytes;
740
741 }
742
743 static int _ast_adsi_available(struct ast_channel *chan)
744 {
745         int cpe = chan->adsicpe & 0xff;
746         if ((cpe == AST_ADSI_AVAILABLE) ||
747             (cpe == AST_ADSI_UNKNOWN))
748                 return 1;
749         return 0;
750 }
751
752 static int _ast_adsi_download_disconnect(unsigned char *buf)
753 {
754         int bytes = 0;
755
756         /* Message type */
757         buf[bytes++] = ADSI_DOWNLOAD_DISC;
758
759         /* Reserve space for length */
760         bytes++;
761
762         buf[1] = bytes - 2;
763         return bytes;
764
765 }
766
767 static int _ast_adsi_display(unsigned char *buf, int page, int line, int just, int wrap, 
768                  char *col1, char *col2)
769 {
770         int bytes = 0;
771
772         /* Sanity check line number */
773
774         if (page) {
775                 if (line > 4) return -1;
776         } else {
777                 if (line > 33) return -1;
778         }
779
780         if (line < 1)
781                 return -1;
782         /* Parameter type */
783         buf[bytes++] = ADSI_LOAD_VIRTUAL_DISP;
784         
785         /* Reserve space for size */
786         bytes++;
787
788         /* Page and wrap indicator */
789         buf[bytes++] = ((page & 0x1) << 7) | ((wrap & 0x1) << 6) | (line & 0x3f);
790
791         /* Justification */
792         buf[bytes++] = (just & 0x3) << 5;
793
794         /* Omit highlight mode definition */
795         buf[bytes++] = 0xff;
796
797         /* Primary column */
798         bytes+= ccopy(buf + bytes, (unsigned char *)col1, 20);
799
800         /* Delimiter */
801         buf[bytes++] = 0xff;
802         
803         /* Secondary column */
804         bytes += ccopy(buf + bytes, (unsigned char *)col2, 20);
805
806         /* Update length */
807         buf[1] = bytes - 2;
808         
809         return bytes;
810
811 }
812
813 static int _ast_adsi_input_control(unsigned char *buf, int page, int line, int display, int format, int just)
814 {
815         int bytes = 0;
816
817         if (page) {
818                 if (line > 4) return -1;
819         } else {
820                 if (line > 33) return -1;
821         }
822
823         if (line < 1)
824                 return -1;
825
826         buf[bytes++] = ADSI_INPUT_CONTROL;
827         bytes++;
828         buf[bytes++] = ((page & 1) << 7) | (line & 0x3f);
829         buf[bytes++] = ((display & 1) << 7) | ((just & 0x3) << 4) | (format & 0x7);
830         
831         buf[1] = bytes - 2;
832         return bytes;
833
834 }
835
836 static int _ast_adsi_input_format(unsigned char *buf, int num, int dir, int wrap, char *format1, char *format2)
837 {
838         int bytes = 0;
839
840         if (!strlen((char *)format1))
841                 return -1;
842
843         buf[bytes++] = ADSI_INPUT_FORMAT;
844         bytes++;
845         buf[bytes++] = ((dir & 1) << 7) | ((wrap & 1) << 6) | (num & 0x7);
846         bytes += ccopy(buf + bytes, (unsigned char *)format1, 20);
847         buf[bytes++] = 0xff;
848         if (format2 && strlen((char *)format2)) {
849                 bytes += ccopy(buf + bytes, (unsigned char *)format2, 20);
850         }
851         buf[1] = bytes - 2;
852         return bytes;
853 }
854
855 static int _ast_adsi_set_keys(unsigned char *buf, unsigned char *keys)
856 {
857         int bytes = 0, x;
858
859         /* Message type */
860         buf[bytes++] = ADSI_INIT_SOFTKEY_LINE;
861         /* Space for size */
862         bytes++;
863         /* Key definitions */
864         for (x = 0; x < 6; x++)
865                 buf[bytes++] = (keys[x] & 0x3f) ? keys[x] : (keys[x] | 0x1);
866         buf[1] = bytes - 2;
867         return bytes;
868 }
869
870 static int _ast_adsi_set_line(unsigned char *buf, int page, int line)
871 {
872         int bytes = 0;
873
874         /* Sanity check line number */
875
876         if (page) {
877                 if (line > 4) return -1;
878         } else {
879                 if (line > 33) return -1;
880         }
881
882         if (line < 1)
883                 return -1;
884         /* Parameter type */
885         buf[bytes++] = ADSI_LINE_CONTROL;
886         
887         /* Reserve space for size */
888         bytes++;
889
890         /* Page and line */
891         buf[bytes++] = ((page & 0x1) << 7) | (line & 0x3f);
892
893         buf[1] = bytes - 2;
894         return bytes;
895
896 };
897
898 static int total = 0;
899 static int speeds = 0;
900
901 static int _ast_adsi_channel_restore(struct ast_channel *chan)
902 {
903         unsigned char dsp[256] = "", keyd[6] = "";
904         int bytes, x;
905
906         /* Start with initial display setup */
907         bytes = 0;
908         bytes += ast_adsi_set_line(dsp + bytes, ADSI_INFO_PAGE, 1);
909
910         /* Prepare key setup messages */
911
912         if (speeds) {
913                 for (x = 0; x < speeds; x++)
914                         keyd[x] = ADSI_SPEED_DIAL + x;
915                 bytes += ast_adsi_set_keys(dsp + bytes, keyd);
916         }
917         ast_adsi_transmit_message_full(chan, dsp, bytes, ADSI_MSG_DISPLAY, 0);
918         return 0;
919
920 }
921
922 static int _ast_adsi_print(struct ast_channel *chan, char **lines, int *aligns, int voice)
923 {
924         unsigned char buf[4096];
925         int bytes = 0, res, x;
926
927         for(x = 0; lines[x]; x++) 
928                 bytes += ast_adsi_display(buf + bytes, ADSI_INFO_PAGE, x+1, aligns[x], 0, lines[x], "");
929         bytes += ast_adsi_set_line(buf + bytes, ADSI_INFO_PAGE, 1);
930         if (voice)
931                 bytes += ast_adsi_voice_mode(buf + bytes, 0);
932         res = ast_adsi_transmit_message_full(chan, buf, bytes, ADSI_MSG_DISPLAY, 0);
933         if (voice)
934                 /* Ignore the resulting DTMF B announcing it's in voice mode */
935                 ast_waitfordigit(chan, 1000);
936         return res;
937 }
938
939 static int _ast_adsi_load_session(struct ast_channel *chan, unsigned char *app, int ver, int data)
940 {
941         unsigned char dsp[256] = "";
942         int bytes = 0, res;
943         char resp[2];
944
945         /* Connect to session */
946         bytes += ast_adsi_connect_session(dsp + bytes, app, ver);
947
948         if (data)
949                 bytes += ast_adsi_data_mode(dsp + bytes);
950
951         /* Prepare key setup messages */
952         if (ast_adsi_transmit_message_full(chan, dsp, bytes, ADSI_MSG_DISPLAY, 0))
953                 return -1;
954         if (app) {
955                 if ((res = ast_readstring(chan, resp, 1, 1200, 1200, "")) < 0)
956                         return -1;
957                 if (res) {
958                         ast_debug(1, "No response from CPE about version.  Assuming not there.\n");
959                         return 0;
960                 }
961                 if (!strcmp(resp, "B")) {
962                         ast_debug(1, "CPE has script '%s' version %d already loaded\n", app, ver);
963                         return 1;
964                 } else if (!strcmp(resp, "A")) {
965                         ast_debug(1, "CPE hasn't script '%s' version %d already loaded\n", app, ver);
966                 } else {
967                         ast_log(LOG_WARNING, "Unexpected CPE response to script query: %s\n", resp);
968                 }
969         } else
970                 return 1;
971         return 0;
972
973 }
974
975 static int _ast_adsi_unload_session(struct ast_channel *chan)
976 {
977         unsigned char dsp[256] = "";
978         int bytes = 0;
979
980         /* Connect to session */
981         bytes += ast_adsi_disconnect_session(dsp + bytes);
982         bytes += ast_adsi_voice_mode(dsp + bytes, 0);
983
984         /* Prepare key setup messages */
985         if (ast_adsi_transmit_message_full(chan, dsp, bytes, ADSI_MSG_DISPLAY, 0))
986                 return -1;
987
988         return 0;
989 }
990
991 static int str2align(char *s)
992 {
993         if (!strncasecmp(s, "l", 1))
994                 return ADSI_JUST_LEFT;
995         else if (!strncasecmp(s, "r", 1))
996                 return ADSI_JUST_RIGHT;
997         else if (!strncasecmp(s, "i", 1))
998                 return ADSI_JUST_IND;
999         else
1000                 return ADSI_JUST_CENT;
1001 }
1002
1003 static void init_state(void)
1004 {
1005         int x;
1006
1007         for (x = 0; x < ADSI_MAX_INTRO; x++)
1008                 aligns[x] = ADSI_JUST_CENT;
1009         ast_copy_string(intro[0], "Welcome to the", sizeof(intro[0]));
1010         ast_copy_string(intro[1], "Asterisk", sizeof(intro[1]));
1011         ast_copy_string(intro[2], "Open Source PBX", sizeof(intro[2]));
1012         total = 3;
1013         speeds = 0;
1014         for (x = 3; x < ADSI_MAX_INTRO; x++)
1015                 intro[x][0] = '\0';
1016         memset(speeddial, 0, sizeof(speeddial));
1017         alignment = ADSI_JUST_CENT;
1018 }
1019
1020 static void adsi_load(void)
1021 {
1022         int x = 0;
1023         struct ast_config *conf = NULL;
1024         struct ast_variable *v;
1025         struct ast_flags config_flags = { 0 };
1026         char *name, *sname;
1027         init_state();
1028
1029         if (!(conf = ast_config_load("adsi.conf", config_flags)))
1030                 return;
1031         
1032         for (v = ast_variable_browse(conf, "intro"); v; v = v->next) {
1033                 if (!strcasecmp(v->name, "alignment"))
1034                         alignment = str2align(v->value);
1035                 else if (!strcasecmp(v->name, "greeting")) {
1036                         if (x < ADSI_MAX_INTRO) {
1037                                 aligns[x] = alignment;
1038                                 ast_copy_string(intro[x], v->value, sizeof(intro[x]));
1039                                 x++;
1040                         }
1041                 } else if (!strcasecmp(v->name, "maxretries")) {
1042                         if (atoi(v->value) > 0)
1043                                 maxretries = atoi(v->value);
1044                 }
1045         }
1046         if (x)
1047                 total = x;
1048                 
1049         x = 0;
1050         for (v = ast_variable_browse(conf, "speeddial"); v; v = v->next) {
1051                 char *stringp = v->value;
1052                 name = strsep(&stringp, ",");
1053                 sname = strsep(&stringp, ",");
1054                 if (!sname) 
1055                         sname = name;
1056                 if (x < ADSI_MAX_SPEED_DIAL) {
1057                         ast_copy_string(speeddial[x][0], v->name, sizeof(speeddial[x][0]));
1058                         ast_copy_string(speeddial[x][1], name, 18);
1059                         ast_copy_string(speeddial[x][2], sname, 7);
1060                         x++;
1061                 }
1062         }
1063         if (x)
1064                 speeds = x;
1065         ast_config_destroy(conf);
1066
1067         return;
1068 }
1069
1070 static int reload(void)
1071 {
1072         adsi_load();
1073         return 0;
1074 }
1075
1076 static int load_module(void)
1077 {
1078         adsi_load();
1079
1080         ast_adsi_begin_download = _ast_adsi_begin_download;
1081         ast_adsi_end_download = _ast_adsi_end_download;
1082         ast_adsi_channel_restore = _ast_adsi_channel_restore;
1083         ast_adsi_print = _ast_adsi_print;
1084         ast_adsi_load_session = _ast_adsi_load_session;
1085         ast_adsi_unload_session = _ast_adsi_unload_session;
1086         ast_adsi_transmit_message = _ast_adsi_transmit_message;
1087         ast_adsi_transmit_message_full = _ast_adsi_transmit_message_full;
1088         ast_adsi_read_encoded_dtmf = _ast_adsi_read_encoded_dtmf;
1089         ast_adsi_connect_session = _ast_adsi_connect_session;
1090         ast_adsi_query_cpeid = _ast_adsi_query_cpeid;
1091         ast_adsi_query_cpeinfo = _ast_adsi_query_cpeinfo;
1092         ast_adsi_get_cpeid = _ast_adsi_get_cpeid;
1093         ast_adsi_get_cpeinfo = _ast_adsi_get_cpeinfo;
1094         ast_adsi_download_connect = _ast_adsi_download_connect;
1095         ast_adsi_disconnect_session = _ast_adsi_disconnect_session;
1096         ast_adsi_download_disconnect = _ast_adsi_download_disconnect;
1097         ast_adsi_data_mode = _ast_adsi_data_mode;
1098         ast_adsi_clear_soft_keys = _ast_adsi_clear_soft_keys;
1099         ast_adsi_clear_screen = _ast_adsi_clear_screen;
1100         ast_adsi_voice_mode = _ast_adsi_voice_mode;
1101         ast_adsi_available = _ast_adsi_available;
1102         ast_adsi_display = _ast_adsi_display;
1103         ast_adsi_set_line = _ast_adsi_set_line;
1104         ast_adsi_load_soft_key = _ast_adsi_load_soft_key;
1105         ast_adsi_set_keys = _ast_adsi_set_keys;
1106         ast_adsi_input_control = _ast_adsi_input_control;
1107         ast_adsi_input_format = _ast_adsi_input_format;
1108
1109         return AST_MODULE_LOAD_SUCCESS;
1110 }
1111
1112 static int unload_module(void)
1113 {
1114         /* Can't unload this once we're loaded */
1115         return -1;
1116 }
1117
1118 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "ADSI Resource",
1119                 .load = load_module,
1120                 .unload = unload_module,
1121                 .reload = reload,
1122                );