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