Wed Oct 28 15:47:55 2009

Asterisk developer's documentation


res_adsi.c

Go to the documentation of this file.
00001 /*
00002  * Asterisk -- An open source telephony toolkit.
00003  *
00004  * Copyright (C) 1999 - 2005, Digium, Inc.
00005  *
00006  * Mark Spencer <markster@digium.com>
00007  *
00008  * Includes code and algorithms from the Zapata library.
00009  *
00010  * See http://www.asterisk.org for more information about
00011  * the Asterisk project. Please do not directly contact
00012  * any of the maintainers of this project for assistance;
00013  * the project provides a web site, mailing lists and IRC
00014  * channels for your use.
00015  *
00016  * This program is free software, distributed under the terms of
00017  * the GNU General Public License Version 2. See the LICENSE file
00018  * at the top of the source tree.
00019  */
00020 
00021 /*! \file
00022  *
00023  * \brief ADSI support 
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 /* Asterisk ADSI button definitions */
00060 #define ADSI_SPEED_DIAL    10 /* 10-15 are reserved for speed dial */
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    /* Initial carrier (imaginary) */
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    /* If first message, Send 150ms of MARK's */
00083    if (msgnum == 1) {
00084       for (x=0;x<150;x++)  /* was 150 */
00085          PUT_CLID_MARKMS;
00086    }
00087    /* Put message type */
00088    PUT_CLID(msgtype);
00089    sum = msgtype;
00090 
00091    /* Put message length (plus one  for the message number) */
00092    PUT_CLID(msglen + 1);
00093    sum += msglen + 1;
00094 
00095    /* Put message number */
00096    PUT_CLID(msgnum);
00097    sum += msgnum;
00098 
00099    /* Put actual message */
00100    for (x=0;x<msglen;x++) {
00101       PUT_CLID(msg[x]);
00102       sum += msg[x];
00103    }
00104 
00105    /* Put 2's compliment of sum */
00106    PUT_CLID(256-(sum & 0xff));
00107 
00108 #if 0
00109    if (last) {
00110       /* Put trailing marks */
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    /* Sends carefully on a full duplex channel by using reading for
00122       timing */
00123    struct ast_frame *inf, outf;
00124    int amt;
00125 
00126    /* Zero out our outgoing frame */
00127    memset(&outf, 0, sizeof(outf));
00128 
00129    if (remainder && *remainder) {
00130       amt = len;
00131 
00132       /* Send remainder if provided */
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       /* Update pointers and lengths */
00147       buf += amt;
00148       len -= amt;
00149    }
00150 
00151    while(len) {
00152       amt = len;
00153       /* If we don't get anything at all back in a second, forget
00154          about it */
00155       if (ast_waitfor(chan, 1000) < 1)
00156          return -1;
00157       inf = ast_read(chan);
00158       /* Detect hangup */
00159       if (!inf)
00160          return -1;
00161       if (inf->frametype == AST_FRAME_VOICE) {
00162          /* Read a voice frame */
00163          if (inf->subclass != AST_FORMAT_ULAW) {
00164             ast_log(LOG_WARNING, "Channel not in ulaw?\n");
00165             return -1;
00166          }
00167          /* Send no more than they sent us */
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          /* Update pointers and lengths */
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    /* msglen must be no more than 256 bits, each */
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    /* Wait up to 500 ms for initial ACK */
00202    int waittime;
00203    struct ast_frame *f;
00204    int rem = 0;
00205    int def;
00206 
00207    if (chan->adsicpe == AST_ADSI_UNAVAILABLE) {
00208       /* Don't bother if we know they don't support ADSI */
00209       errno = ENOSYS;
00210       return -1;
00211    }
00212 
00213    while(retries < maxretries) {
00214       if (!(chan->adsicpe & ADSI_FLAG_DATAMODE)) {
00215          /* Generate CAS (no SAS) */
00216          ast_gen_cas(buf, 0, 680, AST_FORMAT_ULAW);
00217       
00218          /* Send CAS */
00219          if (adsi_careful_send(chan, buf, 680, NULL)) {
00220             ast_log(LOG_WARNING, "Unable to send CAS\n");
00221          }
00222          /* Wait For DTMF result */
00223          waittime = 500;
00224          for(;;) {
00225             if (((res = ast_waitfor(chan, waittime)) < 1)) {
00226                /* Didn't get back DTMF A in time */
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                   /* Okay, this is an ADSI CPE.  Note this for future reference, too */
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       /* Get real result */
00292       res = ast_readstring(chan, ack, 2, 1000, 1000, "");
00293       /* Check for hangup */
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    /* Setup the resident soft key stuff, a piece at a time */
00326    /* Upload what scripts we can for voicemail ahead of time */
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         /* Setup the resident soft key stuff, a piece at a time */
00344         /* Upload what scripts we can for voicemail ahead of time */
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    /* Carefully copy the requested data */
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    /* Abort if invalid key specified */
00446    if ((key < 2) || (key > 33))
00447       return -1;
00448    buf[bytes++] = ADSI_LOAD_SOFTKEY;
00449    /* Reserve for length */
00450    bytes++;
00451    /* Which key */
00452    buf[bytes++] = key;
00453 
00454    /* Carefully copy long label */
00455    bytes += ccopy(buf + bytes, (unsigned char *)llabel, 18);
00456 
00457    /* Place delimiter */
00458    buf[bytes++] = 0xff;
00459 
00460    /* Short label */
00461    bytes += ccopy(buf + bytes, (unsigned char *)slabel, 7);
00462 
00463 
00464    /* If specified, copy return string */
00465    if (ret) {
00466       /* Place delimiter */
00467       buf[bytes++] = 0xff;
00468       if (data)
00469          buf[bytes++] = ADSI_SWITCH_TO_DATA2;
00470       /* Carefully copy return string */
00471       bytes += ccopy(buf + bytes, (unsigned char *)ret, 20);
00472 
00473    }
00474    /* Replace parameter length */
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    /* Message type */
00486    buf[bytes++] = ADSI_CONNECT_SESSION;
00487 
00488    /* Reserve space for length */
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    /* Message type */
00509    buf[bytes++] = ADSI_DOWNLOAD_CONNECT;
00510 
00511    /* Reserve space for length */
00512    bytes++;
00513 
00514    /* Primary column */
00515    bytes+= ccopy(buf + bytes, (unsigned char *)service, 18);
00516 
00517    /* Delimiter */
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    /* Message type */
00538    buf[bytes++] = ADSI_DISC_SESSION;
00539 
00540    /* Reserve space for length */
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    /* Reserve space for length */
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    /* Reserve space for length */
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       /* Wait up to a second for a digit */
00578       res = ast_waitfordigit(chan, 1000);
00579       if (!res)
00580          break;
00581       if (res == '*') {
00582          gotstar = 1;   
00583          continue;
00584       }
00585       /* Ignore anything other than a digit */
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    /* Get response */
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       /* Ignore the resulting DTMF B announcing it's in voice mode */
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    /* Get width */
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    /* Get height */
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    /* Get buttons */
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       /* Ignore the resulting DTMF B announcing it's in voice mode */
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    /* Message type */
00705    buf[bytes++] = ADSI_SWITCH_TO_DATA;
00706 
00707    /* Reserve space for length */
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    /* Message type */
00720    buf[bytes++] = ADSI_CLEAR_SOFTKEY;
00721 
00722    /* Reserve space for length */
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    /* Message type */
00735    buf[bytes++] = ADSI_CLEAR_SCREEN;
00736 
00737    /* Reserve space for length */
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    /* Message type */
00750    buf[bytes++] = ADSI_SWITCH_TO_VOICE;
00751 
00752    /* Reserve space for length */
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    /* Message type */
00776    buf[bytes++] = ADSI_DOWNLOAD_DISC;
00777 
00778    /* Reserve space for length */
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    /* Sanity check line number */
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    /* Parameter type */
00802    buf[bytes++] = ADSI_LOAD_VIRTUAL_DISP;
00803    
00804    /* Reserve space for size */
00805    bytes++;
00806 
00807    /* Page and wrap indicator */
00808    buf[bytes++] = ((page & 0x1) << 7) | ((wrap & 0x1) << 6) | (line & 0x3f);
00809 
00810    /* Justification */
00811    buf[bytes++] = (just & 0x3) << 5;
00812 
00813    /* Omit highlight mode definition */
00814    buf[bytes++] = 0xff;
00815 
00816    /* Primary column */
00817    bytes+= ccopy(buf + bytes, (unsigned char *)col1, 20);
00818 
00819    /* Delimiter */
00820    buf[bytes++] = 0xff;
00821    
00822    /* Secondary column */
00823    bytes += ccopy(buf + bytes, (unsigned char *)col2, 20);
00824 
00825    /* Update length */
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    /* Message type */
00879    buf[bytes++] = ADSI_INIT_SOFTKEY_LINE;
00880    /* Space for size */
00881    bytes++;
00882    /* Key definitions */
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    /* Sanity check line number */
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    /* Parameter type */
00904    buf[bytes++] = ADSI_LINE_CONTROL;
00905    
00906    /* Reserve space for size */
00907    bytes++;
00908 
00909    /* Page and line */
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    /* Start with initial display setup */
00930    bytes = 0;
00931    bytes += adsi_set_line(dsp + bytes, ADSI_INFO_PAGE, 1);
00932 
00933    /* Prepare key setup messages */
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       /* Ignore the resulting DTMF B announcing it's in voice mode */
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    /* Connect to session */
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    /* Prepare key setup messages */
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    /* Connect to session */
01016    bytes = 0;
01017    bytes += adsi_disconnect_session(dsp + bytes);
01018    bytes += adsi_voice_mode(dsp + bytes, 0);
01019 
01020    /* Prepare key setup messages */
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             /* Up to 20 digits */
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    /* Can't unload this once we're loaded */
01124    return -1;
01125 }
01126 
01127 char *description(void)
01128 {
01129    return "ADSI Resource";
01130 }
01131 
01132 int usecount(void)
01133 {
01134    /* We should never be unloaded */
01135    return 1;
01136 }
01137 
01138 char *key()
01139 {
01140    return ASTERISK_GPL_KEY;
01141 }

Generated on Wed Oct 28 15:47:55 2009 for Asterisk - the Open Source PBX by  doxygen 1.5.6