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