remove a bunch of useless #include "options.h"
[asterisk/asterisk.git] / main / callerid.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2005, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file
20  *
21  * \brief CallerID Generation support 
22  *
23  * \author Mark Spencer <markster@digium.com> 
24  */
25
26 #include "asterisk.h"
27
28 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
29
30 #include <time.h>
31 #include <math.h>
32 #include <ctype.h>
33
34 #include "asterisk/ulaw.h"
35 #include "asterisk/alaw.h"
36 #include "asterisk/frame.h"
37 #include "asterisk/channel.h"
38 #include "asterisk/callerid.h"
39 #include "asterisk/fskmodem.h"
40 #include "asterisk/utils.h"
41
42 struct callerid_state {
43         fsk_data fskd;
44         char rawdata[256];
45         short oldstuff[160];
46         int oldlen;
47         int pos;
48         int type;
49         int cksum;
50         char name[64];
51         char number[64];
52         int flags;
53         int sawflag;
54         int len;
55
56         int skipflag; 
57         unsigned short crc;
58 };
59
60
61 float cid_dr[4], cid_di[4];
62 float clidsb = 8000.0 / 1200.0;
63 float sasdr, sasdi;
64 float casdr1, casdi1, casdr2, casdi2;
65
66 #define CALLERID_SPACE  2200.0          /*!< 2200 hz for "0" */
67 #define CALLERID_MARK   1200.0          /*!< 1200 hz for "1" */
68 #define SAS_FREQ                 440.0
69 #define CAS_FREQ1               2130.0
70 #define CAS_FREQ2               2750.0
71
72 #define AST_CALLERID_UNKNOWN    "<unknown>"
73
74 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)
75 {
76         int x;
77         float t;
78         for (x = 0; x < len; x++) {
79                 t = *cr1 * ddr1 - *ci1 * ddi1;
80                 *ci1 = *cr1 * ddi1 + *ci1 * ddr1;
81                 *cr1 = t;
82                 t = 2.0 - (*cr1 * *cr1 + *ci1 * *ci1);
83                 *cr1 *= t;
84                 *ci1 *= t;      
85
86                 t = *cr2 * ddr2 - *ci2 * ddi2;
87                 *ci2 = *cr2 * ddi2 + *ci2 * ddr2;
88                 *cr2 = t;
89                 t = 2.0 - (*cr2 * *cr2 + *ci2 * *ci2);
90                 *cr2 *= t;
91                 *ci2 *= t;      
92                 buf[x] = AST_LIN2X((*cr1 + *cr2) * 2048.0);
93         }
94 }
95
96 static inline void gen_tone(unsigned char *buf, int len, int codec, float ddr1, float ddi1, float *cr1, float *ci1)
97 {
98         int x;
99         float t;
100         for (x = 0; x < len; x++) {
101                 t = *cr1 * ddr1 - *ci1 * ddi1;
102                 *ci1 = *cr1 * ddi1 + *ci1 * ddr1;
103                 *cr1 = t;
104                 t = 2.0 - (*cr1 * *cr1 + *ci1 * *ci1);
105                 *cr1 *= t;
106                 *ci1 *= t;      
107                 buf[x] = AST_LIN2X(*cr1 * 8192.0);
108         }
109 }
110
111 /*! \brief Initialize stuff for inverse FFT */
112 void callerid_init(void)
113 {
114         cid_dr[0] = cos(CALLERID_SPACE * 2.0 * M_PI / 8000.0);
115         cid_di[0] = sin(CALLERID_SPACE * 2.0 * M_PI / 8000.0);
116         cid_dr[1] = cos(CALLERID_MARK * 2.0 * M_PI / 8000.0);
117         cid_di[1] = sin(CALLERID_MARK * 2.0 * M_PI / 8000.0);
118         sasdr = cos(SAS_FREQ * 2.0 * M_PI / 8000.0);
119         sasdi = sin(SAS_FREQ * 2.0 * M_PI / 8000.0);
120         casdr1 = cos(CAS_FREQ1 * 2.0 * M_PI / 8000.0);
121         casdi1 = sin(CAS_FREQ1 * 2.0 * M_PI / 8000.0);
122         casdr2 = cos(CAS_FREQ2 * 2.0 * M_PI / 8000.0);
123         casdi2 = sin(CAS_FREQ2 * 2.0 * M_PI / 8000.0);
124 }
125
126 struct callerid_state *callerid_new(int cid_signalling)
127 {
128         struct callerid_state *cid;
129
130         if ((cid = ast_calloc(1, sizeof(*cid)))) {
131                 cid->fskd.ispb = 7;             /* 1200 baud */ 
132                 /* Set up for 1200 / 8000 freq *32 to allow ints */
133                 cid->fskd.pllispb  = (int)(8000 * 32  / 1200);
134                 cid->fskd.pllids   = cid->fskd.pllispb/32;
135                 cid->fskd.pllispb2 = cid->fskd.pllispb/2;
136                 
137                 cid->fskd.icont = 0;           /* PLL REset */
138                 /* cid->fskd.hdlc = 0; */       /* Async */
139                 cid->fskd.nbit = 8;             /* 8 bits */
140                 cid->fskd.instop = 1;           /* 1 stop bit */
141                 /* cid->fskd.paridad = 0; */    /* No parity */
142                 cid->fskd.bw = 1;               /* Filter 800 Hz */
143                 if (cid_signalling == 2) {      /* v23 signalling */
144                         cid->fskd.f_mark_idx  = 4;      /* 1300 Hz */
145                         cid->fskd.f_space_idx = 5;      /* 2100 Hz */
146                 } else {                        /* Bell 202 signalling as default */
147                         cid->fskd.f_mark_idx  = 2;      /* 1200 Hz */
148                         cid->fskd.f_space_idx = 3;      /* 2200 Hz */
149                 }
150                 /* cid->fskd.pcola = 0; */      /* No clue */
151                 /* cid->fskd.cont = 0.0; */     /* Digital PLL reset */
152                 /* cid->fskd.x0 = 0.0; */
153                 /* cid->fskd.state = 0; */
154                 cid->flags = CID_UNKNOWN_NAME | CID_UNKNOWN_NUMBER;
155                 /* cid->pos = 0; */
156
157                 fskmodem_init(&cid->fskd);
158         }
159
160         return cid;
161 }
162
163 void callerid_get(struct callerid_state *cid, char **name, char **number, int *flags)
164 {
165         *flags = cid->flags;
166         if (cid->flags & (CID_UNKNOWN_NAME | CID_PRIVATE_NAME))
167                 *name = NULL;
168         else
169                 *name = cid->name;
170         if (cid->flags & (CID_UNKNOWN_NUMBER | CID_PRIVATE_NUMBER))
171                 *number = NULL;
172         else
173                 *number = cid->number;
174 }
175
176 void callerid_get_dtmf(char *cidstring, char *number, int *flags)
177 {
178         int i;
179         int code;
180
181         /* "Clear" the number-buffer. */
182         number[0] = 0;
183
184         if (strlen(cidstring) < 2) {
185                 ast_debug(1, "No cid detected\n");
186                 *flags = CID_UNKNOWN_NUMBER;
187                 return;
188         }
189         
190         /* Detect protocol and special types */
191         if (cidstring[0] == 'B') {
192                 /* Handle special codes */
193                 code = atoi(&cidstring[1]);
194                 if (code == 0)
195                         *flags = CID_UNKNOWN_NUMBER;
196                 else if (code == 10) 
197                         *flags = CID_PRIVATE_NUMBER;
198                 else
199                         ast_debug(1, "Unknown DTMF code %d\n", code);
200         } else if (cidstring[0] == 'D' && cidstring[2] == '#') {
201                 /* .DK special code */
202                 if (cidstring[1] == '1')
203                         *flags = CID_PRIVATE_NUMBER;
204                 if (cidstring[1] == '2' || cidstring[1] == '3')
205                         *flags = CID_UNKNOWN_NUMBER;
206         } else if (cidstring[0] == 'D' || cidstring[0] == 'A') {
207                 /* "Standard" callerid */
208                 for (i = 1; i < strlen(cidstring); i++) {
209                         if (cidstring[i] == 'C' || cidstring[i] == '#')
210                                 break;
211                         if (isdigit(cidstring[i]))
212                                 number[i-1] = cidstring[i];
213                         else
214                                 ast_debug(1, "Unknown CID digit '%c'\n",
215                                         cidstring[i]);
216                 }
217                 number[i-1] = 0;
218         } else if (isdigit(cidstring[0])) {
219                 /* It begins with a digit, so we parse it as a number and hope
220                  * for the best */
221                 ast_log(LOG_WARNING, "Couldn't detect start-character. CID "
222                         "parsing might be unreliable\n");
223                 for (i = 0; i < strlen(cidstring); i++) {
224                         if (isdigit(cidstring[i]))
225                                 number[i] = cidstring[i];
226                         else
227                                 break;
228                 }
229                 number[i] = 0;
230         } else {
231                 ast_debug(1, "Unknown CID protocol, start digit '%c'\n", cidstring[0]);
232                 *flags = CID_UNKNOWN_NUMBER;
233         }
234 }
235
236 int ast_gen_cas(unsigned char *outbuf, int sendsas, int len, int codec)
237 {
238         int pos = 0;
239         int saslen = 2400;
240         float cr1 = 1.0;
241         float ci1 = 0.0;
242         float cr2 = 1.0;
243         float ci2 = 0.0;
244
245         if (sendsas) {
246                 if (len < saslen)
247                         return -1;
248                 gen_tone(outbuf, saslen, codec, sasdr, sasdi, &cr1, &ci1);
249                 len -= saslen;
250                 pos += saslen;
251                 cr2 = cr1;
252                 ci2 = ci1;
253         }
254         gen_tones(outbuf + pos, len, codec, casdr1, casdi1, casdr2, casdi2, &cr1, &ci1, &cr2, &ci2);
255         return 0;
256 }
257
258 static unsigned short calc_crc(unsigned short crc, unsigned char data)
259 {
260         unsigned int i, j, org, dst;
261         org = data;
262         dst = 0;
263
264         for (i = 0; i < CHAR_BIT; i++) {
265                 org <<= 1;
266                 dst >>= 1;
267                 if (org & 0x100) 
268                         dst |= 0x80;
269         }
270         data = (unsigned char) dst;
271         crc ^= (unsigned int) data << (16 - CHAR_BIT);
272         for (j = 0; j < CHAR_BIT; j++) {
273                 if (crc & 0x8000U)
274                         crc = (crc << 1) ^ 0x1021U ;
275                 else
276                         crc <<= 1 ;
277         }
278         return crc;
279 }
280
281 int callerid_feed_jp(struct callerid_state *cid, unsigned char *ubuf, int len, int codec)
282 {
283         int mylen = len;
284         int olen;
285         int b = 'X';
286         int b2;
287         int res;
288         int x;
289         short *buf;
290
291         buf = alloca(2 * len + cid->oldlen);
292
293         memcpy(buf, cid->oldstuff, cid->oldlen);
294         mylen += cid->oldlen / 2;
295
296         for (x = 0; x < len; x++) 
297                 buf[x+cid->oldlen/2] = AST_XLAW(ubuf[x]);
298
299         while (mylen >= 160) {
300                 b = b2 = 0;
301                 olen = mylen;
302                 res = fsk_serial(&cid->fskd, buf, &mylen, &b);
303
304                 if (mylen < 0) {
305                         ast_log(LOG_ERROR, "fsk_serial made mylen < 0 (%d)\n", mylen);
306                         return -1;
307                 }
308
309                 buf += (olen - mylen);
310
311                 if (res < 0) {
312                         ast_log(LOG_NOTICE, "fsk_serial failed\n");
313                         return -1;
314                 }
315
316                 if (res == 1) {
317                         b2 = b;
318                         b  &= 0x7f;
319
320                         /* crc checksum calculation */
321                         if (cid->sawflag > 1)
322                                 cid->crc = calc_crc(cid->crc, (unsigned char) b2);
323
324                         /* Ignore invalid bytes */
325                         if (b > 0xff)
326                                 continue;
327
328                         /* skip DLE if needed */
329                         if (cid->sawflag > 0) {
330                                 if (cid->sawflag != 5 && cid->skipflag == 0 && b == 0x10) {
331                                         cid->skipflag = 1 ;
332                                         continue ;
333                                 }
334                         }
335                         if (cid->skipflag == 1)
336                                 cid->skipflag = 0 ;
337
338                         /* caller id retrieval */
339                         switch (cid->sawflag) {
340                         case 0: /* DLE */
341                                 if (b == 0x10) {
342                                         cid->sawflag = 1;
343                                         cid->skipflag = 0;
344                                         cid->crc = 0;
345                                 }
346                                 break;
347                         case 1: /* SOH */
348                                 if (b == 0x01) 
349                                         cid->sawflag = 2;
350                                 break ;
351                         case 2: /* HEADER */
352                                 if (b == 0x07) 
353                                         cid->sawflag = 3;
354                                 break;
355                         case 3: /* STX */
356                                 if (b == 0x02) 
357                                         cid->sawflag = 4;
358                                 break;
359                         case 4: /* SERVICE TYPE */
360                                 if (b == 0x40) 
361                                         cid->sawflag = 5;
362                                 break;
363                         case 5: /* Frame Length */
364                                 cid->sawflag = 6;
365                                 break;  
366                         case 6: /* NUMBER TYPE */
367                                 cid->sawflag = 7;
368                                 cid->pos = 0;
369                                 cid->rawdata[cid->pos++] = b;
370                                 break;
371                         case 7: /* NUMBER LENGTH */
372                                 cid->sawflag = 8;
373                                 cid->len = b;
374                                 if ((cid->len+2) >= sizeof(cid->rawdata)) {
375                                         ast_log(LOG_WARNING, "too long caller id string\n") ;
376                                         return -1;
377                                 }
378                                 cid->rawdata[cid->pos++] = b;
379                                 break;
380                         case 8: /* Retrieve message */
381                                 cid->rawdata[cid->pos++] = b;
382                                 cid->len--;
383                                 if (cid->len<=0) {
384                                         cid->rawdata[cid->pos] = '\0';
385                                         cid->sawflag = 9;
386                                 }
387                                 break;
388                         case 9: /* ETX */
389                                 cid->sawflag = 10;
390                                 break;
391                         case 10: /* CRC Checksum 1 */
392                                 cid->sawflag = 11;
393                                 break;
394                         case 11: /* CRC Checksum 2 */
395                                 cid->sawflag = 12;
396                                 if (cid->crc != 0) {
397                                         ast_log(LOG_WARNING, "crc checksum error\n") ;
398                                         return -1;
399                                 } 
400                                 /* extract caller id data */
401                                 for (x = 0; x < cid->pos;) {
402                                         switch (cid->rawdata[x++]) {
403                                         case 0x02: /* caller id  number */
404                                                 cid->number[0] = '\0';
405                                                 cid->name[0] = '\0';
406                                                 cid->flags = 0;
407                                                 res = cid->rawdata[x++];
408                                                 ast_copy_string(cid->number, &cid->rawdata[x], res+1);
409                                                 x += res;
410                                                 break;
411                                         case 0x21: /* additional information */
412                                                 /* length */
413                                                 x++; 
414                                                 /* number type */
415                                                 switch (cid->rawdata[x]) { 
416                                                 case 0x00: /* unknown */
417                                                 case 0x01: /* international number */
418                                                 case 0x02: /* domestic number */
419                                                 case 0x03: /* network */
420                                                 case 0x04: /* local call */
421                                                 case 0x06: /* short dial number */
422                                                 case 0x07: /* reserved */
423                                                 default:   /* reserved */
424                                                         ast_debug(2, "cid info:#1=%X\n", cid->rawdata[x]);
425                                                         break ;
426                                                 }
427                                                 x++; 
428                                                 /* numbering plan octed 4 */
429                                                 x++; 
430                                                 /* numbering plan octed 5 */
431                                                 switch (cid->rawdata[x]) { 
432                                                 case 0x00: /* unknown */
433                                                 case 0x01: /* recommendation E.164 ISDN */
434                                                 case 0x03: /* recommendation X.121 */
435                                                 case 0x04: /* telex dial plan */
436                                                 case 0x08: /* domestic dial plan */
437                                                 case 0x09: /* private dial plan */
438                                                 case 0x05: /* reserved */
439                                                 default:   /* reserved */
440                                                         ast_debug(2, "cid info:#2=%X\n", cid->rawdata[x]);
441                                                         break ;
442                                                 }
443                                                 x++; 
444                                                 break ;
445                                         case 0x04: /* no callerid reason */
446                                                 /* length */
447                                                 x++; 
448                                                 /* no callerid reason code */
449                                                 switch (cid->rawdata[x]) {
450                                                 case 'P': /* caller id denied by user */
451                                                 case 'O': /* service not available */
452                                                 case 'C': /* pay phone */
453                                                 case 'S': /* service congested */
454                                                                 cid->flags |= CID_UNKNOWN_NUMBER;
455                                                         ast_debug(2, "no cid reason:%c\n",cid->rawdata[x]);
456                                                         break ;
457                                                 }
458                                                 x++; 
459                                                 break ;
460                                         case 0x09: /* dialed number */
461                                                 /* length */
462                                                 res = cid->rawdata[x++];
463                                                 /* dialed number */
464                                                 x += res;
465                                                 break ;
466                                         case 0x22: /* dialed number additional information */
467                                                 /* length */
468                                                 x++;
469                                                 /* number type */
470                                                 switch (cid->rawdata[x]) {
471                                                 case 0x00: /* unknown */
472                                                 case 0x01: /* international number */
473                                                 case 0x02: /* domestic number */
474                                                 case 0x03: /* network */
475                                                 case 0x04: /* local call */
476                                                 case 0x06: /* short dial number */
477                                                 case 0x07: /* reserved */
478                                                 default:   /* reserved */
479                                                         if (option_debug > 1)
480                                                                 ast_log(LOG_NOTICE, "did info:#1=%X\n", cid->rawdata[x]);
481                                                         break ;
482                                                 }
483                                                 x++;
484                                                 /* numbering plan octed 4 */
485                                                 x++;
486                                                 /* numbering plan octed 5 */
487                                                 switch (cid->rawdata[x]) {
488                                                 case 0x00: /* unknown */
489                                                 case 0x01: /* recommendation E.164 ISDN */
490                                                 case 0x03: /* recommendation X.121 */
491                                                 case 0x04: /* telex dial plan */
492                                                 case 0x08: /* domestic dial plan */
493                                                 case 0x09: /* private dial plan */
494                                                 case 0x05: /* reserved */
495                                                 default:   /* reserved */
496                                                         ast_debug(2, "did info:#2=%X\n", cid->rawdata[x]);
497                                                         break ;
498                                                 }
499                                                 x++;
500                                                 break ;
501                                         }
502                                 }
503                                 return 1;
504                                 break;
505                         default:
506                                 ast_log(LOG_ERROR, "invalid value in sawflag %d\n", cid->sawflag);
507                         }
508                 }
509         }
510         if (mylen) {
511                 memcpy(cid->oldstuff, buf, mylen * 2);
512                 cid->oldlen = mylen * 2;
513         } else
514                 cid->oldlen = 0;
515         
516         return 0;
517 }
518
519
520 int callerid_feed(struct callerid_state *cid, unsigned char *ubuf, int len, int codec)
521 {
522         int mylen = len;
523         int olen;
524         int b = 'X';
525         int res;
526         int x;
527         short *buf;
528
529         buf = alloca(2 * len + cid->oldlen);
530
531         memcpy(buf, cid->oldstuff, cid->oldlen);
532         mylen += cid->oldlen/2;
533
534         for (x = 0; x < len; x++) 
535                 buf[x+cid->oldlen/2] = AST_XLAW(ubuf[x]);
536         while (mylen >= 160) {
537                 olen = mylen;
538                 res = fsk_serial(&cid->fskd, buf, &mylen, &b);
539                 if (mylen < 0) {
540                         ast_log(LOG_ERROR, "fsk_serial made mylen < 0 (%d)\n", mylen);
541                         return -1;
542                 }
543                 buf += (olen - mylen);
544                 if (res < 0) {
545                         ast_log(LOG_NOTICE, "fsk_serial failed\n");
546                         return -1;
547                 }
548                 if (res == 1) {
549                         /* Ignore invalid bytes */
550                         if (b > 0xff)
551                                 continue;
552                         switch (cid->sawflag) {
553                         case 0: /* Look for flag */
554                                 if (b == 'U')
555                                         cid->sawflag = 2;
556                                 break;
557                         case 2: /* Get lead-in */
558                                 if ((b == 0x04) || (b == 0x80)) {
559                                         cid->type = b;
560                                         cid->sawflag = 3;
561                                         cid->cksum = b;
562                                 }
563                                 break;
564                         case 3: /* Get length */
565                                 /* Not a lead in.  We're ready  */
566                                 cid->sawflag = 4;
567                                 cid->len = b;
568                                 cid->pos = 0;
569                                 cid->cksum += b;
570                                 break;
571                         case 4: /* Retrieve message */
572                                 if (cid->pos >= 128) {
573                                         ast_log(LOG_WARNING, "Caller ID too long???\n");
574                                         return -1;
575                                 }
576                                 cid->rawdata[cid->pos++] = b;
577                                 cid->len--;
578                                 cid->cksum += b;
579                                 if (!cid->len) {
580                                         cid->rawdata[cid->pos] = '\0';
581                                         cid->sawflag = 5;
582                                 }
583                                 break;
584                         case 5: /* Check checksum */
585                                 if (b != (256 - (cid->cksum & 0xff))) {
586                                         ast_log(LOG_NOTICE, "Caller*ID failed checksum\n");
587                                         /* Try again */
588                                         cid->sawflag = 0;
589                                         break;
590                                 }
591                 
592                                 cid->number[0] = '\0';
593                                 cid->name[0] = '\0';
594                                 /* If we get this far we're fine.  */
595                                 if (cid->type == 0x80) {
596                                         /* MDMF */
597                                         /* Go through each element and process */
598                                         for (x = 0; x < cid->pos;) {
599                                                 switch (cid->rawdata[x++]) {
600                                                 case 1:
601                                                         /* Date */
602                                                         break;
603                                                 case 2: /* Number */
604                                                 case 3: /* Number (for Zebble) */
605                                                 case 4: /* Number */
606                                                         res = cid->rawdata[x];
607                                                         if (res > 32) {
608                                                                 ast_log(LOG_NOTICE, "Truncating long caller ID number from %d bytes to 32\n", cid->rawdata[x]);
609                                                                 res = 32; 
610                                                         }
611                                                         if (ast_strlen_zero(cid->number)) {
612                                                                 memcpy(cid->number, cid->rawdata + x + 1, res);
613                                                                 /* Null terminate */
614                                                                 cid->number[res] = '\0';
615                                                         }
616                                                         break;
617                                                 case 6: /* Stentor Call Qualifier (ie. Long Distance call) */
618                                                         break;
619                                                 case 7: /* Name */
620                                                 case 8: /* Name */
621                                                         res = cid->rawdata[x];
622                                                         if (res > 32) {
623                                                                 ast_log(LOG_NOTICE, "Truncating long caller ID name from %d bytes to 32\n", cid->rawdata[x]);
624                                                                 res = 32; 
625                                                         }
626                                                         memcpy(cid->name, cid->rawdata + x + 1, res);
627                                                         cid->name[res] = '\0';
628                                                         break;
629                                                 case 17: /* UK: Call type, 1=Voice Call, 2=Ringback when free, 129=Message waiting  */
630                                                 case 19: /* UK: Network message system status (Number of messages waiting) */
631                                                 case 22: /* Something French */
632                                                         break;
633                                                 default:
634                                                         ast_log(LOG_NOTICE, "Unknown IE %d\n", cid->rawdata[x - 1]);
635                                                 }
636                                                 res = cid->rawdata[x];
637                                                 if (0 > res){   /* Negative offset in the CID Spill */
638                                                         ast_log(LOG_NOTICE, "IE %d has bad field length of %d at offset %d\n", cid->rawdata[x-1], cid->rawdata[x], x);
639                                                         /* Try again */
640                                                         cid->sawflag = 0;
641                                                         break;  /* Exit the loop */
642                                                 }
643                                                 x += cid->rawdata[x];
644                                                 x++;
645                                         }
646                                 } else {
647                                         /* SDMF */
648                                         ast_copy_string(cid->number, cid->rawdata + 8, sizeof(cid->number));
649                                 }
650                                 /* Update flags */
651                                 cid->flags = 0;
652                                 if (!strcmp(cid->number, "P")) {
653                                         strcpy(cid->number, "");
654                                         cid->flags |= CID_PRIVATE_NUMBER;
655                                 } else if (!strcmp(cid->number, "O") || ast_strlen_zero(cid->number)) {
656                                         strcpy(cid->number, "");
657                                         cid->flags |= CID_UNKNOWN_NUMBER;
658                                 }
659                                 if (!strcmp(cid->name, "P")) {
660                                         strcpy(cid->name, "");
661                                         cid->flags |= CID_PRIVATE_NAME;
662                                 } else if (!strcmp(cid->name, "O") || ast_strlen_zero(cid->name)) {
663                                         strcpy(cid->name, "");
664                                         cid->flags |= CID_UNKNOWN_NAME;
665                                 }
666                                 return 1;
667                                 break;
668                         default:
669                                 ast_log(LOG_ERROR, "Dunno what to do with a digit in sawflag %d\n", cid->sawflag);
670                         }
671                 }
672         }
673         if (mylen) {
674                 memcpy(cid->oldstuff, buf, mylen * 2);
675                 cid->oldlen = mylen * 2;
676         } else
677                 cid->oldlen = 0;
678
679         return 0;
680 }
681
682 void callerid_free(struct callerid_state *cid)
683 {
684         ast_free(cid);
685 }
686
687 static int callerid_genmsg(char *msg, int size, const char *number, const char *name, int flags)
688 {
689         struct timeval tv = ast_tvnow();
690         struct ast_tm tm;
691         char *ptr;
692         int res;
693         int i, x;
694
695         /* Get the time */
696         ast_localtime(&tv, &tm, NULL);
697         
698         ptr = msg;
699         
700         /* Format time and message header */
701         res = snprintf(ptr, size, "\001\010%02d%02d%02d%02d", tm.tm_mon + 1,
702                                 tm.tm_mday, tm.tm_hour, tm.tm_min);
703         size -= res;
704         ptr += res;
705         if (ast_strlen_zero(number) || (flags & CID_UNKNOWN_NUMBER)) {
706                 /* Indicate number not known */
707                 res = snprintf(ptr, size, "\004\001O");
708                 size -= res;
709                 ptr += res;
710         } else if (flags & CID_PRIVATE_NUMBER) {
711                 /* Indicate number is private */
712                 res = snprintf(ptr, size, "\004\001P");
713                 size -= res;
714                 ptr += res;
715         } else {
716                 /* Send up to 16 digits of number MAX */
717                 i = strlen(number);
718                 if (i > 16)
719                         i = 16;
720                 res = snprintf(ptr, size, "\002%c", i);
721                 size -= res;
722                 ptr += res;
723                 for (x = 0; x < i; x++)
724                         ptr[x] = number[x];
725                 ptr[i] = '\0';
726                 ptr += i;
727                 size -= i;
728         }
729
730         if (ast_strlen_zero(name) || (flags & CID_UNKNOWN_NAME)) {
731                 /* Indicate name not known */
732                 res = snprintf(ptr, size, "\010\001O");
733                 size -= res;
734                 ptr += res;
735         } else if (flags & CID_PRIVATE_NAME) {
736                 /* Indicate name is private */
737                 res = snprintf(ptr, size, "\010\001P");
738                 size -= res;
739                 ptr += res;
740         } else {
741                 /* Send up to 16 digits of name MAX */
742                 i = strlen(name);
743                 if (i > 16)
744                         i = 16;
745                 res = snprintf(ptr, size, "\007%c", i);
746                 size -= res;
747                 ptr += res;
748                 for (x = 0; x < i; x++)
749                         ptr[x] = name[x];
750                 ptr[i] = '\0';
751                 ptr += i;
752                 size -= i;
753         }
754         return (ptr - msg);
755         
756 }
757
758 int vmwi_generate(unsigned char *buf, int active, int mdmf, int codec)
759 {
760         unsigned char msg[256];
761         int len=0;
762         int sum;
763         int x;
764         int bytes = 0;
765         float cr = 1.0;
766         float ci = 0.0;
767         float scont = 0.0;
768
769         if (mdmf) {
770                 /* MDMF Message waiting */
771                 msg[len++] = 0x82;
772                 /* Length is 3 */
773                 msg[len++] = 3;
774                 /* IE is "Message Waiting Parameter" */
775                 msg[len++] = 0xb;
776                 /* Length of IE is one */
777                 msg[len++] = 1;
778                 /* Active or not */
779                 if (active)
780                         msg[len++] = 0xff;
781                 else
782                         msg[len++] = 0x00;
783         } else {
784                 /* SDMF Message waiting */
785                 msg[len++] = 0x6;
786                 /* Length is 3 */
787                 msg[len++] = 3;
788                 if (active) {
789                         msg[len++] = 0x42;
790                         msg[len++] = 0x42;
791                         msg[len++] = 0x42;
792                 } else {
793                         msg[len++] = 0x6f;
794                         msg[len++] = 0x6f;
795                         msg[len++] = 0x6f;
796                 }
797         }
798         sum = 0;
799         for (x = 0; x < len; x++)
800                 sum += msg[x];
801         sum = (256 - (sum & 255));
802         msg[len++] = sum;
803         /* Wait a half a second */
804         for (x = 0; x < 4000; x++)
805                 PUT_BYTE(0x7f);
806         /* Transmit 30 0x55's (looks like a square wave) for channel seizure */
807         for (x = 0; x < 30; x++)
808                 PUT_CLID(0x55);
809         /* Send 170ms of callerid marks */
810         for (x = 0; x < 170; x++)
811                 PUT_CLID_MARKMS;
812         for (x = 0; x < len; x++) {
813                 PUT_CLID(msg[x]);
814         }
815         /* Send 50 more ms of marks */
816         for (x = 0; x < 50; x++)
817                 PUT_CLID_MARKMS;
818         return bytes;
819 }
820
821 int callerid_generate(unsigned char *buf, const char *number, const char *name, int flags, int callwaiting, int codec)
822 {
823         int bytes=0;
824         int x, sum;
825         int len;
826
827         /* Initial carriers (real/imaginary) */
828         float cr = 1.0;
829         float ci = 0.0;
830         float scont = 0.0;
831         char msg[256];
832         len = callerid_genmsg(msg, sizeof(msg), number, name, flags);
833         if (!callwaiting) {
834                 /* Wait a half a second */
835                 for (x = 0; x < 4000; x++)
836                         PUT_BYTE(0x7f);
837                 /* Transmit 30 0x55's (looks like a square wave) for channel seizure */
838                 for (x = 0; x < 30; x++)
839                         PUT_CLID(0x55);
840         }
841         /* Send 150ms of callerid marks */
842         for (x = 0; x < 150; x++)
843                 PUT_CLID_MARKMS;
844         /* Send 0x80 indicating MDMF format */
845         PUT_CLID(0x80);
846         /* Put length of whole message */
847         PUT_CLID(len);
848         sum = 0x80 + strlen(msg);
849         /* Put each character of message and update checksum */
850         for (x = 0; x < len; x++) {
851                 PUT_CLID(msg[x]);
852                 sum += msg[x];
853         }
854         /* Send 2's compliment of sum */
855         PUT_CLID(256 - (sum & 255));
856
857         /* Send 50 more ms of marks */
858         for (x = 0; x < 50; x++)
859                 PUT_CLID_MARKMS;
860         
861         return bytes;
862 }
863
864 /*! \brief Clean up phone string
865  * remove '(', ' ', ')', non-trailing '.', and '-' not in square brackets.
866  * Basically, remove anything that could be invalid in a pattern.
867  */
868 void ast_shrink_phone_number(char *n)
869 {
870         int x, y=0;
871         int bracketed = 0;
872
873         for (x = 0; n[x]; x++) {
874                 switch (n[x]) {
875                 case '[':
876                         bracketed++;
877                         n[y++] = n[x];
878                         break;
879                 case ']':
880                         bracketed--;
881                         n[y++] = n[x];
882                         break;
883                 case '-':
884                         if (bracketed)
885                                 n[y++] = n[x];
886                         break;
887                 case '.':
888                         if (!n[x+1])
889                                 n[y++] = n[x];
890                         break;
891                 default:
892                         /* ignore parenthesis and whitespace */
893                         if (!strchr("( )", n[x]))
894                                 n[y++] = n[x];
895                 }
896         }
897         n[y] = '\0';
898 }
899
900 /*! \brief Checks if phone number consists of valid characters 
901         \param exten    String that needs to be checked
902         \param valid    Valid characters in string
903         \return 1 if valid string, 0 if string contains invalid characters
904 */
905 static int ast_is_valid_string(const char *exten, const char *valid)
906 {
907         int x;
908
909         if (ast_strlen_zero(exten))
910                 return 0;
911         for (x = 0; exten[x]; x++)
912                 if (!strchr(valid, exten[x]))
913                         return 0;
914         return 1;
915 }
916
917 /*! \brief checks if string consists only of digits and * \# and + 
918         \return 1 if string is valid AST phone number
919         \return 0 if not
920 */
921 int ast_isphonenumber(const char *n)
922 {
923         return ast_is_valid_string(n, "0123456789*#+");
924 }
925
926 /*! \brief checks if string consists only of digits and ( ) - * \# and + 
927         Pre-qualifies the string for ast_shrink_phone_number()
928         \return 1 if string is valid AST shrinkable phone number
929         \return 0 if not
930 */
931 int ast_is_shrinkable_phonenumber(const char *exten)
932 {
933         return ast_is_valid_string(exten, "0123456789*#+()-.");
934 }
935
936 /*! \brief parse string for caller id information 
937         \return always returns 0, as the code always returns something.
938   XXX note that 'name' is not parsed consistently e.g. we have
939
940         input                   location        name
941         " foo bar " <123>       123             ' foo bar ' (with spaces around)
942         " foo bar "             NULL            'foo bar' (without spaces around)
943         " foo bar  <123>"       123             '" foo bar'
944   The parsing of leading and trailing space/quotes should be more consistent.
945 */
946 int ast_callerid_parse(char *instr, char **name, char **location)
947 {
948         char *ns, *ne, *ls, *le;
949
950         /* Try "name" <location> format or name <location> format */
951         if ((ls = strchr(instr, '<')) && (le = strchr(ls, '>'))) {
952                 *ls = *le = '\0';       /* location found, trim off the brackets */
953                 *location = ls + 1;     /* and this is the result */
954                 if ((ns = strchr(instr, '"')) && (ne = strchr(ns + 1, '"'))) {
955                         *ns = *ne = '\0';       /* trim off the quotes */
956                         *name = ns + 1;         /* and this is the name */
957                 } else { /* no quotes, trim off leading and trailing spaces */
958                         *name = ast_skip_blanks(instr);
959                         ast_trim_blanks(*name);
960                 }
961         } else {        /* no valid brackets */
962                 char tmp[256];
963
964                 ast_copy_string(tmp, instr, sizeof(tmp));
965                 ast_shrink_phone_number(tmp);
966                 if (ast_isphonenumber(tmp)) {   /* Assume it's just a location */
967                         *name = NULL;
968                         strcpy(instr, tmp); /* safe, because tmp will always be the same size or smaller than instr */
969                         *location = instr;
970                 } else { /* Assume it's just a name. */
971                         *location = NULL;
972                         if ((ns = strchr(instr, '"')) && (ne = strchr(ns + 1, '"'))) {
973                                 *ns = *ne = '\0';       /* trim off the quotes */
974                                 *name = ns + 1;         /* and this is the name */
975                         } else { /* no quotes, trim off leading and trailing spaces */
976                                 *name = ast_skip_blanks(instr);
977                                 ast_trim_blanks(*name);
978                         }
979                 }
980         }
981         return 0;
982 }
983
984 static int __ast_callerid_generate(unsigned char *buf, const char *name, const char *number, int callwaiting, int codec)
985 {
986         if (ast_strlen_zero(name))
987                 name = NULL;
988         if (ast_strlen_zero(number))
989                 number = NULL;
990         return callerid_generate(buf, number, name, 0, callwaiting, codec);
991 }
992
993 int ast_callerid_generate(unsigned char *buf, const char *name, const char *number, int codec)
994 {
995         return __ast_callerid_generate(buf, name, number, 0, codec);
996 }
997
998 int ast_callerid_callwaiting_generate(unsigned char *buf, const char *name, const char *number, int codec)
999 {
1000         return __ast_callerid_generate(buf, name, number, 1, codec);
1001 }
1002
1003 char *ast_callerid_merge(char *buf, int bufsiz, const char *name, const char *num, const char *unknown)
1004 {
1005         if (!unknown)
1006                 unknown = "<unknown>";
1007         if (name && num)
1008                 snprintf(buf, bufsiz, "\"%s\" <%s>", name, num);
1009         else if (name) 
1010                 ast_copy_string(buf, name, bufsiz);
1011         else if (num)
1012                 ast_copy_string(buf, num, bufsiz);
1013         else
1014                 ast_copy_string(buf, unknown, bufsiz);
1015         return buf;
1016 }
1017
1018 int ast_callerid_split(const char *buf, char *name, int namelen, char *num, int numlen)
1019 {
1020         char *tmp;
1021         char *l = NULL, *n = NULL;
1022
1023         tmp = ast_strdupa(buf);
1024         ast_callerid_parse(tmp, &n, &l);
1025         if (n)
1026                 ast_copy_string(name, n, namelen);
1027         else
1028                 name[0] = '\0';
1029         if (l) {
1030                 ast_shrink_phone_number(l);
1031                 ast_copy_string(num, l, numlen);
1032         } else
1033                 num[0] = '\0';
1034         return 0;
1035 }
1036
1037 /*! \brief Translation table for Caller ID Presentation settings */
1038 static struct {
1039         int val;
1040         const char *name;
1041         const char *description;
1042 } pres_types[] = {
1043         {  AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED, "allowed_not_screened", "Presentation Allowed, Not Screened"},
1044         {  AST_PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN, "allowed_passed_screen", "Presentation Allowed, Passed Screen"},
1045         {  AST_PRES_ALLOWED_USER_NUMBER_FAILED_SCREEN, "allowed_failed_screen", "Presentation Allowed, Failed Screen"},
1046         {  AST_PRES_ALLOWED_NETWORK_NUMBER, "allowed", "Presentation Allowed, Network Number"},
1047         {  AST_PRES_PROHIB_USER_NUMBER_NOT_SCREENED, "prohib_not_screened", "Presentation Prohibited, Not Screened"},
1048         {  AST_PRES_PROHIB_USER_NUMBER_PASSED_SCREEN, "prohib_passed_screen", "Presentation Prohibited, Passed Screen"},
1049         {  AST_PRES_PROHIB_USER_NUMBER_FAILED_SCREEN, "prohib_failed_screen", "Presentation Prohibited, Failed Screen"},
1050         {  AST_PRES_PROHIB_NETWORK_NUMBER, "prohib", "Presentation Prohibited, Network Number"},
1051         {  AST_PRES_NUMBER_NOT_AVAILABLE, "unavailable", "Number Unavailable"},
1052 };
1053
1054 /*! \brief Convert caller ID text code to value 
1055         used in config file parsing
1056         \param data text string
1057         \return value AST_PRES_ from callerid.h 
1058 */
1059 int ast_parse_caller_presentation(const char *data)
1060 {
1061         int i;
1062
1063         for (i = 0; i < ((sizeof(pres_types) / sizeof(pres_types[0]))); i++) {
1064                 if (!strcasecmp(pres_types[i].name, data))
1065                         return pres_types[i].val;
1066         }
1067
1068         return -1;
1069 }
1070
1071 /*! \brief Convert caller ID pres value to explanatory string 
1072         \param data value (see callerid.h AST_PRES_ ) 
1073         \return string for human presentation
1074 */
1075 const char *ast_describe_caller_presentation(int data)
1076 {
1077         int i;
1078
1079         for (i = 0; i < ((sizeof(pres_types) / sizeof(pres_types[0]))); i++) {
1080                 if (pres_types[i].val == data)
1081                         return pres_types[i].description;
1082         }
1083
1084         return "unknown";
1085 }
1086
1087 /*! \brief Convert caller ID pres value to text code
1088         \param data text string
1089         \return string for config file
1090 */
1091 const char *ast_named_caller_presentation(int data)
1092 {
1093         int i;
1094
1095         for (i = 0; i < ((sizeof(pres_types) / sizeof(pres_types[0]))); i++) {
1096                 if (pres_types[i].val == data)
1097                         return pres_types[i].name;
1098         }
1099
1100         return "unknown";
1101 }