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