res/res_adsi.c

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