Fixes numerous spelling errors. Patch submitted by alecdavis.
[asterisk/asterisk.git] / apps / app_sms.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2004 - 2005, Adrian Kennard, rights assigned to Digium
5  *
6  * See http://www.asterisk.org for more information about
7  * the Asterisk project. Please do not directly contact
8  * any of the maintainers of this project for assistance;
9  * the project provides a web site, mailing lists and IRC
10  * channels for your use.
11  *
12  * This program is free software, distributed under the terms of
13  * the GNU General Public License Version 2. See the LICENSE file
14  * at the top of the source tree.
15  */
16
17 /*! \file
18  *
19  * \brief SMS application - ETSI ES 201 912 protocol 1 implementation
20  * 
21  * \par Development notes
22  * \note The ETSI standards are available free of charge from ETSI at
23  *      http://pda.etsi.org/pda/queryform.asp
24  *      Among the relevant documents here we have:
25  *
26  *      ES 201 912      SMS for PSTN/ISDN
27  *      TS 123 040      Technical realization of SMS
28  *
29  * 
30  * \ingroup applications
31  *
32  * \author Adrian Kennard (for the original protocol 1 code)
33  * \author Filippo Grassilli (Hyppo) - protocol 2 support
34  *                 Not fully tested, under development
35  */
36
37 #include "asterisk.h"
38
39 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
40
41 #include <dirent.h>
42 #include <ctype.h>
43 #include <sys/stat.h>
44
45 #include "asterisk/paths.h"  /* use ast_config_AST_SPOOL_DIR and LOG_DIR */
46 #include "asterisk/lock.h"
47 #include "asterisk/file.h"
48 #include "asterisk/channel.h"
49 #include "asterisk/pbx.h"
50 #include "asterisk/module.h"
51 #include "asterisk/alaw.h"
52 #include "asterisk/callerid.h"
53 #include "asterisk/utils.h"
54 #include "asterisk/app.h"
55
56 /*** DOCUMENTATION
57         <application name="SMS" language="en_US">
58                 <synopsis>
59                         Communicates with SMS service centres and SMS capable analogue phones.
60                 </synopsis>
61                 <syntax>
62                         <parameter name="name" required="true">
63                                 <para>The name of the queue used in <filename>/var/spool/asterisk/sms</filename></para>
64                         </parameter>
65                         <parameter name="options">
66                                 <optionlist>
67                                         <option name="a">
68                                                 <para>Answer, i.e. send initial FSK packet.</para>
69                                         </option>
70                                         <option name="s">
71                                                 <para>Act as service centre talking to a phone.</para>
72                                         </option>
73                                         <option name="t">
74                                                 <para>Use protocol 2 (default used is protocol 1).</para>
75                                         </option>
76                                         <option name="p">
77                                                 <para>Set the initial delay to N ms (default is <literal>300</literal>).
78                                                 addr and body are a deprecated format to send messages out.</para>
79                                         </option>
80                                         <option name="r">
81                                                 <para>Set the Status Report Request (SRR) bit.</para>
82                                         </option>
83                                         <option name="o">
84                                                 <para>The body should be coded as octets not 7-bit symbols.</para>
85                                         </option>
86                                 </optionlist>
87                         </parameter>
88                         <parameter name="addr" />
89                         <parameter name="body" />
90                 </syntax>
91                 <description>
92                         <para>SMS handles exchange of SMS data with a call to/from SMS capable phone or SMS PSTN service center.
93                         Can send and/or receive SMS messages. Works to ETSI ES 201 912; compatible with BT SMS PSTN service in
94                         UK and Telecom Italia in Italy.</para>
95                         <para>Typical usage is to use to handle calls from the SMS service centre CLI, or to set up a call using
96                         <literal>outgoing</literal> or manager interface to connect service centre to SMS().</para>
97                         <para>"Messages are processed as per text file message queues. smsq (a separate software) is a command to
98                         generate message queues and send messages.</para>
99                         <note><para>The protocol has tight delay bounds. Please use short frames and disable/keep short the
100                         jitter buffer on the ATA to make sure that respones (ACK etc.) are received in time.</para></note>
101                 </description>
102         </application>
103  ***/
104
105 /* #define OUTALAW */        /* enable this to output Alaw rather than linear */
106
107 /* ToDo */
108 /* Add full VP support */
109 /* Handle status report messages (generation and reception) */
110 /* Time zones on time stamps */
111 /* user ref field */
112
113 static volatile unsigned char message_ref;  /* arbitary message ref */
114 static volatile unsigned int seq;           /* arbitrary message sequence number for unqiue files */
115
116 static char log_file[255];
117
118 static char *app = "SMS";
119
120 /*
121  * 80 samples of a single period of the wave. At 8000 Hz, it means these
122  * are the samples of a 100 Hz signal.
123  * To pick the two carriers (1300Hz for '1' and 2100 Hz for '0') used by
124  * the modulation, we should take one every 13 and 21 samples respectively.
125  */
126 static const signed short wave[] = {
127         0, 392, 782, 1167, 1545, 1913, 2270, 2612, 2939, 3247, 3536, 3802, 4045, 4263, 4455, 4619, 4755, 4862, 4938, 4985,
128         5000, 4985, 4938, 4862, 4755, 4619, 4455, 4263, 4045, 3802, 3536, 3247, 2939, 2612, 2270, 1913, 1545, 1167, 782, 392,
129         0, -392, -782, -1167,
130          -1545, -1913, -2270, -2612, -2939, -3247, -3536, -3802, -4045, -4263, -4455, -4619, -4755, -4862, -4938, -4985, -5000,
131         -4985, -4938, -4862,
132         -4755, -4619, -4455, -4263, -4045, -3802, -3536, -3247, -2939, -2612, -2270, -1913, -1545, -1167, -782, -392
133 };
134
135 #ifdef OUTALAW
136 static unsigned char wavea[80];
137 typedef unsigned char output_t;
138 static const output_t *wave_out = wavea;    /* outgoing samples */
139 #define __OUT_FMT AST_FORMAT_ALAW;
140 #else
141 typedef signed short output_t;
142 static const output_t *wave_out = wave;     /* outgoing samples */
143 #define __OUT_FMT AST_FORMAT_SLINEAR
144 #endif
145
146 #define OSYNC_BITS      80                      /* initial sync bits */
147
148 /*!
149  * The SMS spec ETSI ES 201 912 defines two protocols with different message types.
150  * Also note that the high bit is used to indicate whether the message
151  * is complete or not, but in two opposite ways:
152  * for Protocol 1, 0x80 means that the message is complete;
153  * for Protocol 2, 0x00 means that the message is complete;
154  */
155 enum message_types {
156         DLL_SMS_MASK        = 0x7f,             /* mask for the valid bits */
157
158         /* Protocol 1 values */
159         DLL1_SMS_DATA       = 0x11,             /* data packet */
160         DLL1_SMS_ERROR      = 0x12,
161         DLL1_SMS_EST        = 0x13,             /* start the connection */
162         DLL1_SMS_REL        = 0x14,             /* end the connection */
163         DLL1_SMS_ACK        = 0x15,
164         DLL1_SMS_NACK       = 0x16,
165
166         DLL1_SMS_COMPLETE   = 0x80,             /* packet is complete */
167         DLL1_SMS_MORE       = 0x00,             /* more data to follow */
168
169         /* Protocol 2 values */
170         DLL2_SMS_EST        = 0x7f,             /* magic number. No message body */
171         DLL2_SMS_INFO_MO    = 0x10,
172         DLL2_SMS_INFO_MT    = 0x11,
173         DLL2_SMS_INFO_STA   = 0x12,
174         DLL2_SMS_NACK       = 0x13,
175         DLL2_SMS_ACK0       = 0x14,             /* ack even-numbered frame */
176         DLL2_SMS_ACK1       = 0x15,             /* ack odd-numbered frame */
177         DLL2_SMS_ENQ        = 0x16,
178         DLL2_SMS_REL        = 0x17,             /* end the connection */
179
180         DLL2_SMS_COMPLETE   = 0x00,             /* packet is complete */
181         DLL2_SMS_MORE       = 0x80,             /* more data to follow */
182 };
183
184 /* SMS 7 bit character mapping to UCS-2 */
185 static const unsigned short defaultalphabet[] = {
186         0x0040, 0x00A3, 0x0024, 0x00A5, 0x00E8, 0x00E9, 0x00F9, 0x00EC,
187         0x00F2, 0x00E7, 0x000A, 0x00D8, 0x00F8, 0x000D, 0x00C5, 0x00E5,
188         0x0394, 0x005F, 0x03A6, 0x0393, 0x039B, 0x03A9, 0x03A0, 0x03A8,
189         0x03A3, 0x0398, 0x039E, 0x00A0, 0x00C6, 0x00E6, 0x00DF, 0x00C9,
190         ' ', '!', '"', '#', 164, '%', '&', 39, '(', ')', '*', '+', ',', '-', '.', '/',
191         '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?',
192         161, 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
193         'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 196, 214, 209, 220, 167,
194         191, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
195         'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 228, 246, 241, 252, 224,
196 };
197
198 static const unsigned short escapes[] = {
199         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x000C, 0, 0, 0, 0, 0,
200         0, 0, 0, 0, 0x005E, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
201         0, 0, 0, 0, 0, 0, 0, 0, 0x007B, 0x007D, 0, 0, 0, 0, 0, 0x005C,
202         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x005B, 0x007E, 0x005D, 0,
203         0x007C, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
204         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
205         0, 0, 0, 0, 0, 0x20AC, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
206         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
207 };
208
209 #define SMSLEN      160          /*!< max SMS length */
210 #define SMSLEN_8    140          /*!< max SMS length for 8-bit char */
211
212 typedef struct sms_s {
213         unsigned char hangup;        /*!< we are done... */
214         unsigned char err;           /*!< set for any errors */
215         unsigned char smsc:1;        /*!< we are SMSC */
216         unsigned char rx:1;          /*!< this is a received message */
217         char queue[30];              /*!< queue name */
218         char oa[20];                 /*!< originating address */
219         char da[20];                 /*!< destination address */
220         struct timeval scts;         /*!< time stamp, UTC */
221         unsigned char pid;           /*!< protocol ID */
222         unsigned char dcs;           /*!< data coding scheme */
223         short mr;                    /*!< message reference - actually a byte, but use -1 for not set */
224         int udl;                     /*!< user data length */
225         int udhl;                    /*!< user data header length */
226         unsigned char srr:1;         /*!< Status Report request */
227         unsigned char udhi:1;        /*!< User Data Header required, even if length 0 */
228         unsigned char rp:1;          /*!< Reply Path */
229         unsigned int vp;             /*!< validity period in minutes, 0 for not set */
230         unsigned short ud[SMSLEN];   /*!< user data (message), UCS-2 coded */
231         unsigned char udh[SMSLEN];   /*!< user data header */
232         char cli[20];                /*!< caller ID */
233         unsigned char ophase;        /*!< phase (0-79) for 0 and 1 frequencies (1300Hz and 2100Hz) */
234         unsigned char ophasep;       /*!< phase (0-79) for 1200 bps */
235         unsigned char obyte;         /*!< byte being sent */
236         unsigned int opause;         /*!< silent pause before sending (in sample periods) */
237         unsigned char obitp;         /*!< bit in byte */
238         unsigned char osync;         /*!< sync bits to send */
239         unsigned char obytep;        /*!< byte in data */
240         unsigned char obyten;        /*!< bytes in data */
241         unsigned char omsg[256];     /*!< data buffer (out) */
242         unsigned char imsg[250];     /*!< data buffer (in) */
243         signed long long ims0,
244                 imc0,
245                 ims1,
246                 imc1;                    /*!< magnitude averages sin/cos 0/1 */
247         unsigned int idle;
248         unsigned short imag;         /*!< signal level */
249         unsigned char ips0;          /*!< phase sin for bit 0, start at  0 inc by 21 mod 80 */
250         unsigned char ips1;          /*!< phase cos for bit 0, start at 20 inc by 21 mod 80 */
251         unsigned char ipc0;          /*!< phase sin for bit 1, start at  0 inc by 13 mod 80 */
252         unsigned char ipc1;          /*!< phase cos for bit 1, start at 20 inc by 13 mod 80 */
253         unsigned char ibitl;         /*!< last bit */
254         unsigned char ibitc;         /*!< bit run length count */
255         unsigned char iphasep;       /*!< bit phase (0-79) for 1200 bps */
256         unsigned char ibitn;         /*!< bit number in byte being received */
257         unsigned char ibytev;        /*!< byte value being received */
258         unsigned char ibytep;        /*!< byte pointer in message */
259         unsigned char ibytec;        /*!< byte checksum for message */
260         unsigned char ierr;          /*!< error flag */
261         unsigned char ibith;         /*!< history of last bits */
262         unsigned char ibitt;         /*!< total of 1's in last 3 bytes */
263         /* more to go here */
264
265         int opause_0;                /*!< initial delay in ms, p() option */
266         int protocol;                /*!< ETSI SMS protocol to use (passed at app call) */
267         int oseizure;                /*!< protocol 2: channel seizure bits to send */
268         int framenumber;             /*!< protocol 2: frame number (for sending ACK0 or ACK1) */
269         char udtxt[SMSLEN];          /*!< user data (message), PLAIN text */
270 } sms_t;
271
272 /* different types of encoding */
273 #define is7bit(dcs)  ( ((dcs) & 0xC0) ? (!((dcs) & 4) ) : (((dcs) & 0xc) == 0) )
274 #define is8bit(dcs)  ( ((dcs) & 0xC0) ? ( ((dcs) & 4) ) : (((dcs) & 0xc) == 4) )
275 #define is16bit(dcs) ( ((dcs) & 0xC0) ? 0               : (((dcs) & 0xc) == 8) )
276
277 static void sms_messagetx(sms_t *h);
278
279 /*! \brief copy number, skipping non digits apart from leading + */
280 static void numcpy(char *d, char *s)
281 {
282         if (*s == '+') {
283                 *d++ = *s++;
284         }
285         while (*s) {
286                 if (isdigit(*s)) {
287                         *d++ = *s;
288                 }
289                 s++;
290         }
291         *d = 0;
292 }
293
294 /*! \brief static, return a date/time in ISO format */
295 static char *isodate(time_t t, char *buf, int len)
296 {
297         struct ast_tm tm;
298         struct timeval local = { t, 0 };
299         ast_localtime(&local, &tm, NULL);
300         ast_strftime(buf, len, "%Y-%m-%dT%H:%M:%S", &tm);
301         return buf;
302 }
303
304 /*! \brief Reads next UCS character from NUL terminated UTF-8 string and advance pointer */
305 /* for non valid UTF-8 sequences, returns character as is */
306 /* Does not advance pointer for null termination */
307 static long utf8decode(unsigned char **pp)
308 {
309         unsigned char *p = *pp;
310         if (!*p) {
311                 return 0;                           /* null termination of string */
312         }
313         (*pp)++;
314         if (*p < 0xC0) {
315                 return *p;                          /* ascii or continuation character */
316         }
317         if (*p < 0xE0) {
318                 if (*p < 0xC2 || (p[1] & 0xC0) != 0x80) {
319                         return *p;                      /* not valid UTF-8 */
320                 }
321                 (*pp)++;
322                 return ((*p & 0x1F) << 6) + (p[1] & 0x3F);
323         }
324         if (*p < 0xF0) {
325                 if ((*p == 0xE0 && p[1] < 0xA0) || (p[1] & 0xC0) != 0x80 || (p[2] & 0xC0) != 0x80) {
326                         return *p;                      /* not valid UTF-8 */
327                 }
328                 (*pp) += 2;
329                 return ((*p & 0x0F) << 12) + ((p[1] & 0x3F) << 6) + (p[2] & 0x3F);
330         }
331         if (*p < 0xF8) {
332                 if ((*p == 0xF0 && p[1] < 0x90) || (p[1] & 0xC0) != 0x80 || (p[2] & 0xC0) != 0x80 || (p[3] & 0xC0) != 0x80) {
333                         return *p;                      /* not valid UTF-8 */
334                 }
335                 (*pp) += 3;
336                 return ((*p & 0x07) << 18) + ((p[1] & 0x3F) << 12) + ((p[2] & 0x3F) << 6) + (p[3] & 0x3F);
337         }
338         if (*p < 0xFC) {
339                 if ((*p == 0xF8 && p[1] < 0x88) || (p[1] & 0xC0) != 0x80 || (p[2] & 0xC0) != 0x80 || (p[3] & 0xC0) != 0x80
340                         || (p[4] & 0xC0) != 0x80) {
341                         return *p;                      /* not valid UTF-8 */
342                 }
343                 (*pp) += 4;
344                 return ((*p & 0x03) << 24) + ((p[1] & 0x3F) << 18) + ((p[2] & 0x3F) << 12) + ((p[3] & 0x3F) << 6) + (p[4] & 0x3F);
345         }
346         if (*p < 0xFE) {
347                 if ((*p == 0xFC && p[1] < 0x84) || (p[1] & 0xC0) != 0x80 || (p[2] & 0xC0) != 0x80 || (p[3] & 0xC0) != 0x80
348                         || (p[4] & 0xC0) != 0x80 || (p[5] & 0xC0) != 0x80) {
349                         return *p;                      /* not valid UTF-8 */
350                 }
351                 (*pp) += 5;
352                 return ((*p & 0x01) << 30) + ((p[1] & 0x3F) << 24) + ((p[2] & 0x3F) << 18) + ((p[3] & 0x3F) << 12) + ((p[4] & 0x3F) << 6) + (p[5] & 0x3F);
353         }
354         return *p;                              /* not sensible */
355 }
356
357 /*! \brief takes a binary header (udhl bytes at udh) and UCS-2 message (udl characters at ud) and packs in to o using SMS 7 bit character codes */
358 /* The return value is the number of septets packed in to o, which is internally limited to SMSLEN */
359 /* o can be null, in which case this is used to validate or count only */
360 /* if the input contains invalid characters then the return value is -1 */
361 static int packsms7(unsigned char *o, int udhl, unsigned char *udh, int udl, unsigned short *ud)
362 {
363         unsigned char p = 0;                    /* output pointer (bytes) */
364         unsigned char b = 0;                    /* bit position */
365         unsigned char n = 0;                    /* output character count */
366         unsigned char dummy[SMSLEN];
367
368         if (o == NULL) {                        /* output to a dummy buffer if o not set */
369                 o = dummy;
370         }
371
372         if (udhl) {                             /* header */
373                 o[p++] = udhl;
374                 b = 1;
375                 n = 1;
376                 while (udhl--) {
377                         o[p++] = *udh++;
378                         b += 8;
379                         while (b >= 7) {
380                                 b -= 7;
381                                 n++;
382                         }
383                         if (n >= SMSLEN)
384                                 return n;
385                 }
386                 if (b) {
387                         b = 7 - b;
388                         if (++n >= SMSLEN)
389                                 return n;
390                 }                                   /* filling to septet boundary */
391         }
392         o[p] = 0;
393         /* message */
394         while (udl--) {
395                 long u;
396                 unsigned char v;
397                 u = *ud++;
398                 /* XXX 0 is invalid ? */
399                 /* look up in defaultalphabet[]. If found, v is the 7-bit code */
400                 for (v = 0; v < 128 && defaultalphabet[v] != u; v++);
401                 if (v == 128 /* not found */ && u && n + 1 < SMSLEN) {
402                         /* if not found, look in the escapes table (we need 2 bytes) */
403                         for (v = 0; v < 128 && escapes[v] != u; v++);
404                         if (v < 128) {  /* escaped sequence, esc + v */
405                                 /* store the low (8-b) bits in o[p], the remaining bits in o[p+1] */
406                                 o[p] |= (27 << b);          /* the low bits go into o[p] */ 
407                                 b += 7;
408                                 if (b >= 8) {
409                                         b -= 8;
410                                         p++;
411                                         o[p] = (27 >> (7 - b));
412                                 }
413                                 n++;
414                         }
415                 }
416                 if (v == 128)
417                         return -1;                      /* invalid character */
418                 /* store, same as above */
419                 o[p] |= (v << b);
420                 b += 7;
421                 if (b >= 8) {
422                         b -= 8;
423                         p++;
424                         o[p] = (v >> (7 - b));
425                 }
426                 if (++n >= SMSLEN)
427                         return n;
428         }
429         return n;
430 }
431
432 /*! \brief takes a binary header (udhl bytes at udh) and UCS-2 message (udl characters at ud)
433  * and packs in to o using 8 bit character codes.
434  * The return value is the number of bytes packed in to o, which is internally limited to 140.
435  * o can be null, in which case this is used to validate or count only.
436  * if the input contains invalid characters then the return value is -1
437  */
438 static int packsms8(unsigned char *o, int udhl, unsigned char *udh, int udl, unsigned short *ud)
439 {
440         unsigned char p = 0;
441         unsigned char dummy[SMSLEN_8];
442
443         if (o == NULL)
444                 o = dummy;
445         /* header - no encoding */
446         if (udhl) {
447                 o[p++] = udhl;
448                 while (udhl--) {
449                         o[p++] = *udh++;
450                         if (p >= SMSLEN_8) {
451                                 return p;
452                         }
453                 }
454         }
455         while (udl--) {
456                 long u;
457                 u = *ud++;
458                 if (u < 0 || u > 0xFF) {
459                         return -1;                      /* not valid */
460                 }
461                 o[p++] = u;
462                 if (p >= SMSLEN_8) {
463                         return p;
464                 }
465         }
466         return p;
467 }
468
469 /*! \brief takes a binary header (udhl bytes at udh) and UCS-2 
470         message (udl characters at ud) and packs in to o using 16 bit 
471         UCS-2 character codes 
472         The return value is the number of bytes packed in to o, which is 
473         internally limited to 140 
474         o can be null, in which case this is used to validate or count 
475         only if the input contains invalid characters then 
476         the return value is -1 */
477 static int packsms16(unsigned char *o, int udhl, unsigned char *udh, int udl, unsigned short *ud)
478 {
479         unsigned char p = 0;
480         unsigned char dummy[SMSLEN_8];
481
482         if (o == NULL) {
483                 o = dummy;
484         }
485         /* header - no encoding */
486         if (udhl) {
487                 o[p++] = udhl;
488                 while (udhl--) {
489                         o[p++] = *udh++;
490                         if (p >= SMSLEN_8) {
491                                 return p;
492                         }
493                 }
494         }
495         while (udl--) {
496                 long u;
497                 u = *ud++;
498                 o[p++] = (u >> 8);
499                 if (p >= SMSLEN_8) {
500                         return p - 1;                   /* could not fit last character */
501                 }
502                 o[p++] = u;
503                 if (p >= SMSLEN_8) {
504                         return p;
505                 }
506         }
507         return p;
508 }
509
510 /*! \brief general pack, with length and data, 
511         returns number of bytes of target used */
512 static int packsms(unsigned char dcs, unsigned char *base, unsigned int udhl, unsigned char *udh, int udl, unsigned short *ud)
513 {
514         unsigned char *p = base;
515         if (udl == 0) {
516                 *p++ = 0;                           /* no user data */
517         } else {
518                 
519                 int l = 0;
520                 if (is7bit(dcs)) {                  /* 7 bit */
521                         if ((l = packsms7(p + 1, udhl, udh, udl, ud)) < 0) {
522                                 l = 0;
523                         }
524                         *p++ = l;
525                         p += (l * 7 + 7) / 8;
526                 } else if (is8bit(dcs)) {           /* 8 bit */
527                         if ((l = packsms8(p + 1, udhl, udh, udl, ud)) < 0) {
528                                 l = 0;
529                         }
530                         *p++ = l;
531                         p += l;
532                 } else {                            /* UCS-2 */
533                         if ((l = packsms16(p + 1, udhl, udh, udl, ud)) < 0) {
534                                 l = 0;
535                         }
536                         *p++ = l;
537                         p += l;
538                 }
539         }
540         return p - base;
541 }
542
543
544 /*! \brief pack a date and return */
545 static void packdate(unsigned char *o, time_t w)
546 {
547         struct ast_tm t;
548         struct timeval topack = { w, 0 };
549         int z;
550
551         ast_localtime(&topack, &t, NULL);
552 #if defined(__FreeBSD__) || defined(__OpenBSD__) || defined( __NetBSD__ ) || defined(__APPLE__) || defined(__CYGWIN__)
553         z = -t.tm_gmtoff / 60 / 15;
554 #else
555         z = timezone / 60 / 15;
556 #endif
557         *o++ = ((t.tm_year % 10) << 4) + (t.tm_year % 100) / 10;
558         *o++ = (((t.tm_mon + 1) % 10) << 4) + (t.tm_mon + 1) / 10;
559         *o++ = ((t.tm_mday % 10) << 4) + t.tm_mday / 10;
560         *o++ = ((t.tm_hour % 10) << 4) + t.tm_hour / 10;
561         *o++ = ((t.tm_min % 10) << 4) + t.tm_min / 10;
562         *o++ = ((t.tm_sec % 10) << 4) + t.tm_sec / 10;
563         if (z < 0) {
564                 *o++ = (((-z) % 10) << 4) + (-z) / 10 + 0x08;
565         } else {
566                 *o++ = ((z % 10) << 4) + z / 10;
567         }
568 }
569
570 /*! \brief unpack a date and return */
571 static struct timeval unpackdate(unsigned char *i)
572 {
573         struct ast_tm t;
574
575         t.tm_year = 100 + (i[0] & 0xF) * 10 + (i[0] >> 4);
576         t.tm_mon = (i[1] & 0xF) * 10 + (i[1] >> 4) - 1;
577         t.tm_mday = (i[2] & 0xF) * 10 + (i[2] >> 4);
578         t.tm_hour = (i[3] & 0xF) * 10 + (i[3] >> 4);
579         t.tm_min = (i[4] & 0xF) * 10 + (i[4] >> 4);
580         t.tm_sec = (i[5] & 0xF) * 10 + (i[5] >> 4);
581         t.tm_isdst = 0;
582         if (i[6] & 0x08) {
583                 t.tm_min += 15 * ((i[6] & 0x7) * 10 + (i[6] >> 4));
584         } else {
585                 t.tm_min -= 15 * ((i[6] & 0x7) * 10 + (i[6] >> 4));
586         }
587
588         return ast_mktime(&t, NULL);
589 }
590
591 /*! \brief unpacks bytes (7 bit encoding) at i, len l septets, 
592         and places in udh and ud setting udhl and udl. udh not used 
593         if udhi not set */
594 static void unpacksms7(unsigned char *i, unsigned char l, unsigned char *udh, int *udhl, unsigned short *ud, int *udl, char udhi)
595 {
596         unsigned char b = 0, p = 0;
597         unsigned short *o = ud;
598         *udhl = 0;
599         if (udhi && l) {                        /* header */
600                 int h = i[p];
601                 *udhl = h;
602                 if (h) {
603                         b = 1;
604                         p++;
605                         l--;
606                         while (h-- && l) {
607                                 *udh++ = i[p++];
608                                 b += 8;
609                                 while (b >= 7) {
610                                         b -= 7;
611                                         l--;
612                                         if (!l) {
613                                                 break;
614                                         }
615                                 }
616                         }
617                         /* adjust for fill, septets */
618                         if (b) {
619                                 b = 7 - b;
620                                 l--;
621                         }
622                 }
623         }
624         while (l--) {
625                 unsigned char v;
626                 if (b < 2) {
627                         v = ((i[p] >> b) & 0x7F);       /* everything in one byte */
628                 } else {
629                         v = ((((i[p] >> b) + (i[p + 1] << (8 - b)))) & 0x7F);
630                 }
631                 b += 7;
632                 if (b >= 8) {
633                         b -= 8;
634                         p++;
635                 }
636                 /* 0x00A0 is the encoding of ESC (27) in defaultalphabet */
637                 if (o > ud && o[-1] == 0x00A0 && escapes[v]) {
638                         o[-1] = escapes[v];
639                 } else {
640                         *o++ = defaultalphabet[v];
641                 }
642         }
643         *udl = (o - ud);
644 }
645
646 /*! \brief unpacks bytes (8 bit encoding) at i, len l septets, 
647  *  and places in udh and ud setting udhl and udl. udh not used 
648  *  if udhi not set.
649  */
650 static void unpacksms8(unsigned char *i, unsigned char l, unsigned char *udh, int *udhl, unsigned short *ud, int *udl, char udhi)
651 {
652         unsigned short *o = ud;
653         *udhl = 0;
654         if (udhi) {
655                 int n = *i;
656                 *udhl = n;
657                 if (n) {
658                         i++;
659                         l--;
660                         while (l && n) {
661                                 l--;
662                                 n--;
663                                 *udh++ = *i++;
664                         }
665                 }
666         }
667         while (l--) {
668                 *o++ = *i++;                        /* not to UTF-8 as explicitly 8 bit coding in DCS */
669         }
670         *udl = (o - ud);
671 }
672
673 /*! \brief unpacks bytes (16 bit encoding) at i, len l septets,
674          and places in udh and ud setting udhl and udl. 
675         udh not used if udhi not set */
676 static void unpacksms16(unsigned char *i, unsigned char l, unsigned char *udh, int *udhl, unsigned short *ud, int *udl, char udhi)
677 {
678         unsigned short *o = ud;
679         *udhl = 0;
680         if (udhi) {
681                 int n = *i;
682                 *udhl = n;
683                 if (n) {
684                         i++;
685                         l--;
686                         while (l && n) {
687                                 l--;
688                                 n--;
689                                 *udh++ = *i++;
690                         }
691                 }
692         }
693         while (l--) {
694                 int v = *i++;
695                 if (l--) {
696                         v = (v << 8) + *i++;
697                 }
698                 *o++ = v;
699         }
700         *udl = (o - ud);
701 }
702
703 /*! \brief general unpack - starts with length byte (octet or septet) and returns number of bytes used, inc length */
704 static int unpacksms(unsigned char dcs, unsigned char *i, unsigned char *udh, int *udhl, unsigned short *ud, int *udl, char udhi)
705 {
706         int l = *i++;
707         if (is7bit(dcs)) {
708                 unpacksms7(i, l, udh, udhl, ud, udl, udhi);
709                 l = (l * 7 + 7) / 8;                /* adjust length to return */
710         } else if (is8bit(dcs)) {
711                 unpacksms8(i, l, udh, udhl, ud, udl, udhi);
712         } else {
713                 unpacksms16(i, l, udh, udhl, ud, udl, udhi);
714         }
715         return l + 1;
716 }
717
718 /*! \brief unpack an address from i, return byte length, unpack to o */
719 static unsigned char unpackaddress(char *o, unsigned char *i)
720 {
721         unsigned char l = i[0], p;
722         if (i[1] == 0x91) {
723                 *o++ = '+';
724         }
725         for (p = 0; p < l; p++) {
726                 if (p & 1) {
727                         *o++ = (i[2 + p / 2] >> 4) + '0';
728                 } else {
729                         *o++ = (i[2 + p / 2] & 0xF) + '0';
730                 }
731         }
732         *o = 0;
733         return (l + 5) / 2;
734 }
735
736 /*! \brief store an address at o, and return number of bytes used */
737 static unsigned char packaddress(unsigned char *o, char *i)
738 {
739         unsigned char p = 2;
740         o[0] = 0;                               /* number of bytes */
741         if (*i == '+') {                        /* record as bit 0 in byte 1 */
742                 i++;
743                 o[1] = 0x91;
744         } else {
745                 o[1] = 0x81;
746         }
747         for ( ; *i ; i++) {
748                 if (!isdigit(*i)) {                 /* ignore non-digits */
749                         continue;
750                 }
751                 if (o[0] & 1) {
752                         o[p++] |= ((*i & 0xF) << 4);
753                 } else {
754                         o[p] = (*i & 0xF);
755                 }
756                 o[0]++;
757         }
758         if (o[0] & 1) {
759                 o[p++] |= 0xF0;                     /* pad */
760         }
761         return p;
762 }
763
764 /*! \brief Log the output, and remove file */
765 static void sms_log(sms_t * h, char status)
766 {
767         int o;
768
769         if (*h->oa == '\0' && *h->da == '\0') {
770                 return;
771         }
772         o = open(log_file, O_CREAT | O_APPEND | O_WRONLY, AST_FILE_MODE);
773         if (o >= 0) {
774                 char line[1000], mrs[3] = "", *p;
775                 char buf[30];
776                 unsigned char n;
777
778                 if (h->mr >= 0) {
779                         snprintf(mrs, sizeof(mrs), "%02X", h->mr);
780                 }
781                 snprintf(line, sizeof(line), "%s %c%c%c%s %s %s %s ",
782                         isodate(time(NULL), buf, sizeof(buf)),
783                         status, h->rx ? 'I' : 'O', h->smsc ? 'S' : 'M', mrs, h->queue,
784                         S_OR(h->oa, "-"), S_OR(h->da, "-") );
785                 p = line + strlen(line);
786                 for (n = 0; n < h->udl; n++) {
787                         if (h->ud[n] == '\\') {
788                                 *p++ = '\\';
789                                 *p++ = '\\';
790                         } else if (h->ud[n] == '\n') {
791                                 *p++ = '\\';
792                                 *p++ = 'n';
793                         } else if (h->ud[n] == '\r') {
794                                 *p++ = '\\';
795                                 *p++ = 'r';
796                         } else if (h->ud[n] < 32 || h->ud[n] == 127) {
797                                 *p++ = 191;
798                         } else {
799                                 *p++ = h->ud[n];
800                         }
801                 }
802                 *p++ = '\n';
803                 *p = 0;
804                 if (write(o, line, strlen(line)) < 0) {
805                         ast_log(LOG_WARNING, "write() failed: %s\n", strerror(errno));
806                 }
807                 close(o);
808         }
809         *h->oa = *h->da = h->udl = 0;
810 }
811
812 /*! \brief parse and delete a file */
813 static void sms_readfile(sms_t * h, char *fn)
814 {
815         char line[1000];
816         FILE *s;
817         char dcsset = 0;                        /* if DSC set */
818         ast_log(LOG_NOTICE, "Sending %s\n", fn);
819         h->rx = h->udl = *h->oa = *h->da = h->pid = h->srr = h->udhi = h->rp = h->vp = h->udhl = 0;
820         h->mr = -1;
821         h->dcs = 0xF1;                          /* normal messages class 1 */
822         h->scts = ast_tvnow();
823         s = fopen(fn, "r");
824         if (s) {
825                 if (unlink(fn)) {                   /* concurrent access, we lost */
826                         fclose(s);
827                         return;
828                 }
829                 while (fgets (line, sizeof(line), s)) { /* process line in file */
830                         char *p;
831                         void *pp = &p;
832                         for (p = line; *p && *p != '\n' && *p != '\r'; p++);
833                         *p = 0;                         /* strip eoln */
834                         p = line;
835                         if (!*p || *p == ';') {
836                                 continue;                   /* blank line or comment, ignore */
837                         }
838                         while (isalnum(*p)) {
839                                 *p = tolower (*p);
840                                 p++;
841                         }
842                         while (isspace (*p)) {
843                                 *p++ = 0;
844                         }
845                         if (*p == '=') {
846                                 *p++ = 0;
847                                 if (!strcmp(line, "ud")) {  /* parse message (UTF-8) */
848                                         unsigned char o = 0;
849                                         memcpy(h->udtxt, p, SMSLEN); /* for protocol 2 */
850                                         while (*p && o < SMSLEN) {
851                                                 h->ud[o++] = utf8decode(pp);
852                                         }
853                                         h->udl = o;
854                                         if (*p) {
855                                                 ast_log(LOG_WARNING, "UD too long in %s\n", fn);
856                                         }
857                                 } else {
858                                         while (isspace (*p)) {
859                                                 p++;
860                                         }
861                                         if (!strcmp(line, "oa") && strlen(p) < sizeof(h->oa)) {
862                                                 numcpy (h->oa, p);
863                                         } else if (!strcmp(line, "da") && strlen(p) < sizeof(h->oa)) {
864                                                 numcpy (h->da, p);
865                                         } else if (!strcmp(line, "pid")) {
866                                                 h->pid = atoi(p);
867                                         } else if (!strcmp(line, "dcs")) {
868                                                 h->dcs = atoi(p);
869                                                 dcsset = 1;
870                                         } else if (!strcmp(line, "mr")) {
871                                                 h->mr = atoi(p);
872                                         } else if (!strcmp(line, "srr")) {
873                                                 h->srr = (atoi(p) ? 1 : 0);
874                                         } else if (!strcmp(line, "vp")) {
875                                                 h->vp = atoi(p);
876                                         } else if (!strcmp(line, "rp")) {
877                                                 h->rp = (atoi(p) ? 1 : 0);
878                                         } else if (!strcmp(line, "scts")) {    /* get date/time */
879                                                 int Y, m, d, H, M, S;
880                                                 /* XXX Why aren't we using ast_strptime here? */
881                                                 if (sscanf(p, "%d-%d-%dT%d:%d:%d", &Y, &m, &d, &H, &M, &S) == 6) {
882                                                         struct ast_tm t = { 0, };
883                                                         t.tm_year = Y - 1900;
884                                                         t.tm_mon = m - 1;
885                                                         t.tm_mday = d;
886                                                         t.tm_hour = H;
887                                                         t.tm_min = M;
888                                                         t.tm_sec = S;
889                                                         t.tm_isdst = -1;
890                                                         h->scts = ast_mktime(&t, NULL);
891                                                         if (h->scts.tv_sec == 0) {
892                                                                 ast_log(LOG_WARNING, "Bad date/timein %s: %s", fn, p);
893                                                         }
894                                                 }
895                                         } else {
896                                                 ast_log(LOG_WARNING, "Cannot parse in %s: %s=%si\n", fn, line, p);
897                                         }
898                                 }
899                         } else if (*p == '#') {                   /* raw hex format */
900                                 *p++ = 0;
901                                 if (*p == '#') {
902                                         p++;
903                                         if (!strcmp(line, "ud")) {        /* user data */
904                                                 int o = 0;
905                                                 while (*p && o < SMSLEN) {
906                                                         if (isxdigit(*p) && isxdigit(p[1]) && isxdigit(p[2]) && isxdigit(p[3])) {
907                                                                 h->ud[o++] =
908                                                                         (((isalpha(*p) ? 9 : 0) + (*p & 0xF)) << 12) +
909                                                                         (((isalpha(p[1]) ? 9 : 0) + (p[1] & 0xF)) << 8) +
910                                                                         (((isalpha(p[2]) ? 9 : 0) + (p[2] & 0xF)) << 4) + ((isalpha(p[3]) ? 9 : 0) + (p[3] & 0xF));
911                                                                 p += 4;
912                                                         } else
913                                                                 break;
914                                                 }
915                                                 h->udl = o;
916                                                 if (*p)
917                                                         ast_log(LOG_WARNING, "UD too long / invalid UCS-2 hex in %s\n", fn);
918                                         } else
919                                                 ast_log(LOG_WARNING, "Only ud can use ## format, %s\n", fn);
920                                 } else if (!strcmp(line, "ud")) {       /* user data */
921                                         int o = 0;
922                                         while (*p && o < SMSLEN) {
923                                                 if (isxdigit(*p) && isxdigit(p[1])) {
924                                                         h->ud[o++] = (((isalpha(*p) ? 9 : 0) + (*p & 0xF)) << 4) + ((isalpha(p[1]) ? 9 : 0) + (p[1] & 0xF));
925                                                         p += 2;
926                                                 } else {
927                                                         break;
928                                                 }
929                                         }
930                                         h->udl = o;
931                                         if (*p) {
932                                                 ast_log(LOG_WARNING, "UD too long / invalid UCS-1 hex in %s\n", fn);
933                                         }
934                                 } else if (!strcmp(line, "udh")) {      /* user data header */
935                                         unsigned char o = 0;
936                                         h->udhi = 1;
937                                         while (*p && o < SMSLEN) {
938                                                 if (isxdigit(*p) && isxdigit(p[1])) {
939                                                         h->udh[o] = (((isalpha(*p) ? 9 : 0) + (*p & 0xF)) << 4) + ((isalpha(p[1]) ? 9 : 0) + (p[1] & 0xF));
940                                                         o++;
941                                                         p += 2;
942                                                 } else {
943                                                         break;
944                                                 }
945                                         }
946                                         h->udhl = o;
947                                         if (*p) {
948                                                 ast_log(LOG_WARNING, "UDH too long / invalid hex in %s\n", fn);
949                                         }
950                                 } else {
951                                         ast_log(LOG_WARNING, "Only ud and udh can use # format, %s\n", fn);
952                                 }
953                         } else {
954                                 ast_log(LOG_WARNING, "Cannot parse in %s: %s\n", fn, line);
955                         }
956                 }
957                 fclose(s);
958                 if (!dcsset && packsms7(0, h->udhl, h->udh, h->udl, h->ud) < 0) {
959                         if (packsms8(0, h->udhl, h->udh, h->udl, h->ud) < 0) {
960                                 if (packsms16(0, h->udhl, h->udh, h->udl, h->ud) < 0) {
961                                         ast_log(LOG_WARNING, "Invalid UTF-8 message even for UCS-2 (%s)\n", fn);
962                                 } else {
963                                         h->dcs = 0x08;          /* default to 16 bit */
964                                         ast_log(LOG_WARNING, "Sending in 16 bit format(%s)\n", fn);
965                                 }
966                         } else {
967                                 h->dcs = 0xF5;              /* default to 8 bit */
968                                 ast_log(LOG_WARNING, "Sending in 8 bit format(%s)\n", fn);
969                         }
970                 }
971                 if (is7bit(h->dcs) && packsms7(0, h->udhl, h->udh, h->udl, h->ud) < 0) {
972                         ast_log(LOG_WARNING, "Invalid 7 bit GSM data %s\n", fn);
973                 }
974                 if (is8bit(h->dcs) && packsms8(0, h->udhl, h->udh, h->udl, h->ud) < 0) {
975                         ast_log(LOG_WARNING, "Invalid 8 bit data %s\n", fn);
976                 }
977                 if (is16bit(h->dcs) && packsms16(0, h->udhl, h->udh, h->udl, h->ud) < 0) {
978                         ast_log(LOG_WARNING, "Invalid 16 bit data %s\n", fn);
979                 }
980         }
981 }
982
983 /*! \brief white a received text message to a file */
984 static void sms_writefile(sms_t * h)
985 {
986         char fn[200] = "", fn2[200] = "";
987         char buf[30];
988         FILE *o;
989
990         if (ast_tvzero(h->scts)) {
991                 h->scts = ast_tvnow();
992         }
993         snprintf(fn, sizeof(fn), "%s/sms/%s", ast_config_AST_SPOOL_DIR, h->smsc ? h->rx ? "morx" : "mttx" : h->rx ? "mtrx" : "motx");
994         ast_mkdir(fn, 0777);                    /* ensure it exists */
995         ast_copy_string(fn2, fn, sizeof(fn2));
996         snprintf(fn2 + strlen(fn2), sizeof(fn2) - strlen(fn2), "/%s.%s-%d", h->queue, isodate(h->scts.tv_sec, buf, sizeof(buf)), seq++);
997         snprintf(fn + strlen(fn), sizeof(fn) - strlen(fn), "/.%s", fn2 + strlen(fn) + 1);
998         if ((o = fopen(fn, "w")) == NULL) {
999                 return;
1000         }
1001
1002         if (*h->oa) {
1003                 fprintf(o, "oa=%s\n", h->oa);
1004         }
1005         if (*h->da) {
1006                 fprintf(o, "da=%s\n", h->da);
1007         }
1008         if (h->udhi) {
1009                 unsigned int p;
1010                 fprintf(o, "udh#");
1011                 for (p = 0; p < h->udhl; p++) {
1012                         fprintf(o, "%02X", h->udh[p]);
1013                 }
1014                 fprintf(o, "\n");
1015         }
1016         if (h->udl) {
1017                 unsigned int p;
1018                 for (p = 0; p < h->udl && h->ud[p] >= ' '; p++);
1019                 if (p < h->udl) {
1020                         fputc(';', o);                  /* cannot use ud=, but include as a comment for human readable */
1021                 }
1022                 fprintf(o, "ud=");
1023                 for (p = 0; p < h->udl; p++) {
1024                         unsigned short v = h->ud[p];
1025                         if (v < 32) {
1026                                 fputc(191, o);
1027                         } else if (v < 0x80) {
1028                                 fputc(v, o);
1029                         } else if (v < 0x800) {
1030                                 fputc(0xC0 + (v >> 6), o);
1031                                 fputc(0x80 + (v & 0x3F), o);
1032                         } else {
1033                                 fputc(0xE0 + (v >> 12), o);
1034                                 fputc(0x80 + ((v >> 6) & 0x3F), o);
1035                                 fputc(0x80 + (v & 0x3F), o);
1036                         }
1037                 }
1038                 fprintf(o, "\n");
1039                 for (p = 0; p < h->udl && h->ud[p] >= ' '; p++);
1040                 if (p < h->udl) {
1041                         for (p = 0; p < h->udl && h->ud[p] < 0x100; p++);
1042                         if (p == h->udl) {              /* can write in ucs-1 hex */
1043                                 fprintf(o, "ud#");
1044                                 for (p = 0; p < h->udl; p++) {
1045                                         fprintf(o, "%02X", h->ud[p]);
1046                                 }
1047                                 fprintf(o, "\n");
1048                         } else {                        /* write in UCS-2 */
1049                                 fprintf(o, "ud##");
1050                                 for (p = 0; p < h->udl; p++) {
1051                                         fprintf(o, "%04X", h->ud[p]);
1052                                 }
1053                                 fprintf(o, "\n");
1054                         }
1055                 }
1056         }
1057         if (h->scts.tv_sec) {
1058                 char datebuf[30];
1059                 fprintf(o, "scts=%s\n", isodate(h->scts.tv_sec, datebuf, sizeof(datebuf)));
1060         }
1061         if (h->pid) {
1062                 fprintf(o, "pid=%d\n", h->pid);
1063         }
1064         if (h->dcs != 0xF1) {
1065                 fprintf(o, "dcs=%d\n", h->dcs);
1066         }
1067         if (h->vp) {
1068                 fprintf(o, "vp=%d\n", h->vp);
1069         }
1070         if (h->srr) {
1071                 fprintf(o, "srr=1\n");
1072         }
1073         if (h->mr >= 0) {
1074                 fprintf(o, "mr=%d\n", h->mr);
1075         }
1076         if (h->rp) {
1077                 fprintf(o, "rp=1\n");
1078         }
1079         fclose(o);
1080         if (rename(fn, fn2)) {
1081                 unlink(fn);
1082         } else {
1083                 ast_log(LOG_NOTICE, "Received to %s\n", fn2);
1084         }
1085 }
1086
1087 /*! \brief read dir skipping dot files... */
1088 static struct dirent *readdirqueue(DIR *d, char *queue)
1089 {
1090         struct dirent *f;
1091         do {
1092                 f = readdir(d);
1093         } while (f && (*f->d_name == '.' || strncmp(f->d_name, queue, strlen(queue)) || f->d_name[strlen(queue)] != '.'));
1094         return f;
1095 }
1096
1097 /*! \brief handle the incoming message */
1098 static unsigned char sms_handleincoming (sms_t * h)
1099 {
1100         unsigned char p = 3;
1101         if (h->smsc) {                          /* SMSC */
1102                 if ((h->imsg[2] & 3) == 1) {        /* SMS-SUBMIT */
1103                         h->udhl = h->udl = 0;
1104                         h->vp = 0;
1105                         h->srr = ((h->imsg[2] & 0x20) ? 1 : 0);
1106                         h->udhi = ((h->imsg[2] & 0x40) ? 1 : 0);
1107                         h->rp = ((h->imsg[2] & 0x80) ? 1 : 0);
1108                         ast_copy_string(h->oa, h->cli, sizeof(h->oa));
1109                         h->scts = ast_tvnow();
1110                         h->mr = h->imsg[p++];
1111                         p += unpackaddress(h->da, h->imsg + p);
1112                         h->pid = h->imsg[p++];
1113                         h->dcs = h->imsg[p++];
1114                         if ((h->imsg[2] & 0x18) == 0x10) {       /* relative VP */
1115                                 if (h->imsg[p] < 144) {
1116                                         h->vp = (h->imsg[p] + 1) * 5;
1117                                 } else if (h->imsg[p] < 168) {
1118                                         h->vp = 720 + (h->imsg[p] - 143) * 30;
1119                                 } else if (h->imsg[p] < 197) {
1120                                         h->vp = (h->imsg[p] - 166) * 1440;
1121                                 } else {
1122                                         h->vp = (h->imsg[p] - 192) * 10080;
1123                                 }
1124                                 p++;
1125                         } else if (h->imsg[2] & 0x18) {
1126                                 p += 7;                     /* ignore enhanced / absolute VP */
1127                         }
1128                         p += unpacksms(h->dcs, h->imsg + p, h->udh, &h->udhl, h->ud, &h->udl, h->udhi);
1129                         h->rx = 1;                      /* received message */
1130                         sms_writefile(h);               /* write the file */
1131                         if (p != h->imsg[1] + 2) {
1132                                 ast_log(LOG_WARNING, "Mismatch receive unpacking %d/%d\n", p, h->imsg[1] + 2);
1133                                 return 0xFF;              /* duh! */
1134                         }
1135                 } else {
1136                         ast_log(LOG_WARNING, "Unknown message type %02X\n", h->imsg[2]);
1137                         return 0xFF;
1138                 }
1139         } else {                                /* client */
1140                 if (!(h->imsg[2] & 3)) {            /* SMS-DELIVER */
1141                         *h->da = h->srr = h->rp = h->vp = h->udhi = h->udhl = h->udl = 0;
1142                         h->srr = ((h->imsg[2] & 0x20) ? 1 : 0);
1143                         h->udhi = ((h->imsg[2] & 0x40) ? 1 : 0);
1144                         h->rp = ((h->imsg[2] & 0x80) ? 1 : 0);
1145                         h->mr = -1;
1146                         p += unpackaddress(h->oa, h->imsg + p);
1147                         h->pid = h->imsg[p++];
1148                         h->dcs = h->imsg[p++];
1149                         h->scts = unpackdate(h->imsg + p);
1150                         p += 7;
1151                         p += unpacksms(h->dcs, h->imsg + p, h->udh, &h->udhl, h->ud, &h->udl, h->udhi);
1152                         h->rx = 1;                      /* received message */
1153                         sms_writefile(h);               /* write the file */
1154                         if (p != h->imsg[1] + 2) {
1155                                 ast_log(LOG_WARNING, "Mismatch receive unpacking %d/%d\n", p, h->imsg[1] + 2);
1156                                 return 0xFF;                /* duh! */
1157                         }
1158                 } else {
1159                         ast_log(LOG_WARNING, "Unknown message type %02X\n", h->imsg[2]);
1160                         return 0xFF;
1161                 }
1162         }
1163         return 0;                               /* no error */
1164 }
1165
1166 #ifdef SOLARIS
1167 #define NAME_MAX 1024
1168 #endif
1169
1170 /*!
1171  * Add data to a protocol 2 message.
1172  * Use the length field (h->omsg[1]) as a pointer to the next free position.
1173  */
1174 static void adddata_proto2(sms_t *h, unsigned char msg, char *data, int size)
1175 {
1176         int x = h->omsg[1] + 2;                 /* Get current position */
1177         if (x == 2) {
1178                 x += 2;                             /* First: skip Payload length (set later) */
1179         }
1180         h->omsg[x++] = msg;                     /* Message code */
1181         h->omsg[x++] = (unsigned char)size;     /* Data size Low */
1182         h->omsg[x++] = 0;                       /* Data size Hi */
1183         for (; size > 0 ; size--) {
1184                 h->omsg[x++] = *data++;
1185         }
1186         h->omsg[1] = x - 2;                     /* Frame size */
1187         h->omsg[2] = x - 4;                     /* Payload length (Lo) */
1188         h->omsg[3] = 0;                         /* Payload length (Hi) */
1189 }
1190
1191 static void putdummydata_proto2(sms_t *h)
1192 {
1193         adddata_proto2(h, 0x10, "\0", 1);           /* Media Identifier > SMS */
1194         adddata_proto2(h, 0x11, "\0\0\0\0\0\0", 6); /* Firmware version */
1195         adddata_proto2(h, 0x12, "\2\0\4", 3);       /* SMS provider ID */
1196         adddata_proto2(h, 0x13, h->udtxt, h->udl);  /* Body */
1197 }
1198
1199 static void sms_compose2(sms_t *h, int more)
1200 {
1201         struct ast_tm tm;
1202         struct timeval now = h->scts;
1203         char stm[9];
1204
1205         h->omsg[0] = 0x00;                      /* set later... */
1206         h->omsg[1] = 0;
1207         putdummydata_proto2(h);
1208         if (h->smsc) {                          /* deliver */
1209                 h->omsg[0] = 0x11;                  /* SMS_DELIVERY */
1210                 /* Required: 10 11 12 13 14 15 17 (seems they must be ordered!) */
1211                 ast_localtime(&now, &tm, NULL);
1212                 sprintf(stm, "%02d%02d%02d%02d", tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min);  /* Date mmddHHMM */
1213                 adddata_proto2(h, 0x14, stm, 8);    /* Date */
1214                 if (*h->oa == 0) {
1215                         strcpy(h->oa, "00000000");
1216                 }
1217                 adddata_proto2(h, 0x15, h->oa, strlen(h->oa)); /* Originator */
1218                 adddata_proto2(h, 0x17, "\1", 1);   /* Calling Terminal ID */
1219         } else {                                /* submit */
1220                 h->omsg[0] = 0x10;                  /* SMS_SUBMIT */
1221                 /* Required: 10 11 12 13 17 18 1B 1C (seems they must be ordered!) */
1222                 adddata_proto2(h, 0x17, "\1", 1);   /* Calling Terminal ID */
1223                 if (*h->da == 0) {
1224                         strcpy(h->da, "00000000");
1225                 }
1226                 adddata_proto2(h, 0x18, h->da, strlen(h->da)); /* Originator */
1227                 adddata_proto2(h, 0x1B, "\1", 1);             /* Called Terminal ID */
1228                 adddata_proto2(h, 0x1C, "\0\0\0", 3);     /* Notification */
1229         }
1230 }
1231
1232 static void putdummydata_proto2(sms_t *h);
1233
1234 #define MAX_DEBUG_LEN   300
1235 static char *sms_hexdump(unsigned char buf[], int size, char *s /* destination */)
1236 {
1237         char *p;
1238         int f;
1239
1240         for (p = s, f = 0; f < size && f < MAX_DEBUG_LEN; f++, p += 3) {
1241                 sprintf(p, "%02X ", (unsigned char)buf[f]);
1242         }
1243         return(s);
1244 }
1245
1246
1247 /*! \brief sms_handleincoming_proto2: handle the incoming message */
1248 static int sms_handleincoming_proto2(sms_t *h)
1249 {
1250         int f, i, sz = 0;
1251         int msg, msgsz;
1252         struct ast_tm tm;
1253         struct timeval now = { 0, 0 };
1254         char debug_buf[MAX_DEBUG_LEN * 3 + 1];
1255
1256         sz = h->imsg[1] + 2;
1257         /* ast_verb(3, "SMS-P2 Frame: %s\n", sms_hexdump(h->imsg, sz, debug_buf)); */
1258
1259         /* Parse message body (called payload) */
1260         now = h->scts = ast_tvnow();
1261         for (f = 4; f < sz; ) {
1262                 msg = h->imsg[f++];
1263                 msgsz = h->imsg[f++];
1264                 msgsz += (h->imsg[f++] * 256);
1265                 switch (msg) {
1266                 case 0x13:                          /* Body */
1267                         ast_verb(3, "SMS-P2 Body#%02X=[%.*s]\n", msg, msgsz, &h->imsg[f]);
1268                         if (msgsz >= sizeof(h->imsg)) {
1269                                 msgsz = sizeof(h->imsg) - 1;
1270                         }
1271                         for (i = 0; i < msgsz; i++) {
1272                                 h->ud[i] = h->imsg[f + i];
1273                         }
1274                         h->udl = msgsz;
1275                         break;
1276                 case 0x14:                          /* Date SCTS */
1277                         now = h->scts = ast_tvnow();
1278                         ast_localtime(&now, &tm, NULL);
1279                         tm.tm_mon = ( (h->imsg[f] * 10) + h->imsg[f + 1] ) - 1;
1280                         tm.tm_mday = ( (h->imsg[f + 2] * 10) + h->imsg[f + 3] );
1281                         tm.tm_hour = ( (h->imsg[f + 4] * 10) + h->imsg[f + 5] );
1282                         tm.tm_min = ( (h->imsg[f + 6] * 10) + h->imsg[f + 7] );
1283                         tm.tm_sec = 0;
1284                         h->scts = ast_mktime(&tm, NULL);
1285                         ast_verb(3, "SMS-P2 Date#%02X=%02d/%02d %02d:%02d\n", msg, tm.tm_mday, tm.tm_mon + 1, tm.tm_hour, tm.tm_min);
1286                         break;
1287                 case 0x15:                          /* Calling line (from SMSC) */
1288                         if (msgsz >= 20) {
1289                                 msgsz = 20 - 1;
1290                         }
1291                         ast_verb(3, "SMS-P2 Origin#%02X=[%.*s]\n", msg, msgsz, &h->imsg[f]);
1292                         ast_copy_string(h->oa, (char *)(&h->imsg[f]), msgsz + 1);
1293                         break;
1294                 case 0x18:                          /* Destination(from TE/phone) */
1295                         if (msgsz >= 20) {
1296                                 msgsz = 20 - 1;
1297                         }
1298                         ast_verb(3, "SMS-P2 Destination#%02X=[%.*s]\n", msg, msgsz, &h->imsg[f]);
1299                         ast_copy_string(h->da, (char *)(&h->imsg[f]), msgsz + 1);
1300                         break;
1301                 case 0x1C:                          /* Notify */
1302                         ast_verb(3, "SMS-P2 Notify#%02X=%s\n", msg, sms_hexdump(&h->imsg[f], 3, debug_buf));
1303                         break;
1304                 default:
1305                         ast_verb(3, "SMS-P2 Par#%02X [%d]: %s\n", msg, msgsz, sms_hexdump(&h->imsg[f], msgsz, debug_buf));
1306                         break;
1307                 }
1308                 f+=msgsz;                           /* Skip to next */
1309         }
1310         h->rx = 1;                              /* received message */
1311         sms_writefile(h);                       /* write the file */
1312         return 0;                               /* no error */
1313 }
1314
1315 #if 0
1316 static void smssend(sms_t *h, char *c)
1317 {
1318         int f, x;
1319         for (f = 0; f < strlen(c); f++) {
1320                 sscanf(&c[f*3], "%x", &x);
1321                 h->omsg[f] = x;
1322         }
1323         sms_messagetx(h);
1324 }
1325 #endif
1326
1327 static void sms_nextoutgoing (sms_t *h);
1328
1329 static void sms_messagerx2(sms_t * h)
1330 {
1331         int p = h->imsg[0] & DLL_SMS_MASK ; /* mask the high bit */
1332         int cause;
1333
1334 #define DLL2_ACK(h) ((h->framenumber & 1) ? DLL2_SMS_ACK1: DLL2_SMS_ACK1)
1335         switch (p) {
1336         case DLL2_SMS_EST:                      /* Protocol 2: Connection ready (fake): send message  */
1337                 sms_nextoutgoing (h);
1338                 /* smssend(h,"11 29 27 00 10 01 00 00 11 06 00 00 00 00 00 00 00 12 03 00 02 00 04 13 01 00 41 14 08 00 30 39 31 35 30 02 30 02 15 02 00 39 30 "); */
1339                 break;
1340
1341         case DLL2_SMS_INFO_MO:                  /* transport SMS_SUBMIT */
1342         case DLL2_SMS_INFO_MT:                  /* transport SMS_DELIVERY */
1343                 cause = sms_handleincoming_proto2(h);
1344                 if (!cause)     {                       /* ACK */
1345                         sms_log(h, 'Y');
1346                 }
1347                 h->omsg[0] = DLL2_ACK(h);
1348                 h->omsg[1] = 0x06;                  /* msg len */
1349                 h->omsg[2] = 0x04;                  /* payload len */
1350                 h->omsg[3] = 0x00;                  /* payload len */
1351                 h->omsg[4] = 0x1f;                  /* Response type */
1352                 h->omsg[5] = 0x01;                  /* parameter len */
1353                 h->omsg[6] = 0x00;                  /* parameter len */
1354                 h->omsg[7] = cause;                 /* CONFIRM or error */
1355                 sms_messagetx(h);
1356                 break;
1357
1358         case DLL2_SMS_NACK:                     /* Protocol 2: SMS_NAK */
1359                 h->omsg[0] = DLL2_SMS_REL;          /* SMS_REL */
1360                 h->omsg[1] = 0x00;                  /* msg len */
1361                 sms_messagetx(h);
1362                 break;
1363
1364         case DLL2_SMS_ACK0:
1365         case DLL2_SMS_ACK1:
1366                 /* SMS_ACK also transport SMS_SUBMIT or SMS_DELIVERY */
1367                 if ( (h->omsg[0] & DLL_SMS_MASK) == DLL2_SMS_REL) {
1368                         /* a response to our Release, just hangup */
1369                         h->hangup = 1;                  /* hangup */
1370                 } else {
1371                         /* XXX depending on what we are.. */
1372                         ast_log(LOG_NOTICE, "SMS_SUBMIT or SMS_DELIVERY");
1373                         sms_nextoutgoing (h);
1374                 }
1375                 break;
1376
1377         case DLL2_SMS_REL:                      /* Protocol 2: SMS_REL (hangup req) */
1378                 h->omsg[0] = DLL2_ACK(h);
1379                 h->omsg[1] = 0;
1380                 sms_messagetx(h);
1381                 break;
1382         }
1383 }
1384
1385 /*! \brief compose a message for protocol 1 */
1386 static void sms_compose1(sms_t *h, int more)
1387 {
1388         unsigned int p = 2;                     /* next byte to write. Skip type and len */
1389
1390         h->omsg[0] = 0x91;                      /* SMS_DATA */
1391         if (h->smsc) {                          /* deliver */
1392                 h->omsg[p++] = (more ? 4 : 0) + ((h->udhl > 0) ? 0x40 : 0);
1393                 p += packaddress(h->omsg + p, h->oa);
1394                 h->omsg[p++] = h->pid;
1395                 h->omsg[p++] = h->dcs;
1396                 packdate(h->omsg + p, h->scts.tv_sec);
1397                 p += 7;
1398                 p += packsms(h->dcs, h->omsg + p, h->udhl, h->udh, h->udl, h->ud);
1399         } else {                                /* submit */
1400                 h->omsg[p++] =
1401                         0x01 + (more ? 4 : 0) + (h->srr ? 0x20 : 0) + (h->rp ? 0x80 : 0) + (h->vp ? 0x10 : 0) + (h->udhi ? 0x40 : 0);
1402                 if (h->mr < 0) {
1403                         h->mr = message_ref++;
1404                 }
1405                 h->omsg[p++] = h->mr;
1406                 p += packaddress(h->omsg + p, h->da);
1407                 h->omsg[p++] = h->pid;
1408                 h->omsg[p++] = h->dcs;
1409                 if (h->vp) {                        /* relative VP */
1410                         if (h->vp < 720) {
1411                                 h->omsg[p++] = (h->vp + 4) / 5 - 1;
1412                         } else if (h->vp < 1440) {
1413                                 h->omsg[p++] = (h->vp - 720 + 29) / 30 + 143;
1414                         } else if (h->vp < 43200) {
1415                                 h->omsg[p++] = (h->vp + 1439) / 1440 + 166;
1416                         } else if (h->vp < 635040) {
1417                                 h->omsg[p++] = (h->vp + 10079) / 10080 + 192;
1418                         } else {
1419                                 h->omsg[p++] = 255;         /* max */
1420                         }
1421                 }
1422                 p += packsms(h->dcs, h->omsg + p, h->udhl, h->udh, h->udl, h->ud);
1423         }
1424         h->omsg[1] = p - 2;
1425 }
1426
1427 /*! \brief find and fill in next message, or send a REL if none waiting */
1428 static void sms_nextoutgoing (sms_t * h)
1429 {         
1430         char fn[100 + NAME_MAX] = "";
1431         DIR *d;
1432         char more = 0;
1433
1434         *h->da = *h->oa = '\0';                 /* clear destinations */
1435         h->rx = 0;                              /* outgoing message */
1436         snprintf(fn, sizeof(fn), "%s/sms/%s", ast_config_AST_SPOOL_DIR, h->smsc ? "mttx" : "motx");
1437         ast_mkdir(fn, 0777);                    /* ensure it exists */
1438         d = opendir(fn);
1439         if (d) {
1440                 struct dirent *f = readdirqueue(d, h->queue);
1441                 if (f) {
1442                         snprintf(fn + strlen(fn), sizeof(fn) - strlen(fn), "/%s", f->d_name);
1443                         sms_readfile(h, fn);
1444                         if (readdirqueue(d, h->queue)) {
1445                                 more = 1;                   /* more to send */
1446                         }
1447                 }
1448                 closedir(d);
1449         }
1450         if (*h->da || *h->oa) {                 /* message to send */
1451                 if (h->protocol == 2) {
1452                         sms_compose2(h, more);
1453                 } else {
1454                         sms_compose1(h, more);
1455                 }
1456         } else {                                /* no message */
1457                 if (h->protocol == 2) {
1458                         h->omsg[0] = 0x17;              /* SMS_REL */
1459                         h->omsg[1] = 0;
1460                 } else {
1461                         h->omsg[0] = 0x94;              /* SMS_REL */
1462                         h->omsg[1] = 0;
1463                 }
1464         }
1465         sms_messagetx(h);
1466 }
1467
1468 #define DIR_RX 1
1469 #define DIR_TX 2
1470 static void sms_debug (int dir, sms_t *h)
1471 {
1472         char txt[259 * 3 + 1];
1473         char *p = txt;                          /* always long enough */
1474         unsigned char *msg = (dir == DIR_RX) ? h->imsg : h->omsg;
1475         int n = (dir == DIR_RX) ? h->ibytep : msg[1] + 2;
1476         int q = 0;
1477         while (q < n && q < 30) {
1478                 sprintf(p, " %02X", msg[q++]);
1479                 p += 3;
1480         }
1481         if (q < n) {
1482                 sprintf(p, "...");
1483         }
1484         ast_verb(3, "SMS %s%s\n", dir == DIR_RX ? "RX" : "TX", txt);
1485 }
1486
1487
1488 static void sms_messagerx(sms_t * h)
1489 {
1490         int cause;
1491
1492         sms_debug (DIR_RX, h);
1493         if (h->protocol == 2) {
1494                 sms_messagerx2(h);
1495                 return;
1496         }
1497         /* parse incoming message for Protocol 1 */
1498         switch (h->imsg[0]) {
1499         case 0x91:                              /* SMS_DATA */
1500                 cause = sms_handleincoming (h);
1501                 if (!cause) {
1502                         sms_log(h, 'Y');
1503                         h->omsg[0] = 0x95;              /* SMS_ACK */
1504                         h->omsg[1] = 0x02;
1505                         h->omsg[2] = 0x00;              /* deliver report */
1506                         h->omsg[3] = 0x00;              /* no parameters */
1507                 } else {                            /* NACK */
1508                         sms_log(h, 'N');
1509                         h->omsg[0] = 0x96;              /* SMS_NACK */
1510                         h->omsg[1] = 3;
1511                         h->omsg[2] = 0;                 /* delivery report */
1512                         h->omsg[3] = cause;             /* cause */
1513                         h->omsg[4] = 0;                 /* no parameters */
1514                 }
1515                 sms_messagetx(h);
1516                 break;
1517
1518         case 0x92:                              /* SMS_ERROR */
1519                 h->err = 1;
1520                 sms_messagetx(h);                   /* send whatever we sent again */
1521                 break;
1522         case 0x93:                              /* SMS_EST */
1523                 sms_nextoutgoing (h);
1524                 break;
1525         case 0x94:                              /* SMS_REL */
1526                 h->hangup = 1;                      /* hangup */
1527                 break;
1528         case 0x95:                              /* SMS_ACK */
1529                 sms_log(h, 'Y');
1530                 sms_nextoutgoing (h);
1531                 break;
1532         case 0x96:                              /* SMS_NACK */
1533                 h->err = 1;
1534                 sms_log(h, 'N');
1535                 sms_nextoutgoing (h);
1536                 break;
1537         default:                                /* Unknown */
1538                 h->omsg[0] = 0x92;                  /* SMS_ERROR */
1539                 h->omsg[1] = 1;
1540                 h->omsg[2] = 3;                     /* unknown message type */
1541                 sms_messagetx(h);
1542                 break;
1543         }
1544 }
1545
1546 static void sms_messagetx(sms_t * h)
1547 {
1548         unsigned char c = 0, p;
1549         int len = h->omsg[1] + 2;               /* total message length excluding checksum */
1550
1551         for (p = 0; p < len; p++) {             /* compute checksum */
1552                 c += h->omsg[p];
1553         }
1554         h->omsg[len] = 0 - c;                   /* actually, (256 - (c & 0fxx)) & 0xff) */
1555         sms_debug(DIR_TX, h);
1556         h->framenumber++;                       /* Proto 2 */
1557         h->obytep = 0;
1558         h->obitp = 0;
1559         if (h->protocol == 2) {                 /* Proto 2: */
1560                 h->oseizure = 300;                  /* 300bits (or more ?) */
1561                 h->obyte = 0;                       /* Seizure starts with  space (0) */
1562                 if (h->omsg[0] == 0x7F) {
1563                         h->opause = 8 * h->opause_0;    /* initial message delay */
1564                 } else {
1565                         h->opause = 400;
1566                 }
1567         } else {                                /* Proto 1: */
1568                 h->oseizure = 0;                    /* No seizure */
1569                 h->obyte = 1;                       /* send mark ('1') at the beginning */
1570                 /* Change the initial message delay. BT requires 300ms,
1571                  * but for others this might be way too much and the phone
1572                  * could time out. XXX make it configurable.
1573                 */
1574                 if (h->omsg[0] == 0x93) {
1575                         h->opause = 8 * h->opause_0;    /* initial message delay */
1576                 } else {
1577                         h->opause = 200;
1578                 }
1579         }
1580         /* Note - setting osync triggers the generator */
1581         h->osync = OSYNC_BITS;                  /* 80 sync bits */
1582         h->obyten = len + 1;                    /* bytes to send (including checksum) */
1583 }
1584
1585 /*!
1586  * outgoing data are produced by this generator function, that reads from
1587  * the descriptor whether it has data to send and which ones.
1588  */
1589 static int sms_generate(struct ast_channel *chan, void *data, int len, int samples)
1590 {
1591         struct ast_frame f = { 0 };
1592 #define MAXSAMPLES (800)
1593         output_t *buf;
1594         sms_t *h = data;
1595         int i;
1596
1597         if (samples > MAXSAMPLES) {
1598                 ast_log(LOG_WARNING, "Only doing %d samples (%d requested)\n",
1599                          MAXSAMPLES, samples);
1600                 samples = MAXSAMPLES;
1601         }
1602         len = samples * sizeof(*buf) + AST_FRIENDLY_OFFSET;
1603         buf = alloca(len);
1604
1605         f.frametype = AST_FRAME_VOICE;
1606         f.subclass = __OUT_FMT;
1607         f.datalen = samples * sizeof(*buf);
1608         f.offset = AST_FRIENDLY_OFFSET;
1609         f.mallocd = 0;
1610         f.data.ptr = buf;
1611         f.samples = samples;
1612         f.src = "app_sms";
1613         /* create a buffer containing the digital sms pattern */
1614         for (i = 0; i < samples; i++) {
1615                 buf[i] = wave_out[0];               /* default is silence */
1616
1617                 if (h->opause) {
1618                         h->opause--;
1619                 } else if (h->obyten || h->osync) { /* sending data */
1620                         buf[i] = wave_out[h->ophase];
1621                         h->ophase += (h->obyte & 1) ? 13 : 21; /* compute next phase */
1622                         if (h->ophase >= 80)
1623                                 h->ophase -= 80;
1624                         if ((h->ophasep += 12) >= 80) { /* time to send the next bit */
1625                                 h->ophasep -= 80;
1626                                 if (h->oseizure > 0) {      /* sending channel seizure (proto 2) */
1627                                         h->oseizure--;
1628                                         h->obyte ^= 1;          /* toggle low bit */
1629                                 } else if (h->osync) {
1630                                         h->obyte = 1;           /* send mark as sync bit */
1631                                         h->osync--;             /* sending sync bits */
1632                                         if (h->osync == 0 && h->protocol == 2 && h->omsg[0] == DLL2_SMS_EST) {
1633                                                 h->obytep = h->obyten = 0; /* we are done */
1634                                         }
1635                                 } else {
1636                                         h->obitp++;
1637                                         if (h->obitp == 1) {
1638                                                 h->obyte = 0;       /* start bit; */
1639                                         } else if (h->obitp == 2) {
1640                                                 h->obyte = h->omsg[h->obytep];
1641                                         } else if (h->obitp == 10) {
1642                                                 h->obyte = 1; /* stop bit */
1643                                                 h->obitp = 0;
1644                                                 h->obytep++;
1645                                                 if (h->obytep == h->obyten) {
1646                                                         h->obytep = h->obyten = 0; /* sent */
1647                                                         h->osync = 10;    /* trailing marks */
1648                                                 }
1649                                         } else {
1650                                                 h->obyte >>= 1;
1651                                         }
1652                                 }
1653                         }
1654                 }
1655         }
1656         if (ast_write(chan, &f) < 0) {
1657                 ast_log(LOG_WARNING, "Failed to write frame to '%s': %s\n", chan->name, strerror(errno));
1658                 return -1;
1659         }
1660         return 0;
1661 #undef MAXSAMPLES
1662 }
1663
1664 /*!
1665  * Just return the pointer to the descriptor that we received.
1666  */
1667 static void *sms_alloc(struct ast_channel *chan, void *sms_t_ptr)
1668 {
1669         return sms_t_ptr;
1670 }
1671
1672 static void sms_release(struct ast_channel *chan, void *data)
1673 {
1674         return; /* nothing to do here. */
1675 }
1676
1677 static struct ast_generator smsgen = {
1678         .alloc = sms_alloc,
1679         .release = sms_release,
1680         .generate = sms_generate,
1681 };
1682
1683 /*!
1684  * Process an incoming frame, trying to detect the carrier and
1685  * decode the message. The two frequencies are 1300 and 2100 Hz.
1686  * The decoder detects the amplitude of the signal over the last
1687  * few samples, filtering the absolute values with a lowpass filter.
1688  * If the magnitude (h->imag) is large enough, multiply the signal
1689  * by the two carriers, and compute the amplitudes m0 and m1.
1690  * Record the current sample as '0' or '1' depending on which one is greater.
1691  * The last 3 bits are stored in h->ibith, with the count of '1'
1692  * bits in h->ibitt.
1693  * XXX the rest is to be determined.
1694  */
1695 static void sms_process(sms_t * h, int samples, signed short *data)
1696 {
1697         int bit;
1698
1699         /*
1700          * Ignore incoming audio while a packet is being transmitted,
1701          * the protocol is half-duplex.
1702          * Unfortunately this means that if the outbound and incoming
1703          * transmission overlap (which is an error condition anyways),
1704          * we may miss some data and this makes debugging harder.
1705          */
1706         if (h->obyten || h->osync) {
1707                 return;
1708         }
1709         for ( ; samples-- ; data++) {
1710                 unsigned long long m0, m1;
1711                 if (abs(*data) > h->imag) {
1712                         h->imag = abs(*data);
1713                 } else {
1714                         h->imag = h->imag * 7 / 8;
1715                 }
1716                 if (h->imag <= 500) {               /* below [arbitrary] threahold: lost carrier */
1717                         if (h->idle++ == 80000) {       /* nothing happening */
1718                                 ast_log(LOG_NOTICE, "No data, hanging up\n");
1719                                 h->hangup = 1;
1720                                 h->err = 1;
1721                         }
1722                         if (h->ierr) {                  /* error */
1723                                 ast_log(LOG_NOTICE, "Error %d, hanging up\n", h->ierr);
1724                                 /* Protocol 1 */
1725                                 h->err = 1;
1726                                 h->omsg[0] = 0x92;          /* error */
1727                                 h->omsg[1] = 1;
1728                                 h->omsg[2] = h->ierr;
1729                                 sms_messagetx(h);           /* send error */
1730                         }
1731                         h->ierr = h->ibitn = h->ibytep = h->ibytec = 0;
1732                         continue;
1733                 }
1734                 h->idle = 0;
1735
1736                 /* multiply signal by the two carriers. */
1737                 h->ims0 = (h->ims0 * 6 + *data * wave[h->ips0]) / 7;
1738                 h->imc0 = (h->imc0 * 6 + *data * wave[h->ipc0]) / 7;
1739                 h->ims1 = (h->ims1 * 6 + *data * wave[h->ips1]) / 7;
1740                 h->imc1 = (h->imc1 * 6 + *data * wave[h->ipc1]) / 7;
1741                 /* compute the amplitudes */
1742                 m0 = h->ims0 * h->ims0 + h->imc0 * h->imc0;
1743                 m1 = h->ims1 * h->ims1 + h->imc1 * h->imc1;
1744
1745                 /* advance the sin/cos pointers */
1746                 if ((h->ips0 += 21) >= 80) {
1747                         h->ips0 -= 80;
1748                 }
1749                 if ((h->ipc0 += 21) >= 80) {
1750                         h->ipc0 -= 80;
1751                 }
1752                 if ((h->ips1 += 13) >= 80) {
1753                         h->ips1 -= 80;
1754                 }
1755                 if ((h->ipc1 += 13) >= 80) {
1756                         h->ipc1 -= 80;
1757                 }
1758
1759                 /* set new bit to 1 or 0 depending on which value is stronger */
1760                 h->ibith <<= 1;
1761                 if (m1 > m0) {
1762                         h->ibith |= 1;
1763                 }
1764                 if (h->ibith & 8) {
1765                         h->ibitt--;
1766                 }
1767                 if (h->ibith & 1) {
1768                         h->ibitt++;
1769                 }
1770                 bit = ((h->ibitt > 1) ? 1 : 0);
1771                 if (bit != h->ibitl) {
1772                         h->ibitc = 1;
1773                 } else {
1774                         h->ibitc++;
1775                 }
1776                 h->ibitl = bit;
1777                 if (!h->ibitn && h->ibitc == 4 && !bit) {
1778                         h->ibitn = 1;
1779                         h->iphasep = 0;
1780                 }
1781                 if (bit && h->ibitc == 200) {       /* sync, restart message */
1782                         /* Protocol 2: empty connection ready (I am master) */
1783                         if (h->framenumber < 0 && h->ibytec >= 160 && !memcmp(h->imsg, "UUUUUUUUUUUUUUUUUUUU", 20)) {
1784                                 h->framenumber = 1;
1785                                 ast_verb(3, "SMS protocol 2 detected\n");
1786                                 h->protocol = 2;
1787                                 h->imsg[0] = 0xff;          /* special message (fake) */
1788                                 h->imsg[1] = h->imsg[2] = 0x00;
1789                                 h->ierr = h->ibitn = h->ibytep = h->ibytec = 0;
1790                                 sms_messagerx(h);
1791                         }
1792                         h->ierr = h->ibitn = h->ibytep = h->ibytec = 0;
1793                 }
1794                 if (h->ibitn) {
1795                         h->iphasep += 12;
1796                         if (h->iphasep >= 80) {         /* next bit */
1797                                 h->iphasep -= 80;
1798                                 if (h->ibitn++ == 9) {      /* end of byte */
1799                                         if (!bit) {             /* bad stop bit */
1800                                                 ast_log(LOG_NOTICE, "bad stop bit");
1801                                                 h->ierr = 0xFF;     /* unknown error */
1802                                         } else {
1803                                                 if (h->ibytep < sizeof(h->imsg)) {
1804                                                         h->imsg[h->ibytep] = h->ibytev;
1805                                                         h->ibytec += h->ibytev;
1806                                                         h->ibytep++;
1807                                                 } else if (h->ibytep == sizeof(h->imsg)) {
1808                                                         ast_log(LOG_NOTICE, "msg too large");
1809                                                         h->ierr = 2;    /* bad message length */
1810                                                 }
1811                                                 if (h->ibytep > 1 && h->ibytep == 3 + h->imsg[1] && !h->ierr) {
1812                                                         if (!h->ibytec) {
1813                                                                 sms_messagerx(h);
1814                                                         } else {
1815                                                                 ast_log(LOG_NOTICE, "bad checksum");
1816                                                                 h->ierr = 1; /* bad checksum */
1817                                                         }
1818                                                 }
1819                                         }
1820                                         h->ibitn = 0;
1821                                 }
1822                                 h->ibytev = (h->ibytev >> 1) + (bit ? 0x80 : 0);
1823                         }
1824                 }
1825         }
1826 }
1827
1828 /*
1829  * Standard argument parsing:
1830  *      - one enum for the flags we recognise,
1831  *      - one enum for argument indexes
1832  *      - AST_APP_OPTIONS() to drive the parsing routine
1833  *      - in the function, AST_DECLARE_APP_ARGS(...) for the arguments.
1834  */
1835 enum sms_flags {
1836         OPTION_BE_SMSC  = (1 << 0),             /* act as sms center */
1837         OPTION_ANSWER   = (1 << 1),             /* answer on incoming calls */
1838         OPTION_TWO      = (1 << 2),                 /* Use Protocol Two */
1839         OPTION_PAUSE    = (1 << 3),             /* pause before sending data, in ms */
1840         OPTION_SRR      = (1 << 4),                 /* set srr */
1841         OPTION_DCS      = (1 << 5),                 /* set dcs */
1842 };
1843
1844 enum sms_opt_args {
1845         OPTION_ARG_PAUSE = 0,
1846         OPTION_ARG_ARRAY_SIZE
1847 };
1848
1849 AST_APP_OPTIONS(sms_options, {
1850         AST_APP_OPTION('s', OPTION_BE_SMSC),
1851         AST_APP_OPTION('a', OPTION_ANSWER),
1852         AST_APP_OPTION('t', OPTION_TWO),
1853         AST_APP_OPTION('r', OPTION_SRR),
1854         AST_APP_OPTION('o', OPTION_DCS),
1855         AST_APP_OPTION_ARG('p', OPTION_PAUSE, OPTION_ARG_PAUSE),
1856         } );
1857
1858 static int sms_exec(struct ast_channel *chan, const char *data)
1859 {
1860         int res = -1;
1861         sms_t h = { 0 };
1862         /* argument parsing support */
1863         struct ast_flags flags;
1864         char *parse, *sms_opts[OPTION_ARG_ARRAY_SIZE] = { 0, };
1865         char *p;
1866         AST_DECLARE_APP_ARGS(sms_args,
1867                 AST_APP_ARG(queue);
1868                 AST_APP_ARG(options);
1869                 AST_APP_ARG(addr);
1870                 AST_APP_ARG(body);
1871         );
1872
1873         if (!data) {
1874                 ast_log(LOG_ERROR, "Requires queue name at least\n");
1875                 return -1;
1876         }
1877
1878         parse = ast_strdupa(data);              /* create a local copy */
1879         AST_STANDARD_APP_ARGS(sms_args, parse);
1880         if (sms_args.argc > 1) {
1881                 ast_app_parse_options(sms_options, &flags, sms_opts, sms_args.options);
1882         }
1883
1884         ast_verb(1, "sms argc %d queue <%s> opts <%s> addr <%s> body <%s>\n",
1885                 sms_args.argc, S_OR(sms_args.queue, ""),
1886                 S_OR(sms_args.options, ""),
1887                 S_OR(sms_args.addr, ""),
1888                 S_OR(sms_args.body, "") );
1889
1890         h.ipc0 = h.ipc1 = 20;                   /* phase for cosine */
1891         h.dcs = 0xF1;                           /* default */
1892
1893         if (chan->cid.cid_num)
1894                 ast_copy_string(h.cli, chan->cid.cid_num, sizeof(h.cli));
1895
1896         if (ast_strlen_zero(sms_args.queue)) {
1897                 ast_log(LOG_ERROR, "Requires queue name\n");
1898                 goto done;
1899         }
1900         if (strlen(sms_args.queue) >= sizeof(h.queue)) {
1901                 ast_log(LOG_ERROR, "Queue name too long\n");
1902                 goto done;
1903         }
1904         ast_copy_string(h.queue, sms_args.queue, sizeof(h.queue));
1905
1906         for (p = h.queue; *p; p++) {
1907                 if (!isalnum(*p)) {
1908                         *p = '-';                       /* make very safe for filenames */
1909                 }
1910         }
1911
1912         h.smsc = ast_test_flag(&flags, OPTION_BE_SMSC);
1913         h.protocol = ast_test_flag(&flags, OPTION_TWO) ? 2 : 1;
1914         if (!ast_strlen_zero(sms_opts[OPTION_ARG_PAUSE])) {
1915                 h.opause_0 = atoi(sms_opts[OPTION_ARG_PAUSE]);
1916         }
1917         if (h.opause_0 < 25 || h.opause_0 > 2000) {
1918                 h.opause_0 = 300;                   /* default 300ms */
1919         }
1920         ast_verb(1, "initial delay %dms\n", h.opause_0);
1921
1922
1923         /* the following apply if there is an arg3/4 and apply to the created message file */
1924         if (ast_test_flag(&flags, OPTION_SRR)) {
1925                 h.srr = 1;
1926         }
1927         if (ast_test_flag(&flags, OPTION_DCS)) {
1928                 h.dcs = 1;
1929         }
1930 #if 0   
1931                 case '1':
1932                 case '2':
1933                 case '3':
1934                 case '4':
1935                 case '5':
1936                 case '6':
1937                 case '7':                           /* set the pid for saved local message */
1938                         h.pid = 0x40 + (*d & 0xF);
1939                         break;
1940                 }
1941 #endif
1942         if (sms_args.argc > 2) {
1943                 unsigned char *up;
1944
1945                 /* submitting a message, not taking call. */
1946                 /* deprecated, use smsq instead */
1947                 h.scts = ast_tvnow();
1948                 if (ast_strlen_zero(sms_args.addr) || strlen(sms_args.addr) >= sizeof(h.oa)) {
1949                         ast_log(LOG_ERROR, "Address too long %s\n", sms_args.addr);
1950                         goto done;
1951                 }
1952                 if (h.smsc) {
1953                         ast_copy_string(h.oa, sms_args.addr, sizeof(h.oa));
1954                 } else {
1955                         ast_copy_string(h.da, sms_args.addr, sizeof(h.da));
1956                         ast_copy_string(h.oa, h.cli, sizeof(h.oa));
1957                 }
1958                 h.udl = 0;
1959                 if (ast_strlen_zero(sms_args.body)) {
1960                         ast_log(LOG_ERROR, "Missing body for %s\n", sms_args.addr);
1961                         goto done;
1962                 }
1963                 up = (unsigned char *)sms_args.body;
1964                 while (*up && h.udl < SMSLEN) {
1965                         h.ud[h.udl++] = utf8decode(&up);
1966                 }
1967                 if (is7bit(h.dcs) && packsms7(0, h.udhl, h.udh, h.udl, h.ud) < 0) {
1968                         ast_log(LOG_WARNING, "Invalid 7 bit GSM data\n");
1969                         goto done;
1970                 }
1971                 if (is8bit(h.dcs) && packsms8(0, h.udhl, h.udh, h.udl, h.ud) < 0) {
1972                         ast_log(LOG_WARNING, "Invalid 8 bit data\n");
1973                         goto done;
1974                 }
1975                 if (is16bit(h.dcs) && packsms16(0, h.udhl, h.udh, h.udl, h.ud) < 0) {
1976                         ast_log(LOG_WARNING, "Invalid 16 bit data\n");
1977                         goto done;
1978                 }
1979                 h.rx = 0;                           /* sent message */
1980                 h.mr = -1;
1981                 sms_writefile(&h);
1982                 res = h.err;
1983                 goto done;
1984         }
1985         
1986         if (chan->_state != AST_STATE_UP) {             /* make sure channel is answered before any TX */
1987                 ast_answer(chan);
1988         }
1989
1990         if (ast_test_flag(&flags, OPTION_ANSWER)) {
1991                 h.framenumber = 1;                  /* Proto 2 */
1992                 /* set up SMS_EST initial message */
1993                 if (h.protocol == 2) {
1994                         h.omsg[0] = DLL2_SMS_EST;
1995                         h.omsg[1] = 0;
1996                 } else {
1997                         h.omsg[0] = DLL1_SMS_EST | DLL1_SMS_COMPLETE;
1998                         h.omsg[1] = 0;
1999                 }
2000                 sms_messagetx(&h);
2001         }
2002
2003         res = ast_set_write_format(chan, __OUT_FMT);
2004         if (res >= 0) {
2005                 res = ast_set_read_format(chan, AST_FORMAT_SLINEAR);
2006         }
2007         if (res < 0) {
2008                 ast_log(LOG_ERROR, "Unable to set to linear mode, giving up\n");
2009                 goto done;
2010         }
2011
2012         if ( (res = ast_activate_generator(chan, &smsgen, &h)) < 0) {
2013                 ast_log(LOG_ERROR, "Failed to activate generator on '%s'\n", chan->name);
2014                 goto done;
2015         }
2016
2017         /* Do our thing here */
2018         for (;;) {
2019                 struct ast_frame *f;
2020                 int i = ast_waitfor(chan, -1);
2021                 if (i < 0) {
2022                         ast_log(LOG_NOTICE, "waitfor failed\n");
2023                         break;
2024                 }
2025                 if (h.hangup) {
2026                         ast_log(LOG_NOTICE, "channel hangup\n");
2027                         break;
2028                 }
2029                 f = ast_read(chan);
2030                 if (!f) {
2031                         ast_log(LOG_NOTICE, "ast_read failed\n");
2032                         break;
2033                 }
2034                 if (f->frametype == AST_FRAME_VOICE) {
2035                         sms_process(&h, f->samples, f->data.ptr);
2036                 }
2037
2038                 ast_frfree(f);
2039         }
2040         res = h.err;                            /* XXX */
2041
2042         sms_log(&h, '?');                       /* log incomplete message */
2043 done:
2044         return (res);
2045 }
2046
2047 static int unload_module(void)
2048 {
2049         return ast_unregister_application(app);
2050 }
2051
2052 static int load_module(void)
2053 {
2054 #ifdef OUTALAW
2055         int p;
2056         for (p = 0; p < 80; p++) {
2057                 wavea[p] = AST_LIN2A(wave[p]);
2058         }
2059 #endif
2060         snprintf(log_file, sizeof(log_file), "%s/sms", ast_config_AST_LOG_DIR);
2061         return ast_register_application_xml(app, sms_exec);
2062 }
2063
2064 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "SMS/PSTN handler");