00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027 #include <time.h>
00028 #include <string.h>
00029 #include <stdio.h>
00030 #include <stdlib.h>
00031 #include <unistd.h>
00032 #include <math.h>
00033 #include <errno.h>
00034
00035 #include "asterisk.h"
00036
00037 ASTERISK_FILE_VERSION(__FILE__, "$Revision: 7221 $")
00038
00039 #include "asterisk/ulaw.h"
00040 #include "asterisk/alaw.h"
00041 #include "asterisk/callerid.h"
00042 #include "asterisk/logger.h"
00043 #include "asterisk/fskmodem.h"
00044 #include "asterisk/channel.h"
00045 #include "asterisk/adsi.h"
00046 #include "asterisk/module.h"
00047 #include "asterisk/config.h"
00048 #include "asterisk/file.h"
00049
00050 #define DEFAULT_ADSI_MAX_RETRIES 3
00051
00052 #define ADSI_MAX_INTRO 20
00053 #define ADSI_MAX_SPEED_DIAL 6
00054
00055 #define ADSI_FLAG_DATAMODE (1 << 8)
00056
00057 static int maxretries = DEFAULT_ADSI_MAX_RETRIES;
00058
00059
00060 #define ADSI_SPEED_DIAL 10
00061
00062 static char intro[ADSI_MAX_INTRO][20];
00063 static int aligns[ADSI_MAX_INTRO];
00064
00065 static char speeddial[ADSI_MAX_SPEED_DIAL][3][20];
00066
00067 static int alignment = 0;
00068
00069 static int adsi_generate(unsigned char *buf, int msgtype, unsigned char *msg, int msglen, int msgnum, int last, int codec)
00070 {
00071 int sum;
00072 int x;
00073 int bytes=0;
00074
00075 float cr = 1.0;
00076 float ci = 0.0;
00077 float scont = 0.0;
00078
00079 if (msglen > 255)
00080 msglen = 255;
00081
00082
00083 if (msgnum == 1) {
00084 for (x=0;x<150;x++)
00085 PUT_CLID_MARKMS;
00086 }
00087
00088 PUT_CLID(msgtype);
00089 sum = msgtype;
00090
00091
00092 PUT_CLID(msglen + 1);
00093 sum += msglen + 1;
00094
00095
00096 PUT_CLID(msgnum);
00097 sum += msgnum;
00098
00099
00100 for (x=0;x<msglen;x++) {
00101 PUT_CLID(msg[x]);
00102 sum += msg[x];
00103 }
00104
00105
00106 PUT_CLID(256-(sum & 0xff));
00107
00108 #if 0
00109 if (last) {
00110
00111 for (x=0;x<50;x++)
00112 PUT_CLID_MARKMS;
00113 }
00114 #endif
00115 return bytes;
00116
00117 }
00118
00119 static int adsi_careful_send(struct ast_channel *chan, unsigned char *buf, int len, int *remainder)
00120 {
00121
00122
00123 struct ast_frame *inf, outf;
00124 int amt;
00125
00126
00127 memset(&outf, 0, sizeof(outf));
00128
00129 if (remainder && *remainder) {
00130 amt = len;
00131
00132
00133 if (amt > *remainder)
00134 amt = *remainder;
00135 else
00136 *remainder = *remainder - amt;
00137 outf.frametype = AST_FRAME_VOICE;
00138 outf.subclass = AST_FORMAT_ULAW;
00139 outf.data = buf;
00140 outf.datalen = amt;
00141 outf.samples = amt;
00142 if (ast_write(chan, &outf)) {
00143 ast_log(LOG_WARNING, "Failed to carefully write frame\n");
00144 return -1;
00145 }
00146
00147 buf += amt;
00148 len -= amt;
00149 }
00150
00151 while(len) {
00152 amt = len;
00153
00154
00155 if (ast_waitfor(chan, 1000) < 1)
00156 return -1;
00157 inf = ast_read(chan);
00158
00159 if (!inf)
00160 return -1;
00161 if (inf->frametype == AST_FRAME_VOICE) {
00162
00163 if (inf->subclass != AST_FORMAT_ULAW) {
00164 ast_log(LOG_WARNING, "Channel not in ulaw?\n");
00165 return -1;
00166 }
00167
00168 if (amt > inf->datalen)
00169 amt = inf->datalen;
00170 else if (remainder)
00171 *remainder = inf->datalen - amt;
00172 outf.frametype = AST_FRAME_VOICE;
00173 outf.subclass = AST_FORMAT_ULAW;
00174 outf.data = buf;
00175 outf.datalen = amt;
00176 outf.samples = amt;
00177 if (ast_write(chan, &outf)) {
00178 ast_log(LOG_WARNING, "Failed to carefully write frame\n");
00179 return -1;
00180 }
00181
00182 buf += amt;
00183 len -= amt;
00184 }
00185 ast_frfree(inf);
00186 }
00187 return 0;
00188 }
00189
00190 static int __adsi_transmit_messages(struct ast_channel *chan, unsigned char **msg, int *msglen, int *msgtype)
00191 {
00192
00193 unsigned char buf[24000 * 5];
00194 int pos = 0, res;
00195 int x;
00196 int start=0;
00197 int retries = 0;
00198
00199 char ack[3];
00200
00201
00202 int waittime;
00203 struct ast_frame *f;
00204 int rem = 0;
00205 int def;
00206
00207 if (chan->adsicpe == AST_ADSI_UNAVAILABLE) {
00208
00209 errno = ENOSYS;
00210 return -1;
00211 }
00212
00213 while(retries < maxretries) {
00214 if (!(chan->adsicpe & ADSI_FLAG_DATAMODE)) {
00215
00216 ast_gen_cas(buf, 0, 680, AST_FORMAT_ULAW);
00217
00218
00219 if (adsi_careful_send(chan, buf, 680, NULL)) {
00220 ast_log(LOG_WARNING, "Unable to send CAS\n");
00221 }
00222
00223 waittime = 500;
00224 for(;;) {
00225 if (((res = ast_waitfor(chan, waittime)) < 1)) {
00226
00227 ast_log(LOG_DEBUG, "No ADSI CPE detected (%d)\n", res);
00228 if (!chan->adsicpe)
00229 chan->adsicpe = AST_ADSI_UNAVAILABLE;
00230 errno = ENOSYS;
00231 return -1;
00232 }
00233 waittime = res;
00234 f = ast_read(chan);
00235 if (!f) {
00236 ast_log(LOG_DEBUG, "Hangup in ADSI\n");
00237 return -1;
00238 }
00239 if (f->frametype == AST_FRAME_DTMF) {
00240 if (f->subclass == 'A') {
00241
00242 if (!chan->adsicpe)
00243 chan->adsicpe = AST_ADSI_AVAILABLE;
00244 break;
00245 } else {
00246 if (f->subclass == 'D') {
00247 ast_log(LOG_DEBUG, "Off-hook capable CPE only, not ADSI\n");
00248 } else
00249 ast_log(LOG_WARNING, "Unknown ADSI response '%c'\n", f->subclass);
00250 if (!chan->adsicpe)
00251 chan->adsicpe = AST_ADSI_UNAVAILABLE;
00252 errno = ENOSYS;
00253 return -1;
00254 }
00255 }
00256 ast_frfree(f);
00257 }
00258
00259 ast_log(LOG_DEBUG, "ADSI Compatible CPE Detected\n");
00260 } else
00261 ast_log(LOG_DEBUG, "Already in data mode\n");
00262
00263 x = 0;
00264 pos = 0;
00265 #if 1
00266 def= ast_channel_defer_dtmf(chan);
00267 #endif
00268 while((x < 6) && msg[x]) {
00269 res = adsi_generate(buf + pos, msgtype[x], msg[x], msglen[x], x+1 - start, (x == 5) || !msg[x+1], AST_FORMAT_ULAW);
00270 if (res < 0) {
00271 ast_log(LOG_WARNING, "Failed to generate ADSI message %d on channel %s\n", x + 1, chan->name);
00272 return -1;
00273 }
00274 ast_log(LOG_DEBUG, "Message %d, of %d input bytes, %d output bytes\n",
00275 x + 1, msglen[x], res);
00276 pos += res;
00277 x++;
00278 }
00279
00280
00281 rem = 0;
00282 res = adsi_careful_send(chan, buf, pos, &rem);
00283 if (!def)
00284 ast_channel_undefer_dtmf(chan);
00285 if (res)
00286 return -1;
00287
00288 ast_log(LOG_DEBUG, "Sent total spill of %d bytes\n", pos);
00289
00290 memset(ack, 0, sizeof(ack));
00291
00292 res = ast_readstring(chan, ack, 2, 1000, 1000, "");
00293
00294 if (res < 0)
00295 return -1;
00296 if (ack[0] == 'D') {
00297 ast_log(LOG_DEBUG, "Acked up to message %d\n", atoi(ack + 1));
00298 start += atoi(ack + 1);
00299 if (start >= x)
00300 break;
00301 else {
00302 retries++;
00303 ast_log(LOG_DEBUG, "Retransmitting (%d), from %d\n", retries, start + 1);
00304 }
00305 } else {
00306 retries++;
00307 ast_log(LOG_WARNING, "Unexpected response to ack: %s (retry %d)\n", ack, retries);
00308 }
00309 }
00310 if (retries >= maxretries) {
00311 ast_log(LOG_WARNING, "Maximum ADSI Retries (%d) exceeded\n", maxretries);
00312 errno = ETIMEDOUT;
00313 return -1;
00314 }
00315 return 0;
00316
00317 }
00318
00319 int adsi_begin_download(struct ast_channel *chan, char *service, unsigned char *fdn, unsigned char *sec, int version)
00320 {
00321 int bytes;
00322 unsigned char buf[256];
00323 char ack[2];
00324 bytes = 0;
00325
00326
00327 bytes += adsi_download_connect(buf + bytes, service, fdn, sec, version);
00328 if (adsi_transmit_message_full(chan, buf, bytes, ADSI_MSG_DOWNLOAD, 0))
00329 return -1;
00330 if (ast_readstring(chan, ack, 1, 10000, 10000, ""))
00331 return -1;
00332 if (ack[0] == 'B')
00333 return 0;
00334 ast_log(LOG_DEBUG, "Download was denied by CPE\n");
00335 return -1;
00336 }
00337
00338 int adsi_end_download(struct ast_channel *chan)
00339 {
00340 int bytes;
00341 unsigned char buf[256];
00342 bytes = 0;
00343
00344
00345 bytes += adsi_download_disconnect(buf + bytes);
00346 if (adsi_transmit_message_full(chan, buf, bytes, ADSI_MSG_DOWNLOAD, 0))
00347 return -1;
00348 return 0;
00349 }
00350
00351 int adsi_transmit_message_full(struct ast_channel *chan, unsigned char *msg, int msglen, int msgtype, int dowait)
00352 {
00353 unsigned char *msgs[5] = { NULL, NULL, NULL, NULL, NULL };
00354 int msglens[5];
00355 int msgtypes[5];
00356 int newdatamode;
00357 int res;
00358 int x;
00359 int writeformat, readformat;
00360 int waitforswitch = 0;
00361
00362 writeformat = chan->writeformat;
00363 readformat = chan->readformat;
00364
00365 newdatamode = chan->adsicpe & ADSI_FLAG_DATAMODE;
00366
00367 for (x=0;x<msglen;x+=(msg[x+1]+2)) {
00368 if (msg[x] == ADSI_SWITCH_TO_DATA) {
00369 ast_log(LOG_DEBUG, "Switch to data is sent!\n");
00370 waitforswitch++;
00371 newdatamode = ADSI_FLAG_DATAMODE;
00372 }
00373
00374 if (msg[x] == ADSI_SWITCH_TO_VOICE) {
00375 ast_log(LOG_DEBUG, "Switch to voice is sent!\n");
00376 waitforswitch++;
00377 newdatamode = 0;
00378 }
00379 }
00380 msgs[0] = msg;
00381
00382 msglens[0] = msglen;
00383 msgtypes[0] = msgtype;
00384
00385 if (msglen > 253) {
00386 ast_log(LOG_WARNING, "Can't send ADSI message of %d bytes, too large\n", msglen);
00387 return -1;
00388 }
00389
00390 ast_stopstream(chan);
00391
00392 if (ast_set_write_format(chan, AST_FORMAT_ULAW)) {
00393 ast_log(LOG_WARNING, "Unable to set write format to ULAW\n");
00394 return -1;
00395 }
00396
00397 if (ast_set_read_format(chan, AST_FORMAT_ULAW)) {
00398 ast_log(LOG_WARNING, "Unable to set read format to ULAW\n");
00399 if (writeformat) {
00400 if (ast_set_write_format(chan, writeformat))
00401 ast_log(LOG_WARNING, "Unable to restore write format to %d\n", writeformat);
00402 }
00403 return -1;
00404 }
00405 res = __adsi_transmit_messages(chan, msgs, msglens, msgtypes);
00406
00407 if (dowait) {
00408 ast_log(LOG_DEBUG, "Wait for switch is '%d'\n", waitforswitch);
00409 while(waitforswitch-- && ((res = ast_waitfordigit(chan, 1000)) > 0)) { res = 0; ast_log(LOG_DEBUG, "Waiting for 'B'...\n"); }
00410 }
00411
00412 if (!res)
00413 chan->adsicpe = (chan->adsicpe & ~ADSI_FLAG_DATAMODE) | newdatamode;
00414
00415 if (writeformat)
00416 ast_set_write_format(chan, writeformat);
00417 if (readformat)
00418 ast_set_read_format(chan, readformat);
00419
00420 if (!res)
00421 res = ast_safe_sleep(chan, 100 );
00422 return res;
00423 }
00424
00425 int adsi_transmit_message(struct ast_channel *chan, unsigned char *msg, int msglen, int msgtype)
00426 {
00427 return adsi_transmit_message_full(chan, msg, msglen, msgtype, 1);
00428 }
00429
00430 static inline int ccopy(unsigned char *dst, unsigned char *src, int max)
00431 {
00432 int x=0;
00433
00434 while ((x < max) && src[x] && (src[x] != 0xff)) {
00435 dst[x] = src[x];
00436 x++;
00437 }
00438 return x;
00439 }
00440
00441 int adsi_load_soft_key(unsigned char *buf, int key, char *llabel, char *slabel, char *ret, int data)
00442 {
00443 int bytes=0;
00444
00445
00446 if ((key < 2) || (key > 33))
00447 return -1;
00448 buf[bytes++] = ADSI_LOAD_SOFTKEY;
00449
00450 bytes++;
00451
00452 buf[bytes++] = key;
00453
00454
00455 bytes += ccopy(buf + bytes, (unsigned char *)llabel, 18);
00456
00457
00458 buf[bytes++] = 0xff;
00459
00460
00461 bytes += ccopy(buf + bytes, (unsigned char *)slabel, 7);
00462
00463
00464
00465 if (ret) {
00466
00467 buf[bytes++] = 0xff;
00468 if (data)
00469 buf[bytes++] = ADSI_SWITCH_TO_DATA2;
00470
00471 bytes += ccopy(buf + bytes, (unsigned char *)ret, 20);
00472
00473 }
00474
00475 buf[1] = bytes - 2;
00476 return bytes;
00477
00478 }
00479
00480 int adsi_connect_session(unsigned char *buf, unsigned char *fdn, int ver)
00481 {
00482 int bytes=0;
00483 int x;
00484
00485
00486 buf[bytes++] = ADSI_CONNECT_SESSION;
00487
00488
00489 bytes++;
00490
00491 if (fdn) {
00492 for (x=0;x<4;x++)
00493 buf[bytes++] = fdn[x];
00494 if (ver > -1)
00495 buf[bytes++] = ver & 0xff;
00496 }
00497
00498 buf[1] = bytes - 2;
00499 return bytes;
00500
00501 }
00502
00503 int adsi_download_connect(unsigned char *buf, char *service, unsigned char *fdn, unsigned char *sec, int ver)
00504 {
00505 int bytes=0;
00506 int x;
00507
00508
00509 buf[bytes++] = ADSI_DOWNLOAD_CONNECT;
00510
00511
00512 bytes++;
00513
00514
00515 bytes+= ccopy(buf + bytes, (unsigned char *)service, 18);
00516
00517
00518 buf[bytes++] = 0xff;
00519
00520 for (x=0;x<4;x++) {
00521 buf[bytes++] = fdn[x];
00522 }
00523 for (x=0;x<4;x++)
00524 buf[bytes++] = sec[x];
00525 buf[bytes++] = ver & 0xff;
00526
00527 buf[1] = bytes - 2;
00528
00529 return bytes;
00530
00531 }
00532
00533 int adsi_disconnect_session(unsigned char *buf)
00534 {
00535 int bytes=0;
00536
00537
00538 buf[bytes++] = ADSI_DISC_SESSION;
00539
00540
00541 bytes++;
00542
00543 buf[1] = bytes - 2;
00544 return bytes;
00545
00546 }
00547
00548 int adsi_query_cpeid(unsigned char *buf)
00549 {
00550 int bytes = 0;
00551 buf[bytes++] = ADSI_QUERY_CPEID;
00552
00553 bytes++;
00554 buf[1] = bytes - 2;
00555 return bytes;
00556 }
00557
00558 int adsi_query_cpeinfo(unsigned char *buf)
00559 {
00560 int bytes = 0;
00561 buf[bytes++] = ADSI_QUERY_CONFIG;
00562
00563 bytes++;
00564 buf[1] = bytes - 2;
00565 return bytes;
00566 }
00567
00568 int adsi_read_encoded_dtmf(struct ast_channel *chan, unsigned char *buf, int maxlen)
00569 {
00570 int bytes = 0;
00571 int res;
00572 unsigned char current = 0;
00573 int gotstar = 0;
00574 int pos = 0;
00575 memset(buf, 0, sizeof(buf));
00576 while(bytes <= maxlen) {
00577
00578 res = ast_waitfordigit(chan, 1000);
00579 if (!res)
00580 break;
00581 if (res == '*') {
00582 gotstar = 1;
00583 continue;
00584 }
00585
00586 if ((res < '0') || (res > '9'))
00587 continue;
00588 res -= '0';
00589 if (gotstar)
00590 res += 9;
00591 if (pos) {
00592 pos = 0;
00593 buf[bytes++] = (res << 4) | current;
00594 } else {
00595 pos = 1;
00596 current = res;
00597 }
00598 gotstar = 0;
00599 }
00600 return bytes;
00601 }
00602
00603 int adsi_get_cpeid(struct ast_channel *chan, unsigned char *cpeid, int voice)
00604 {
00605 unsigned char buf[256];
00606 int bytes = 0;
00607 int res;
00608 bytes += adsi_data_mode(buf);
00609 adsi_transmit_message_full(chan, buf, bytes, ADSI_MSG_DISPLAY, 0);
00610
00611 bytes = 0;
00612 bytes += adsi_query_cpeid(buf);
00613 adsi_transmit_message_full(chan, buf, bytes, ADSI_MSG_DISPLAY, 0);
00614
00615
00616 memset(buf, 0, sizeof(buf));
00617 res = adsi_read_encoded_dtmf(chan, cpeid, 4);
00618 if (res != 4) {
00619 ast_log(LOG_WARNING, "Got %d bytes back of encoded DTMF, expecting 4\n", res);
00620 res = 0;
00621 } else {
00622 res = 1;
00623 }
00624
00625 if (voice) {
00626 bytes = 0;
00627 bytes += adsi_voice_mode(buf, 0);
00628 adsi_transmit_message_full(chan, buf, bytes, ADSI_MSG_DISPLAY, 0);
00629
00630 ast_waitfordigit(chan, 1000);
00631 }
00632 return res;
00633 }
00634
00635 int adsi_get_cpeinfo(struct ast_channel *chan, int *width, int *height, int *buttons, int voice)
00636 {
00637 unsigned char buf[256];
00638 int bytes = 0;
00639 int res;
00640 bytes += adsi_data_mode(buf);
00641 adsi_transmit_message_full(chan, buf, bytes, ADSI_MSG_DISPLAY, 0);
00642
00643 bytes = 0;
00644 bytes += adsi_query_cpeinfo(buf);
00645 adsi_transmit_message_full(chan, buf, bytes, ADSI_MSG_DISPLAY, 0);
00646
00647
00648 memset(buf, 0, sizeof(buf));
00649 res = ast_readstring(chan, (char *)buf, 2, 1000, 500, "");
00650 if (res < 0)
00651 return res;
00652 if (strlen((char *)buf) != 2) {
00653 ast_log(LOG_WARNING, "Got %d bytes of width, expecting 2\n", res);
00654 res = 0;
00655 } else {
00656 res = 1;
00657 }
00658 if (width)
00659 *width = atoi((char *)buf);
00660
00661 memset(buf, 0, sizeof(buf));
00662 if (res) {
00663 res = ast_readstring(chan, (char *)buf, 2, 1000, 500, "");
00664 if (res < 0)
00665 return res;
00666 if (strlen((char *)buf) != 2) {
00667 ast_log(LOG_WARNING, "Got %d bytes of height, expecting 2\n", res);
00668 res = 0;
00669 } else {
00670 res = 1;
00671 }
00672 if (height)
00673 *height= atoi((char *)buf);
00674 }
00675
00676 memset(buf, 0, sizeof(buf));
00677 if (res) {
00678 res = ast_readstring(chan, (char *)buf, 1, 1000, 500, "");
00679 if (res < 0)
00680 return res;
00681 if (strlen((char *)buf) != 1) {
00682 ast_log(LOG_WARNING, "Got %d bytes of buttons, expecting 1\n", res);
00683 res = 0;
00684 } else {
00685 res = 1;
00686 }
00687 if (buttons)
00688 *buttons = atoi((char *)buf);
00689 }
00690 if (voice) {
00691 bytes = 0;
00692 bytes += adsi_voice_mode(buf, 0);
00693 adsi_transmit_message_full(chan, buf, bytes, ADSI_MSG_DISPLAY, 0);
00694
00695 ast_waitfordigit(chan, 1000);
00696 }
00697 return res;
00698 }
00699
00700 int adsi_data_mode(unsigned char *buf)
00701 {
00702 int bytes=0;
00703
00704
00705 buf[bytes++] = ADSI_SWITCH_TO_DATA;
00706
00707
00708 bytes++;
00709
00710 buf[1] = bytes - 2;
00711 return bytes;
00712
00713 }
00714
00715 int adsi_clear_soft_keys(unsigned char *buf)
00716 {
00717 int bytes=0;
00718
00719
00720 buf[bytes++] = ADSI_CLEAR_SOFTKEY;
00721
00722
00723 bytes++;
00724
00725 buf[1] = bytes - 2;
00726 return bytes;
00727
00728 }
00729
00730 int adsi_clear_screen(unsigned char *buf)
00731 {
00732 int bytes=0;
00733
00734
00735 buf[bytes++] = ADSI_CLEAR_SCREEN;
00736
00737
00738 bytes++;
00739
00740 buf[1] = bytes - 2;
00741 return bytes;
00742
00743 }
00744
00745 int adsi_voice_mode(unsigned char *buf, int when)
00746 {
00747 int bytes=0;
00748
00749
00750 buf[bytes++] = ADSI_SWITCH_TO_VOICE;
00751
00752
00753 bytes++;
00754
00755 buf[bytes++] = when & 0x7f;
00756
00757 buf[1] = bytes - 2;
00758 return bytes;
00759
00760 }
00761
00762 int adsi_available(struct ast_channel *chan)
00763 {
00764 int cpe = chan->adsicpe & 0xff;
00765 if ((cpe == AST_ADSI_AVAILABLE) ||
00766 (cpe == AST_ADSI_UNKNOWN))
00767 return 1;
00768 return 0;
00769 }
00770
00771 int adsi_download_disconnect(unsigned char *buf)
00772 {
00773 int bytes=0;
00774
00775
00776 buf[bytes++] = ADSI_DOWNLOAD_DISC;
00777
00778
00779 bytes++;
00780
00781 buf[1] = bytes - 2;
00782 return bytes;
00783
00784 }
00785
00786 int adsi_display(unsigned char *buf, int page, int line, int just, int wrap,
00787 char *col1, char *col2)
00788 {
00789 int bytes=0;
00790
00791
00792
00793 if (page) {
00794 if (line > 4) return -1;
00795 } else {
00796 if (line > 33) return -1;
00797 }
00798
00799 if (line < 1)
00800 return -1;
00801
00802 buf[bytes++] = ADSI_LOAD_VIRTUAL_DISP;
00803
00804
00805 bytes++;
00806
00807
00808 buf[bytes++] = ((page & 0x1) << 7) | ((wrap & 0x1) << 6) | (line & 0x3f);
00809
00810
00811 buf[bytes++] = (just & 0x3) << 5;
00812
00813
00814 buf[bytes++] = 0xff;
00815
00816
00817 bytes+= ccopy(buf + bytes, (unsigned char *)col1, 20);
00818
00819
00820 buf[bytes++] = 0xff;
00821
00822
00823 bytes += ccopy(buf + bytes, (unsigned char *)col2, 20);
00824
00825
00826 buf[1] = bytes - 2;
00827
00828 return bytes;
00829
00830 }
00831
00832 int adsi_input_control(unsigned char *buf, int page, int line, int display, int format, int just)
00833 {
00834 int bytes=0;
00835
00836 if (page) {
00837 if (line > 4) return -1;
00838 } else {
00839 if (line > 33) return -1;
00840 }
00841
00842 if (line < 1)
00843 return -1;
00844
00845 buf[bytes++] = ADSI_INPUT_CONTROL;
00846 bytes++;
00847 buf[bytes++] = ((page & 1) << 7) | (line & 0x3f);
00848 buf[bytes++] = ((display & 1) << 7) | ((just & 0x3) << 4) | (format & 0x7);
00849
00850 buf[1] = bytes - 2;
00851 return bytes;
00852
00853 }
00854
00855 int adsi_input_format(unsigned char *buf, int num, int dir, int wrap, char *format1, char *format2)
00856 {
00857 int bytes = 0;
00858
00859 if (!strlen((char *)format1))
00860 return -1;
00861
00862 buf[bytes++] = ADSI_INPUT_FORMAT;
00863 bytes++;
00864 buf[bytes++] = ((dir & 1) << 7) | ((wrap & 1) << 6) | (num & 0x7);
00865 bytes += ccopy(buf + bytes, (unsigned char *)format1, 20);
00866 buf[bytes++] = 0xff;
00867 if (format2 && strlen((char *)format2)) {
00868 bytes += ccopy(buf + bytes, (unsigned char *)format2, 20);
00869 }
00870 buf[1] = bytes - 2;
00871 return bytes;
00872 }
00873
00874 int adsi_set_keys(unsigned char *buf, unsigned char *keys)
00875 {
00876 int bytes=0;
00877 int x;
00878
00879 buf[bytes++] = ADSI_INIT_SOFTKEY_LINE;
00880
00881 bytes++;
00882
00883 for (x=0;x<6;x++)
00884 buf[bytes++] = (keys[x] & 0x3f) ? keys[x] : (keys[x] | 0x1);
00885 buf[1] = bytes - 2;
00886 return bytes;
00887 }
00888
00889 int adsi_set_line(unsigned char *buf, int page, int line)
00890 {
00891 int bytes=0;
00892
00893
00894
00895 if (page) {
00896 if (line > 4) return -1;
00897 } else {
00898 if (line > 33) return -1;
00899 }
00900
00901 if (line < 1)
00902 return -1;
00903
00904 buf[bytes++] = ADSI_LINE_CONTROL;
00905
00906
00907 bytes++;
00908
00909
00910 buf[bytes++] = ((page & 0x1) << 7) | (line & 0x3f);
00911
00912 buf[1] = bytes - 2;
00913 return bytes;
00914
00915 };
00916
00917 static int total = 0;
00918 static int speeds = 0;
00919
00920 int adsi_channel_restore(struct ast_channel *chan)
00921 {
00922 unsigned char dsp[256];
00923 int bytes;
00924 int x;
00925 unsigned char keyd[6];
00926
00927 memset(dsp, 0, sizeof(dsp));
00928
00929
00930 bytes = 0;
00931 bytes += adsi_set_line(dsp + bytes, ADSI_INFO_PAGE, 1);
00932
00933
00934
00935 if (speeds) {
00936 memset(keyd, 0, sizeof(keyd));
00937 for (x=0;x<speeds;x++) {
00938 keyd[x] = ADSI_SPEED_DIAL + x;
00939 }
00940 bytes += adsi_set_keys(dsp + bytes, keyd);
00941 }
00942 adsi_transmit_message_full(chan, dsp, bytes, ADSI_MSG_DISPLAY, 0);
00943 return 0;
00944
00945 }
00946
00947 int adsi_print(struct ast_channel *chan, char **lines, int *aligns, int voice)
00948 {
00949 unsigned char buf[4096];
00950 int bytes=0;
00951 int res;
00952 int x;
00953 for(x=0;lines[x];x++)
00954 bytes += adsi_display(buf + bytes, ADSI_INFO_PAGE, x+1, aligns[x], 0, lines[x], "");
00955 bytes += adsi_set_line(buf + bytes, ADSI_INFO_PAGE, 1);
00956 if (voice) {
00957 bytes += adsi_voice_mode(buf + bytes, 0);
00958 }
00959 res = adsi_transmit_message_full(chan, buf, bytes, ADSI_MSG_DISPLAY, 0);
00960 if (voice) {
00961
00962 ast_waitfordigit(chan, 1000);
00963 }
00964 return res;
00965 }
00966
00967 int adsi_load_session(struct ast_channel *chan, unsigned char *app, int ver, int data)
00968 {
00969 unsigned char dsp[256];
00970 int bytes;
00971 int res;
00972 char resp[2];
00973
00974 memset(dsp, 0, sizeof(dsp));
00975
00976
00977 bytes = 0;
00978 bytes += adsi_connect_session(dsp + bytes, app, ver);
00979
00980 if (data)
00981 bytes += adsi_data_mode(dsp + bytes);
00982
00983
00984 if (adsi_transmit_message_full(chan, dsp, bytes, ADSI_MSG_DISPLAY, 0))
00985 return -1;
00986 if (app) {
00987 res = ast_readstring(chan, resp, 1, 1200, 1200, "");
00988 if (res < 0)
00989 return -1;
00990 if (res) {
00991 ast_log(LOG_DEBUG, "No response from CPE about version. Assuming not there.\n");
00992 return 0;
00993 }
00994 if (!strcmp(resp, "B")) {
00995 ast_log(LOG_DEBUG, "CPE has script '%s' version %d already loaded\n", app, ver);
00996 return 1;
00997 } else if (!strcmp(resp, "A")) {
00998 ast_log(LOG_DEBUG, "CPE hasn't script '%s' version %d already loaded\n", app, ver);
00999 } else {
01000 ast_log(LOG_WARNING, "Unexpected CPE response to script query: %s\n", resp);
01001 }
01002 } else
01003 return 1;
01004 return 0;
01005
01006 }
01007
01008 int adsi_unload_session(struct ast_channel *chan)
01009 {
01010 unsigned char dsp[256];
01011 int bytes;
01012
01013 memset(dsp, 0, sizeof(dsp));
01014
01015
01016 bytes = 0;
01017 bytes += adsi_disconnect_session(dsp + bytes);
01018 bytes += adsi_voice_mode(dsp + bytes, 0);
01019
01020
01021 if (adsi_transmit_message_full(chan, dsp, bytes, ADSI_MSG_DISPLAY, 0))
01022 return -1;
01023 return 0;
01024 }
01025
01026 static int str2align(char *s)
01027 {
01028 if (!strncasecmp(s, "l", 1))
01029 return ADSI_JUST_LEFT;
01030 else if (!strncasecmp(s, "r", 1))
01031 return ADSI_JUST_RIGHT;
01032 else if (!strncasecmp(s, "i", 1))
01033 return ADSI_JUST_IND;
01034 else
01035 return ADSI_JUST_CENT;
01036 }
01037
01038 static void init_state(void)
01039 {
01040 int x;
01041
01042 for (x=0;x<ADSI_MAX_INTRO;x++)
01043 aligns[x] = ADSI_JUST_CENT;
01044 strncpy(intro[0], "Welcome to the", sizeof(intro[0]) - 1);
01045 strncpy(intro[1], "Asterisk", sizeof(intro[1]) - 1);
01046 strncpy(intro[2], "Open Source PBX", sizeof(intro[2]) - 1);
01047 total = 3;
01048 speeds = 0;
01049 for (x=3;x<ADSI_MAX_INTRO;x++)
01050 intro[x][0] = '\0';
01051 memset(speeddial, 0, sizeof(speeddial));
01052 alignment = ADSI_JUST_CENT;
01053 }
01054
01055 static void adsi_load(void)
01056 {
01057 int x;
01058 struct ast_config *conf;
01059 struct ast_variable *v;
01060 char *name, *sname;
01061 init_state();
01062 conf = ast_config_load("adsi.conf");
01063 if (conf) {
01064 x=0;
01065 v = ast_variable_browse(conf, "intro");
01066 while(v) {
01067 if (!strcasecmp(v->name, "alignment"))
01068 alignment = str2align(v->value);
01069 else if (!strcasecmp(v->name, "greeting")) {
01070 if (x < ADSI_MAX_INTRO) {
01071 aligns[x] = alignment;
01072 strncpy(intro[x], v->value, sizeof(intro[x]) - 1);
01073 intro[x][sizeof(intro[x]) - 1] = '\0';
01074 x++;
01075 }
01076 } else if (!strcasecmp(v->name, "maxretries")) {
01077 if (atoi(v->value) > 0)
01078 maxretries = atoi(v->value);
01079 }
01080 v = v->next;
01081 }
01082 v = ast_variable_browse(conf, "speeddial");
01083 if (x)
01084 total = x;
01085 x = 0;
01086 while(v) {
01087 char *stringp=NULL;
01088 stringp=v->value;
01089 name = strsep(&stringp, ",");
01090 sname = strsep(&stringp, ",");
01091 if (!sname)
01092 sname = name;
01093 if (x < ADSI_MAX_SPEED_DIAL) {
01094
01095 strncpy(speeddial[x][0], v->name, sizeof(speeddial[x][0]) - 1);
01096 strncpy(speeddial[x][1], name, 18);
01097 strncpy(speeddial[x][2], sname, 7);
01098 x++;
01099 }
01100 v = v->next;
01101
01102 }
01103 if (x)
01104 speeds = x;
01105 ast_config_destroy(conf);
01106 }
01107 }
01108
01109 int reload(void)
01110 {
01111 adsi_load();
01112 return 0;
01113 }
01114
01115 int load_module(void)
01116 {
01117 adsi_load();
01118 return 0;
01119 }
01120
01121 int unload_module(void)
01122 {
01123
01124 return -1;
01125 }
01126
01127 char *description(void)
01128 {
01129 return "ADSI Resource";
01130 }
01131
01132 int usecount(void)
01133 {
01134
01135 return 1;
01136 }
01137
01138 char *key()
01139 {
01140 return ASTERISK_GPL_KEY;
01141 }