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