Sat Nov 25 00:45:31 2006

Asterisk developer's documentation


callerid.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  * See http://www.asterisk.org for more information about
00009  * the Asterisk project. Please do not directly contact
00010  * any of the maintainers of this project for assistance;
00011  * the project provides a web site, mailing lists and IRC
00012  * channels for your use.
00013  *
00014  * This program is free software, distributed under the terms of
00015  * the GNU General Public License Version 2. See the LICENSE file
00016  * at the top of the source tree.
00017  */
00018 
00019 /*! \file
00020  *
00021  * \brief CallerID Generation support 
00022  * 
00023  */
00024 
00025 #include <time.h>
00026 #include <string.h>
00027 #include <stdio.h>
00028 #include <stdlib.h>
00029 #include <unistd.h>
00030 #include <math.h>
00031 #include <ctype.h>
00032 
00033 #include "asterisk.h"
00034 
00035 ASTERISK_FILE_VERSION(__FILE__, "$Revision: 32582 $")
00036 
00037 #include "asterisk/ulaw.h"
00038 #include "asterisk/alaw.h"
00039 #include "asterisk/frame.h"
00040 #include "asterisk/channel.h"
00041 #include "asterisk/callerid.h"
00042 #include "asterisk/logger.h"
00043 #include "asterisk/fskmodem.h"
00044 #include "asterisk/utils.h"
00045 
00046 struct callerid_state {
00047    fsk_data fskd;
00048    char rawdata[256];
00049    short oldstuff[160];
00050    int oldlen;
00051    int pos;
00052    int type;
00053    int cksum;
00054    char name[64];
00055    char number[64];
00056    int flags;
00057    int sawflag;
00058    int len;
00059 };
00060 
00061 
00062 float cid_dr[4], cid_di[4];
00063 float clidsb = 8000.0 / 1200.0;
00064 float sasdr, sasdi;
00065 float casdr1, casdi1, casdr2, casdi2;
00066 
00067 #define CALLERID_SPACE  2200.0      /*!< 2200 hz for "0" */
00068 #define CALLERID_MARK   1200.0      /*!< 1200 hz for "1" */
00069 #define SAS_FREQ      440.0
00070 #define CAS_FREQ1    2130.0
00071 #define CAS_FREQ2    2750.0
00072 
00073 #define AST_CALLERID_UNKNOWN  "<unknown>"
00074 
00075 static inline void gen_tones(unsigned char *buf, int len, int codec, float ddr1, float ddi1, float ddr2, float ddi2, float *cr1, float *ci1, float *cr2, float *ci2)
00076 {
00077    int x;
00078    float t;
00079    for (x=0;x<len;x++) {
00080       t = *cr1 * ddr1 - *ci1 * ddi1;
00081       *ci1 = *cr1 * ddi1 + *ci1 * ddr1;
00082       *cr1 = t;
00083       t = 2.0 - (*cr1 * *cr1 + *ci1 * *ci1);
00084       *cr1 *= t;
00085       *ci1 *= t;  
00086 
00087       t = *cr2 * ddr2 - *ci2 * ddi2;
00088       *ci2 = *cr2 * ddi2 + *ci2 * ddr2;
00089       *cr2 = t;
00090       t = 2.0 - (*cr2 * *cr2 + *ci2 * *ci2);
00091       *cr2 *= t;
00092       *ci2 *= t;  
00093       buf[x] = AST_LIN2X((*cr1 + *cr2) * 2048.0);
00094    }
00095 }
00096 
00097 static inline void gen_tone(unsigned char *buf, int len, int codec, float ddr1, float ddi1, float *cr1, float *ci1)
00098 {
00099    int x;
00100    float t;
00101    for (x=0;x<len;x++) {
00102       t = *cr1 * ddr1 - *ci1 * ddi1;
00103       *ci1 = *cr1 * ddi1 + *ci1 * ddr1;
00104       *cr1 = t;
00105       t = 2.0 - (*cr1 * *cr1 + *ci1 * *ci1);
00106       *cr1 *= t;
00107       *ci1 *= t;  
00108       buf[x] = AST_LIN2X(*cr1 * 8192.0);
00109    }
00110 }
00111 
00112 /*! \brief Initialize stuff for inverse FFT */
00113 void callerid_init(void)
00114 {
00115    cid_dr[0] = cos(CALLERID_SPACE * 2.0 * M_PI / 8000.0);
00116    cid_di[0] = sin(CALLERID_SPACE * 2.0 * M_PI / 8000.0);
00117    cid_dr[1] = cos(CALLERID_MARK * 2.0 * M_PI / 8000.0);
00118    cid_di[1] = sin(CALLERID_MARK * 2.0 * M_PI / 8000.0);
00119    sasdr = cos(SAS_FREQ * 2.0 * M_PI / 8000.0);
00120    sasdi = sin(SAS_FREQ * 2.0 * M_PI / 8000.0);
00121    casdr1 = cos(CAS_FREQ1 * 2.0 * M_PI / 8000.0);
00122    casdi1 = sin(CAS_FREQ1 * 2.0 * M_PI / 8000.0);
00123    casdr2 = cos(CAS_FREQ2 * 2.0 * M_PI / 8000.0);
00124    casdi2 = sin(CAS_FREQ2 * 2.0 * M_PI / 8000.0);
00125 }
00126 
00127 struct callerid_state *callerid_new(int cid_signalling)
00128 {
00129    struct callerid_state *cid;
00130    cid = malloc(sizeof(struct callerid_state));
00131    if (cid) {
00132       memset(cid, 0, sizeof(struct callerid_state));
00133       cid->fskd.spb = 7;      /* 1200 baud */
00134       cid->fskd.hdlc = 0;     /* Async */
00135       cid->fskd.nbit = 8;     /* 8 bits */
00136       cid->fskd.nstop = 1; /* 1 stop bit */
00137       cid->fskd.paridad = 0;  /* No parity */
00138       cid->fskd.bw=1;         /* Filter 800 Hz */
00139       if (cid_signalling == 2) { /* v23 signalling */
00140          cid->fskd.f_mark_idx =  4; /* 1300 Hz */
00141          cid->fskd.f_space_idx = 5; /* 2100 Hz */
00142       } else { /* Bell 202 signalling as default */ 
00143          cid->fskd.f_mark_idx =  2; /* 1200 Hz */
00144          cid->fskd.f_space_idx = 3; /* 2200 Hz */
00145       }
00146       cid->fskd.pcola = 0;    /* No clue */
00147       cid->fskd.cont = 0;        /* Digital PLL reset */
00148       cid->fskd.x0 = 0.0;
00149       cid->fskd.state = 0;
00150       memset(cid->name, 0, sizeof(cid->name));
00151       memset(cid->number, 0, sizeof(cid->number));
00152       cid->flags = CID_UNKNOWN_NAME | CID_UNKNOWN_NUMBER;
00153       cid->pos = 0;
00154    } else
00155       ast_log(LOG_WARNING, "Out of memory\n");
00156    return cid;
00157 }
00158 
00159 void callerid_get(struct callerid_state *cid, char **name, char **number, int *flags)
00160 {
00161    *flags = cid->flags;
00162    if (cid->flags & (CID_UNKNOWN_NAME | CID_PRIVATE_NUMBER))
00163       *name = NULL;
00164    else
00165       *name = cid->name;
00166    if (cid->flags & (CID_UNKNOWN_NUMBER | CID_PRIVATE_NUMBER))
00167       *number = NULL;
00168    else
00169       *number = cid->number;
00170 }
00171 
00172 void callerid_get_dtmf(char *cidstring, char *number, int *flags)
00173 {
00174    int i;
00175    int code;
00176 
00177    /* "Clear" the number-buffer. */
00178    number[0] = 0;
00179 
00180    if (strlen(cidstring) < 2) {
00181       ast_log(LOG_DEBUG, "No cid detected\n");
00182       *flags = CID_UNKNOWN_NUMBER;
00183       return;
00184    }
00185    
00186    /* Detect protocol and special types */
00187    if (cidstring[0] == 'B') {
00188       /* Handle special codes */
00189       code = atoi(&cidstring[1]);
00190       if (code == 0)
00191          *flags = CID_UNKNOWN_NUMBER;
00192       else if (code == 10) 
00193          *flags = CID_PRIVATE_NUMBER;
00194       else
00195          ast_log(LOG_DEBUG, "Unknown DTMF code %d\n", code);
00196    } else if (cidstring[0] == 'D' && cidstring[2] == '#') {
00197       /* .DK special code */
00198       if (cidstring[1] == '1')
00199          *flags = CID_PRIVATE_NUMBER;
00200       if (cidstring[1] == '2' || cidstring[1] == '3')
00201          *flags = CID_UNKNOWN_NUMBER;
00202    } else if (cidstring[0] == 'D' || cidstring[0] == 'A') {
00203       /* "Standard" callerid */
00204       for (i = 1; i < strlen(cidstring); i++ ) {
00205          if (cidstring[i] == 'C' || cidstring[i] == '#')
00206             break;
00207          if (isdigit(cidstring[i]))
00208             number[i-1] = cidstring[i];
00209          else
00210             ast_log(LOG_DEBUG, "Unknown CID digit '%c'\n",
00211                cidstring[i]);
00212       }
00213       number[i-1] = 0;
00214    } else if (isdigit(cidstring[0])) {
00215       /* It begins with a digit, so we parse it as a number and hope
00216        * for the best */
00217       ast_log(LOG_WARNING, "Couldn't detect start-character. CID "
00218          "parsing might be unreliable\n");
00219       for (i = 0; i < strlen(cidstring); i++) {
00220          if (isdigit(cidstring[i]))
00221                                 number[i] = cidstring[i];
00222          else
00223             break;
00224       }
00225       number[i] = 0;
00226    } else {
00227       ast_log(LOG_DEBUG, "Unknown CID protocol, start digit '%c'\n", 
00228          cidstring[0]);
00229       *flags = CID_UNKNOWN_NUMBER;
00230    }
00231 }
00232 
00233 int ast_gen_cas(unsigned char *outbuf, int sendsas, int len, int codec)
00234 {
00235    int pos = 0;
00236    int saslen=2400;
00237    float cr1 = 1.0;
00238    float ci1 = 0.0;
00239    float cr2 = 1.0;
00240    float ci2 = 0.0;
00241    if (sendsas) {
00242       if (len < saslen)
00243          return -1;
00244       gen_tone(outbuf, saslen, codec, sasdr, sasdi, &cr1, &ci1);
00245       len -= saslen;
00246       pos += saslen;
00247       cr2 = cr1;
00248       ci2 = ci1;
00249    }
00250    gen_tones(outbuf + pos, len, codec, casdr1, casdi1, casdr2, casdi2, &cr1, &ci1, &cr2, &ci2);
00251    return 0;
00252 }
00253 
00254 int callerid_feed(struct callerid_state *cid, unsigned char *ubuf, int len, int codec)
00255 {
00256    int mylen = len;
00257    int olen;
00258    int b = 'X';
00259    int res;
00260    int x;
00261    short *buf = malloc(2 * len + cid->oldlen);
00262    short *obuf = buf;
00263    if (!buf) {
00264       ast_log(LOG_WARNING, "Out of memory\n");
00265       return -1;
00266    }
00267    memset(buf, 0, 2 * len + cid->oldlen);
00268    memcpy(buf, cid->oldstuff, cid->oldlen);
00269    mylen += cid->oldlen/2;
00270    for (x=0;x<len;x++) 
00271       buf[x+cid->oldlen/2] = AST_XLAW(ubuf[x]);
00272    while(mylen >= 160) {
00273       olen = mylen;
00274       res = fsk_serie(&cid->fskd, buf, &mylen, &b);
00275       if (mylen < 0) {
00276          ast_log(LOG_ERROR, "fsk_serie made mylen < 0 (%d)\n", mylen);
00277          free(obuf);
00278          return -1;
00279       }
00280       buf += (olen - mylen);
00281       if (res < 0) {
00282          ast_log(LOG_NOTICE, "fsk_serie failed\n");
00283          return -1;
00284       }
00285       if (res == 1) {
00286          /* Ignore invalid bytes */
00287          if (b > 0xff)
00288             continue;
00289          switch(cid->sawflag) {
00290          case 0: /* Look for flag */
00291             if (b == 'U')
00292                cid->sawflag = 2;
00293             break;
00294          case 2: /* Get lead-in */
00295             if ((b == 0x04) || (b == 0x80)) {
00296                cid->type = b;
00297                cid->sawflag = 3;
00298                cid->cksum = b;
00299             }
00300             break;
00301          case 3:  /* Get length */
00302             /* Not a lead in.  We're ready  */
00303             cid->sawflag = 4;
00304             cid->len = b;
00305             cid->pos = 0;
00306             cid->cksum += b;
00307             break;
00308          case 4: /* Retrieve message */
00309             if (cid->pos >= 128) {
00310                ast_log(LOG_WARNING, "Caller ID too long???\n");
00311                free(obuf);
00312                return -1;
00313             }
00314             cid->rawdata[cid->pos++] = b;
00315             cid->len--;
00316             cid->cksum += b;
00317             if (!cid->len) {
00318                cid->rawdata[cid->pos] = '\0';
00319                cid->sawflag = 5;
00320             }
00321             break;
00322          case 5: /* Check checksum */
00323             if (b != (256 - (cid->cksum & 0xff))) {
00324                ast_log(LOG_NOTICE, "Caller*ID failed checksum\n");
00325                /* Try again */
00326                cid->sawflag = 0;
00327                break;
00328             }
00329       
00330             cid->number[0] = '\0';
00331             cid->name[0] = '\0';
00332             /* If we get this far we're fine.  */
00333             if (cid->type == 0x80) {
00334                /* MDMF */
00335                /* Go through each element and process */
00336                for (x=0;x< cid->pos;) {
00337                   switch(cid->rawdata[x++]) {
00338                   case 1:
00339                      /* Date */
00340                      break;
00341                   case 2: /* Number */
00342                   case 3: /* Number (for Zebble) */
00343                   case 4: /* Number */
00344                      res = cid->rawdata[x];
00345                      if (res > 32) {
00346                         ast_log(LOG_NOTICE, "Truncating long caller ID number from %d bytes to 32\n", cid->rawdata[x]);
00347                         res = 32; 
00348                      }
00349                      if (ast_strlen_zero(cid->number)) {
00350                         memcpy(cid->number, cid->rawdata + x + 1, res);
00351                         /* Null terminate */
00352                         cid->number[res] = '\0';
00353                      }
00354                      break;
00355                   case 6: /* Stentor Call Qualifier (ie. Long Distance call) */
00356                      break;
00357                   case 7: /* Name */
00358                   case 8: /* Name */
00359                      res = cid->rawdata[x];
00360                      if (res > 32) {
00361                         ast_log(LOG_NOTICE, "Truncating long caller ID name from %d bytes to 32\n", cid->rawdata[x]);
00362                         res = 32; 
00363                      }
00364                      memcpy(cid->name, cid->rawdata + x + 1, res);
00365                      cid->name[res] = '\0';
00366                      break;
00367                   case 17: /* UK: Call type, 1=Voice Call, 2=Ringback when free, 129=Message waiting  */
00368                   case 19: /* UK: Network message system status (Number of messages waiting) */
00369                   case 22: /* Something French */
00370                      break;
00371                   default:
00372                      ast_log(LOG_NOTICE, "Unknown IE %d\n", cid->rawdata[x-1]);
00373                   }
00374                   x += cid->rawdata[x];
00375                   x++;
00376                }
00377             } else {
00378                /* SDMF */
00379                ast_copy_string(cid->number, cid->rawdata + 8, sizeof(cid->number));
00380             }
00381             /* Update flags */
00382             cid->flags = 0;
00383             if (!strcmp(cid->number, "P")) {
00384                strcpy(cid->number, "");
00385                cid->flags |= CID_PRIVATE_NUMBER;
00386             } else if (!strcmp(cid->number, "O") || ast_strlen_zero(cid->number)) {
00387                strcpy(cid->number, "");
00388                cid->flags |= CID_UNKNOWN_NUMBER;
00389             }
00390             if (!strcmp(cid->name, "P")) {
00391                strcpy(cid->name, "");
00392                cid->flags |= CID_PRIVATE_NAME;
00393             } else if (!strcmp(cid->name, "O") || ast_strlen_zero(cid->name)) {
00394                strcpy(cid->name, "");
00395                cid->flags |= CID_UNKNOWN_NAME;
00396             }
00397             free(obuf);
00398             return 1;
00399             break;
00400          default:
00401             ast_log(LOG_ERROR, "Dunno what to do with a digit in sawflag %d\n", cid->sawflag);
00402          }
00403       }
00404    }
00405    if (mylen) {
00406       memcpy(cid->oldstuff, buf, mylen * 2);
00407       cid->oldlen = mylen * 2;
00408    } else
00409       cid->oldlen = 0;
00410    free(obuf);
00411    return 0;
00412 }
00413 
00414 void callerid_free(struct callerid_state *cid)
00415 {
00416    free(cid);
00417 }
00418 
00419 static int callerid_genmsg(char *msg, int size, char *number, char *name, int flags)
00420 {
00421    time_t t;
00422    struct tm tm;
00423    char *ptr;
00424    int res;
00425    int i,x;
00426    /* Get the time */
00427    time(&t);
00428    localtime_r(&t,&tm);
00429    
00430    ptr = msg;
00431    
00432    /* Format time and message header */
00433    res = snprintf(ptr, size, "\001\010%02d%02d%02d%02d", tm.tm_mon + 1,
00434             tm.tm_mday, tm.tm_hour, tm.tm_min);
00435    size -= res;
00436    ptr += res;
00437    if (ast_strlen_zero(number) || (flags & CID_UNKNOWN_NUMBER)) {
00438       /* Indicate number not known */
00439       res = snprintf(ptr, size, "\004\001O");
00440       size -= res;
00441       ptr += res;
00442    } else if (flags & CID_PRIVATE_NUMBER) {
00443       /* Indicate number is private */
00444       res = snprintf(ptr, size, "\004\001P");
00445       size -= res;
00446       ptr += res;
00447    } else {
00448       /* Send up to 16 digits of number MAX */
00449       i = strlen(number);
00450       if (i > 16) i = 16;
00451       res = snprintf(ptr, size, "\002%c", i);
00452       size -= res;
00453       ptr += res;
00454       for (x=0;x<i;x++)
00455          ptr[x] = number[x];
00456       ptr[i] = '\0';
00457       ptr += i;
00458       size -= i;
00459    }
00460 
00461    if (ast_strlen_zero(name) || (flags & CID_UNKNOWN_NAME)) {
00462       /* Indicate name not known */
00463       res = snprintf(ptr, size, "\010\001O");
00464       size -= res;
00465       ptr += res;
00466    } else if (flags & CID_PRIVATE_NAME) {
00467       /* Indicate name is private */
00468       res = snprintf(ptr, size, "\010\001P");
00469       size -= res;
00470       ptr += res;
00471    } else {
00472       /* Send up to 16 digits of name MAX */
00473       i = strlen(name);
00474       if (i > 16) i = 16;
00475       res = snprintf(ptr, size, "\007%c", i);
00476       size -= res;
00477       ptr += res;
00478       for (x=0;x<i;x++)
00479          ptr[x] = name[x];
00480       ptr[i] = '\0';
00481       ptr += i;
00482       size -= i;
00483    }
00484    return (ptr - msg);
00485    
00486 }
00487 
00488 int vmwi_generate(unsigned char *buf, int active, int mdmf, int codec)
00489 {
00490    unsigned char msg[256];
00491    int len=0;
00492    int sum;
00493    int x;
00494    int bytes = 0;
00495    float cr = 1.0;
00496    float ci = 0.0;
00497    float scont = 0.0;
00498    if (mdmf) {
00499       /* MDMF Message waiting */
00500       msg[len++] = 0x82;
00501       /* Length is 3 */
00502       msg[len++] = 3;
00503       /* IE is "Message Waiting Parameter" */
00504       msg[len++] = 0xb;
00505       /* Length of IE is one */
00506       msg[len++] = 1;
00507       /* Active or not */
00508       if (active)
00509          msg[len++] = 0xff;
00510       else
00511          msg[len++] = 0x00;
00512    } else {
00513       /* SDMF Message waiting */
00514       msg[len++] = 0x6;
00515       /* Length is 3 */
00516       msg[len++] = 3;
00517       if (active) {
00518          msg[len++] = 0x42;
00519          msg[len++] = 0x42;
00520          msg[len++] = 0x42;
00521       } else {
00522          msg[len++] = 0x6f;
00523          msg[len++] = 0x6f;
00524          msg[len++] = 0x6f;
00525       }
00526    }
00527    sum = 0;
00528    for (x=0;x<len;x++)
00529       sum += msg[x];
00530    sum = (256 - (sum & 255));
00531    msg[len++] = sum;
00532    /* Wait a half a second */
00533    for (x=0;x<4000;x++)
00534       PUT_BYTE(0x7f);
00535    /* Transmit 30 0x55's (looks like a square wave) for channel seizure */
00536    for (x=0;x<30;x++)
00537       PUT_CLID(0x55);
00538    /* Send 170ms of callerid marks */
00539    for (x=0;x<170;x++)
00540       PUT_CLID_MARKMS;
00541    for (x=0;x<len;x++) {
00542       PUT_CLID(msg[x]);
00543    }
00544    /* Send 50 more ms of marks */
00545    for (x=0;x<50;x++)
00546       PUT_CLID_MARKMS;
00547    return bytes;
00548 }
00549 
00550 int callerid_generate(unsigned char *buf, char *number, char *name, int flags, int callwaiting, int codec)
00551 {
00552    int bytes=0;
00553    int x, sum;
00554    int len;
00555    /* Initial carriers (real/imaginary) */
00556    float cr = 1.0;
00557    float ci = 0.0;
00558    float scont = 0.0;
00559    char msg[256];
00560    len = callerid_genmsg(msg, sizeof(msg), number, name, flags);
00561    if (!callwaiting) {
00562       /* Wait a half a second */
00563       for (x=0;x<4000;x++)
00564          PUT_BYTE(0x7f);
00565       /* Transmit 30 0x55's (looks like a square wave) for channel seizure */
00566       for (x=0;x<30;x++)
00567          PUT_CLID(0x55);
00568    }
00569    /* Send 150ms of callerid marks */
00570    for (x=0;x<150;x++)
00571       PUT_CLID_MARKMS;
00572    /* Send 0x80 indicating MDMF format */
00573    PUT_CLID(0x80);
00574    /* Put length of whole message */
00575    PUT_CLID(len);
00576    sum = 0x80 + strlen(msg);
00577    /* Put each character of message and update checksum */
00578    for (x=0;x<len; x++) {
00579       PUT_CLID(msg[x]);
00580       sum += msg[x];
00581    }
00582    /* Send 2's compliment of sum */
00583    PUT_CLID(256 - (sum & 255));
00584 
00585    /* Send 50 more ms of marks */
00586    for (x=0;x<50;x++)
00587       PUT_CLID_MARKMS;
00588    
00589    return bytes;
00590 }
00591 
00592 void ast_shrink_phone_number(char *n)
00593 {
00594    int x,y=0;
00595    int bracketed=0;
00596    for (x=0;n[x];x++) {
00597       switch(n[x]) {
00598       case '[':
00599          bracketed++;
00600          n[y++] = n[x];
00601          break;
00602       case ']':
00603          bracketed--;
00604          n[y++] = n[x];
00605          break;
00606       case '-':
00607          if (bracketed)
00608             n[y++] = n[x];
00609          break;
00610       case '.':
00611          if (!n[x+1])
00612             n[y++] = n[x];
00613          break;
00614       default:
00615          if (!strchr("( )", n[x]))
00616             n[y++] = n[x];
00617       }
00618    }
00619    n[y] = '\0';
00620 }
00621 
00622 /*! \brief checks if string consists only of digits and * \# and + 
00623    \return 1 if string is valid AST phone number
00624    \return 0 if not
00625 */
00626 int ast_isphonenumber(char *n)
00627 {
00628    int x;
00629    if (ast_strlen_zero(n))
00630       return 0;
00631    for (x=0;n[x];x++)
00632       if (!strchr("0123456789*#+", n[x]))
00633          return 0;
00634    return 1;
00635 }
00636 
00637 /*! \brief parse string for caller id information 
00638    \return returns -1 on failure, otherwise 0
00639 */
00640 int ast_callerid_parse(char *instr, char **name, char **location)
00641 {
00642    char *ns, *ne;
00643    char *ls, *le;
00644    char tmp[256];
00645    /* Try for "name" <location> format or 
00646       name <location> format */
00647    if ((ls = strchr(instr, '<')) && (le = strchr(ls, '>'))) {
00648       /* Found the location */
00649       *le = '\0';
00650       *ls = '\0';
00651       *location = ls + 1;
00652       if ((ns = strchr(instr, '\"')) && (ne = strchr(ns + 1, '\"'))) {
00653          /* Get name out of quotes */
00654          *ns = '\0';
00655          *ne = '\0';
00656          *name = ns + 1;
00657          return 0;
00658       } else {
00659          /* Just trim off any trailing spaces */
00660          *name = instr;
00661          while(!ast_strlen_zero(instr) && (instr[strlen(instr) - 1] < 33))
00662             instr[strlen(instr) - 1] = '\0';
00663          /* And leading spaces */
00664          *name = ast_skip_blanks(*name);
00665          return 0;
00666       }
00667    } else {
00668       ast_copy_string(tmp, instr, sizeof(tmp));
00669       ast_shrink_phone_number(tmp);
00670       if (ast_isphonenumber(tmp)) {
00671          /* Assume it's just a location */
00672          *name = NULL;
00673          *location = instr;
00674       } else {
00675          /* Assume it's just a name.  Make sure it's not quoted though */
00676          *name = instr;
00677          while(*(*name) && ((*(*name) < 33) || (*(*name) == '\"'))) (*name)++;
00678          ne = *name + strlen(*name) - 1;
00679          while((ne > *name) && ((*ne < 33) || (*ne == '\"'))) { *ne = '\0'; ne--; }
00680          *location = NULL;
00681       }
00682       return 0;
00683    }
00684    return -1;
00685 }
00686 
00687 static int __ast_callerid_generate(unsigned char *buf, char *name, char *number, int callwaiting, int codec)
00688 {
00689    if (ast_strlen_zero(name))
00690       name = NULL;
00691    if (ast_strlen_zero(number))
00692       number = NULL;
00693    return callerid_generate(buf, number, name, 0, callwaiting, codec);
00694 }
00695 
00696 int ast_callerid_generate(unsigned char *buf, char *name, char *number, int codec)
00697 {
00698    return __ast_callerid_generate(buf, name, number, 0, codec);
00699 }
00700 
00701 int ast_callerid_callwaiting_generate(unsigned char *buf, char *name, char *number, int codec)
00702 {
00703    return __ast_callerid_generate(buf, name, number, 1, codec);
00704 }
00705 
00706 char *ast_callerid_merge(char *buf, int bufsiz, const char *name, const char *num, const char *unknown)
00707 {
00708    if (!unknown)
00709       unknown = "<unknown>";
00710    if (name && num)
00711       snprintf(buf, bufsiz, "\"%s\" <%s>", name, num);
00712    else if (name) 
00713       ast_copy_string(buf, name, bufsiz);
00714    else if (num)
00715       ast_copy_string(buf, num, bufsiz);
00716    else
00717       ast_copy_string(buf, unknown, bufsiz);
00718    return buf;
00719 }
00720 
00721 int ast_callerid_split(const char *buf, char *name, int namelen, char *num, int numlen)
00722 {
00723    char *tmp;
00724    char *l = NULL, *n = NULL;
00725    tmp = ast_strdupa(buf);
00726    if (!tmp) {
00727       name[0] = '\0';
00728       num[0] = '\0';
00729       return -1;
00730    }
00731    ast_callerid_parse(tmp, &n, &l);
00732    if (n)
00733       ast_copy_string(name, n, namelen);
00734    else
00735       name[0] = '\0';
00736    if (l) {
00737       ast_shrink_phone_number(l);
00738       ast_copy_string(num, l, numlen);
00739    } else
00740       num[0] = '\0';
00741    return 0;
00742 }
00743 
00744 static struct {
00745    int val;
00746    char *name;
00747    char *description;
00748 } pres_types[] = {
00749    {  AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED, "allowed_not_screened", "Presentation Allowed, Not Screened"},
00750    {  AST_PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN, "allowed_passed_screen", "Presentation Allowed, Passed Screen"},
00751    {  AST_PRES_ALLOWED_USER_NUMBER_FAILED_SCREEN, "allowed_failed_screen", "Presentation Allowed, Failed Screen"},
00752    {  AST_PRES_ALLOWED_NETWORK_NUMBER, "allowed", "Presentation Allowed, Network Number"},
00753    {  AST_PRES_PROHIB_USER_NUMBER_NOT_SCREENED, "prohib_not_screened", "Presentation Prohibited, Not Screened"},
00754    {  AST_PRES_PROHIB_USER_NUMBER_PASSED_SCREEN, "prohib_passed_screen", "Presentation Prohibited, Passed Screen"},
00755    {  AST_PRES_PROHIB_USER_NUMBER_FAILED_SCREEN, "prohib_failed_screen", "Presentation Prohibited, Failed Screen"},
00756    {  AST_PRES_PROHIB_NETWORK_NUMBER, "prohib", "Presentation Prohibited, Network Number"},
00757    {  AST_PRES_NUMBER_NOT_AVAILABLE, "unavailable", "Number Unavailable"},
00758 };
00759 
00760 /*! \brief Convert caller ID text code to value 
00761    used in config file parsing
00762    \param data text string
00763    \return value AST_PRES_ from callerid.h 
00764 */
00765 int ast_parse_caller_presentation(const char *data)
00766 {
00767    int i;
00768 
00769    for (i = 0; i < ((sizeof(pres_types) / sizeof(pres_types[0]))); i++) {
00770       if (!strcasecmp(pres_types[i].name, data))
00771          return pres_types[i].val;
00772    }
00773 
00774    return -1;
00775 }
00776 
00777 /*! \brief Convert caller ID pres value to explanatory string 
00778    \param data value (see callerid.h AST_PRES_ ) 
00779    \return string for human presentation
00780 */
00781 const char *ast_describe_caller_presentation(int data)
00782 {
00783    int i;
00784 
00785    for (i = 0; i < ((sizeof(pres_types) / sizeof(pres_types[0]))); i++) {
00786       if (pres_types[i].val == data)
00787          return pres_types[i].description;
00788    }
00789 
00790    return "unknown";
00791 }

Generated on Sat Nov 25 00:45:31 2006 for Asterisk - the Open Source PBX by  doxygen 1.4.6