Add revk's SMS application (bug #1437). Thanks!

git-svn-id: http://svn.digium.com/svn/asterisk/trunk@2805 f38db490-d61c-443f-a65b-d21fe96a405b

1 files changed, 1227 insertions, 0 deletions

diff --git a/apps/app_sms.c b/apps/app_sms.c
new file mode 100755
index 000000000..8b6d0cb44
--- /dev/null
+++ b/apps/app_sms.c
@@ -0,0 +1,1227 @@
+/*
+ * Asterisk -- A telephony toolkit for Linux.
+ *
+ * SMS application - ETSI ES 201 912 protocol 1 implimentation
+ * 
+ * Copyright (C) 2004, Adrian Kennard, rights assigned to Digium
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License
+ */
+
+#include <asterisk/lock.h>
+#include <asterisk/file.h>
+#include <asterisk/logger.h>
+#include <asterisk/options.h>
+#include <asterisk/channel.h>
+#include <asterisk/pbx.h>
+#include <asterisk/module.h>
+#include <asterisk/callerid.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <ctype.h>
+
+#include <pthread.h>
+
+/* ToDo */
+/* When acting as SC and answering, should check for messages and send instead of sending EST as first packet */
+/* Add full VP support */
+/* Handle status report messages (generation and reception) */
+/* Log to show oa and da with no spaces to allow parsing */
+/* USC2 coding */
+
+static unsigned char message_ref;	/* arbitary message ref */
+
+static char *tdesc = "SMS/PSTN handler";
+
+static char *app = "SMS";
+
+static char *synopsis = "Communicates with SMS service centres and SMS capable analogue phones";
+
+static char *descrip =
+  "  SMS(name|[a][s]):  SMS handles exchange of SMS data with a call to/from SMS capabale\n"
+  "phone or SMS PSTN service centre. Can send and/or receive SMS messages.\n"
+  "Returns 0 if call handled correctly, or -1 if there were any problems.\n"
+  "Works to ETSI ES 201 912 compatible with BT SMS PSTN service in UK\n"
+  "Typical usage is to use to handle called from the SMS service centre CLI,\n"
+  "or to set up a call using 'outgoing' or manager interface to connect service centre to SMS()\n"
+  "name is the name of the queue used in /var/spool/asterisk/sms\n"
+  "Argument 'a' means answer, i.e. send initial FSK packet.\n"
+  "Argument 's' means act as service centre talking to a phone.\n"
+  "Messages are processed as per text file message queues.\n"
+  "Can also call as SMS(name|[s]|number|message) to queue a message.\n";
+
+static signed short wave[] =
+  { 0, 392, 782, 1167, 1545, 1913, 2270, 2612, 2939, 3247, 3536, 3802, 4045, 4263, 4455, 4619, 4755, 4862, 4938, 4985,
+  5000, 4985, 4938, 4862, 4755, 4619, 4455, 4263, 4045, 3802, 3536, 3247, 2939, 2612, 2270, 1913, 1545, 1167, 782, 392,
+  0, -392, -782, -1167,
+  -1545, -1913, -2270, -2612, -2939, -3247, -3536, -3802, -4045, -4263, -4455, -4619, -4755, -4862, -4938, -4985, -5000,
+  -4985, -4938, -4862,
+  -4755, -4619, -4455, -4263, -4045, -3802, -3536, -3247, -2939, -2612, -2270, -1913, -1545, -1167, -782, -392
+};
+
+STANDARD_LOCAL_USER;
+
+LOCAL_USER_DECL;
+
+/* SMS 7 bit character mapping */
+/* Note that some greek characters are simply coded as 191 (inverted question mark) as ISO-8859-1 does not do greek */
+/* Note 27 (escape) is to be displayed as a space as per GSM 03.38 */
+static unsigned char sms7to8[] = {
+  '@', 163, '$', 165, 232, 233, 249, 236, 242, 199, 10, 216, 248, 13, 197, 229,
+  191, '_', 191, 191, 191, 191, 191, 191, 191, 191, 191, ' ', 198, 230, 223, 201,
+  ' ', '!', '"', '#', 164, '%', '&', 39, '(', ')', '*', '+', ',', '-', '.', '/',
+  '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?',
+  161, 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
+  'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 196, 214, 209, 220, 167,
+  191, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
+  'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 228, 246, 241, 252, 224,
+};
+unsigned char sms8to7[256];
+
+typedef struct sms_s
+{
+  unsigned char hangup;		/* we are done... */
+  unsigned char smsc;		/* we are SMSC */
+  char queue[30];		/* queue name */
+  char oa[20];			/* originating address */
+  char da[20];			/* destination address */
+  time_t scts;			/* time stamp */
+  unsigned char pid;		/* protocol ID */
+  unsigned char dcs;		/* data coding scheme */
+  unsigned char mr;		/* message reference */
+  unsigned char udl;		/* user date length */
+  unsigned char srr:1;		/* Status Report request */
+  unsigned char rp:1;		/* Reply Path */
+  unsigned int vp;		/* validity period in minutes, 0 for not set */
+  unsigned char ud[160];	/* user data (message) */
+  unsigned char cli[20];	/* caller ID */
+  unsigned char ophase;		/* phase (0-79) for 0 and 1 frequencies (1300Hz and 2100Hz) */
+  unsigned char ophasep;	/* phase (0-79) for 1200 bps */
+  unsigned char obyte;		/* byte being sent */
+  unsigned int opause;		/* silent pause before sending (in sample periods) */
+  unsigned char obitp;		/* bit in byte */
+  unsigned char osync;		/* sync bits to send */
+  unsigned char obytep;		/* byte in data */
+  unsigned char obyten;		/* bytes in data */
+  unsigned char omsg[256];	/* data buffer (out) */
+  unsigned char imsg[200];	/* data buffer (in) */
+  signed long long ims0, imc0, ims1, imc1;	/* magnitude averages sin/cos 0/1 */
+  unsigned int idle;
+  unsigned short imag;		/* signal level */
+  unsigned char ips0, ips1, ipc0, ipc1;	/* phase sin/cos 0/1 */
+  unsigned char ibitl;		/* last bit */
+  unsigned char ibitc;		/* bit run length count */
+  unsigned char iphasep;	/* bit phase (0-79) for 1200 bps */
+  unsigned char ibitn;		/* bit number in byte being received */
+  unsigned char ibytev;		/* byte value being received */
+  unsigned char ibytep;		/* byte pointer in messafe */
+  unsigned char ibytec;		/* byte checksum for message */
+  unsigned char ierr;		/* error flag */
+  unsigned char ibith;		/* history of last bits */
+  unsigned char ibitt;		/* total of 1's in last 3 bites */
+  /* more to go here */
+} sms_t;
+
+static void *
+sms_alloc (struct ast_channel *chan, void *params)
+{
+  return params;
+}
+
+static void
+sms_release (struct ast_channel *chan, void *data)
+{
+  return;
+}
+
+static void sms_messagetx (sms_t * h);
+
+/* copy number, skipping non digits apart from leading + */
+static void
+numcpy (char *d, char *s)
+{
+  if (*s == '+')
+    *d++ = *s++;
+  while (*s)
+    {
+      if (isdigit (*s))
+	*d++ = *s;
+      s++;
+    }
+  *d = 0;
+}
+
+static char *
+isodate (time_t t)
+{				/* static, return a date/time in ISO format */
+  static char date[20];
+  strftime (date, sizeof (date), "%Y-%m-%d %H:%M:%S", localtime (&t));
+  return date;
+}
+
+/* pack n bytes from i to o and return number of bytes */
+static unsigned char
+pack7 (unsigned char *o, unsigned char *i, unsigned char n)
+{
+  unsigned char p = 0, b = 0;
+  /* fixup - map character set perhaps... */
+  o[0] = 0;
+  while (n--)
+    {
+      o[p] |= ((sms8to7[*i] & 0x7F) << b);
+      b += 7;
+      if (b >= 8)
+	{
+	  b -= 8;
+	  p++;
+	  o[p] = ((sms8to7[*i] & 0x7F) >> (7 - b));
+	}
+      i++;
+    }
+  if (b)
+    p++;
+  return p;
+}
+
+/* check if all characters are valid 7 bit coding characters */
+static unsigned char
+check7 (unsigned char l, unsigned char *p)
+{
+  while (l--)
+    if (sms8to7[*p++] & 0x80)
+      return 1;
+  return 0;
+}
+
+/* pack a date and return */
+static void
+packdate (unsigned char *o, time_t w)
+{
+  struct tm *t = localtime (&w);
+  int z = timezone / 3600 / 15;
+  *o++ = ((t->tm_year % 10) << 4) + (t->tm_year % 100) / 10;
+  *o++ = (((t->tm_mon + 1) % 10) << 4) + (t->tm_mon + 1) / 10;
+  *o++ = ((t->tm_mday % 10) << 4) + t->tm_mday / 10;
+  *o++ = ((t->tm_hour % 10) << 4) + t->tm_hour / 10;
+  *o++ = ((t->tm_min % 10) << 4) + t->tm_min / 10;
+  *o++ = ((t->tm_sec % 10) << 4) + t->tm_sec / 10;
+  if (z < 0)
+    *o++ = (((-z) % 10) << 4) + (-z) / 10 + 0x08;
+  else
+    *o++ = ((z % 10) << 4) + z / 10;
+}
+
+/* unpack a date and return */
+static time_t
+unpackdate (unsigned char *i)
+{
+  struct tm t;
+  t.tm_year = 100 + (i[0] & 0xF) * 10 + (i[0] >> 4);
+  t.tm_mon = (i[1] & 0xF) * 10 + (i[1] >> 4) - 1;
+  t.tm_mday = (i[2] & 0xF) * 10 + (i[2] >> 4);
+  t.tm_hour = (i[3] & 0xF) * 10 + (i[3] >> 4);
+  t.tm_min = (i[4] & 0xF) * 10 + (i[4] >> 4);
+  t.tm_sec = (i[5] & 0xF) * 10 + (i[5] >> 4);
+  t.tm_isdst = 0;
+  if (i[6] & 0x08)
+    t.tm_min += 15 * ((i[6] & 0x7) * 10 + (i[6] >> 4));
+  else
+    t.tm_min -= 15 * ((i[6] & 0x7) * 10 + (i[6] >> 4));
+  return mktime (&t);
+}
+
+/* unpack bytes from i to o and return number of source bytes. */
+static unsigned char
+unpack7 (unsigned char *o, unsigned char *i, unsigned char l)
+{
+  unsigned char b = 0, p = 0;
+  while (l--)
+    {
+      if (b < 2)
+	*o++ = sms7to8[((i[p] >> b) & 0x7F)];
+      else
+	*o++ = sms7to8[((((i[p] >> b) + (i[p + 1] << (8 - b)))) & 0x7F)];
+      b += 7;
+      if (b >= 8)
+	{
+	  b -= 8;
+	  p++;
+	}
+    }
+  if (b)
+    p++;
+  return p;
+}
+
+/* unpack an address from i, return byte length, unpack to o */
+static unsigned char
+unpackaddress (char *o, unsigned char *i)
+{
+  unsigned char l = i[0], p;
+  if (i[1] == 0x91)
+    *o++ = '+';
+  for (p = 0; p < l; p++)
+    {
+      if (p & 1)
+	*o++ = (i[2 + p / 2] >> 4) + '0';
+      else
+	*o++ = (i[2 + p / 2] & 0xF) + '0';
+    }
+  *o = 0;
+  return (l + 5) / 2;
+}
+
+/* store an address at o, and return number of bytes used */
+static unsigned char
+packaddress (unsigned char *o, char *i)
+{
+  unsigned char p = 2;
+  o[0] = 0;
+  if (*i == '+')
+    {
+      i++;
+      o[1] = 0x91;
+    }
+  else
+    o[1] = 0x81;
+  while (*i)
+    if (isdigit (*i))
+      {
+	if (o[0] & 1)
+	  o[p++] |= ((*i & 0xF) << 4);
+	else
+	  o[p] = (*i & 0xF);
+	o[0]++;
+	i++;
+      }
+    else
+      i++;
+  if (o[0] & 1)
+    o[p++] |= 0xF0;		/* pad */
+  return p;
+}
+
+static void
+sms_log (sms_t * h, char status)
+{				/* log the output, and remove file */
+  if (*h->oa || *h->da)
+    {
+      int o = open ("/var/log/asterisk/sms", O_CREAT | O_APPEND | O_WRONLY, 0666);
+      if (o >= 0)
+	{
+	  char line[1000], *p;
+	  unsigned char n;
+	  sprintf (line, "%s %c %s %s %s ", isodate (time (0)), status, h->queue, *h->oa ? h->oa : "-",
+		   *h->da ? h->da : "-");
+	  p = line + strlen (line);
+	  for (n = 0; n < h->udl; n++)
+	    if (h->ud[n] == '\\')
+	      {
+		*p++ = '\\';
+		*p++ = '\\';
+	      }
+	    else if (h->ud[n] == '\n')
+	      {
+		*p++ = '\\';
+		*p++ = 'n';
+	      }
+	    else if (h->ud[n] == '\r')
+	      {
+		*p++ = '\\';
+		*p++ = 'r';
+	      }
+	    else if (h->ud[n] < 32 || h->ud[n] == 127)
+	      *p++ = 191;
+	    else
+	      *p++ = h->ud[n];
+	  *p++ = '\n';
+	  *p = 0;
+	  write (o, line, strlen (line));
+	  close (o);
+	}
+      *h->oa = *h->da = h->udl = 0;
+    }
+}
+
+/* parse and delete a file */
+static void
+sms_readfile (sms_t * h, char *fn)
+{
+  char line[1000];
+  FILE *s;
+  char dcsset = 0;		/* if DSC set */
+  ast_log (LOG_EVENT, "Sending %s\n", fn);
+  h->udl = *h->oa = *h->da = h->pid = h->srr = h->rp = h->vp = 0;
+  h->dcs = 0xF1;		/* normal messages class 1 */
+  h->scts = time (0);
+  h->mr = message_ref++;
+  s = fopen (fn, "r");
+  if (s)
+    {
+      if (unlink (fn))
+	{			/* concurrent access, we lost */
+	  fclose (s);
+	  return;
+	}
+      while (fgets (line, sizeof (line), s))
+	{			/* process line in file */
+	  char *p;
+	  for (p = line; *p && *p != '\n' && *p != '\r'; p++);
+	  *p = 0;		/* strip eoln */
+	  //ast_log (LOG_EVENT, "Line %s\n", line);
+	  p = line;
+	  if (!*p || *p == ';')
+	    continue;		/* blank line or comment, ignore */
+	  while (isalnum (*p))
+	    {
+	      *p = tolower (*p);
+	      p++;
+	    }
+	  while (isspace (*p))
+	    *p++ = 0;
+	  if (*p == '=')
+	    {
+	      *p++ = 0;
+	      if (!strcmp (line, "ud"))
+		{		/* parse message */
+		  unsigned char o = 0;
+		  while (*p && o < 160)
+		    {
+		      if (*p == '\\')
+			{
+			  p++;
+			  if (*p == '\\')
+			    h->ud[o++] = *p++;
+			  else if (*p == 'n')
+			    {
+			      h->ud[o++] = '\n';
+			      p++;
+			    }
+			  else if (*p == 'r')
+			    {
+			      h->ud[o++] = '\r';
+			      p++;
+			    }
+			}
+		      else
+			h->ud[o++] = *p++;
+		    }
+		  h->udl = o;
+		  if (*p)
+		    ast_log (LOG_WARNING, "UD too long in %s\n", fn);
+		}
+	      else
+		{
+		  while (isspace (*p))
+		    p++;
+		  if (!strcmp (line, "oa") && strlen (p) < sizeof (h->oa))
+		    numcpy (h->oa, p);
+		  else if (!strcmp (line, "da") && strlen (p) < sizeof (h->oa))
+		    numcpy (h->da, p);
+		  else if (!strcmp (line, "pid"))
+		    h->pid = atoi (p);
+		  else if (!strcmp (line, "dcs"))
+		    {
+		      h->dcs = atoi (p);
+		      dcsset = 1;
+		    }
+		  else if (!strcmp (line, "mr"))
+		    h->mr = atoi (p);
+		  else if (!strcmp (line, "srr"))
+		    h->srr = (atoi (p) ? 1 : 0);
+		  else if (!strcmp (line, "vp"))
+		    h->vp = atoi (p);
+		  else if (!strcmp (line, "rp"))
+		    h->rp = (atoi (p) ? 1 : 0);
+		  else if (!strcmp (line, "scts"))
+		    {		/* get date/time */
+		      int Y, m, d, H, M, S;
+		      if (sscanf (p, "%d-%d-%d %d:%d:%d", &Y, &m, &d, &H, &M, &S) == 6)
+			{
+			  struct tm t;
+			  t.tm_year = Y - 1900;
+			  t.tm_mon = m - 1;
+			  t.tm_mday = d;
+			  t.tm_hour = H;
+			  t.tm_min = M;
+			  t.tm_sec = S;
+			  t.tm_isdst = -1;
+			  h->scts = mktime (&t);
+			  if (h->scts == (time_t) - 1)
+			    ast_log (LOG_WARNING, "Bad date/timein %s: %s", fn, p);
+			}
+		    }
+		  else
+		    ast_log (LOG_WARNING, "Cannot parse in %s: %s=%si\n", fn, line, p);
+		}
+	    }
+	  else if (*p == '#')
+	    {			/* raw hex format */
+	      *p++ = 0;
+	      if (!strcmp (line, "ud"))
+		{
+		  unsigned char o = 0;
+		  while (*p && o < 160)
+		    {
+		      if (isxdigit (*p) && isxdigit (p[1]))
+			{
+			  h->ud[o] =
+			    (((isalpha (*p) ? 9 : 0) + (*p & 0xF)) << 4) + ((isalpha (p[1]) ? 9 : 0) + (p[1] & 0xF));
+			  o++;
+			  p += 2;
+			}
+		      else
+			break;
+		    }
+		  h->udl = o;
+		  if (*p)
+		    ast_log (LOG_WARNING, "UD too long / invalid hex in %s\n", fn);
+		}
+	      else
+		ast_log (LOG_WARNING, "Only ud can use 8 bit key format with # instead of =\n");
+	    }
+	  else
+	    ast_log (LOG_WARNING, "Cannot parse in %s: %s\n", fn, line);
+	}
+      fclose (s);
+      if (!dcsset && h->udl <= 140 && check7 (h->udl, h->ud))
+	{
+	  h->dcs = 0xF5;	// default to 8 bit
+	  ast_log (LOG_WARNING, "Sending in 8 bit format because of illegal characters %s\n", fn);
+	}
+      if ((h->dcs & 4) && h->udl > 140)
+	{
+	  ast_log (LOG_WARNING, "8 bit data too long, truncated %s\n", fn);
+	  h->udl = 140;
+	}
+      else if (!(h->dcs & 4) && check7 (h->udl, h->ud))
+	ast_log (LOG_WARNING, "Invalid 7 bit GSM data %s\n", fn);
+    }
+  //ast_log (LOG_EVENT, "Loaded %s\n", fn);
+}
+
+/* white a received text message to a file */
+static void
+sms_writefile (sms_t * h)
+{
+  char fn[200], fn2[200];
+  FILE *o;
+  strcpy (fn, "/var/spool/asterisk/sms");
+  mkdir (fn, 0777);		/* ensure it exists */
+  sprintf (fn + strlen (fn), "/%s.%s", h->smsc ? "me-sc" : "sc-me", h->queue);
+  mkdir (fn, 0777);		/* ensure it exists */
+  strcpy (fn2, fn);
+  strftime (fn2 + strlen (fn2), 30, "/%Y-%m-%d_%H:%M:%S", localtime (&h->scts));
+  sprintf (fn2 + strlen (fn2), "-%02X", h->mr);
+  sprintf (fn + strlen (fn), "/.%s", fn2 + strlen (fn) + 1);
+  o = fopen (fn, "w");
+  if (o)
+    {
+      fprintf (o, "mr=%d\n", h->mr);
+      if (*h->oa)
+	fprintf (o, "oa=%s\n", h->oa);
+      if (*h->da)
+	fprintf (o, "da=%s\n", h->da);
+      if (h->pid)
+	fprintf (o, "pid=%d\n", h->pid);
+      if (h->dcs != 0xF1)
+	fprintf (o, "dcs=%d\n", h->dcs);
+      if (h->vp)
+	fprintf (o, "srr=%d\n", h->vp);
+      if (h->srr)
+	fprintf (o, "srr=1\n");
+      if (h->rp)
+	fprintf (o, "rp=1\n");
+      if (h->scts)
+	fprintf (o, "scts=%s\n", isodate (h->scts));
+      if (h->udl)
+	{
+	  unsigned int p;
+	  for (p = 0; p < h->udl && ((h->ud[p] >= 32 && h->ud[p] != 127) || h->ud[p] == '\n' || h->ud[p] == '\r'); p++);
+	  if (p < h->udl)
+	    {			// use a hex format as unprintable characters
+	      fprintf (o, "ud#");
+	      for (p = 0; p < h->udl; p++)
+		fprintf (o, "%02X", h->ud[p]);
+	      fprintf (o, "\n;");
+	      /* followed by commented line using printable characters */
+	    }
+	  fprintf (o, "ud=");
+	  for (p = 0; p < h->udl; p++)
+	    {
+	      if (h->ud[p] == '\\')
+		fprintf (o, "\\\\");
+	      else if (h->ud[p] == '\r')
+		fprintf (o, "\\r");
+	      else if (h->ud[p] == '\n')
+		fprintf (o, "\\n");
+	      else if (h->ud[p] < 32 || h->ud[p] == 127)
+		fputc (191, o);
+	      else
+		fputc (h->ud[p], o);
+	    }
+	  fprintf (o, "\n");
+	}
+      fclose (o);
+      if (rename (fn, fn2))
+	unlink (fn);
+      else
+	ast_log (LOG_EVENT, "Received to %s\n", fn2);
+    }
+}
+
+/* read dir skipping dot files... */
+static struct dirent *
+readdirdot (DIR * d)
+{
+  struct dirent *f;
+  do
+    {
+      f = readdir (d);
+    }
+  while (f && *f->d_name == '.');
+  return f;
+}
+
+/* handle the incoming message */
+static unsigned char
+sms_handleincoming (sms_t * h)
+{
+  unsigned char p = 3;
+  if (h->smsc)
+    {				/* SMSC */
+      if ((h->imsg[2] & 3) == 1)
+	{			/* SMS-SUBMIT */
+	  h->vp = 0;
+	  h->srr = ((h->imsg[2] & 0x20) ? 1 : 0);
+	  h->rp = ((h->imsg[2] & 0x80) ? 1 : 0);
+	  strcpy (h->oa, h->cli);
+	  h->scts = time (0);
+	  h->mr = h->imsg[p++];
+	  p += unpackaddress (h->da, h->imsg + p);
+	  h->pid = h->imsg[p++];
+	  h->dcs = h->imsg[p++];
+	  if ((h->imsg[2] & 0x18) == 0x10)
+	    {			/* relative VP */
+	      if (h->imsg[p] < 144)
+		h->vp = (h->imsg[p] + 1) * 5;
+	      else if (h->imsg[p] < 168)
+		h->vp = 720 + (h->imsg[p] - 143) * 30;
+	      else if (h->imsg[p] < 197)
+		h->vp = (h->imsg[p] - 166) * 1440;
+	      else
+		h->vp = (h->imsg[p] - 192) * 10080;
+	      p++;
+	    }
+	  else if (h->imsg[2] & 0x18)
+	    p += 7;		/* ignore enhanced / absolute VP */
+	  h->udl = h->imsg[p++];
+	  if (h->udl)
+	    {
+	      if (h->dcs & 4)
+		{
+		  memcpy (h->ud, h->imsg + p, h->udl);
+		  p += h->udl;
+		}
+	      else
+		p += unpack7 (h->ud, h->imsg + p, h->udl);
+	    }
+	  sms_writefile (h);	/* write the file */
+	  if (p != h->imsg[1] + 2)
+	    return 0xFF;	/* duh! */
+	}
+      else
+	{
+	  ast_log (LOG_WARNING, "Unknown message type %02X\n", h->imsg[2]);
+	  return 0xFF;
+	}
+    }
+  else
+    {				/* client */
+      if (!(h->imsg[2] & 3))
+	{			/* SMS-DELIVER */
+	  *h->da = h->srr = h->rp = h->vp = 0;
+	  h->mr = message_ref++;
+	  p += unpackaddress (h->oa, h->imsg + p);
+	  h->pid = h->imsg[p++];
+	  h->dcs = h->imsg[p++];
+	  h->scts = unpackdate (h->imsg + p);
+	  p += 7;
+	  h->udl = h->imsg[p++];
+	  if (h->udl)
+	    {
+	      if (h->dcs & 4)
+		{
+		  memcpy (h->ud, h->imsg + p, h->udl);
+		  p += h->udl;
+		}
+	      else
+		p += unpack7 (h->ud, h->imsg + p, h->udl);
+	    }
+	  sms_writefile (h);	/* write the file */
+	  if (p != h->imsg[1] + 2)
+	    return 0xFF;	/* duh! */
+	}
+      else
+	{
+	  ast_log (LOG_WARNING, "Unknown message type %02X\n", h->imsg[2]);
+	  return 0xFF;
+	}
+    }
+  return 0;			/* no error */
+}
+
+static void
+sms_nextoutgoing (sms_t * h)
+{				/* find and fill in next message, or send a REL if none waiting */
+  char fn[100 + NAME_MAX];
+  DIR *d;
+  char more = 0;
+  strcpy (fn, "/var/spool/asterisk/sms");
+  mkdir (fn, 0777);		/* ensure it exists */
+  sprintf (fn + strlen (fn), "/%s.%s", h->smsc ? "sc-me" : "me-sc", h->queue);
+  mkdir (fn, 0777);		/* ensure it exists */
+  d = opendir (fn);
+  if (d)
+    {
+      struct dirent *f = readdirdot (d);
+      if (f)
+	{
+	  sprintf (fn + strlen (fn), "/%s", f->d_name);
+	  sms_readfile (h, fn);
+	  if (readdirdot (d))
+	    more = 1;		/* more to send */
+	}
+      closedir (d);
+    }
+  if (*h->da || *h->oa)
+    {				/* message to send */
+      unsigned char p = 2;
+      h->omsg[0] = 0x91;	/* SMS_DATA */
+      if (h->smsc)
+	{			/* deliver */
+	  h->omsg[p++] = (more ? 4 : 0);
+	  p += packaddress (h->omsg + p, h->oa);
+	  h->omsg[p++] = h->pid;
+	  h->omsg[p++] = h->dcs;
+	  packdate (h->omsg + p, h->scts);
+	  p += 7;
+	  h->omsg[p++] = h->udl;
+	  if (h->udl)
+	    {
+	      if (h->dcs & 4)
+		{
+		  memcpy (h->omsg + p, h->ud, h->udl);
+		  p += h->udl;
+		}
+	      else
+		p += pack7 (h->omsg + p, h->ud, h->udl);
+	    }
+	}
+      else
+	{			/* submit */
+	  h->omsg[p++] = 0x01 + (more ? 4 : 0) + (h->srr ? 0x20 : 0) + (h->rp ? 0x80 : 0) + (h->vp ? 0x10 : 0);
+	  h->omsg[p++] = h->mr;
+	  p += packaddress (h->omsg + p, h->da);
+	  h->omsg[p++] = h->pid;
+	  h->omsg[p++] = h->dcs;
+	  if (h->vp)
+	    {			/* relative VP */
+	      if (h->vp < 720)
+		h->omsg[p++] = (h->vp + 4) / 5 - 1;
+	      else if (h->vp < 1440)
+		h->omsg[p++] = (h->vp - 720 + 29) / 30 + 143;
+	      else if (h->vp < 43200)
+		h->omsg[p++] = (h->vp + 1439) / 1440 + 166;
+	      else if (h->vp < 635040)
+		h->omsg[p++] = (h->vp + 10079) / 10080 + 192;
+	      else
+		h->omsg[p++] = 255;	/* max */
+	    }
+	  h->omsg[p++] = h->udl;
+	  if (h->udl)
+	    {
+	      if (h->dcs & 4)
+		{
+		  memcpy (h->omsg + p, h->ud, h->udl);
+		  p += h->udl;
+		}
+	      else
+		p += pack7 (h->omsg + p, h->ud, h->udl);
+	    }
+	}
+      h->omsg[1] = p - 2;
+      sms_messagetx (h);
+    }
+  else
+    {				/* no message */
+      h->omsg[0] = 0x94;	/* SMS_REL */
+      h->omsg[1] = 0;
+      sms_messagetx (h);
+    }
+}
+
+static void
+sms_messagerx (sms_t * h)
+{
+  ast_verbose (VERBOSE_PREFIX_3 "SMS RX %02X %02X %02X %02X %02X %02X...\n", h->imsg[0], h->imsg[1], h->imsg[2],
+	       h->imsg[3], h->imsg[4], h->imsg[5]);
+  /* testing */
+  switch (h->imsg[0])
+    {
+    case 0x91:			/* SMS_DATA */
+      {
+	unsigned char cause = sms_handleincoming (h);
+	if (!cause)
+	  {
+	    sms_log (h, 'Y');
+	    h->omsg[0] = 0x95;	/* SMS_ACK */
+	    h->omsg[1] = 0x02;
+	    h->omsg[2] = 0x00;	/* deliver report */
+	    h->omsg[3] = 0x00;	/* no parameters */
+	  }
+	else
+	  {			/* NACK */
+	    sms_log (h, 'N');
+	    h->omsg[0] = 0x96;	/* SMS_NACK */
+	    h->omsg[1] = 3;
+	    h->omsg[2] = 0;	/* delivery report */
+	    h->omsg[3] = cause;	/* cause */
+	    h->omsg[4] = 0;	/* no parameters */
+	  }
+	sms_messagetx (h);
+      }
+      break;
+    case 0x92:			/* SMS_ERROR */
+      sms_messagetx (h);	/* send whatever we sent again */
+      break;
+    case 0x93:			/* SMS_EST */
+      sms_nextoutgoing (h);
+      break;
+    case 0x94:			/* SMS_REL */
+      h->hangup = 1;		/* hangup */
+      break;
+    case 0x95:			/* SMS_ACK */
+      sms_log (h, 'Y');
+      sms_nextoutgoing (h);
+      break;
+    case 0x96:			/* SMS_NACK */
+      sms_log (h, 'N');
+      sms_nextoutgoing (h);
+      break;
+    default:			/* Unknown */
+      h->omsg[0] = 0x92;	/* SMS_ERROR */
+      h->omsg[1] = 1;
+      h->omsg[2] = 3;		/* unknown message type; */
+      sms_messagetx (h);
+      break;
+    }
+}
+
+static void
+sms_messagetx (sms_t * h)
+{
+  unsigned char c = 0, p;
+  for (p = 0; p < h->omsg[1] + 2; p++)
+    c += h->omsg[p];
+  h->omsg[h->omsg[1] + 2] = 0 - c;
+  ast_verbose (VERBOSE_PREFIX_3 "SMS TX %02X %02X %02X %02X %02X %02X...\n", h->omsg[0], h->omsg[1], h->omsg[2],
+	       h->omsg[3], h->omsg[4], h->omsg[5]);
+  h->obyte = 1;
+  h->opause = 200;
+  if (h->omsg[0] == 0x93)
+    h->opause = 2400;		/* initial message delay 300ms (for BT) */
+  h->obytep = 0;
+  h->obitp = 0;
+  h->osync = 80;
+  h->obyten = h->omsg[1] + 3;
+}
+
+
+static int
+sms_generate (struct ast_channel *chan, void *data, int len, int samples)
+{
+  struct ast_frame f;
+  unsigned char waste[AST_FRIENDLY_OFFSET];
+  signed short buf[800];
+  sms_t *h = data;
+  int i;
+
+  if (len > sizeof (buf))
+    {
+      ast_log (LOG_WARNING, "Only doing %d bytes (%d bytes requested)\n", sizeof (buf) / sizeof (signed short), len);
+      len = sizeof (buf);
+      samples = len / 2;
+    }
+  waste[0] = 0;			/* make compiler happy */
+  f.frametype = AST_FRAME_VOICE;
+  f.subclass = AST_FORMAT_SLINEAR;
+  f.offset = AST_FRIENDLY_OFFSET;
+  f.mallocd = 0;
+  f.data = buf;
+  f.datalen = samples * 2;
+  f.samples = samples;
+  f.src = "app_sms";
+  /* create a buffer containing the digital sms pattern */
+  for (i = 0; i < samples; i++)
+    {
+      buf[i] = 0;
+      if (h->opause)
+	h->opause--;
+      else if (h->obyten || h->osync)
+	{			/* sending data */
+	  buf[i] = wave[h->ophase];
+	  if ((h->ophase += ((h->obyte & 1) ? 13 : 21)) >= 80)
+	    h->ophase -= 80;
+	  if ((h->ophasep += 12) >= 80)
+	    {			/* next bit */
+	      h->ophasep -= 80;
+	      if (h->osync)
+		h->osync--;	/* sending sync bits */
+	      else
+		{
+		  h->obyte >>= 1;
+		  h->obitp++;
+		  if (h->obitp == 1)
+		    h->obyte = 0;	/* start bit; */
+		  else if (h->obitp == 2)
+		    h->obyte = h->omsg[h->obytep];
+		  else if (h->obitp == 10)
+		    {
+		      h->obyte = 1;	/* stop bit */
+		      h->obitp = 0;
+		      h->obytep++;
+		      if (h->obytep == h->obyten)
+			{
+			  h->obytep = h->obyten = 0;	/* sent */
+			  h->osync = 10;	/* trailing marks */
+			}
+		    }
+		}
+	    }
+	}
+    }
+  if (ast_write (chan, &f) < 0)
+    {
+      ast_log (LOG_WARNING, "Failed to write frame to '%s': %s\n", chan->name, strerror (errno));
+      return -1;
+    }
+  return 0;
+}
+
+static void
+sms_process (sms_t * h, int samples, signed short *data)
+{
+  if (h->obyten || h->osync)
+    return;			/* sending */
+  while (samples--)
+    {
+      unsigned long long m0, m1;
+      if (abs (*data) > h->imag)
+	h->imag = abs (*data);
+      else
+	h->imag = h->imag * 7 / 8;
+      if (h->imag > 500)
+	{
+	  h->ims0 = (h->ims0 * 6 + *data * wave[h->ips0]) / 7;
+	  h->idle = 0;
+	  h->imc0 = (h->imc0 * 6 + *data * wave[h->ipc0]) / 7;
+	  h->ims1 = (h->ims1 * 6 + *data * wave[h->ips1]) / 7;
+	  h->imc1 = (h->imc1 * 6 + *data * wave[h->ipc1]) / 7;
+	  m0 = h->ims0 * h->ims0 + h->imc0 * h->imc0;
+	  m1 = h->ims1 * h->ims1 + h->imc1 * h->imc1;
+	  if ((h->ips0 += 21) >= 80)
+	    h->ips0 -= 80;
+	  if ((h->ipc0 += 21) >= 80)
+	    h->ipc0 -= 80;
+	  if ((h->ips1 += 13) >= 80)
+	    h->ips1 -= 80;
+	  if ((h->ipc1 += 13) >= 80)
+	    h->ipc1 -= 80;
+	  {
+	    char bit;
+	    h->ibith <<= 1;
+	    if (m1 > m0)
+	      h->ibith |= 1;
+	    if (h->ibith & 8)
+	      h->ibitt--;
+	    if (h->ibith & 1)
+	      h->ibitt++;
+	    bit = ((h->ibitt > 1) ? 1 : 0);
+	    if (bit != h->ibitl)
+	      h->ibitc = 1;
+	    else
+	      h->ibitc++;
+	    h->ibitl = bit;
+	    if (!h->ibitn && h->ibitc == 4 && !bit)
+	      {
+		h->ibitn = 1;
+		h->iphasep = 0;
+	      }
+	    if (bit && h->ibitc == 200)
+	      {			/* sync, restart message */
+		h->ierr = h->ibitn = h->ibytep = h->ibytec = 0;
+	      }
+	    if (h->ibitn)
+	      {
+		h->iphasep += 12;
+		if (h->iphasep >= 80)
+		  {		/* next bit */
+		    h->iphasep -= 80;
+		    if (h->ibitn++ == 9)
+		      {		/* end of byte */
+			if (!bit)	/* bad stop bit */
+			  h->ierr = 0xFF;	/* unknown error */
+			else
+			  {
+			    if (h->ibytep < sizeof (h->imsg))
+			      {
+				h->imsg[h->ibytep] = h->ibytev;
+				h->ibytec += h->ibytev;
+				h->ibytep++;
+			      }
+			    else if (h->ibytep == sizeof (h->imsg))
+			      h->ierr = 2;	/* bad message length */
+			    if (h->ibytep > 1 && h->ibytep == 3 + h->imsg[1] && !h->ierr)
+			      {
+				if (!h->ibytec)
+				  sms_messagerx (h);
+				else
+				  h->ierr = 1;	/* bad checksum */
+			      }
+			  }
+			h->ibitn = 0;
+		      }
+		    h->ibytev = (h->ibytev >> 1) + (bit ? 0x80 : 0);
+		  }
+	      }
+	  }
+	}
+      else
+	{			/* lost carrier */
+	  if (h->idle++ == 80000)
+	    {			/* nothing happening */
+	      ast_log (LOG_EVENT, "No data, hanging up\n");
+	      h->hangup = 1;
+	    }
+	  if (h->ierr)
+	    {			/* error */
+	      h->omsg[0] = 0x92;	/* error */
+	      h->omsg[1] = 1;
+	      h->omsg[2] = h->ierr;
+	      sms_messagetx (h);	/* send error */
+	    }
+	  h->ierr = h->ibitn = h->ibytep = h->ibytec = 0;
+	}
+      data++;
+    }
+}
+
+static struct ast_generator smsgen = {
+alloc:sms_alloc,
+release:sms_release,
+generate:sms_generate,
+};
+
+static int
+sms_exec (struct ast_channel *chan, void *data)
+{
+  int res = -1;
+  struct localuser *u;
+  struct ast_frame *f;
+  sms_t h = { 0 };
+  h.ipc0 = h.ipc1 = 20;		/* phase for cosine */
+  h.dcs = 0xF1;			/* default */
+  if (!data)
+    {
+      ast_log (LOG_ERROR, "Requires queue name at least\n");
+      return -1;
+    }
+
+  if (chan->callerid)
+    {				/* get caller ID. Used as originating address on sc side receives */
+      char temp[256], *name, *num;
+      strncpy (temp, chan->callerid, sizeof (temp));
+      ast_callerid_parse (temp, &name, &num);
+      if (!num)
+	num = temp;
+      ast_shrink_phone_number (num);
+      if (strlen (num) < sizeof (h.cli))
+	strcpy (h.cli, num);
+    }
+
+  {
+    char *d = data, *p, answer = 0;
+    if (!*d || *d == '|')
+      {
+	ast_log (LOG_ERROR, "Requires queue name\n");
+	return -1;
+      }
+    for (p = d; *p && *p != '|'; p++);
+    if (p - d >= sizeof (h.queue))
+      {
+	ast_log (LOG_ERROR, "Queue name too long\n");
+	return -1;
+      }
+    strncpy (h.queue, d, p - d);
+    if (*p == '|')
+      p++;
+    d = p;
+    for (p = h.queue; *p; p++)
+      if (!isalnum (*p))
+	*p = '-';		/* make very safe for filenames */
+    while (*d && *d != '|')
+      {
+	switch (*d)
+	  {
+	  case 'a':		/* we have to send the initial FSK sequence */
+	    answer = 1;
+	    break;
+	  case 's':		/* we are acting as a service centre talking to a phone */
+	    h.smsc = 1;
+	    break;
+	    /* the following apply if there is an arg3/4 and apply to the created message file */
+	  case 'r':
+	    h.srr = 1;
+	    break;
+	  case 'o':
+	    h.dcs |= 4;		/* octets */
+	    break;
+	  case '1':
+	  case '2':
+	  case '3':
+	  case '4':
+	  case '5':
+	  case '6':
+	  case '7':		/* set the pid for saved local message */
+	    h.pid = 0x40 + (*d & 0xF);
+	    break;
+	  }
+	d++;
+      }
+    if (*d == '|')
+      {				/* submitting a message, not taking call. */
+	d++;
+	h.scts = time (0);
+	for (p = d; *p && *p != '|'; p++);
+	if (*p)
+	  *p++ = 0;
+	if (strlen (d) >= sizeof (h.oa))
+	  {
+	    ast_log (LOG_ERROR, "Address too long %s\n", d);
+	    return 0;
+	  }
+	strcpy (h.smsc ? h.oa : h.da, d);
+	if (!h.smsc)
+	  strcpy (h.oa, h.cli);
+	d = p;
+	if (!(h.dcs & 4) && check7 (h.udl, h.ud))
+	  ast_log (LOG_WARNING, "Invalid GSM characters in %.*s\n", h.udl, h.ud);
+	if (strlen (d) > ((h.dcs & 4) ? 140 : 160))
+	  {
+	    ast_log (LOG_ERROR, "Message too long %s\n", d);
+	    h.udl = ((h.dcs & 4) ? 140 : 160);
+	  }
+	else
+	  h.udl = strlen (d);
+	if (h.udl)
+	  memcpy (h.ud, d, h.udl);
+	h.smsc = !h.smsc;	/* file woul go in wrong directory otherwise... */
+	sms_writefile (&h);
+	return 0;
+      }
+
+    if (answer)
+      {				/* set up SMS_EST initial message */
+	h.omsg[0] = 0x93;
+	h.omsg[1] = 0;
+	sms_messagetx (&h);
+      }
+  }
+
+  LOCAL_USER_ADD (u);
+  if (chan->_state != AST_STATE_UP)
+    ast_answer (chan);
+
+  res = ast_set_write_format (chan, AST_FORMAT_SLINEAR);
+  if (res >= 0)
+    res = ast_set_read_format (chan, AST_FORMAT_SLINEAR);
+  if (res < 0)
+    {
+      LOCAL_USER_REMOVE (u);
+      ast_log (LOG_ERROR, "Unable to set to linear mode, giving up\n");
+      return -1;
+    }
+
+  if (ast_activate_generator (chan, &smsgen, &h) < 0)
+    {
+      LOCAL_USER_REMOVE (u);
+      ast_log (LOG_ERROR, "Failed to activate generator on '%s'\n", chan->name);
+      return -1;
+    }
+
+  /* Do our thing here */
+  while (ast_waitfor (chan, -1) > -1 && !h.hangup)
+    {
+      f = ast_read (chan);
+      if (!f)
+	break;
+      if (f->frametype == AST_FRAME_VOICE)
+	{
+	  sms_process (&h, f->samples, f->data);
+	}
+
+      ast_frfree (f);
+    }
+
+  sms_log (&h, '?');		/* log incomplete message */
+
+  LOCAL_USER_REMOVE (u);
+  return h.hangup;
+}
+
+int
+unload_module (void)
+{
+  STANDARD_HANGUP_LOCALUSERS;
+  return ast_unregister_application (app);
+}
+
+int
+load_module (void)
+{
+  {				/* fill in sms8to7 from sms7to8 */
+    int p;
+    for (p = 0; p < 256; p++)
+      sms8to7[p] = 0xE0;	/* inverted question mark and invalid */
+    for (p = 0; p < 128; p++)
+      sms8to7[sms7to8[p]] = p;
+  }
+  return ast_register_application (app, sms_exec, synopsis, descrip);
+}
+
+char *
+description (void)
+{
+  return tdesc;
+}
+
+int
+usecount (void)
+{
+  int res;
+  STANDARD_USECOUNT (res);
+  return res;
+}
+
+char *
+key ()
+{
+  return ASTERISK_GPL_KEY;
+}