res/res_adsi.c

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