Test for Asterisk Version info
[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--) {
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                 unpacksms16(i, l, udh, udhl, ud, udl, udhi);
718         }
719         return l + 1;
720 }
721
722 /*! \brief unpack an address from i, return byte length, unpack to o */
723 static unsigned char unpackaddress(char *o, unsigned char *i)
724 {
725         unsigned char l = i[0], p;
726         if (i[1] == 0x91) {
727                 *o++ = '+';
728         }
729         for (p = 0; p < l; p++) {
730                 if (p & 1) {
731                         *o++ = (i[2 + p / 2] >> 4) + '0';
732                 } else {
733                         *o++ = (i[2 + p / 2] & 0xF) + '0';
734                 }
735         }
736         *o = 0;
737         return (l + 5) / 2;
738 }
739
740 /*! \brief store an address at o, and return number of bytes used */
741 static unsigned char packaddress(unsigned char *o, char *i)
742 {
743         unsigned char p = 2;
744         o[0] = 0;                               /* number of bytes */
745         if (*i == '+') {                        /* record as bit 0 in byte 1 */
746                 i++;
747                 o[1] = 0x91;
748         } else {
749                 o[1] = 0x81;
750         }
751         for ( ; *i ; i++) {
752                 if (!isdigit(*i)) {                 /* ignore non-digits */
753                         continue;
754                 }
755                 if (o[0] & 1) {
756                         o[p++] |= ((*i & 0xF) << 4);
757                 } else {
758                         o[p] = (*i & 0xF);
759                 }
760                 o[0]++;
761         }
762         if (o[0] & 1) {
763                 o[p++] |= 0xF0;                     /* pad */
764         }
765         return p;
766 }
767
768 /*! \brief Log the output, and remove file */
769 static void sms_log(sms_t * h, char status)
770 {
771         int o;
772
773         if (*h->oa == '\0' && *h->da == '\0') {
774                 return;
775         }
776         o = open(log_file, O_CREAT | O_APPEND | O_WRONLY, AST_FILE_MODE);
777         if (o >= 0) {
778                 char line[1000], mrs[3] = "", *p;
779                 char buf[30];
780                 unsigned char n;
781
782                 if (h->mr >= 0) {
783                         snprintf(mrs, sizeof(mrs), "%02X", h->mr);
784                 }
785                 snprintf(line, sizeof(line), "%s %c%c%c%s %s %s %s ",
786                         isodate(time(NULL), buf, sizeof(buf)),
787                         status, h->rx ? 'I' : 'O', h->smsc ? 'S' : 'M', mrs, h->queue,
788                         S_OR(h->oa, "-"), S_OR(h->da, "-") );
789                 p = line + strlen(line);
790                 for (n = 0; n < h->udl; n++) {
791                         if (h->ud[n] == '\\') {
792                                 *p++ = '\\';
793                                 *p++ = '\\';
794                         } else if (h->ud[n] == '\n') {
795                                 *p++ = '\\';
796                                 *p++ = 'n';
797                         } else if (h->ud[n] == '\r') {
798                                 *p++ = '\\';
799                                 *p++ = 'r';
800                         } else if (h->ud[n] < 32 || h->ud[n] == 127) {
801                                 *p++ = 191;
802                         } else {
803                                 *p++ = h->ud[n];
804                         }
805                 }
806                 *p++ = '\n';
807                 *p = 0;
808                 if (write(o, line, strlen(line)) < 0) {
809                         ast_log(LOG_WARNING, "write() failed: %s\n", strerror(errno));
810                 }
811                 close(o);
812         }
813         *h->oa = *h->da = h->udl = 0;
814 }
815
816 /*! \brief parse and delete a file */
817 static void sms_readfile(sms_t * h, char *fn)
818 {
819         char line[1000];
820         FILE *s;
821         char dcsset = 0;                        /* if DSC set */
822         ast_log(LOG_NOTICE, "Sending %s\n", fn);
823         h->rx = h->udl = *h->oa = *h->da = h->pid = h->srr = h->udhi = h->rp = h->vp = h->udhl = 0;
824         h->mr = -1;
825         h->dcs = 0xF1;                          /* normal messages class 1 */
826         h->scts = ast_tvnow();
827         s = fopen(fn, "r");
828         if (s) {
829                 if (unlink(fn)) {                   /* concurrent access, we lost */
830                         fclose(s);
831                         return;
832                 }
833                 while (fgets (line, sizeof(line), s)) { /* process line in file */
834                         char *p;
835                         void *pp = &p;
836                         for (p = line; *p && *p != '\n' && *p != '\r'; p++);
837                         *p = 0;                         /* strip eoln */
838                         p = line;
839                         if (!*p || *p == ';') {
840                                 continue;                   /* blank line or comment, ignore */
841                         }
842                         while (isalnum(*p)) {
843                                 *p = tolower (*p);
844                                 p++;
845                         }
846                         while (isspace (*p)) {
847                                 *p++ = 0;
848                         }
849                         if (*p == '=') {
850                                 *p++ = 0;
851                                 if (!strcmp(line, "ud")) {  /* parse message (UTF-8) */
852                                         unsigned char o = 0;
853                                         memcpy(h->udtxt, p, SMSLEN); /* for protocol 2 */
854                                         while (*p && o < SMSLEN) {
855                                                 h->ud[o++] = utf8decode(pp);
856                                         }
857                                         h->udl = o;
858                                         if (*p) {
859                                                 ast_log(LOG_WARNING, "UD too long in %s\n", fn);
860                                         }
861                                 } else {
862                                         while (isspace (*p)) {
863                                                 p++;
864                                         }
865                                         if (!strcmp(line, "oa") && strlen(p) < sizeof(h->oa)) {
866                                                 numcpy (h->oa, p);
867                                         } else if (!strcmp(line, "da") && strlen(p) < sizeof(h->oa)) {
868                                                 numcpy (h->da, p);
869                                         } else if (!strcmp(line, "pid")) {
870                                                 h->pid = atoi(p);
871                                         } else if (!strcmp(line, "dcs")) {
872                                                 h->dcs = atoi(p);
873                                                 dcsset = 1;
874                                         } else if (!strcmp(line, "mr")) {
875                                                 h->mr = atoi(p);
876                                         } else if (!strcmp(line, "srr")) {
877                                                 h->srr = (atoi(p) ? 1 : 0);
878                                         } else if (!strcmp(line, "vp")) {
879                                                 h->vp = atoi(p);
880                                         } else if (!strcmp(line, "rp")) {
881                                                 h->rp = (atoi(p) ? 1 : 0);
882                                         } else if (!strcmp(line, "scts")) {    /* get date/time */
883                                                 int Y, m, d, H, M, S;
884                                                 /* XXX Why aren't we using ast_strptime here? */
885                                                 if (sscanf(p, "%4d-%2d-%2dT%2d:%2d:%2d", &Y, &m, &d, &H, &M, &S) == 6) {
886                                                         struct ast_tm t = { 0, };
887                                                         t.tm_year = Y - 1900;
888                                                         t.tm_mon = m - 1;
889                                                         t.tm_mday = d;
890                                                         t.tm_hour = H;
891                                                         t.tm_min = M;
892                                                         t.tm_sec = S;
893                                                         t.tm_isdst = -1;
894                                                         h->scts = ast_mktime(&t, NULL);
895                                                         if (h->scts.tv_sec == 0) {
896                                                                 ast_log(LOG_WARNING, "Bad date/timein %s: %s", fn, p);
897                                                         }
898                                                 }
899                                         } else {
900                                                 ast_log(LOG_WARNING, "Cannot parse in %s: %s=%si\n", fn, line, p);
901                                         }
902                                 }
903                         } else if (*p == '#') {                   /* raw hex format */
904                                 *p++ = 0;
905                                 if (*p == '#') {
906                                         p++;
907                                         if (!strcmp(line, "ud")) {        /* user data */
908                                                 int o = 0;
909                                                 while (*p && o < SMSLEN) {
910                                                         if (isxdigit(*p) && isxdigit(p[1]) && isxdigit(p[2]) && isxdigit(p[3])) {
911                                                                 h->ud[o++] =
912                                                                         (((isalpha(*p) ? 9 : 0) + (*p & 0xF)) << 12) +
913                                                                         (((isalpha(p[1]) ? 9 : 0) + (p[1] & 0xF)) << 8) +
914                                                                         (((isalpha(p[2]) ? 9 : 0) + (p[2] & 0xF)) << 4) + ((isalpha(p[3]) ? 9 : 0) + (p[3] & 0xF));
915                                                                 p += 4;
916                                                         } else
917                                                                 break;
918                                                 }
919                                                 h->udl = o;
920                                                 if (*p)
921                                                         ast_log(LOG_WARNING, "UD too long / invalid UCS-2 hex in %s\n", fn);
922                                         } else
923                                                 ast_log(LOG_WARNING, "Only ud can use ## format, %s\n", fn);
924                                 } else if (!strcmp(line, "ud")) {       /* user data */
925                                         int o = 0;
926                                         while (*p && o < SMSLEN) {
927                                                 if (isxdigit(*p) && isxdigit(p[1])) {
928                                                         h->ud[o++] = (((isalpha(*p) ? 9 : 0) + (*p & 0xF)) << 4) + ((isalpha(p[1]) ? 9 : 0) + (p[1] & 0xF));
929                                                         p += 2;
930                                                 } else {
931                                                         break;
932                                                 }
933                                         }
934                                         h->udl = o;
935                                         if (*p) {
936                                                 ast_log(LOG_WARNING, "UD too long / invalid UCS-1 hex in %s\n", fn);
937                                         }
938                                 } else if (!strcmp(line, "udh")) {      /* user data header */
939                                         unsigned char o = 0;
940                                         h->udhi = 1;
941                                         while (*p && o < SMSLEN) {
942                                                 if (isxdigit(*p) && isxdigit(p[1])) {
943                                                         h->udh[o] = (((isalpha(*p) ? 9 : 0) + (*p & 0xF)) << 4) + ((isalpha(p[1]) ? 9 : 0) + (p[1] & 0xF));
944                                                         o++;
945                                                         p += 2;
946                                                 } else {
947                                                         break;
948                                                 }
949                                         }
950                                         h->udhl = o;
951                                         if (*p) {
952                                                 ast_log(LOG_WARNING, "UDH too long / invalid hex in %s\n", fn);
953                                         }
954                                 } else {
955                                         ast_log(LOG_WARNING, "Only ud and udh can use # format, %s\n", fn);
956                                 }
957                         } else {
958                                 ast_log(LOG_WARNING, "Cannot parse in %s: %s\n", fn, line);
959                         }
960                 }
961                 fclose(s);
962                 if (!dcsset && packsms7(0, h->udhl, h->udh, h->udl, h->ud) < 0) {
963                         if (packsms8(0, h->udhl, h->udh, h->udl, h->ud) < 0) {
964                                 if (packsms16(0, h->udhl, h->udh, h->udl, h->ud) < 0) {
965                                         ast_log(LOG_WARNING, "Invalid UTF-8 message even for UCS-2 (%s)\n", fn);
966                                 } else {
967                                         h->dcs = 0x08;          /* default to 16 bit */
968                                         ast_log(LOG_WARNING, "Sending in 16 bit format(%s)\n", fn);
969                                 }
970                         } else {
971                                 h->dcs = 0xF5;              /* default to 8 bit */
972                                 ast_log(LOG_WARNING, "Sending in 8 bit format(%s)\n", fn);
973                         }
974                 }
975                 if (is7bit(h->dcs) && packsms7(0, h->udhl, h->udh, h->udl, h->ud) < 0) {
976                         ast_log(LOG_WARNING, "Invalid 7 bit GSM data %s\n", fn);
977                 }
978                 if (is8bit(h->dcs) && packsms8(0, h->udhl, h->udh, h->udl, h->ud) < 0) {
979                         ast_log(LOG_WARNING, "Invalid 8 bit data %s\n", fn);
980                 }
981                 if (is16bit(h->dcs) && packsms16(0, h->udhl, h->udh, h->udl, h->ud) < 0) {
982                         ast_log(LOG_WARNING, "Invalid 16 bit data %s\n", fn);
983                 }
984         }
985 }
986
987 /*! \brief white a received text message to a file */
988 static void sms_writefile(sms_t * h)
989 {
990         char fn[200] = "", fn2[200] = "";
991         char buf[30];
992         FILE *o;
993
994         if (ast_tvzero(h->scts)) {
995                 h->scts = ast_tvnow();
996         }
997         snprintf(fn, sizeof(fn), "%s/sms/%s", ast_config_AST_SPOOL_DIR, h->smsc ? h->rx ? "morx" : "mttx" : h->rx ? "mtrx" : "motx");
998         ast_mkdir(fn, 0777);                    /* ensure it exists */
999         ast_copy_string(fn2, fn, sizeof(fn2));
1000         snprintf(fn2 + strlen(fn2), sizeof(fn2) - strlen(fn2), "/%s.%s-%d", h->queue, isodate(h->scts.tv_sec, buf, sizeof(buf)), seq++);
1001         snprintf(fn + strlen(fn), sizeof(fn) - strlen(fn), "/.%s", fn2 + strlen(fn) + 1);
1002         if ((o = fopen(fn, "w")) == NULL) {
1003                 return;
1004         }
1005
1006         if (*h->oa) {
1007                 fprintf(o, "oa=%s\n", h->oa);
1008         }
1009         if (*h->da) {
1010                 fprintf(o, "da=%s\n", h->da);
1011         }
1012         if (h->udhi) {
1013                 unsigned int p;
1014                 fprintf(o, "udh#");
1015                 for (p = 0; p < h->udhl; p++) {
1016                         fprintf(o, "%02X", h->udh[p]);
1017                 }
1018                 fprintf(o, "\n");
1019         }
1020         if (h->udl) {
1021                 unsigned int p;
1022                 for (p = 0; p < h->udl && h->ud[p] >= ' '; p++);
1023                 if (p < h->udl) {
1024                         fputc(';', o);                  /* cannot use ud=, but include as a comment for human readable */
1025                 }
1026                 fprintf(o, "ud=");
1027                 for (p = 0; p < h->udl; p++) {
1028                         unsigned short v = h->ud[p];
1029                         if (v < 32) {
1030                                 fputc(191, o);
1031                         } else if (v < 0x80) {
1032                                 fputc(v, o);
1033                         } else if (v < 0x800) {
1034                                 fputc(0xC0 + (v >> 6), o);
1035                                 fputc(0x80 + (v & 0x3F), o);
1036                         } else {
1037                                 fputc(0xE0 + (v >> 12), o);
1038                                 fputc(0x80 + ((v >> 6) & 0x3F), o);
1039                                 fputc(0x80 + (v & 0x3F), o);
1040                         }
1041                 }
1042                 fprintf(o, "\n");
1043                 for (p = 0; p < h->udl && h->ud[p] >= ' '; p++);
1044                 if (p < h->udl) {
1045                         for (p = 0; p < h->udl && h->ud[p] < 0x100; p++);
1046                         if (p == h->udl) {              /* can write in ucs-1 hex */
1047                                 fprintf(o, "ud#");
1048                                 for (p = 0; p < h->udl; p++) {
1049                                         fprintf(o, "%02X", h->ud[p]);
1050                                 }
1051                                 fprintf(o, "\n");
1052                         } else {                        /* write in UCS-2 */
1053                                 fprintf(o, "ud##");
1054                                 for (p = 0; p < h->udl; p++) {
1055                                         fprintf(o, "%04X", h->ud[p]);
1056                                 }
1057                                 fprintf(o, "\n");
1058                         }
1059                 }
1060         }
1061         if (h->scts.tv_sec) {
1062                 char datebuf[30];
1063                 fprintf(o, "scts=%s\n", isodate(h->scts.tv_sec, datebuf, sizeof(datebuf)));
1064         }
1065         if (h->pid) {
1066                 fprintf(o, "pid=%d\n", h->pid);
1067         }
1068         if (h->dcs != 0xF1) {
1069                 fprintf(o, "dcs=%d\n", h->dcs);
1070         }
1071         if (h->vp) {
1072                 fprintf(o, "vp=%d\n", h->vp);
1073         }
1074         if (h->srr) {
1075                 fprintf(o, "srr=1\n");
1076         }
1077         if (h->mr >= 0) {
1078                 fprintf(o, "mr=%d\n", h->mr);
1079         }
1080         if (h->rp) {
1081                 fprintf(o, "rp=1\n");
1082         }
1083         fclose(o);
1084         if (rename(fn, fn2)) {
1085                 unlink(fn);
1086         } else {
1087                 ast_log(LOG_NOTICE, "Received to %s\n", fn2);
1088         }
1089 }
1090
1091 /*! \brief read dir skipping dot files... */
1092 static struct dirent *readdirqueue(DIR *d, char *queue)
1093 {
1094         struct dirent *f;
1095         do {
1096                 f = readdir(d);
1097         } while (f && (*f->d_name == '.' || strncmp(f->d_name, queue, strlen(queue)) || f->d_name[strlen(queue)] != '.'));
1098         return f;
1099 }
1100
1101 /*! \brief handle the incoming message */
1102 static unsigned char sms_handleincoming (sms_t * h)
1103 {
1104         unsigned char p = 3;
1105         if (h->smsc) {                          /* SMSC */
1106                 if ((h->imsg[2] & 3) == 1) {        /* SMS-SUBMIT */
1107                         h->udhl = h->udl = 0;
1108                         h->vp = 0;
1109                         h->srr = ((h->imsg[2] & 0x20) ? 1 : 0);
1110                         h->udhi = ((h->imsg[2] & 0x40) ? 1 : 0);
1111                         h->rp = ((h->imsg[2] & 0x80) ? 1 : 0);
1112                         ast_copy_string(h->oa, h->cli, sizeof(h->oa));
1113                         h->scts = ast_tvnow();
1114                         h->mr = h->imsg[p++];
1115                         p += unpackaddress(h->da, h->imsg + p);
1116                         h->pid = h->imsg[p++];
1117                         h->dcs = h->imsg[p++];
1118                         if ((h->imsg[2] & 0x18) == 0x10) {       /* relative VP */
1119                                 if (h->imsg[p] < 144) {
1120                                         h->vp = (h->imsg[p] + 1) * 5;
1121                                 } else if (h->imsg[p] < 168) {
1122                                         h->vp = 720 + (h->imsg[p] - 143) * 30;
1123                                 } else if (h->imsg[p] < 197) {
1124                                         h->vp = (h->imsg[p] - 166) * 1440;
1125                                 } else {
1126                                         h->vp = (h->imsg[p] - 192) * 10080;
1127                                 }
1128                                 p++;
1129                         } else if (h->imsg[2] & 0x18) {
1130                                 p += 7;                     /* ignore enhanced / absolute VP */
1131                         }
1132                         p += unpacksms(h->dcs, h->imsg + p, h->udh, &h->udhl, h->ud, &h->udl, h->udhi);
1133                         h->rx = 1;                      /* received message */
1134                         sms_writefile(h);               /* write the file */
1135                         if (p != h->imsg[1] + 2) {
1136                                 ast_log(LOG_WARNING, "Mismatch receive unpacking %d/%d\n", p, h->imsg[1] + 2);
1137                                 return 0xFF;              /* duh! */
1138                         }
1139                 } else {
1140                         ast_log(LOG_WARNING, "Unknown message type %02X\n", h->imsg[2]);
1141                         return 0xFF;
1142                 }
1143         } else {                                /* client */
1144                 if (!(h->imsg[2] & 3)) {            /* SMS-DELIVER */
1145                         *h->da = h->srr = h->rp = h->vp = h->udhi = h->udhl = h->udl = 0;
1146                         h->srr = ((h->imsg[2] & 0x20) ? 1 : 0);
1147                         h->udhi = ((h->imsg[2] & 0x40) ? 1 : 0);
1148                         h->rp = ((h->imsg[2] & 0x80) ? 1 : 0);
1149                         h->mr = -1;
1150                         p += unpackaddress(h->oa, h->imsg + p);
1151                         h->pid = h->imsg[p++];
1152                         h->dcs = h->imsg[p++];
1153                         h->scts = unpackdate(h->imsg + p);
1154                         p += 7;
1155                         p += unpacksms(h->dcs, h->imsg + p, h->udh, &h->udhl, h->ud, &h->udl, h->udhi);
1156                         h->rx = 1;                      /* received message */
1157                         sms_writefile(h);               /* write the file */
1158                         if (p != h->imsg[1] + 2) {
1159                                 ast_log(LOG_WARNING, "Mismatch receive unpacking %d/%d\n", p, h->imsg[1] + 2);
1160                                 return 0xFF;                /* duh! */
1161                         }
1162                 } else {
1163                         ast_log(LOG_WARNING, "Unknown message type %02X\n", h->imsg[2]);
1164                         return 0xFF;
1165                 }
1166         }
1167         return 0;                               /* no error */
1168 }
1169
1170 #ifdef SOLARIS
1171 #define NAME_MAX 1024
1172 #endif
1173
1174 /*!
1175  * Add data to a protocol 2 message.
1176  * Use the length field (h->omsg[1]) as a pointer to the next free position.
1177  */
1178 static void adddata_proto2(sms_t *h, unsigned char msg, char *data, int size)
1179 {
1180         int x = h->omsg[1] + 2;                 /* Get current position */
1181         if (x == 2) {
1182                 x += 2;                             /* First: skip Payload length (set later) */
1183         }
1184         h->omsg[x++] = msg;                     /* Message code */
1185         h->omsg[x++] = (unsigned char)size;     /* Data size Low */
1186         h->omsg[x++] = 0;                       /* Data size Hi */
1187         for (; size > 0 ; size--) {
1188                 h->omsg[x++] = *data++;
1189         }
1190         h->omsg[1] = x - 2;                     /* Frame size */
1191         h->omsg[2] = x - 4;                     /* Payload length (Lo) */
1192         h->omsg[3] = 0;                         /* Payload length (Hi) */
1193 }
1194
1195 static void putdummydata_proto2(sms_t *h)
1196 {
1197         adddata_proto2(h, 0x10, "\0", 1);           /* Media Identifier > SMS */
1198         adddata_proto2(h, 0x11, "\0\0\0\0\0\0", 6); /* Firmware version */
1199         adddata_proto2(h, 0x12, "\2\0\4", 3);       /* SMS provider ID */
1200         adddata_proto2(h, 0x13, h->udtxt, h->udl);  /* Body */
1201 }
1202
1203 static void sms_compose2(sms_t *h, int more)
1204 {
1205         struct ast_tm tm;
1206         struct timeval now = h->scts;
1207         char stm[9];
1208
1209         h->omsg[0] = 0x00;                      /* set later... */
1210         h->omsg[1] = 0;
1211         putdummydata_proto2(h);
1212         if (h->smsc) {                          /* deliver */
1213                 h->omsg[0] = 0x11;                  /* SMS_DELIVERY */
1214                 /* Required: 10 11 12 13 14 15 17 (seems they must be ordered!) */
1215                 ast_localtime(&now, &tm, NULL);
1216                 sprintf(stm, "%02d%02d%02d%02d", tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min);  /* Date mmddHHMM */
1217                 adddata_proto2(h, 0x14, stm, 8);    /* Date */
1218                 if (*h->oa == 0) {
1219                         strcpy(h->oa, "00000000");
1220                 }
1221                 adddata_proto2(h, 0x15, h->oa, strlen(h->oa)); /* Originator */
1222                 adddata_proto2(h, 0x17, "\1", 1);   /* Calling Terminal ID */
1223         } else {                                /* submit */
1224                 h->omsg[0] = 0x10;                  /* SMS_SUBMIT */
1225                 /* Required: 10 11 12 13 17 18 1B 1C (seems they must be ordered!) */
1226                 adddata_proto2(h, 0x17, "\1", 1);   /* Calling Terminal ID */
1227                 if (*h->da == 0) {
1228                         strcpy(h->da, "00000000");
1229                 }
1230                 adddata_proto2(h, 0x18, h->da, strlen(h->da)); /* Originator */
1231                 adddata_proto2(h, 0x1B, "\1", 1);             /* Called Terminal ID */
1232                 adddata_proto2(h, 0x1C, "\0\0\0", 3);     /* Notification */
1233         }
1234 }
1235
1236 static void putdummydata_proto2(sms_t *h);
1237
1238 #define MAX_DEBUG_LEN   300
1239 static char *sms_hexdump(unsigned char buf[], int size, char *s /* destination */)
1240 {
1241         char *p;
1242         int f;
1243
1244         for (p = s, f = 0; f < size && f < MAX_DEBUG_LEN; f++, p += 3) {
1245                 sprintf(p, "%02X ", (unsigned char)buf[f]);
1246         }
1247         return(s);
1248 }
1249
1250
1251 /*! \brief sms_handleincoming_proto2: handle the incoming message */
1252 static int sms_handleincoming_proto2(sms_t *h)
1253 {
1254         int f, i, sz = 0;
1255         int msg, msgsz;
1256         struct ast_tm tm;
1257         struct timeval now = { 0, 0 };
1258         char debug_buf[MAX_DEBUG_LEN * 3 + 1];
1259
1260         sz = h->imsg[1] + 2;
1261         /* ast_verb(3, "SMS-P2 Frame: %s\n", sms_hexdump(h->imsg, sz, debug_buf)); */
1262
1263         /* Parse message body (called payload) */
1264         now = h->scts = ast_tvnow();
1265         for (f = 4; f < sz; ) {
1266                 msg = h->imsg[f++];
1267                 msgsz = h->imsg[f++];
1268                 msgsz += (h->imsg[f++] * 256);
1269                 switch (msg) {
1270                 case 0x13:                          /* Body */
1271                         ast_verb(3, "SMS-P2 Body#%02X=[%.*s]\n", msg, msgsz, &h->imsg[f]);
1272                         if (msgsz >= sizeof(h->ud)) {
1273                                 msgsz = sizeof(h->ud) - 1;
1274                         }
1275                         for (i = 0; i < msgsz; i++) {
1276                                 h->ud[i] = h->imsg[f + i];
1277                         }
1278                         h->udl = msgsz;
1279                         break;
1280                 case 0x14:                          /* Date SCTS */
1281                         now = h->scts = ast_tvnow();
1282                         ast_localtime(&now, &tm, NULL);
1283                         tm.tm_mon = ( (h->imsg[f] * 10) + h->imsg[f + 1] ) - 1;
1284                         tm.tm_mday = ( (h->imsg[f + 2] * 10) + h->imsg[f + 3] );
1285                         tm.tm_hour = ( (h->imsg[f + 4] * 10) + h->imsg[f + 5] );
1286                         tm.tm_min = ( (h->imsg[f + 6] * 10) + h->imsg[f + 7] );
1287                         tm.tm_sec = 0;
1288                         h->scts = ast_mktime(&tm, NULL);
1289                         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);
1290                         break;
1291                 case 0x15:                          /* Calling line (from SMSC) */
1292                         if (msgsz >= 20) {
1293                                 msgsz = 20 - 1;
1294                         }
1295                         ast_verb(3, "SMS-P2 Origin#%02X=[%.*s]\n", msg, msgsz, &h->imsg[f]);
1296                         ast_copy_string(h->oa, (char *)(&h->imsg[f]), msgsz + 1);
1297                         break;
1298                 case 0x18:                          /* Destination(from TE/phone) */
1299                         if (msgsz >= 20) {
1300                                 msgsz = 20 - 1;
1301                         }
1302                         ast_verb(3, "SMS-P2 Destination#%02X=[%.*s]\n", msg, msgsz, &h->imsg[f]);
1303                         ast_copy_string(h->da, (char *)(&h->imsg[f]), msgsz + 1);
1304                         break;
1305                 case 0x1C:                          /* Notify */
1306                         ast_verb(3, "SMS-P2 Notify#%02X=%s\n", msg, sms_hexdump(&h->imsg[f], 3, debug_buf));
1307                         break;
1308                 default:
1309                         ast_verb(3, "SMS-P2 Par#%02X [%d]: %s\n", msg, msgsz, sms_hexdump(&h->imsg[f], msgsz, debug_buf));
1310                         break;
1311                 }
1312                 f+=msgsz;                           /* Skip to next */
1313         }
1314         h->rx = 1;                              /* received message */
1315         sms_writefile(h);                       /* write the file */
1316         return 0;                               /* no error */
1317 }
1318
1319 #if 0
1320 static void smssend(sms_t *h, char *c)
1321 {
1322         int f, x;
1323         for (f = 0; f < strlen(c); f++) {
1324                 sscanf(&c[f*3], "%x", &x);
1325                 h->omsg[f] = x;
1326         }
1327         sms_messagetx(h);
1328 }
1329 #endif
1330
1331 static void sms_nextoutgoing (sms_t *h);
1332
1333 static void sms_messagerx2(sms_t * h)
1334 {
1335         int p = h->imsg[0] & DLL_SMS_MASK ; /* mask the high bit */
1336         int cause;
1337
1338 #define DLL2_ACK(h) ((h->framenumber & 1) ? DLL2_SMS_ACK1: DLL2_SMS_ACK1)
1339         switch (p) {
1340         case DLL2_SMS_EST:                      /* Protocol 2: Connection ready (fake): send message  */
1341                 sms_nextoutgoing (h);
1342                 /* 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 "); */
1343                 break;
1344
1345         case DLL2_SMS_INFO_MO:                  /* transport SMS_SUBMIT */
1346         case DLL2_SMS_INFO_MT:                  /* transport SMS_DELIVERY */
1347                 cause = sms_handleincoming_proto2(h);
1348                 if (!cause)     {                       /* ACK */
1349                         sms_log(h, 'Y');
1350                 }
1351                 h->omsg[0] = DLL2_ACK(h);
1352                 h->omsg[1] = 0x06;                  /* msg len */
1353                 h->omsg[2] = 0x04;                  /* payload len */
1354                 h->omsg[3] = 0x00;                  /* payload len */
1355                 h->omsg[4] = 0x1f;                  /* Response type */
1356                 h->omsg[5] = 0x01;                  /* parameter len */
1357                 h->omsg[6] = 0x00;                  /* parameter len */
1358                 h->omsg[7] = cause;                 /* CONFIRM or error */
1359                 sms_messagetx(h);
1360                 break;
1361
1362         case DLL2_SMS_NACK:                     /* Protocol 2: SMS_NAK */
1363                 h->omsg[0] = DLL2_SMS_REL;          /* SMS_REL */
1364                 h->omsg[1] = 0x00;                  /* msg len */
1365                 sms_messagetx(h);
1366                 break;
1367
1368         case DLL2_SMS_ACK0:
1369         case DLL2_SMS_ACK1:
1370                 /* SMS_ACK also transport SMS_SUBMIT or SMS_DELIVERY */
1371                 if ( (h->omsg[0] & DLL_SMS_MASK) == DLL2_SMS_REL) {
1372                         /* a response to our Release, just hangup */
1373                         h->hangup = 1;                  /* hangup */
1374                 } else {
1375                         /* XXX depending on what we are.. */
1376                         ast_log(LOG_NOTICE, "SMS_SUBMIT or SMS_DELIVERY\n");
1377                         sms_nextoutgoing (h);
1378                 }
1379                 break;
1380
1381         case DLL2_SMS_REL:                      /* Protocol 2: SMS_REL (hangup req) */
1382                 h->omsg[0] = DLL2_ACK(h);
1383                 h->omsg[1] = 0;
1384                 sms_messagetx(h);
1385                 break;
1386         }
1387 }
1388
1389 /*! \brief compose a message for protocol 1 */
1390 static void sms_compose1(sms_t *h, int more)
1391 {
1392         unsigned int p = 2;                     /* next byte to write. Skip type and len */
1393
1394         h->omsg[0] = 0x91;                      /* SMS_DATA */
1395         if (h->smsc) {                          /* deliver */
1396                 h->omsg[p++] = (more ? 4 : 0) + ((h->udhl > 0) ? 0x40 : 0);
1397                 p += packaddress(h->omsg + p, h->oa);
1398                 h->omsg[p++] = h->pid;
1399                 h->omsg[p++] = h->dcs;
1400                 packdate(h->omsg + p, h->scts.tv_sec);
1401                 p += 7;
1402                 p += packsms(h->dcs, h->omsg + p, h->udhl, h->udh, h->udl, h->ud);
1403         } else {                                /* submit */
1404                 h->omsg[p++] =
1405                         0x01 + (more ? 4 : 0) + (h->srr ? 0x20 : 0) + (h->rp ? 0x80 : 0) + (h->vp ? 0x10 : 0) + (h->udhi ? 0x40 : 0);
1406                 if (h->mr < 0) {
1407                         h->mr = message_ref++;
1408                 }
1409                 h->omsg[p++] = h->mr;
1410                 p += packaddress(h->omsg + p, h->da);
1411                 h->omsg[p++] = h->pid;
1412                 h->omsg[p++] = h->dcs;
1413                 if (h->vp) {                        /* relative VP */
1414                         if (h->vp < 720) {
1415                                 h->omsg[p++] = (h->vp + 4) / 5 - 1;
1416                         } else if (h->vp < 1440) {
1417                                 h->omsg[p++] = (h->vp - 720 + 29) / 30 + 143;
1418                         } else if (h->vp < 43200) {
1419                                 h->omsg[p++] = (h->vp + 1439) / 1440 + 166;
1420                         } else if (h->vp < 635040) {
1421                                 h->omsg[p++] = (h->vp + 10079) / 10080 + 192;
1422                         } else {
1423                                 h->omsg[p++] = 255;         /* max */
1424                         }
1425                 }
1426                 p += packsms(h->dcs, h->omsg + p, h->udhl, h->udh, h->udl, h->ud);
1427         }
1428         h->omsg[1] = p - 2;
1429 }
1430
1431 /*! \brief find and fill in next message, or send a REL if none waiting */
1432 static void sms_nextoutgoing (sms_t * h)
1433 {         
1434         char fn[100 + NAME_MAX] = "";
1435         DIR *d;
1436         char more = 0;
1437
1438         *h->da = *h->oa = '\0';                 /* clear destinations */
1439         h->rx = 0;                              /* outgoing message */
1440         snprintf(fn, sizeof(fn), "%s/sms/%s", ast_config_AST_SPOOL_DIR, h->smsc ? "mttx" : "motx");
1441         ast_mkdir(fn, 0777);                    /* ensure it exists */
1442         d = opendir(fn);
1443         if (d) {
1444                 struct dirent *f = readdirqueue(d, h->queue);
1445                 if (f) {
1446                         snprintf(fn + strlen(fn), sizeof(fn) - strlen(fn), "/%s", f->d_name);
1447                         sms_readfile(h, fn);
1448                         if (readdirqueue(d, h->queue)) {
1449                                 more = 1;                   /* more to send */
1450                         }
1451                 }
1452                 closedir(d);
1453         }
1454         if (*h->da || *h->oa) {                 /* message to send */
1455                 if (h->protocol == 2) {
1456                         sms_compose2(h, more);
1457                 } else {
1458                         sms_compose1(h, more);
1459                 }
1460         } else {                                /* no message */
1461                 if (h->protocol == 2) {
1462                         h->omsg[0] = 0x17;              /* SMS_REL */
1463                         h->omsg[1] = 0;
1464                 } else {
1465                         h->omsg[0] = 0x94;              /* SMS_REL */
1466                         h->omsg[1] = 0;
1467                 }
1468         }
1469         sms_messagetx(h);
1470 }
1471
1472 #define DIR_RX 1
1473 #define DIR_TX 2
1474 static void sms_debug (int dir, sms_t *h)
1475 {
1476         char txt[259 * 3 + 1];
1477         char *p = txt;                          /* always long enough */
1478         unsigned char *msg = (dir == DIR_RX) ? h->imsg : h->omsg;
1479         int n = (dir == DIR_RX) ? h->ibytep : msg[1] + 2;
1480         int q = 0;
1481         while (q < n && q < 30) {
1482                 sprintf(p, " %02X", msg[q++]);
1483                 p += 3;
1484         }
1485         if (q < n) {
1486                 sprintf(p, "...");
1487         }
1488         ast_verb(3, "SMS %s%s\n", dir == DIR_RX ? "RX" : "TX", txt);
1489 }
1490
1491
1492 static void sms_messagerx(sms_t * h)
1493 {
1494         int cause;
1495
1496         sms_debug (DIR_RX, h);
1497         if (h->protocol == 2) {
1498                 sms_messagerx2(h);
1499                 return;
1500         }
1501         /* parse incoming message for Protocol 1 */
1502         switch (h->imsg[0]) {
1503         case 0x91:                              /* SMS_DATA */
1504                 cause = sms_handleincoming (h);
1505                 if (!cause) {
1506                         sms_log(h, 'Y');
1507                         h->omsg[0] = 0x95;              /* SMS_ACK */
1508                         h->omsg[1] = 0x02;
1509                         h->omsg[2] = 0x00;              /* deliver report */
1510                         h->omsg[3] = 0x00;              /* no parameters */
1511                 } else {                            /* NACK */
1512                         sms_log(h, 'N');
1513                         h->omsg[0] = 0x96;              /* SMS_NACK */
1514                         h->omsg[1] = 3;
1515                         h->omsg[2] = 0;                 /* delivery report */
1516                         h->omsg[3] = cause;             /* cause */
1517                         h->omsg[4] = 0;                 /* no parameters */
1518                 }
1519                 sms_messagetx(h);
1520                 break;
1521
1522         case 0x92:                              /* SMS_ERROR */
1523                 h->err = 1;
1524                 sms_messagetx(h);                   /* send whatever we sent again */
1525                 break;
1526         case 0x93:                              /* SMS_EST */
1527                 sms_nextoutgoing (h);
1528                 break;
1529         case 0x94:                              /* SMS_REL */
1530                 h->hangup = 1;                      /* hangup */
1531                 break;
1532         case 0x95:                              /* SMS_ACK */
1533                 sms_log(h, 'Y');
1534                 sms_nextoutgoing (h);
1535                 break;
1536         case 0x96:                              /* SMS_NACK */
1537                 h->err = 1;
1538                 sms_log(h, 'N');
1539                 sms_nextoutgoing (h);
1540                 break;
1541         default:                                /* Unknown */
1542                 h->omsg[0] = 0x92;                  /* SMS_ERROR */
1543                 h->omsg[1] = 1;
1544                 h->omsg[2] = 3;                     /* unknown message type */
1545                 sms_messagetx(h);
1546                 break;
1547         }
1548 }
1549
1550 static void sms_messagetx(sms_t * h)
1551 {
1552         unsigned char c = 0, p;
1553         int len = h->omsg[1] + 2;               /* total message length excluding checksum */
1554
1555         for (p = 0; p < len; p++) {             /* compute checksum */
1556                 c += h->omsg[p];
1557         }
1558         h->omsg[len] = 0 - c;                   /* actually, (256 - (c & 0fxx)) & 0xff) */
1559         sms_debug(DIR_TX, h);
1560         h->framenumber++;                       /* Proto 2 */
1561         h->obytep = 0;
1562         h->obitp = 0;
1563         if (h->protocol == 2) {                 /* Proto 2: */
1564                 h->oseizure = 300;                  /* 300bits (or more ?) */
1565                 h->obyte = 0;                       /* Seizure starts with  space (0) */
1566                 if (h->omsg[0] == 0x7F) {
1567                         h->opause = 8 * h->opause_0;    /* initial message delay */
1568                 } else {
1569                         h->opause = 400;
1570                 }
1571         } else {                                /* Proto 1: */
1572                 h->oseizure = 0;                    /* No seizure */
1573                 h->obyte = 1;                       /* send mark ('1') at the beginning */
1574                 /* Change the initial message delay. BT requires 300ms,
1575                  * but for others this might be way too much and the phone
1576                  * could time out. XXX make it configurable.
1577                 */
1578                 if (h->omsg[0] == 0x93) {
1579                         h->opause = 8 * h->opause_0;    /* initial message delay */
1580                 } else {
1581                         h->opause = 200;
1582                 }
1583         }
1584         /* Note - setting osync triggers the generator */
1585         h->osync = OSYNC_BITS;                  /* 80 sync bits */
1586         h->obyten = len + 1;                    /* bytes to send (including checksum) */
1587 }
1588
1589 /*!
1590  * outgoing data are produced by this generator function, that reads from
1591  * the descriptor whether it has data to send and which ones.
1592  */
1593 static int sms_generate(struct ast_channel *chan, void *data, int len, int samples)
1594 {
1595         struct ast_frame f = { 0 };
1596 #define MAXSAMPLES (800)
1597         output_t *buf;
1598         sms_t *h = data;
1599         int i;
1600
1601         if (samples > MAXSAMPLES) {
1602                 ast_log(LOG_WARNING, "Only doing %d samples (%d requested)\n",
1603                          MAXSAMPLES, samples);
1604                 samples = MAXSAMPLES;
1605         }
1606         len = samples * sizeof(*buf) + AST_FRIENDLY_OFFSET;
1607         buf = ast_alloca(len);
1608
1609         f.frametype = AST_FRAME_VOICE;
1610         ast_format_set(&f.subclass.format, __OUT_FMT, 0);
1611         f.datalen = samples * sizeof(*buf);
1612         f.offset = AST_FRIENDLY_OFFSET;
1613         f.mallocd = 0;
1614         f.data.ptr = buf;
1615         f.samples = samples;
1616         f.src = "app_sms";
1617         /* create a buffer containing the digital sms pattern */
1618         for (i = 0; i < samples; i++) {
1619                 buf[i] = wave_out[0];               /* default is silence */
1620
1621                 if (h->opause) {
1622                         h->opause--;
1623                 } else if (h->obyten || h->osync) { /* sending data */
1624                         buf[i] = wave_out[h->ophase];
1625                         h->ophase += (h->obyte & 1) ? 13 : 21; /* compute next phase */
1626                         if (h->ophase >= 80)
1627                                 h->ophase -= 80;
1628                         if ((h->ophasep += 12) >= 80) { /* time to send the next bit */
1629                                 h->ophasep -= 80;
1630                                 if (h->oseizure > 0) {      /* sending channel seizure (proto 2) */
1631                                         h->oseizure--;
1632                                         h->obyte ^= 1;          /* toggle low bit */
1633                                 } else if (h->osync) {
1634                                         h->obyte = 1;           /* send mark as sync bit */
1635                                         h->osync--;             /* sending sync bits */
1636                                         if (h->osync == 0 && h->protocol == 2 && h->omsg[0] == DLL2_SMS_EST) {
1637                                                 h->obytep = h->obyten = 0; /* we are done */
1638                                         }
1639                                 } else {
1640                                         h->obitp++;
1641                                         if (h->obitp == 1) {
1642                                                 h->obyte = 0;       /* start bit; */
1643                                         } else if (h->obitp == 2) {
1644                                                 h->obyte = h->omsg[h->obytep];
1645                                         } else if (h->obitp == 10) {
1646                                                 h->obyte = 1; /* stop bit */
1647                                                 h->obitp = 0;
1648                                                 h->obytep++;
1649                                                 if (h->obytep == h->obyten) {
1650                                                         h->obytep = h->obyten = 0; /* sent */
1651                                                         h->osync = 10;    /* trailing marks */
1652                                                 }
1653                                         } else {
1654                                                 h->obyte >>= 1;
1655                                         }
1656                                 }
1657                         }
1658                 }
1659         }
1660         if (ast_write(chan, &f) < 0) {
1661                 ast_log(LOG_WARNING, "Failed to write frame to '%s': %s\n", ast_channel_name(chan), strerror(errno));
1662                 return -1;
1663         }
1664         return 0;
1665 #undef MAXSAMPLES
1666 }
1667
1668 /*!
1669  * Just return the pointer to the descriptor that we received.
1670  */
1671 static void *sms_alloc(struct ast_channel *chan, void *sms_t_ptr)
1672 {
1673         return sms_t_ptr;
1674 }
1675
1676 static void sms_release(struct ast_channel *chan, void *data)
1677 {
1678         return; /* nothing to do here. */
1679 }
1680
1681 static struct ast_generator smsgen = {
1682         .alloc = sms_alloc,
1683         .release = sms_release,
1684         .generate = sms_generate,
1685 };
1686
1687 /*!
1688  * Process an incoming frame, trying to detect the carrier and
1689  * decode the message. The two frequencies are 1300 and 2100 Hz.
1690  * The decoder detects the amplitude of the signal over the last
1691  * few samples, filtering the absolute values with a lowpass filter.
1692  * If the magnitude (h->imag) is large enough, multiply the signal
1693  * by the two carriers, and compute the amplitudes m0 and m1.
1694  * Record the current sample as '0' or '1' depending on which one is greater.
1695  * The last 3 bits are stored in h->ibith, with the count of '1'
1696  * bits in h->ibitt.
1697  * XXX the rest is to be determined.
1698  */
1699 static void sms_process(sms_t * h, int samples, signed short *data)
1700 {
1701         int bit;
1702
1703         /*
1704          * Ignore incoming audio while a packet is being transmitted,
1705          * the protocol is half-duplex.
1706          * Unfortunately this means that if the outbound and incoming
1707          * transmission overlap (which is an error condition anyways),
1708          * we may miss some data and this makes debugging harder.
1709          */
1710         if (h->obyten || h->osync) {
1711                 return;
1712         }
1713         for ( ; samples-- ; data++) {
1714                 unsigned long long m0, m1;
1715                 if (abs(*data) > h->imag) {
1716                         h->imag = abs(*data);
1717                 } else {
1718                         h->imag = h->imag * 7 / 8;
1719                 }
1720                 if (h->imag <= 500) {               /* below [arbitrary] threahold: lost carrier */
1721                         if (h->idle++ == 80000) {       /* nothing happening */
1722                                 ast_log(LOG_NOTICE, "No data, hanging up\n");
1723                                 h->hangup = 1;
1724                                 h->err = 1;
1725                         }
1726                         if (h->ierr) {                  /* error */
1727                                 ast_log(LOG_NOTICE, "Error %d, hanging up\n", h->ierr);
1728                                 /* Protocol 1 */
1729                                 h->err = 1;
1730                                 h->omsg[0] = 0x92;          /* error */
1731                                 h->omsg[1] = 1;
1732                                 h->omsg[2] = h->ierr;
1733                                 sms_messagetx(h);           /* send error */
1734                         }
1735                         h->ierr = h->ibitn = h->ibytep = h->ibytec = 0;
1736                         continue;
1737                 }
1738                 h->idle = 0;
1739
1740                 /* multiply signal by the two carriers. */
1741                 h->ims0 = (h->ims0 * 6 + *data * wave[h->ips0]) / 7;
1742                 h->imc0 = (h->imc0 * 6 + *data * wave[h->ipc0]) / 7;
1743                 h->ims1 = (h->ims1 * 6 + *data * wave[h->ips1]) / 7;
1744                 h->imc1 = (h->imc1 * 6 + *data * wave[h->ipc1]) / 7;
1745                 /* compute the amplitudes */
1746                 m0 = h->ims0 * h->ims0 + h->imc0 * h->imc0;
1747                 m1 = h->ims1 * h->ims1 + h->imc1 * h->imc1;
1748
1749                 /* advance the sin/cos pointers */
1750                 if ((h->ips0 += 21) >= 80) {
1751                         h->ips0 -= 80;
1752                 }
1753                 if ((h->ipc0 += 21) >= 80) {
1754                         h->ipc0 -= 80;
1755                 }
1756                 if ((h->ips1 += 13) >= 80) {
1757                         h->ips1 -= 80;
1758                 }
1759                 if ((h->ipc1 += 13) >= 80) {
1760                         h->ipc1 -= 80;
1761                 }
1762
1763                 /* set new bit to 1 or 0 depending on which value is stronger */
1764                 h->ibith <<= 1;
1765                 if (m1 > m0) {
1766                         h->ibith |= 1;
1767                 }
1768                 if (h->ibith & 8) {
1769                         h->ibitt--;
1770                 }
1771                 if (h->ibith & 1) {
1772                         h->ibitt++;
1773                 }
1774                 bit = ((h->ibitt > 1) ? 1 : 0);
1775                 if (bit != h->ibitl) {
1776                         h->ibitc = 1;
1777                 } else {
1778                         h->ibitc++;
1779                 }
1780                 h->ibitl = bit;
1781                 if (!h->ibitn && h->ibitc == 4 && !bit) {
1782                         h->ibitn = 1;
1783                         h->iphasep = 0;
1784                 }
1785                 if (bit && h->ibitc == 200) {       /* sync, restart message */
1786                         /* Protocol 2: empty connection ready (I am master) */
1787                         if (h->framenumber < 0 && h->ibytec >= 160 && !memcmp(h->imsg, "UUUUUUUUUUUUUUUUUUUU", 20)) {
1788                                 h->framenumber = 1;
1789                                 ast_verb(3, "SMS protocol 2 detected\n");
1790                                 h->protocol = 2;
1791                                 h->imsg[0] = 0xff;          /* special message (fake) */
1792                                 h->imsg[1] = h->imsg[2] = 0x00;
1793                                 h->ierr = h->ibitn = h->ibytep = h->ibytec = 0;
1794                                 sms_messagerx(h);
1795                         }
1796                         h->ierr = h->ibitn = h->ibytep = h->ibytec = 0;
1797                 }
1798                 if (h->ibitn) {
1799                         h->iphasep += 12;
1800                         if (h->iphasep >= 80) {         /* next bit */
1801                                 h->iphasep -= 80;
1802                                 if (h->ibitn++ == 9) {      /* end of byte */
1803                                         if (!bit) {             /* bad stop bit */
1804                                                 ast_log(LOG_NOTICE, "bad stop bit\n");
1805                                                 h->ierr = 0xFF;     /* unknown error */
1806                                         } else {
1807                                                 if (h->ibytep < sizeof(h->imsg)) {
1808                                                         h->imsg[h->ibytep] = h->ibytev;
1809                                                         h->ibytec += h->ibytev;
1810                                                         h->ibytep++;
1811                                                 } else if (h->ibytep == sizeof(h->imsg)) {
1812                                                         ast_log(LOG_NOTICE, "msg too large\n");
1813                                                         h->ierr = 2;    /* bad message length */
1814                                                 }
1815                                                 if (h->ibytep > 1 && h->ibytep == 3 + h->imsg[1] && !h->ierr) {
1816                                                         if (!h->ibytec) {
1817                                                                 sms_messagerx(h);
1818                                                         } else {
1819                                                                 ast_log(LOG_NOTICE, "bad checksum\n");
1820                                                                 h->ierr = 1; /* bad checksum */
1821                                                         }
1822                                                 }
1823                                         }
1824                                         h->ibitn = 0;
1825                                 }
1826                                 h->ibytev = (h->ibytev >> 1) + (bit ? 0x80 : 0);
1827                         }
1828                 }
1829         }
1830 }
1831
1832 /*
1833  * Standard argument parsing:
1834  *      - one enum for the flags we recognise,
1835  *      - one enum for argument indexes
1836  *      - AST_APP_OPTIONS() to drive the parsing routine
1837  *      - in the function, AST_DECLARE_APP_ARGS(...) for the arguments.
1838  */
1839 enum sms_flags {
1840         OPTION_BE_SMSC  = (1 << 0),             /* act as sms center */
1841         OPTION_ANSWER   = (1 << 1),             /* answer on incoming calls */
1842         OPTION_TWO      = (1 << 2),                 /* Use Protocol Two */
1843         OPTION_PAUSE    = (1 << 3),             /* pause before sending data, in ms */
1844         OPTION_SRR      = (1 << 4),                 /* set srr */
1845         OPTION_DCS      = (1 << 5),                 /* set dcs */
1846 };
1847
1848 enum sms_opt_args {
1849         OPTION_ARG_PAUSE = 0,
1850         OPTION_ARG_ARRAY_SIZE
1851 };
1852
1853 AST_APP_OPTIONS(sms_options, {
1854         AST_APP_OPTION('s', OPTION_BE_SMSC),
1855         AST_APP_OPTION('a', OPTION_ANSWER),
1856         AST_APP_OPTION('t', OPTION_TWO),
1857         AST_APP_OPTION('r', OPTION_SRR),
1858         AST_APP_OPTION('o', OPTION_DCS),
1859         AST_APP_OPTION_ARG('p', OPTION_PAUSE, OPTION_ARG_PAUSE),
1860         } );
1861
1862 static int sms_exec(struct ast_channel *chan, const char *data)
1863 {
1864         int res = -1;
1865         sms_t h = { 0 };
1866         /* argument parsing support */
1867         struct ast_flags flags;
1868         char *parse, *sms_opts[OPTION_ARG_ARRAY_SIZE] = { 0, };
1869         char *p;
1870         AST_DECLARE_APP_ARGS(sms_args,
1871                 AST_APP_ARG(queue);
1872                 AST_APP_ARG(options);
1873                 AST_APP_ARG(addr);
1874                 AST_APP_ARG(body);
1875         );
1876
1877         if (!data) {
1878                 ast_log(LOG_ERROR, "Requires queue name at least\n");
1879                 return -1;
1880         }
1881
1882         parse = ast_strdupa(data);              /* create a local copy */
1883         AST_STANDARD_APP_ARGS(sms_args, parse);
1884         if (sms_args.argc > 1) {
1885                 ast_app_parse_options(sms_options, &flags, sms_opts, sms_args.options);
1886         }
1887
1888         ast_verb(1, "sms argc %d queue <%s> opts <%s> addr <%s> body <%s>\n",
1889                 sms_args.argc, S_OR(sms_args.queue, ""),
1890                 S_OR(sms_args.options, ""),
1891                 S_OR(sms_args.addr, ""),
1892                 S_OR(sms_args.body, "") );
1893
1894         h.ipc0 = h.ipc1 = 20;                   /* phase for cosine */
1895         h.dcs = 0xF1;                           /* default */
1896
1897         ast_copy_string(h.cli,
1898                 S_COR(ast_channel_caller(chan)->id.number.valid, ast_channel_caller(chan)->id.number.str, ""),
1899                 sizeof(h.cli));
1900
1901         if (ast_strlen_zero(sms_args.queue)) {
1902                 ast_log(LOG_ERROR, "Requires queue name\n");
1903                 goto done;
1904         }
1905         if (strlen(sms_args.queue) >= sizeof(h.queue)) {
1906                 ast_log(LOG_ERROR, "Queue name too long\n");
1907                 goto done;
1908         }
1909         ast_copy_string(h.queue, sms_args.queue, sizeof(h.queue));
1910
1911         for (p = h.queue; *p; p++) {
1912                 if (!isalnum(*p)) {
1913                         *p = '-';                       /* make very safe for filenames */
1914                 }
1915         }
1916
1917         h.smsc = ast_test_flag(&flags, OPTION_BE_SMSC);
1918         h.protocol = ast_test_flag(&flags, OPTION_TWO) ? 2 : 1;
1919         if (!ast_strlen_zero(sms_opts[OPTION_ARG_PAUSE])) {
1920                 h.opause_0 = atoi(sms_opts[OPTION_ARG_PAUSE]);
1921         }
1922         if (h.opause_0 < 25 || h.opause_0 > 2000) {
1923                 h.opause_0 = 300;                   /* default 300ms */
1924         }
1925         ast_verb(1, "initial delay %dms\n", h.opause_0);
1926
1927
1928         /* the following apply if there is an arg3/4 and apply to the created message file */
1929         if (ast_test_flag(&flags, OPTION_SRR)) {
1930                 h.srr = 1;
1931         }
1932         if (ast_test_flag(&flags, OPTION_DCS)) {
1933                 h.dcs = 1;
1934         }
1935 #if 0   
1936                 case '1':
1937                 case '2':
1938                 case '3':
1939                 case '4':
1940                 case '5':
1941                 case '6':
1942                 case '7':                           /* set the pid for saved local message */
1943                         h.pid = 0x40 + (*d & 0xF);
1944                         break;
1945                 }
1946 #endif
1947         if (sms_args.argc > 2) {
1948                 unsigned char *up;
1949
1950                 /* submitting a message, not taking call. */
1951                 /* deprecated, use smsq instead */
1952                 h.scts = ast_tvnow();
1953                 if (ast_strlen_zero(sms_args.addr) || strlen(sms_args.addr) >= sizeof(h.oa)) {
1954                         ast_log(LOG_ERROR, "Address too long %s\n", sms_args.addr);
1955                         goto done;
1956                 }
1957                 if (h.smsc) {
1958                         ast_copy_string(h.oa, sms_args.addr, sizeof(h.oa));
1959                 } else {
1960                         ast_copy_string(h.da, sms_args.addr, sizeof(h.da));
1961                         ast_copy_string(h.oa, h.cli, sizeof(h.oa));
1962                 }
1963                 h.udl = 0;
1964                 if (ast_strlen_zero(sms_args.body)) {
1965                         ast_log(LOG_ERROR, "Missing body for %s\n", sms_args.addr);
1966                         goto done;
1967                 }
1968                 up = (unsigned char *)sms_args.body;
1969                 while (*up && h.udl < SMSLEN) {
1970                         h.ud[h.udl++] = utf8decode(&up);
1971                 }
1972                 if (is7bit(h.dcs) && packsms7(0, h.udhl, h.udh, h.udl, h.ud) < 0) {
1973                         ast_log(LOG_WARNING, "Invalid 7 bit GSM data\n");
1974                         goto done;
1975                 }
1976                 if (is8bit(h.dcs) && packsms8(0, h.udhl, h.udh, h.udl, h.ud) < 0) {
1977                         ast_log(LOG_WARNING, "Invalid 8 bit data\n");
1978                         goto done;
1979                 }
1980                 if (is16bit(h.dcs) && packsms16(0, h.udhl, h.udh, h.udl, h.ud) < 0) {
1981                         ast_log(LOG_WARNING, "Invalid 16 bit data\n");
1982                         goto done;
1983                 }
1984                 h.rx = 0;                           /* sent message */
1985                 h.mr = -1;
1986                 sms_writefile(&h);
1987                 res = h.err;
1988                 goto done;
1989         }
1990         
1991         if (ast_channel_state(chan) != AST_STATE_UP) {          /* make sure channel is answered before any TX */
1992                 ast_answer(chan);
1993         }
1994
1995         if (ast_test_flag(&flags, OPTION_ANSWER)) {
1996                 h.framenumber = 1;                  /* Proto 2 */
1997                 /* set up SMS_EST initial message */
1998                 if (h.protocol == 2) {
1999                         h.omsg[0] = DLL2_SMS_EST;
2000                         h.omsg[1] = 0;
2001                 } else {
2002                         h.omsg[0] = DLL1_SMS_EST | DLL1_SMS_COMPLETE;
2003                         h.omsg[1] = 0;
2004                 }
2005                 sms_messagetx(&h);
2006         }
2007
2008         res = ast_set_write_format_by_id(chan, __OUT_FMT);
2009         if (res >= 0) {
2010                 res = ast_set_read_format_by_id(chan, AST_FORMAT_SLINEAR);
2011         }
2012         if (res < 0) {
2013                 ast_log(LOG_ERROR, "Unable to set to linear mode, giving up\n");
2014                 goto done;
2015         }
2016
2017         if ( (res = ast_activate_generator(chan, &smsgen, &h)) < 0) {
2018                 ast_log(LOG_ERROR, "Failed to activate generator on '%s'\n", ast_channel_name(chan));
2019                 goto done;
2020         }
2021
2022         /* Do our thing here */
2023         for (;;) {
2024                 struct ast_frame *f;
2025                 int i = ast_waitfor(chan, -1);
2026                 if (i < 0) {
2027                         ast_log(LOG_NOTICE, "waitfor failed\n");
2028                         break;
2029                 }
2030                 if (h.hangup) {
2031                         ast_log(LOG_NOTICE, "channel hangup\n");
2032                         break;
2033                 }
2034                 f = ast_read(chan);
2035                 if (!f) {
2036                         ast_log(LOG_NOTICE, "ast_read failed\n");
2037                         break;
2038                 }
2039                 if (f->frametype == AST_FRAME_VOICE) {
2040                         sms_process(&h, f->samples, f->data.ptr);
2041                 }
2042
2043                 ast_frfree(f);
2044         }
2045         res = h.err;                            /* XXX */
2046
2047         /* 
2048          * The SMS generator data is on the stack.  We _MUST_ make sure the generator
2049          * is stopped before returning from this function.
2050          */
2051         ast_deactivate_generator(chan);
2052
2053         sms_log(&h, '?');                       /* log incomplete message */
2054 done:
2055         return (res);
2056 }
2057
2058 static int unload_module(void)
2059 {
2060         return ast_unregister_application(app);
2061 }
2062
2063 static int load_module(void)
2064 {
2065 #ifdef OUTALAW
2066         int p;
2067         for (p = 0; p < 80; p++) {
2068                 wavea[p] = AST_LIN2A(wave[p]);
2069         }
2070 #endif
2071         snprintf(log_file, sizeof(log_file), "%s/sms", ast_config_AST_LOG_DIR);
2072         return ast_register_application_xml(app, sms_exec);
2073 }
2074
2075 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "SMS/PSTN handler");