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