65 float cid_dr[4], cid_di[4];
66 float clidsb = 8000.0 / 1200.0;
68 float casdr1, casdi1, casdr2, casdi2;
70 #define CALLERID_SPACE 2200.0
71 #define CALLERID_MARK 1200.0
72 #define SAS_FREQ 440.0
73 #define CAS_FREQ1 2130.0
74 #define CAS_FREQ2 2750.0
76 #define AST_CALLERID_UNKNOWN "<unknown>"
78 static inline void gen_tones(
unsigned char *buf,
int len,
struct ast_format *codec,
float ddr1,
float ddi1,
float ddr2,
float ddi2,
float *cr1,
float *ci1,
float *cr2,
float *ci2)
82 for (x = 0; x < len; x++) {
83 t = *cr1 * ddr1 - *ci1 * ddi1;
84 *ci1 = *cr1 * ddi1 + *ci1 * ddr1;
86 t = 2.0 - (*cr1 * *cr1 + *ci1 * *ci1);
90 t = *cr2 * ddr2 - *ci2 * ddi2;
91 *ci2 = *cr2 * ddi2 + *ci2 * ddr2;
93 t = 2.0 - (*cr2 * *cr2 + *ci2 * *ci2);
96 buf[x] = AST_LIN2X((*cr1 + *cr2) * 2048.0);
100 static inline void gen_tone(
unsigned char *buf,
int len,
struct ast_format *codec,
float ddr1,
float ddi1,
float *cr1,
float *ci1)
104 for (x = 0; x < len; x++) {
105 t = *cr1 * ddr1 - *ci1 * ddi1;
106 *ci1 = *cr1 * ddi1 + *ci1 * ddr1;
108 t = 2.0 - (*cr1 * *cr1 + *ci1 * *ci1);
111 buf[x] = AST_LIN2X(*cr1 * 8192.0);
122 sasdr = cos(SAS_FREQ * 2.0 * M_PI / 8000.0);
123 sasdi = sin(SAS_FREQ * 2.0 * M_PI / 8000.0);
124 casdr1 = cos(CAS_FREQ1 * 2.0 * M_PI / 8000.0);
125 casdi1 = sin(CAS_FREQ1 * 2.0 * M_PI / 8000.0);
126 casdr2 = cos(CAS_FREQ2 * 2.0 * M_PI / 8000.0);
127 casdi2 = sin(CAS_FREQ2 * 2.0 * M_PI / 8000.0);
135 #ifdef INTEGER_CALLERID
138 cid->fskd.
pllispb = (int)(8000 * 32 / 1200);
139 cid->fskd.pllids = cid->fskd.
pllispb/32;
140 cid->fskd.pllispb2 = cid->fskd.
pllispb/2;
148 if (cid_signalling == 2) {
159 cid->flags = CID_UNKNOWN_NAME | CID_UNKNOWN_NUMBER;
162 fskmodem_init(&cid->fskd);
167 cid->fskd.
nstop = 1.0;
170 if (cid_signalling == 2) {
181 cid->flags = CID_UNKNOWN_NAME | CID_UNKNOWN_NUMBER;
192 if (cid->flags & (CID_UNKNOWN_NAME | CID_PRIVATE_NAME)) {
197 if (cid->flags & (CID_UNKNOWN_NUMBER | CID_PRIVATE_NUMBER)) {
200 *number = cid->number;
202 *redirecting = cid->redirecting;
219 if (strlen(cidstring) < 2) {
221 *flags = CID_UNKNOWN_NUMBER;
226 if (cidstring[0] ==
'B') {
228 code = atoi(&cidstring[1]);
230 *flags = CID_UNKNOWN_NUMBER;
232 *flags = CID_PRIVATE_NUMBER;
234 ast_debug(1,
"Unknown DTMF code %d\n", code);
235 }
else if (cidstring[0] ==
'D' && cidstring[2] ==
'#') {
237 if (cidstring[1] ==
'1')
238 *flags = CID_PRIVATE_NUMBER;
239 if (cidstring[1] ==
'2' || cidstring[1] ==
'3')
240 *flags = CID_UNKNOWN_NUMBER;
241 }
else if (cidstring[0] ==
'D' || cidstring[0] ==
'A') {
243 for (i = 1; i < strlen(cidstring); i++) {
244 if (cidstring[i] ==
'C' || cidstring[i] ==
'#')
246 if (isdigit(cidstring[i]))
247 number[i-1] = cidstring[i];
253 }
else if (isdigit(cidstring[0])) {
256 ast_log(LOG_WARNING,
"Couldn't detect start-character. CID "
257 "parsing might be unreliable\n");
258 for (i = 0; i < strlen(cidstring); i++) {
259 if (isdigit(cidstring[i]))
260 number[i] = cidstring[i];
266 ast_debug(1,
"Unknown CID protocol, start digit '%c'\n", cidstring[0]);
267 *flags = CID_UNKNOWN_NUMBER;
283 gen_tone(outbuf, saslen, codec, sasdr, sasdi, &cr1, &ci1);
289 gen_tones(outbuf + pos, len, codec, casdr1, casdi1, casdr2, casdi2, &cr1, &ci1, &cr2, &ci2);
293 static unsigned short calc_crc(
unsigned short crc,
unsigned char data)
295 unsigned int i, j, org, dst;
299 for (i = 0; i < CHAR_BIT; i++) {
305 data = (
unsigned char) dst;
306 crc ^= (
unsigned int) data << (16 - CHAR_BIT);
307 for (j = 0; j < CHAR_BIT; j++) {
309 crc = (crc << 1) ^ 0x1021U ;
328 memcpy(buf, cid->oldstuff, cid->oldlen);
329 mylen += cid->oldlen / 2;
331 for (x = 0; x < len; x++)
332 buf[x+cid->oldlen/2] = AST_XLAW(ubuf[x]);
334 while (mylen >= 160) {
337 res =
fsk_serial(&cid->fskd, buf, &mylen, &b);
340 ast_log(LOG_ERROR,
"No start bit found in fsk data.\n");
344 buf += (olen - mylen);
347 ast_log(LOG_NOTICE,
"fsk_serial failed\n");
356 if (cid->sawflag > 1)
357 cid->crc = calc_crc(cid->crc, (
unsigned char) b2);
364 if (cid->sawflag > 0) {
365 if (cid->sawflag != 5 && cid->skipflag == 0 && b == 0x10) {
370 if (cid->skipflag == 1)
374 switch (cid->sawflag) {
404 cid->rawdata[cid->pos++] = b;
409 if ((cid->len+2) >=
sizeof(cid->rawdata)) {
410 ast_log(LOG_WARNING,
"too long caller id string\n") ;
413 cid->rawdata[cid->pos++] = b;
416 cid->rawdata[cid->pos++] = b;
419 cid->rawdata[cid->pos] =
'\0';
432 ast_log(LOG_WARNING,
"crc checksum error\n") ;
436 for (x = 0; x < cid->pos;) {
437 switch (cid->rawdata[x++]) {
439 cid->number[0] =
'\0';
442 res = cid->rawdata[x++];
450 switch (cid->rawdata[x]) {
459 ast_debug(2,
"cid info:#1=%X\n", (
unsigned)cid->rawdata[x]);
466 switch (cid->rawdata[x]) {
475 ast_debug(2,
"cid info:#2=%X\n", (
unsigned)cid->rawdata[x]);
484 switch (cid->rawdata[x]) {
489 cid->flags |= CID_UNKNOWN_NUMBER;
490 ast_debug(2,
"no cid reason:%c\n", cid->rawdata[x]);
497 res = cid->rawdata[x++];
505 switch (cid->rawdata[x]) {
514 if (DEBUG_ATLEAST(2))
515 ast_log(LOG_NOTICE,
"did info:#1=%X\n", (
unsigned)cid->rawdata[x]);
522 switch (cid->rawdata[x]) {
531 ast_debug(2,
"did info:#2=%X\n", (
unsigned)cid->rawdata[x]);
541 ast_log(LOG_ERROR,
"invalid value in sawflag %d\n", cid->sawflag);
546 memcpy(cid->oldstuff, buf, mylen * 2);
547 cid->oldlen = mylen * 2;
554 static const char *mdmf_param_name(
int param)
557 case 0x1:
return "Date/Time";
558 case 0x2:
return "Caller Number";
559 case 0x3:
return "DNIS";
560 case 0x4:
return "Reason For Absence of Number";
561 case 0x5:
return "Reason For Redirection";
562 case 0x6:
return "Call Qualifier";
563 case 0x7:
return "Name";
564 case 0x8:
return "Reason For Absence of Name";
565 case 0xB:
return "Message Waiting";
566 default:
return "Unknown";
581 memcpy(buf, cid->oldstuff, cid->oldlen);
582 mylen += cid->oldlen/2;
584 for (x = 0; x < len; x++)
585 buf[x+cid->oldlen/2] = AST_XLAW(ubuf[x]);
586 while (mylen >= 160) {
588 res =
fsk_serial(&cid->fskd, buf, &mylen, &b);
590 ast_log(LOG_ERROR,
"No start bit found in fsk data.\n");
593 buf += (olen - mylen);
595 ast_log(LOG_NOTICE,
"fsk_serial failed\n");
600 if (cid->sawflag != 5) {
615 switch (cid->sawflag) {
621 if ((b == 0x04) || (b == 0x80) || (b == 0x06) || (b == 0x82)) {
635 if (cid->pos >= 128) {
636 ast_log(LOG_WARNING,
"Caller ID too long???\n");
639 cid->rawdata[cid->pos++] = b;
643 cid->rawdata[cid->pos] =
'\0';
648 if ((b + cid->cksum) & 0xff) {
649 ast_log(LOG_NOTICE,
"Caller*ID failed checksum\n");
655 cid->number[0] =
'\0';
659 cid->redirecting = 0;
661 if ((cid->type == 0x80) || (cid->type == 0x82)) {
663 ast_debug(6,
"%s Caller*ID spill received\n", cid->type == 0x80 ?
"MDMF" :
"MDMF Message Waiting");
665 for (x = 0; x < cid->pos;) {
666 int param = cid->rawdata[x++];
667 ast_debug(7,
"Caller*ID parameter %d (%s), length %d\n", param, mdmf_param_name(param), cid->rawdata[x]);
690 ast_debug(3,
"Caller*ID Dialable Directory Number: '%.*s'\n", cid->rawdata[x], cid->rawdata + x + 1);
694 res = cid->rawdata[x];
696 ast_log(LOG_NOTICE,
"Truncating long caller ID number from %d bytes to 32\n", cid->rawdata[x]);
699 if (ast_strlen_zero(cid->number)) {
700 memcpy(cid->number, cid->rawdata + x + 1, res);
702 cid->number[res] =
'\0';
706 res = cid->rawdata[x];
708 ast_log(LOG_WARNING,
"Redirecting parameter length is %d?\n", res);
711 switch (*(cid->rawdata + x + 1)) {
713 cid->redirecting = AST_REDIRECTING_REASON_USER_BUSY;
716 cid->redirecting = AST_REDIRECTING_REASON_NO_ANSWER;
719 cid->redirecting = AST_REDIRECTING_REASON_UNCONDITIONAL;
722 cid->redirecting = AST_REDIRECTING_REASON_CALL_FWD_DTE;
725 cid->redirecting = AST_REDIRECTING_REASON_DEFLECTION;
728 ast_log(LOG_WARNING,
"Redirecting reason is %02x?\n", *(cid->rawdata + x + 1));
733 res = cid->rawdata[x];
734 if (res == 1 && *(cid->rawdata + x + 1) ==
'L') {
735 cid->flags |= CID_QUALIFIER;
736 }
else if (res >= 1) {
737 ast_debug(2,
"Invalid value (len %d) received for Call Qualifier: '%c'\n", res, *(cid->rawdata + x + 1));
742 res = cid->rawdata[x];
744 ast_log(LOG_NOTICE,
"Truncating long caller ID name from %d bytes to 32\n", cid->rawdata[x]);
747 memcpy(cid->name, cid->rawdata + x + 1, res);
748 cid->name[res] =
'\0';
751 res = cid->rawdata[x + 1];
753 cid->flags |= CID_MSGWAITING;
755 cid->flags |= CID_NOMSGWAITING;
762 ast_log(LOG_NOTICE,
"Unknown IE %d\n", cid->rawdata[x - 1]);
764 res = cid->rawdata[x];
766 ast_log(LOG_NOTICE,
"IE %d has bad field length of %d at offset %d\n", cid->rawdata[x-1], cid->rawdata[x], x);
771 x += cid->rawdata[x];
774 }
else if (cid->type == 0x6) {
776 ast_debug(6,
"VMWI SDMF Caller*ID spill received\n");
777 if (cid->rawdata[2] == 0x42) {
778 cid->flags |= CID_MSGWAITING;
779 }
else if (cid->rawdata[2] == 0x6f) {
780 cid->flags |= CID_NOMSGWAITING;
784 ast_debug(6,
"SDMF Caller*ID spill received\n");
787 if (!strcmp(cid->number,
"P")) {
788 ast_debug(6,
"Caller*ID number is private\n");
789 strcpy(cid->number,
"");
790 cid->flags |= CID_PRIVATE_NUMBER;
791 }
else if (!strcmp(cid->number,
"O")) {
792 ast_debug(6,
"Caller*ID number is out of area\n");
793 strcpy(cid->number,
"");
794 cid->flags |= CID_UNKNOWN_NUMBER;
795 }
else if (ast_strlen_zero(cid->number)) {
796 ast_debug(6,
"No Caller*ID number provided, and no reason provided for its absence\n");
797 strcpy(cid->number,
"");
798 cid->flags |= CID_UNKNOWN_NUMBER;
800 ast_debug(6,
"Caller*ID number is '%s'\n", cid->number);
802 if (!strcmp(cid->name,
"P")) {
803 ast_debug(6,
"Caller*ID name is private\n");
804 strcpy(cid->name,
"");
805 cid->flags |= CID_PRIVATE_NAME;
806 }
else if (!strcmp(cid->name,
"O")) {
807 ast_debug(6,
"Caller*ID name is out of area\n");
808 strcpy(cid->name,
"");
809 cid->flags |= CID_UNKNOWN_NAME;
810 }
else if (ast_strlen_zero(cid->name)) {
811 ast_debug(6,
"No Caller*ID name provided, and no reason provided for its absence\n");
812 strcpy(cid->name,
"");
813 cid->flags |= CID_UNKNOWN_NAME;
815 ast_debug(6,
"Caller*ID name is '%s'\n", cid->name);
820 ast_log(LOG_ERROR,
"Dunno what to do with a digit in sawflag %d\n", cid->sawflag);
825 memcpy(cid->oldstuff, buf, mylen * 2);
826 cid->oldlen = mylen * 2;
838 static int callerid_genmsg(
char *msg,
int size,
const char *
number,
const char *name,
int flags,
int format,
839 const char *ddn,
int redirecting,
const char *tz)
853 res = snprintf(ptr, size,
"\001\010%02d%02d%02d%02d", tm.tm_mon + 1,
854 tm.tm_mday, tm.tm_hour, tm.tm_min);
858 if (ast_strlen_zero(number) || (flags & CID_UNKNOWN_NUMBER)) {
860 res = snprintf(ptr, size,
"\004\001O");
863 }
else if (flags & CID_PRIVATE_NUMBER) {
865 res = snprintf(ptr, size,
"\004\001P");
873 res = snprintf(ptr, size,
"\002%c", i);
876 for (x = 0; x < i; x++)
888 if (ast_strlen_zero(name) || (flags & CID_UNKNOWN_NAME)) {
890 res = snprintf(ptr, size,
"\010\001O");
893 }
else if (flags & CID_PRIVATE_NAME) {
895 res = snprintf(ptr, size,
"\010\001P");
903 res = snprintf(ptr, size,
"\007%c", i);
906 for (x = 0; x < i; x++)
914 if (flags & CID_QUALIFIER) {
915 res = snprintf(ptr, size,
"\006\001L");
924 if (redirecting >= 0) {
926 switch (redirecting) {
927 case AST_REDIRECTING_REASON_USER_BUSY:
928 res = snprintf(ptr, size,
"\005\001\001");
930 case AST_REDIRECTING_REASON_NO_ANSWER:
931 res = snprintf(ptr, size,
"\005\001\002");
933 case AST_REDIRECTING_REASON_UNCONDITIONAL:
934 res = snprintf(ptr, size,
"\005\001\003");
936 case AST_REDIRECTING_REASON_CALL_FWD_DTE:
937 res = snprintf(ptr, size,
"\005\001\004");
939 case AST_REDIRECTING_REASON_DEFLECTION:
940 res = snprintf(ptr, size,
"\005\001\005");
968 len = callerid_genmsg(msg+2,
sizeof(msg)-2, number, name, flags,
CID_TYPE_MDMF,
"", -1, NULL);
1017 for (x = 0; x < len; x++)
1019 sum = (256 - (sum & 255));
1022 for (x = 0; x < 4000; x++)
1025 for (x = 0; x < 30; x++)
1028 for (x = 0; x < 170; x++)
1030 for (x = 0; x < len; x++) {
1034 for (x = 0; x < 50; x++)
1045 int flags,
int format,
int callwaiting,
struct ast_format *codec)
1052 int flags,
int format,
int callwaiting,
struct ast_format *codec,
const char *tz)
1063 len = callerid_genmsg(msg,
sizeof(msg), number, name, flags, format, ddn, redirecting, tz);
1066 for (x = 0; x < 4000; x++)
1069 for (x = 0; x < 30; x++)
1073 for (x = 0; x < 150; x++)
1079 sum = 0x80 + strlen(msg);
1081 for (x = 0; x < len; x++) {
1086 PUT_CLID(256 - (sum & 255));
1089 for (x = 0; x < 50; x++)
1106 for (x = 0; n[x]; x++) {
1126 if (!strchr(
"( )", n[x]))
1144 if (ast_strlen_zero(exten))
1146 for (x = 0; exten[x]; x++)
1147 if (!strchr(valid, exten[x]))
1168 int quotes_stripped = 0;
1173 if (instr != input_str) {
1174 quotes_stripped = 1;
1178 if ((ls = strrchr(instr,
'<'))) {
1179 if ((le = strrchr(ls,
'>'))) {
1208 static int __ast_callerid_generate(
unsigned char *buf,
const char *name,
const char *number,
1209 const char *ddn,
int redirecting,
int pres,
int qualifier,
int format,
int callwaiting,
struct ast_format *codec,
const char *tz)
1213 ast_debug(1,
"Caller ID Type %s: Number: %s, Name: %s, DDN: %s, Redirecting Reason: %s, Pres: %s, Qualifier: %s, Format: %s\n",
1217 if (ast_strlen_zero(name))
1219 if (ast_strlen_zero(number))
1222 if (pres & AST_PRES_RESTRICTED) {
1223 flags |= CID_PRIVATE_NUMBER;
1224 flags |= CID_PRIVATE_NAME;
1225 }
else if (pres & AST_PRES_UNAVAILABLE) {
1226 flags |= CID_UNKNOWN_NUMBER;
1227 flags |= CID_UNKNOWN_NAME;
1231 flags |= CID_QUALIFIER;
1239 return __ast_callerid_generate(buf, name, number,
"", -1, 0, 0,
CID_TYPE_MDMF, 0, codec, NULL);
1244 return __ast_callerid_generate(buf, name, number,
"", -1, 0, 0,
CID_TYPE_MDMF, 1, codec, NULL);
1248 const char *ddn,
int redirecting,
int pres,
int qualifier,
int format,
struct ast_format *codec)
1250 return __ast_callerid_generate(buf, name, number, ddn, redirecting, pres, qualifier, format, 0, codec, NULL);
1254 const char *ddn,
int redirecting,
int pres,
int qualifier,
struct ast_format *codec)
1257 return __ast_callerid_generate(buf, name, number, ddn, redirecting, pres, qualifier,
CID_TYPE_MDMF, 1, codec, NULL);
1261 const char *ddn,
int redirecting,
int pres,
int qualifier,
int format,
struct ast_format *codec,
const char *tz)
1263 return __ast_callerid_generate(buf, name, number, ddn, redirecting, pres, qualifier, format, 0, codec, tz);
1267 const char *ddn,
int redirecting,
int pres,
int qualifier,
struct ast_format *codec,
const char *tz)
1270 return __ast_callerid_generate(buf, name, number, ddn, redirecting, pres, qualifier,
CID_TYPE_MDMF, 1, codec, tz);
1273 char *ast_callerid_merge(
char *buf,
int bufsiz,
const char *name,
const char *num,
const char *unknown)
1276 unknown =
"<unknown>";
1281 snprintf(buf, bufsiz,
"\"%s\" <%s>", name_buf, num);
1292 int ast_callerid_split(
const char *buf,
char *name,
int namelen,
char *num,
int numlen)
1295 char *l = NULL, *n = NULL;
1314 const char *description;
1320 { AST_PRES_ALLOWED | AST_PRES_USER_NUMBER_UNSCREENED,
"allowed_not_screened",
"Presentation Allowed, Not Screened" },
1321 { AST_PRES_ALLOWED | AST_PRES_USER_NUMBER_PASSED_SCREEN,
"allowed_passed_screen",
"Presentation Allowed, Passed Screen" },
1322 { AST_PRES_ALLOWED | AST_PRES_USER_NUMBER_FAILED_SCREEN,
"allowed_failed_screen",
"Presentation Allowed, Failed Screen" },
1323 { AST_PRES_ALLOWED | AST_PRES_NETWORK_NUMBER,
"allowed",
"Presentation Allowed, Network Number" },
1325 { AST_PRES_RESTRICTED | AST_PRES_USER_NUMBER_UNSCREENED,
"prohib_not_screened",
"Presentation Prohibited, Not Screened" },
1326 { AST_PRES_RESTRICTED | AST_PRES_USER_NUMBER_PASSED_SCREEN,
"prohib_passed_screen",
"Presentation Prohibited, Passed Screen" },
1327 { AST_PRES_RESTRICTED | AST_PRES_USER_NUMBER_FAILED_SCREEN,
"prohib_failed_screen",
"Presentation Prohibited, Failed Screen" },
1328 { AST_PRES_RESTRICTED | AST_PRES_NETWORK_NUMBER,
"prohib",
"Presentation Prohibited, Network Number" },
1330 { AST_PRES_UNAVAILABLE | AST_PRES_NETWORK_NUMBER,
"unavailable",
"Number Unavailable" },
1331 { AST_PRES_UNAVAILABLE | AST_PRES_USER_NUMBER_UNSCREENED,
"unavailable",
"Number Unavailable" },
1332 { AST_PRES_UNAVAILABLE | AST_PRES_USER_NUMBER_FAILED_SCREEN,
"unavailable",
"Number Unavailable" },
1333 { AST_PRES_UNAVAILABLE | AST_PRES_USER_NUMBER_PASSED_SCREEN,
"unavailable",
"Number Unavailable" },
1350 for (index = 0; index < ARRAY_LEN(pres_types); ++index) {
1351 if (!strcasecmp(pres_types[index].name, data)) {
1352 return pres_types[index].value;
1368 for (index = 0; index < ARRAY_LEN(pres_types); ++index) {
1369 if (pres_types[index].value == data) {
1370 return pres_types[index].description;
1386 for (index = 0; index < ARRAY_LEN(pres_types); ++index) {
1387 if (pres_types[index].value == data) {
1388 return pres_types[index].name;
1398 { AST_REDIRECTING_REASON_UNKNOWN,
"unknown",
"Unknown" },
1399 { AST_REDIRECTING_REASON_USER_BUSY,
"cfb",
"Call Forwarding Busy" },
1400 { AST_REDIRECTING_REASON_NO_ANSWER,
"cfnr",
"Call Forwarding No Reply" },
1401 { AST_REDIRECTING_REASON_UNAVAILABLE,
"unavailable",
"Callee is Unavailable" },
1402 { AST_REDIRECTING_REASON_UNCONDITIONAL,
"cfu",
"Call Forwarding Unconditional" },
1403 { AST_REDIRECTING_REASON_TIME_OF_DAY,
"time_of_day",
"Time of Day" },
1404 { AST_REDIRECTING_REASON_DO_NOT_DISTURB,
"dnd",
"Do Not Disturb" },
1405 { AST_REDIRECTING_REASON_DEFLECTION,
"deflection",
"Call Deflection" },
1406 { AST_REDIRECTING_REASON_FOLLOW_ME,
"follow_me",
"Follow Me" },
1407 { AST_REDIRECTING_REASON_OUT_OF_ORDER,
"out_of_order",
"Called DTE Out-Of-Order" },
1408 { AST_REDIRECTING_REASON_AWAY,
"away",
"Callee is Away" },
1409 { AST_REDIRECTING_REASON_CALL_FWD_DTE,
"cf_dte",
"Call Forwarding By The Called DTE" },
1410 { AST_REDIRECTING_REASON_SEND_TO_VM,
"send_to_vm",
"Call is being redirected to user's voicemail" },
1413 { AST_REDIRECTING_REASON_USER_BUSY,
"user-busy" },
1414 { AST_REDIRECTING_REASON_NO_ANSWER,
"no-answer" },
1415 { AST_REDIRECTING_REASON_UNCONDITIONAL,
"unconditional" },
1416 { AST_REDIRECTING_REASON_TIME_OF_DAY,
"time-of-day" },
1417 { AST_REDIRECTING_REASON_DO_NOT_DISTURB,
"do-not-disturb" },
1418 { AST_REDIRECTING_REASON_FOLLOW_ME,
"follow-me" },
1419 { AST_REDIRECTING_REASON_OUT_OF_ORDER,
"out-of-service" },
1427 for (index = 0; index < ARRAY_LEN(redirecting_reason_types); ++index) {
1428 if (!strcasecmp(redirecting_reason_types[index].name, data)) {
1429 return redirecting_reason_types[index].value;
1440 for (index = 0; index < ARRAY_LEN(redirecting_reason_types); ++index) {
1441 if (redirecting_reason_types[index].value == data) {
1442 return redirecting_reason_types[index].description ?:
"Redirecting reason alias-bug";
1453 if (!ast_strlen_zero(data->
str)) {
1458 for (index = 0; index < ARRAY_LEN(redirecting_reason_types); ++index) {
1459 if (redirecting_reason_types[index].value == data->
code) {
1460 return redirecting_reason_types[index].name;
1483 for (index = 0; index < ARRAY_LEN(connected_line_source_types); ++index) {
1484 if (!strcasecmp(connected_line_source_types[index].name, data)) {
1485 return connected_line_source_types[index].value;
1496 for (index = 0; index < ARRAY_LEN(connected_line_source_types); ++index) {
1497 if (connected_line_source_types[index].value == data) {
1498 return connected_line_source_types[index].description;
1509 for (index = 0; index < ARRAY_LEN(connected_line_source_types); ++index) {
1510 if (connected_line_source_types[index].value == data) {
1511 return connected_line_source_types[index].name;
1521 { AST_PARTY_CHAR_SET_UNKNOWN,
"unknown",
"Unknown" },
1522 { AST_PARTY_CHAR_SET_ISO8859_1,
"iso8859-1",
"ISO8859-1" },
1523 { AST_PARTY_CHAR_SET_WITHDRAWN,
"withdrawn",
"Withdrawn" },
1524 { AST_PARTY_CHAR_SET_ISO8859_2,
"iso8859-2",
"ISO8859-2" },
1525 { AST_PARTY_CHAR_SET_ISO8859_3,
"iso8859-3",
"ISO8859-3" },
1526 { AST_PARTY_CHAR_SET_ISO8859_4,
"iso8859-4",
"ISO8859-4" },
1527 { AST_PARTY_CHAR_SET_ISO8859_5,
"iso8859-5",
"ISO8859-5" },
1528 { AST_PARTY_CHAR_SET_ISO8859_7,
"iso8859-7",
"ISO8859-7" },
1529 { AST_PARTY_CHAR_SET_ISO10646_BMPSTRING,
"bmp",
"ISO10646 Bmp String" },
1530 { AST_PARTY_CHAR_SET_ISO10646_UTF_8STRING,
"utf8",
"ISO10646 UTF-8 String" },
1538 for (index = 0; index < ARRAY_LEN(party_name_charset_tbl); ++index) {
1539 if (!strcasecmp(party_name_charset_tbl[index].name, data)) {
1540 return party_name_charset_tbl[index].value;
1551 for (index = 0; index < ARRAY_LEN(party_name_charset_tbl); ++index) {
1552 if (party_name_charset_tbl[index].value == data) {
1553 return party_name_charset_tbl[index].description;
1564 for (index = 0; index < ARRAY_LEN(party_name_charset_tbl); ++index) {
1565 if (party_name_charset_tbl[index].value == data) {
1566 return party_name_charset_tbl[index].name;
A-Law to Signed linear conversion.
int callerid_generate(unsigned char *buf, const char *number, const char *name, int flags, int callwaiting, struct ast_format *codec)
Generates a CallerID FSK stream in ulaw format suitable for transmission.
void callerid_get_dtmf(char *cidstring, char *number, int *flags)
Get and parse DTMF-based callerid.
static int ast_is_valid_string(const char *exten, const char *valid)
Checks if phone number consists of valid characters.
static const struct ast_value_translation pres_types[]
Translation table for Caller ID Presentation settings.
Asterisk main include file. File version handling, generic pbx functions.
const char * ast_describe_caller_presentation(int data)
Convert caller ID pres value to explanatory string.
const char * ast_redirecting_reason_name(const struct ast_party_redirecting_reason *data)
Convert redirecting reason value to text code.
CallerID (and other GR30) management and generation Includes code and algorithms from the Zapata libr...
Time-related functions and macros.
int ast_callerid_callwaiting_full_generate(unsigned char *buf, const char *name, const char *number, const char *ddn, int redirecting, int pres, int qualifier, struct ast_format *codec)
Generate Caller-ID spill but in a format suitable for Call Waiting(tm)'s Caller*ID(tm) ...
struct ast_tm * ast_localtime(const struct timeval *timep, struct ast_tm *p_tm, const char *zone)
Timezone-independent version of localtime_r(3).
int ast_callerid_vmwi_generate(unsigned char *buf, int active, int type, struct ast_format *codec, const char *name, const char *number, int flags)
Generate message waiting indicator.
void callerid_get(struct callerid_state *cid, char **name, char **number, int *flags)
Extract info out of callerID state machine. Flags are listed above.
struct timeval ast_tvnow(void)
Returns current timeval. Meant to replace calls to gettimeofday().
#define CID_MWI_TYPE_MDMF_FULL
int ast_gen_cas(unsigned char *outbuf, int sendsas, int len, struct ast_format *codec)
Generate a CAS (CPE Alert Signal) tone for 'n' samples.
int callerid_full_generate(unsigned char *buf, const char *number, const char *name, const char *ddn, int redirecting, int flags, int format, int callwaiting, struct ast_format *codec)
Generates a CallerID FSK stream in ulaw format suitable for transmission.
int callerid_full_tz_generate(unsigned char *buf, const char *number, const char *name, const char *ddn, int redirecting, int flags, int format, int callwaiting, struct ast_format *codec, const char *tz)
Generates a CallerID FSK stream in ulaw format suitable for transmission.
int code
enum AST_REDIRECTING_REASON value for redirection
int ast_callerid_full_generate(unsigned char *buf, const char *name, const char *number, const char *ddn, int redirecting, int pres, int qualifier, int format, struct ast_format *codec)
Generate Caller-ID spill from the "callerid" field of asterisk (in e-mail address like format) ...
void callerid_free(struct callerid_state *cid)
This function frees callerid_state cid.
void callerid_init(void)
Initialize stuff for inverse FFT.
char * ast_strip_quoted(char *s, const char *beg_quotes, const char *end_quotes)
Strip leading/trailing whitespace and quotes from a string.
int ast_callerid_callwaiting_full_tz_generate(unsigned char *buf, const char *name, const char *number, const char *ddn, int redirecting, int pres, int qualifier, struct ast_format *codec, const char *tz)
Generate Caller-ID spill but in a format suitable for Call Waiting(tm)'s Caller*ID(tm) ...
u-Law to Signed linear conversion
General Asterisk PBX channel definitions.
const char * ast_redirecting_reason_describe(int data)
Convert redirecting reason value to explanatory string.
#define ast_strdupa(s)
duplicate a string in memory from the stack
int ast_is_shrinkable_phonenumber(const char *exten)
Check if a string consists only of digits and + # ( ) - . (meaning it can be cleaned with ast_shrink_...
void ast_unescape_quoted(char *quote_str)
Unescape quotes in a string.
char * ast_strip(char *s)
Strip leading/trailing whitespace from a string.
Asterisk internal frame definitions.
static const struct ast_value_translation connected_line_source_types[]
Translation table for connected line update source settings.
#define ast_debug(level,...)
Log a DEBUG message.
int ast_party_name_charset_parse(const char *data)
Convert ast_party_name.char_set text code to value (used in config file parsing)
#define ast_alloca(size)
call __builtin_alloca to ensure we get gcc builtin semantics
int callerid_feed_jp(struct callerid_state *cid, unsigned char *ubuf, int len, struct ast_format *codec)
Read samples into the state machine.
Redirecting reason information.
int ast_parse_caller_presentation(const char *data)
Convert caller ID text code to value (used in config file parsing)
static const struct ast_value_translation party_name_charset_tbl[]
Translation table for ast_party_name char-set settings.
int ast_connected_line_source_parse(const char *data)
Convert connected line update source text code to value (used in config file parsing) ...
char * str
a string value for the redirecting reason
void ast_shrink_phone_number(char *n)
Clean up phone string.
#define ast_calloc(num, len)
A wrapper for calloc()
char * ast_escape_quoted(const char *string, char *outbuf, int buflen)
Escape characters found in a quoted string.
const char * ast_connected_line_source_name(int data)
Convert connected line update source value to text code.
int callerid_feed(struct callerid_state *cid, unsigned char *ubuf, int len, struct ast_format *codec)
Read samples into the state machine.
static const struct ast_value_translation redirecting_reason_types[]
Translation table for redirecting reason settings.
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
const char * ast_party_name_charset_describe(int data)
Convert ast_party_name.char_set value to explanatory string.
int ast_callerid_callwaiting_generate(unsigned char *buf, const char *name, const char *number, struct ast_format *codec)
Generate Caller-ID spill but in a format suitable for Call Waiting(tm)'s Caller*ID(tm) ...
#define CID_MWI_TYPE_MDMF
int ast_isphonenumber(const char *n)
Check if a string consists only of digits and + #.
void callerid_get_with_redirecting(struct callerid_state *cid, char **name, char **number, int *flags, int *redirecting)
Extract info out of callerID state machine. Flags are listed above.
struct callerid_state * callerid_new(int cid_signalling)
Create a callerID state machine.
const char * ast_party_name_charset_str(int data)
Convert ast_party_name.char_set value to text code.
int ast_callerid_parse(char *input_str, char **name, char **location)
Destructively parse inbuf into name and location (or number)
int fsk_serial(fsk_data *fskd, short *buffer, int *len, int *outbyte)
Retrieve a serial byte into outbyte. Buffer is a pointer into a series of shorts and len records the ...
int ast_callerid_full_tz_generate(unsigned char *buf, const char *name, const char *number, const char *ddn, int redirecting, int pres, int qualifier, int format, struct ast_format *codec, const char *tz)
Generate Caller-ID spill from the "callerid" field of asterisk (in e-mail address like format) ...
int ast_redirecting_reason_parse(const char *data)
Convert redirecting reason text code to value (used in config file parsing)
int ast_callerid_generate(unsigned char *buf, const char *name, const char *number, struct ast_format *codec)
Generate Caller-ID spill from the "callerid" field of asterisk (in e-mail address like format) ...
const char * ast_connected_line_source_describe(int data)
Convert connected line update source value to explanatory string.
const char * ast_named_caller_presentation(int data)
Convert caller ID pres value to text code.