![markster](/assets/img/avatar_default.png)
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@256 f38db490-d61c-443f-a65b-d21fe96a405b
475 lines
11 KiB
C
Executable file
475 lines
11 KiB
C
Executable file
/*
|
|
* Asterisk -- A telephony toolkit for Linux.
|
|
*
|
|
* CallerID Generation support
|
|
*
|
|
* Copyright (C) 2001, Linux Support Services, Inc.
|
|
*
|
|
* Mark Spencer <markster@linux-support.net>
|
|
*
|
|
* This program is free software, distributed under the terms of
|
|
* the GNU General Public License.
|
|
*
|
|
* Includes code and algorithms from the Zapata library.
|
|
*
|
|
*/
|
|
|
|
#include <time.h>
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <math.h>
|
|
#include <asterisk/ulaw.h>
|
|
#include <asterisk/callerid.h>
|
|
#include <asterisk/logger.h>
|
|
#include <asterisk/fskmodem.h>
|
|
|
|
|
|
struct callerid_state {
|
|
fsk_data fskd;
|
|
char rawdata[256];
|
|
short oldstuff[160];
|
|
int oldlen;
|
|
int pos;
|
|
int type;
|
|
int cksum;
|
|
char name[64];
|
|
char number[64];
|
|
int flags;
|
|
int sawflag;
|
|
int len;
|
|
};
|
|
|
|
static float dr[4], di[4];
|
|
static float clidsb = 8000.0 / 1200.0;
|
|
|
|
#define CALLERID_SPACE 2200.0 /* 2200 hz for "0" */
|
|
#define CALLERID_MARK 1200.0 /* 1200 hz for "1" */
|
|
|
|
void callerid_init(void)
|
|
{
|
|
/* Initialize stuff for inverse FFT */
|
|
dr[0] = cos(CALLERID_SPACE * 2.0 * M_PI / 8000.0);
|
|
di[0] = sin(CALLERID_SPACE * 2.0 * M_PI / 8000.0);
|
|
dr[1] = cos(CALLERID_MARK * 2.0 * M_PI / 8000.0);
|
|
di[1] = sin(CALLERID_MARK * 2.0 * M_PI / 8000.0);
|
|
}
|
|
|
|
struct callerid_state *callerid_new(void)
|
|
{
|
|
struct callerid_state *cid;
|
|
cid = malloc(sizeof(struct callerid_state));
|
|
memset(cid, 0, sizeof(*cid));
|
|
if (cid) {
|
|
cid->fskd.spb = 7; /* 1200 baud */
|
|
cid->fskd.hdlc = 0; /* Async */
|
|
cid->fskd.nbit = 8; /* 8 bits */
|
|
cid->fskd.nstop = 1; /* 1 stop bit */
|
|
cid->fskd.paridad = 0; /* No parity */
|
|
cid->fskd.bw=1; /* Filter 800 Hz */
|
|
cid->fskd.f_mark_idx = 2; /* 1200 Hz */
|
|
cid->fskd.f_space_idx = 3; /* 2200 Hz */
|
|
cid->fskd.pcola = 0; /* No clue */
|
|
cid->fskd.cont = 0; /* Digital PLL reset */
|
|
cid->fskd.x0 = 0.0;
|
|
cid->fskd.state = 0;
|
|
memset(cid->name, 0, sizeof(cid->name));
|
|
memset(cid->number, 0, sizeof(cid->number));
|
|
cid->flags = CID_UNKNOWN_NAME | CID_UNKNOWN_NUMBER;
|
|
cid->pos = 0;
|
|
} else
|
|
ast_log(LOG_WARNING, "Out of memory\n");
|
|
return cid;
|
|
}
|
|
|
|
void callerid_get(struct callerid_state *cid, char **name, char **number, int *flags)
|
|
{
|
|
*flags = cid->flags;
|
|
if (cid->flags & (CID_UNKNOWN_NAME | CID_PRIVATE_NUMBER))
|
|
*name = NULL;
|
|
else
|
|
*name = cid->name;
|
|
if (cid->flags & (CID_UNKNOWN_NUMBER | CID_PRIVATE_NUMBER))
|
|
*number = NULL;
|
|
else
|
|
*number = cid->number;
|
|
}
|
|
|
|
int callerid_feed(struct callerid_state *cid, unsigned char *ubuf, int len)
|
|
{
|
|
int mylen = len;
|
|
int olen;
|
|
int b = 'X';
|
|
int res;
|
|
int x;
|
|
short *buf = malloc(2 * len + cid->oldlen);
|
|
short *obuf = buf;
|
|
if (!buf) {
|
|
ast_log(LOG_WARNING, "Out of memory\n");
|
|
return -1;
|
|
}
|
|
memset(buf, 0, 2 * len + cid->oldlen);
|
|
memcpy(buf, cid->oldstuff, cid->oldlen);
|
|
mylen += cid->oldlen/2;
|
|
for (x=0;x<len;x++)
|
|
buf[x+cid->oldlen/2] = ast_mulaw[ubuf[x]];
|
|
while(mylen >= 80) {
|
|
olen = mylen;
|
|
res = fsk_serie(&cid->fskd, buf, &mylen, &b);
|
|
buf += (olen - mylen);
|
|
if (res < 0) {
|
|
ast_log(LOG_NOTICE, "fsk_serie failed\n");
|
|
return -1;
|
|
}
|
|
if (res == 1) {
|
|
/* Ignore invalid bytes */
|
|
if (b > 0xff)
|
|
continue;
|
|
switch(cid->sawflag) {
|
|
case 0: /* Look for flag */
|
|
if (b == 'U')
|
|
cid->sawflag = 2;
|
|
break;
|
|
case 2: /* Get lead-in */
|
|
if ((b == 0x04) || (b == 0x80)) {
|
|
cid->type = b;
|
|
cid->sawflag = 3;
|
|
cid->cksum = b;
|
|
}
|
|
break;
|
|
case 3: /* Get length */
|
|
/* Not a lead in. We're ready */
|
|
cid->sawflag = 4;
|
|
cid->len = b;
|
|
cid->pos = 0;
|
|
cid->cksum += b;
|
|
break;
|
|
case 4: /* Retrieve message */
|
|
if (cid->pos >= 128) {
|
|
ast_log(LOG_WARNING, "Caller ID too long???\n");
|
|
return -1;
|
|
}
|
|
cid->rawdata[cid->pos++] = b;
|
|
cid->len--;
|
|
cid->cksum += b;
|
|
if (!cid->len) {
|
|
cid->rawdata[cid->pos] = '\0';
|
|
cid->sawflag = 5;
|
|
}
|
|
break;
|
|
case 5: /* Check checksum */
|
|
if (b != (256 - (cid->cksum & 0xff))) {
|
|
ast_log(LOG_NOTICE, "Caller*ID failed checksum\n");
|
|
/* Try again */
|
|
cid->sawflag = 0;
|
|
break;
|
|
}
|
|
|
|
strcpy(cid->number, "");
|
|
strcpy(cid->name, "");
|
|
/* If we get this far we're fine. */
|
|
if (cid->type == 0x80) {
|
|
/* MDMF */
|
|
/* Go through each element and process */
|
|
for (x=0;x< cid->pos;) {
|
|
switch(cid->rawdata[x++]) {
|
|
case 1:
|
|
/* Date */
|
|
break;
|
|
case 2: /* Number */
|
|
case 4: /* Number */
|
|
res = cid->rawdata[x];
|
|
if (res > 32) {
|
|
ast_log(LOG_NOTICE, "Truncating long caller ID number from %d bytes to 32\n", cid->rawdata[x]);
|
|
res = 32;
|
|
}
|
|
memcpy(cid->number, cid->rawdata + x + 1, res);
|
|
/* Null terminate */
|
|
cid->number[res] = '\0';
|
|
break;
|
|
case 7: /* Name */
|
|
case 8: /* Name */
|
|
res = cid->rawdata[x];
|
|
if (res > 32) {
|
|
ast_log(LOG_NOTICE, "Truncating long caller ID name from %d bytes to 32\n", cid->rawdata[x]);
|
|
res = 32;
|
|
}
|
|
memcpy(cid->name, cid->rawdata + x + 1, res);
|
|
cid->name[res] = '\0';
|
|
break;
|
|
default:
|
|
ast_log(LOG_NOTICE, "Unknown IE %d\n", cid->rawdata[x-1]);
|
|
}
|
|
x += cid->rawdata[x];
|
|
x++;
|
|
}
|
|
} else {
|
|
/* SDMF */
|
|
strncpy(cid->number, cid->rawdata + 8, sizeof(cid->number));
|
|
}
|
|
/* Update flags */
|
|
cid->flags = 0;
|
|
if (!strcmp(cid->number, "P")) {
|
|
strcpy(cid->number, "");
|
|
cid->flags |= CID_PRIVATE_NUMBER;
|
|
} else if (!strcmp(cid->number, "O") || !strlen(cid->number)) {
|
|
strcpy(cid->number, "");
|
|
cid->flags |= CID_UNKNOWN_NUMBER;
|
|
}
|
|
if (!strcmp(cid->name, "P")) {
|
|
strcpy(cid->name, "");
|
|
cid->flags |= CID_PRIVATE_NAME;
|
|
} else if (!strcmp(cid->name, "O") || !strlen(cid->name)) {
|
|
strcpy(cid->name, "");
|
|
cid->flags |= CID_UNKNOWN_NAME;
|
|
}
|
|
return 1;
|
|
break;
|
|
default:
|
|
ast_log(LOG_ERROR, "Dunno what to do with a digit in sawflag %d\n", cid->sawflag);
|
|
}
|
|
}
|
|
}
|
|
if (mylen) {
|
|
memcpy(cid->oldstuff, buf, mylen * 2);
|
|
cid->oldlen = mylen * 2;
|
|
}
|
|
free(obuf);
|
|
return 0;
|
|
}
|
|
|
|
void callerid_free(struct callerid_state *cid)
|
|
{
|
|
free(cid);
|
|
}
|
|
|
|
static void callerid_genmsg(char *msg, int size, char *number, char *name, int flags)
|
|
{
|
|
time_t t;
|
|
struct tm *tm;
|
|
char *ptr;
|
|
int res;
|
|
int i,x;
|
|
/* Get the time */
|
|
time(&t);
|
|
tm = localtime(&t);
|
|
|
|
ptr = msg;
|
|
|
|
/* Format time and message header */
|
|
res = snprintf(ptr, size, "\001\010%02d%02d%02d%02d", tm->tm_mon + 1,
|
|
tm->tm_mday, tm->tm_hour, tm->tm_min);
|
|
size -= res;
|
|
ptr += res;
|
|
if (!number || !strlen(number) || (flags & CID_UNKNOWN_NUMBER)) {
|
|
/* Indicate number not known */
|
|
res = snprintf(ptr, size, "\004\001O");
|
|
size -= res;
|
|
ptr += res;
|
|
} else if (flags & CID_PRIVATE_NUMBER) {
|
|
/* Indicate number is private */
|
|
res = snprintf(ptr, size, "\004\001P");
|
|
size -= res;
|
|
ptr += res;
|
|
} else {
|
|
/* Send up to 10 digits of number MAX */
|
|
i = strlen(number);
|
|
if (i > 10) i = 10;
|
|
res = snprintf(ptr, size, "\002%c", i);
|
|
size -= res;
|
|
ptr += res;
|
|
for (x=0;x<i;x++)
|
|
ptr[x] = number[x];
|
|
ptr[i] = '\0';
|
|
ptr += i;
|
|
size -= i;
|
|
}
|
|
|
|
if (!name || !strlen(name) || (flags & CID_UNKNOWN_NAME)) {
|
|
/* Indicate name not known */
|
|
res = snprintf(ptr, size, "\010\001O");
|
|
size -= res;
|
|
ptr += res;
|
|
} else if (flags & CID_PRIVATE_NAME) {
|
|
/* Indicate name is private */
|
|
res = snprintf(ptr, size, "\010\001P");
|
|
size -= res;
|
|
ptr += res;
|
|
} else {
|
|
/* Send up to 10 digits of number MAX */
|
|
i = strlen(name);
|
|
if (i > 16) i = 16;
|
|
res = snprintf(ptr, size, "\007%c", i);
|
|
size -= res;
|
|
ptr += res;
|
|
for (x=0;x<i;x++)
|
|
ptr[x] = name[x];
|
|
ptr[i] = '\0';
|
|
ptr += i;
|
|
size -= i;
|
|
}
|
|
|
|
}
|
|
|
|
static inline float callerid_getcarrier(float *cr, float *ci, int bit)
|
|
{
|
|
/* Move along. There's nothing to see here... */
|
|
float t;
|
|
t = *cr * dr[bit] - *ci * di[bit];
|
|
*ci = *cr * di[bit] + *ci * dr[bit];
|
|
*cr = t;
|
|
|
|
t = 2.0 - (*cr * *cr + *ci * *ci);
|
|
*cr *= t;
|
|
*ci *= t;
|
|
return *cr;
|
|
}
|
|
|
|
#define PUT_BYTE(a) do { \
|
|
*(buf++) = (a); \
|
|
bytes++; \
|
|
} while(0)
|
|
|
|
#define PUT_AUDIO_SAMPLE(y) do { \
|
|
int index = (short)(rint(8192.0 * (y))); \
|
|
*(buf++) = ast_lin2mu[index + 32768]; \
|
|
bytes++; \
|
|
} while(0)
|
|
|
|
#define PUT_CLID_MARKMS do { \
|
|
int x; \
|
|
for (x=0;x<8;x++) \
|
|
PUT_AUDIO_SAMPLE(callerid_getcarrier(&cr, &ci, 1)); \
|
|
} while(0)
|
|
|
|
#define PUT_CLID_BAUD(bit) do { \
|
|
while(scont < clidsb) { \
|
|
PUT_AUDIO_SAMPLE(callerid_getcarrier(&cr, &ci, bit)); \
|
|
scont += 1.0; \
|
|
} \
|
|
scont -= clidsb; \
|
|
} while(0)
|
|
|
|
|
|
#define PUT_CLID(byte) do { \
|
|
int z; \
|
|
unsigned char b = (byte); \
|
|
PUT_CLID_BAUD(0); /* Start bit */ \
|
|
for (z=0;z<8;z++) { \
|
|
PUT_CLID_BAUD(b & 1); \
|
|
b >>= 1; \
|
|
} \
|
|
PUT_CLID_BAUD(1); /* Stop bit */ \
|
|
} while(0);
|
|
|
|
int callerid_generate(unsigned char *buf, char *number, char *name, int flags)
|
|
{
|
|
int bytes=0;
|
|
int x, sum;
|
|
/* Initial carriers (real/imaginary) */
|
|
float cr = 1.0;
|
|
float ci = 0.0;
|
|
float scont = 0.0;
|
|
char msg[256];
|
|
callerid_genmsg(msg, sizeof(msg), number, name, flags);
|
|
for (x=0;x<4000;x++)
|
|
PUT_BYTE(0x7f);
|
|
/* Transmit 30 0x55's (looks like a square wave */
|
|
for (x=0;x<30;x++)
|
|
PUT_CLID(0x55);
|
|
/* Send 150ms of callerid marks */
|
|
for (x=0;x<150;x++)
|
|
PUT_CLID_MARKMS;
|
|
/* Send 0x80 indicating MDMF format */
|
|
PUT_CLID(0x80);
|
|
/* Put length of whole message */
|
|
PUT_CLID(strlen(msg));
|
|
sum = 0x80 + strlen(msg);
|
|
/* Put each character of message and update checksum */
|
|
for (x=0;x<strlen(msg); x++) {
|
|
PUT_CLID(msg[x]);
|
|
sum += msg[x];
|
|
}
|
|
/* Send 2's compliment of sum */
|
|
PUT_CLID(256 - (sum & 255));
|
|
/* Send 50 more ms of marks */
|
|
for (x=0;x<50;x++)
|
|
PUT_CLID_MARKMS;
|
|
|
|
return bytes;
|
|
}
|
|
|
|
void ast_shrink_phone_number(char *n)
|
|
{
|
|
int x,y=0;
|
|
for (x=0;n[x];x++)
|
|
if (!strchr("( )-.", n[x]))
|
|
n[y++] = n[x];
|
|
n[y] = '\0';
|
|
}
|
|
|
|
int ast_isphonenumber(char *n)
|
|
{
|
|
int x;
|
|
for (x=0;n[x];x++)
|
|
if (!strchr("0123456789", n[x]))
|
|
return 0;
|
|
return 1;
|
|
}
|
|
|
|
int ast_callerid_parse(char *instr, char **name, char **location)
|
|
{
|
|
char *ns, *ne;
|
|
char *ls, *le;
|
|
/* Try for "name" <location> format or
|
|
name <location> format */
|
|
if ((ls = strchr(instr, '<')) && (le = strchr(ls, '>'))) {
|
|
/* Found the location */
|
|
*le = '\0';
|
|
*ls = '\0';
|
|
*location = ls + 1;
|
|
if ((ns = strchr(instr, '\"')) && (ne = strchr(ns + 1, '\"'))) {
|
|
/* Get name out of quotes */
|
|
*ns = '\0';
|
|
*ne = '\0';
|
|
*name = ns + 1;
|
|
return 0;
|
|
} else {
|
|
/* Just trim off any trailing spaces */
|
|
*name = instr;
|
|
while(strlen(instr) && (instr[strlen(instr) - 1] < 33))
|
|
instr[strlen(instr) - 1] = '\0';
|
|
/* And leading spaces */
|
|
while(**name && (**name < 33))
|
|
name++;
|
|
return 0;
|
|
}
|
|
} else {
|
|
/* Assume it's just a location */
|
|
*name = NULL;
|
|
*location = instr;
|
|
return 0;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
int ast_callerid_generate(unsigned char *buf, char *callerid)
|
|
{
|
|
char tmp[256];
|
|
char *n, *l;
|
|
if (!callerid)
|
|
return callerid_generate(buf, NULL, NULL, 0);
|
|
strncpy(tmp, callerid, sizeof(tmp));
|
|
if (ast_callerid_parse(tmp, &n, &l)) {
|
|
ast_log(LOG_WARNING, "Unable to parse '%s' into CallerID name & number\n", callerid);
|
|
return callerid_generate(buf, NULL, NULL, 0);
|
|
}
|
|
ast_shrink_phone_number(l);
|
|
if (!n && (!ast_isphonenumber(l)))
|
|
return callerid_generate(buf, NULL, NULL, 0);
|
|
if (!ast_isphonenumber(l))
|
|
return callerid_generate(buf, NULL, n, 0);
|
|
return callerid_generate(buf, l, n, 0);
|
|
}
|