*** ./callerid.c.org	Thu Nov  2 22:55:39 2006
--- ./callerid.c	Tue Apr 17 00:11:01 2007
***************
*** 42,47 ****
--- 42,48 ----
  #include "asterisk/logger.h"
  #include "asterisk/fskmodem.h"
  #include "asterisk/utils.h"
+ #include "asterisk/options.h"
  
  struct callerid_state {
  	fsk_data fskd;
***************
*** 56,61 ****
--- 57,67 ----
  	int flags;
  	int sawflag;
  	int len;
+ 	/* for Japan */
+ 	int dleflag;
+ 	int jpflag;
+ 	unsigned short crc;
+ 	char dinumber[64];
  };
  
  
***************
*** 69,77 ****
  #define SAS_FREQ		 440.0
  #define CAS_FREQ1		2130.0
  #define CAS_FREQ2		2750.0
- 
  #define AST_CALLERID_UNKNOWN	"<unknown>"
  
  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)
  {
  	int x;
--- 75,143 ----
  #define SAS_FREQ		 440.0
  #define CAS_FREQ1		2130.0
  #define CAS_FREQ2		2750.0
  #define AST_CALLERID_UNKNOWN	"<unknown>"
  
+ /* for japanese number display */
+ /* CRC */
+ const unsigned short int crctab[] =
+ {
+  	// Polynominal = 0x1021 (X^16 + X^12 + X^5 + 1)
+  	0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
+  	0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
+  	0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
+  	0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
+  	0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
+  	0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
+ 	0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
+  	0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
+  	0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
+  	0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
+  	0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
+  	0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
+  	0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
+  	0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
+  	0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
+  	0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
+  	0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
+  	0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
+  	0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
+  	0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
+  	0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
+  	0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
+  	0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
+  	0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
+  	0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
+  	0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
+  	0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
+  	0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
+  	0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
+  	0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
+  	0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
+  	0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0,
+ };
+ 
+ unsigned short update_crc(unsigned short crc, unsigned char data) 
+ {
+  	unsigned char index;
+  	/* reverse msb..lsb */
+  	unsigned int i, a, b;
+  	a = data;
+  	b = 0;
+  	for (i=0; i<8; i++) {
+  		a <<= 1;
+  		b >>= 1;
+  		if (a & 0x100) {
+  			b |= 0x80;
+  		}
+  	}
+  	data = (unsigned char)b;
+  	/* update crc */
+ 	index = (unsigned char)(crc >> 8);
+ 	index ^= data;
+ 	crc = (crc << 8) ^ crctab[index];
+ 	return crc;
+ }
+ 
  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)
  {
  	int x;
***************
*** 136,142 ****
  		cid->fskd.nstop = 1;	/* 1 stop bit */
  		cid->fskd.paridad = 0;	/* No parity */
  		cid->fskd.bw=1;			/* Filter 800 Hz */
! 		if (cid_signalling == 2) { /* v23 signalling */
  			cid->fskd.f_mark_idx =  4;	/* 1300 Hz */
  			cid->fskd.f_space_idx = 5;	/* 2100 Hz */
  		} else { /* Bell 202 signalling as default */ 
--- 202,211 ----
  		cid->fskd.nstop = 1;	/* 1 stop bit */
  		cid->fskd.paridad = 0;	/* No parity */
  		cid->fskd.bw=1;			/* Filter 800 Hz */
! 		if (cid_signalling == CID_SIG_V23) { /* v23 signalling */
! 			cid->fskd.f_mark_idx =  4;	/* 1300 Hz */
! 			cid->fskd.f_space_idx = 5;	/* 2100 Hz */
! 		} else if (cid_signalling == CID_SIG_V23JP){ /* v23 japan */
  			cid->fskd.f_mark_idx =  4;	/* 1300 Hz */
  			cid->fskd.f_space_idx = 5;	/* 2100 Hz */
  		} else { /* Bell 202 signalling as default */ 
***************
*** 151,156 ****
--- 220,230 ----
  		memset(cid->number, 0, sizeof(cid->number));
  		cid->flags = CID_UNKNOWN_NAME | CID_UNKNOWN_NUMBER;
  		cid->pos = 0;
+ 		/* Japan */
+ 		cid->dleflag = 0;
+ 		cid->jpflag = 0;
+ 		cid->crc = 0;
+ 		memset(cid->dinumber,0,sizeof(cid->dinumber));
  	} else
  		ast_log(LOG_WARNING, "Out of memory\n");
  	return cid;
***************
*** 169,174 ****
--- 243,256 ----
  		*number = cid->number;
  }
  
+ void callerid_get_dinumber(struct callerid_state *cid, char **exten)
+ {
+ 	if (cid->dinumber[0] == 0 )
+ 		*exten = NULL;
+ 	else
+ 		*exten = cid->dinumber;
+ }
+ 
  void callerid_get_dtmf(char *cidstring, char *number, int *flags)
  {
  	int i;
***************
*** 412,417 ****
--- 494,770 ----
  	return 0;
  }
  
+ /* Japanese Number Display decoding */
+ int callerid_feed_jp(struct callerid_state *cid, unsigned char *ubuf, int len, int codec)
+ {
+ 	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_XLAW(ubuf[x]);
+ 	while(mylen >= 160) {
+ 		olen = mylen;
+ 		res = fsk_serie(&cid->fskd, buf, &mylen, &b);
+ 		if (mylen < 0) {
+ 			ast_log(LOG_ERROR, "fsk_serie made mylen < 0 (%d)\n", mylen);
+ 			return -1;
+ 		}
+ 		buf += (olen - mylen);
+ 		if (res < 0) {
+ 			ast_log(LOG_NOTICE, "fsk_serie failed\n");
+ 			return -1;
+ 		}
+ 		if (res == 1) {
+ 			/* for japanese number display */
+ 			/* crc */
+ 			if (cid->jpflag == 0)
+ 				cid->crc = 0;
+ 			if (cid->jpflag > 1) {
+ 				cid->crc = update_crc(cid->crc, (unsigned char)b);
+ /*
+ 				if(option_verbose > 2)
+ 					ast_verbose(VERBOSE_PREFIX_3 "JP (%02x,%02x CRC %04x) %d\n", b, b & 0x7f, cid->crc, cid->jpflag);
+ */
+ 			}
+ 			if (cid->jpflag > 5 && cid->jpflag < 7) {
+ 				/* parity check */
+ 				int b1 = b;
+ 				b1 = ((b1 & 0xf0) >> 4) ^ (b1 & 0x0f);
+ 				b1 = ((b1 & 0x0c) >> 2) ^ (b1 & 0x03);
+ 				b1 = ((b1 & 0x02) >> 1) ^ (b1 & 0x01);
+ 				if (b1 != 0) {
+ 					ast_log(LOG_WARNING, "Parity error\n");
+ 					return -1;
+ 				}
+ 				b &= 0x7f;
+ 				/* DLE escape sequence */
+ 				if (cid->dleflag == 0 && b == 0x10) {
+ 					cid->dleflag = 1;
+ 					continue;
+ 				}
+ 				if (cid->dleflag == 1) {
+ 					cid->dleflag = 0;
+ 					switch(b) {
+ 					case 1:
+ 					case 2:
+ 					case 3:
+ 					case 0x10:
+ 						break;
+ 					default:
+ 						ast_log(LOG_WARNING, "DLE escape sequence error %02xd\n", b);
+ 						return -1;
+ 					}
+ 				}
+ 			}
+ 			
+ 			/* Ignore invalid bytes */
+ 			if (b > 0xff)
+ 				continue;
+ 			switch(cid->sawflag) {
+ 			case 0: /* Look for flag */
+ 				if (b == 'U')
+ 					cid->sawflag = 2;
+ 				/* for japanese number display */
+ 				switch (cid->jpflag) {
+ 				case 0: if (b == 0x90) cid->jpflag++; break; /* DLE */
+ 				case 1: if (b == 0x81) cid->jpflag++; break; /* SOH */
+ 				case 2: if (b == 0x87) cid->jpflag++; break; /* header */
+ 				case 3: if (b == 0x90) cid->jpflag++; break; /* DLE */
+ 				case 4: if (b == 0x82) cid->jpflag++; break; /* STX */
+ 				case 5:
+ 					if (b == 0xc0) {                     /* info start */
+ 						cid->sawflag = 3;
+ 						cid->type    = 0x80; /* MDMF */
+ 						cid->jpflag++;
+ 					}
+ 					break;
+ 				}
+ 
+ 				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 */
+ 				/* for japanese number display */
+ 				if (cid->jpflag == 6) {
+ 					/* ETX */
+ 					if (b != 3) {
+ 						ast_log(LOG_WARNING, "Caller ID sequence error (%02x)\n", b);
+ 						return -1;
+ 					}
+ 					cid->jpflag++;
+ 					continue;
+ 				} else if (cid->jpflag == 7) {
+ 					/* crc 1st byte */
+ 					cid->jpflag++;
+ 					continue;
+ 				} else if (cid->jpflag == 8) {
+ 					/* crc 2nd byte */
+ 					if (cid->crc != 0) {
+ 						ast_log(LOG_WARNING, "Caller ID CRC error\n");
+ 						return -1;
+ 					}
+ 					if(option_verbose > 2)
+ 						ast_verbose(VERBOSE_PREFIX_3 "JP CRC OK\n");
+ 				} else
+ 
+ 				if (b != (256 - (cid->cksum & 0xff))) {
+ 					ast_log(LOG_NOTICE, "Caller*ID failed checksum\n");
+ 					/* Try again */
+ 					cid->sawflag = 0;
+ 					break;
+ 				}
+ 		
+ 				cid->number[0] = '\0';
+ 				cid->name[0] = '\0';
+ 				/* 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 3: /* Number (for Zebble) */
+ 						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; 
+ 							}
+ 							if (ast_strlen_zero(cid->number)) {
+ 								memcpy(cid->number, cid->rawdata + x + 1, res);
+ 								/* Null terminate */
+ 								cid->number[res] = '\0';
+ 							}
+ 							break;
+ 						case 6: /* Stentor Call Qualifier (ie. Long Distance call) */
+ 							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;
+ 						case 9:
+ 							/* for japanese number display */
+ 							if (res > 32) {
+ 								ast_log(LOG_NOTICE, "Truncating long Dial in number from %d bytes to 32\n", cid->rawdata[x]);
+ 								res = 32; 
+ 							}
+ 							if (ast_strlen_zero(cid->dinumber)) {
+ 								memcpy(cid->dinumber, cid->rawdata + x + 1, res);
+ 								/* Null terminate */
+ 								cid->dinumber[res] = '\0';
+ 							}
+ 							break;
+ 						case 17: /* UK: Call type, 1=Voice Call, 2=Ringback when free, 129=Message waiting  */
+ 						case 19: /* UK: Network message system status (Number of messages waiting) */
+ 						case 22: /* Something French */
+ 						case 33: /* for japanese number display */
+ 							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)-1);
+ 				}
+ 
+ 				/* for japanese number display */
+ 				if (cid->jpflag == 8) {
+ 					cid->flags = 0;
+ 					if (!strcmp(cid->number, "P")
+ 						|| !strcmp(cid->number, "O")
+ 						|| !strcmp(cid->number, "C")
+ 						|| !strcmp(cid->number, "S")
+ 						) {
+ 						/*snprintf(cid->name, sizeof(cid->name), "\"%s\"", cid->number);*/
+ 						strcpy(cid->name, cid->number);
+ 						strcpy(cid->number, "");
+ 						cid->flags |= CID_UNKNOWN_NUMBER;
+ 					}
+ 					return 1;
+ 				} 
+ 				
+ 				/* Update flags */
+ 				cid->flags = 0;
+ 				if (!strcmp(cid->number, "P")) {
+ 					strcpy(cid->number, "");
+ 					cid->flags |= CID_PRIVATE_NUMBER;
+ 				} else if (!strcmp(cid->number, "O") || ast_strlen_zero(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") || ast_strlen_zero(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;
+ 	} else
+ 		cid->oldlen = 0;
+ 	free(obuf);
+ 	return 0;
+ }
+ /* End of Japanese Number Display */
+ 
+ 
  void callerid_free(struct callerid_state *cid)
  {
  	free(cid);