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