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