Merge sms stuff and move to "utils" subdir (bug #2973)
[asterisk/asterisk.git] / utils / smsq.c
1 #include <stdio.h>
2 #include <popt.h>
3 #include <sys/types.h>
4 #include <sys/stat.h>
5 #include <fcntl.h>
6 #include <malloc.h>
7 #include <dirent.h>
8 #include <string.h>
9 #include <ctype.h>
10 #include <stdlib.h>
11 #include <unistd.h>
12 #include <time.h>
13
14 // SMS queuing application for use with asterisk app_sms
15 // by Adrian Kennard, 2004
16
17 /* reads next USC character from null terminated UTF-8 string and advanced pointer */
18 /* for non valid UTF-8 sequences, returns character as is */
19 /* Does not advance pointer for null termination */
20 static int utf8decode (unsigned char **pp)
21 {
22    unsigned char *p = *pp;
23    if (!*p)
24       return 0;                 /* null termination of string */
25    (*pp)++;
26    if (*p < 0xC0)
27       return *p;                /* ascii or continuation character */
28    if (*p < 0xE0)
29    {
30       if (*p < 0xC2 || (p[1] & 0xC0) != 0x80)
31          return *p;             /* not valid UTF-8 */
32       (*pp)++;
33       return ((*p & 0x1F) << 6) + (p[1] & 0x3F);
34    }
35    if (*p < 0xF0)
36    {
37       if ((*p == 0xE0 && p[1] < 0xA0) || (p[1] & 0xC0) != 0x80 || (p[2] & 0xC0) != 0x80)
38          return *p;             /* not valid UTF-8 */
39       (*pp) += 2;
40       return ((*p & 0x0F) << 12) + ((p[1] & 0x3F) << 6) + (p[2] & 0x3F);
41    }
42    if (*p < 0xF8)
43    {
44       if ((*p == 0xF0 && p[1] < 0x90) || (p[1] & 0xC0) != 0x80 || (p[2] & 0xC0) != 0x80 || (p[3] & 0xC0) != 0x80)
45          return *p;             /* not valid UTF-8 */
46       (*pp) += 3;
47       return ((*p & 0x07) << 18) + ((p[1] & 0x3F) << 12) + ((p[2] & 0x3F) << 6) + (p[3] & 0x3F);
48    }
49    if (*p < 0xFC)
50    {
51       if ((*p == 0xF8 && p[1] < 0x88) || (p[1] & 0xC0) != 0x80 || (p[2] & 0xC0) != 0x80 || (p[3] & 0xC0) != 0x80
52           || (p[4] & 0xC0) != 0x80)
53          return *p;             /* not valid UTF-8 */
54       (*pp) += 4;
55       return ((*p & 0x03) << 24) + ((p[1] & 0x3F) << 18) + ((p[2] & 0x3F) << 12) + ((p[3] & 0x3F) << 6) + (p[4] & 0x3F);
56    }
57    if (*p < 0xFE)
58    {
59       if ((*p == 0xFC && p[1] < 0x84) || (p[1] & 0xC0) != 0x80 || (p[2] & 0xC0) != 0x80 || (p[3] & 0xC0) != 0x80
60           || (p[4] & 0xC0) != 0x80 || (p[5] & 0xC0) != 0x80)
61          return *p;             /* not valid UTF-8 */
62       (*pp) += 5;
63       return ((*p & 0x01) << 30) + ((p[1] & 0x3F) << 24) + ((p[2] & 0x3F) << 18) + ((p[3] & 0x3F) << 12) + ((p[4] & 0x3F) << 6) +
64          (p[5] & 0x3F);
65    }
66    return *p;                   /* not sensible */
67 }
68
69 // check for any queued messages in specific queue (queue="" means any queue)
70 // returns 0 if nothing queued, 1 if queued and outgoing set up OK, 2 of outgoing exists
71 static char txqcheck (char *dir, char *queue, char subaddress, char *channel, char *callerid, int wait, int delay, int retries, int concurrent)
72 {
73    char ogname[100],
74      temp[100],
75      dirname[100],
76     *p=NULL;
77    FILE *f;
78    DIR *d;
79    int ql = strlen (queue);
80    struct dirent *fn;
81    sprintf (dirname, "sms/%s", dir);
82    d = opendir (dirname);
83    if (!d)
84       return 0;
85    while ((fn = readdir (d))
86           && !(*fn->d_name != '.'
87                && ((!ql && (p = strchr (fn->d_name, '.'))) || (ql && !strncmp (fn->d_name, queue, ql) && fn->d_name[ql] == '.'))));
88    if (!fn)
89    {
90       closedir (d);
91       return 0;
92    }
93    if (!ql)
94    {                            // not searching any specific queue, so use whatr we found as the queue
95       queue = fn->d_name;
96       ql = p - queue;
97    }
98    p = strchr (queue, '-');
99    if (p && p < queue + ql)
100    {
101       ql = p - queue;
102       subaddress = p[1];
103    }
104    sprintf (temp, "sms/.smsq-%d", getpid ());
105    f = fopen (temp, "w");
106    if (!f)
107    {
108       perror (temp);
109       closedir (d);
110       return 0;
111    }
112    fprintf (f, "Channel: ");
113    if (!channel)
114       fprintf (f, "Local/%.*s\n", ql, queue);
115    else
116    {
117       p = strchr (channel, '/');
118       if (!p)
119          p = channel;
120       p = strchr (p, 'X');
121       if (p)
122          fprintf (f, "%.*s%c%s\n", p - channel, channel, subaddress, p + 1);
123       else
124          fprintf (f, "%s\n", channel);
125    }
126    fprintf (f, "Callerid: SMS <");
127    if (!callerid)
128       fprintf (f, "%.*s", ql, queue);
129    else
130    {
131       p = strchr (callerid, 'X');
132       if (p)
133          fprintf (f, "%.*s%c%s", p - callerid, callerid, subaddress, p + 1);
134       else
135          fprintf (f, "%s", callerid);
136    }
137    fprintf (f, ">\n");
138    fprintf (f, "Application: SMS\n");
139    fprintf (f, "Data: %.*s", ql, queue);
140    if (dir[1] == 't')
141       fprintf (f, "|s");
142    fprintf (f, "\nMaxRetries: %d\n", retries);
143    fprintf (f, "RetryTime: %d\n", delay);
144    fprintf (f, "WaitTime: %d\n", wait);
145    fclose (f);
146    closedir (d);
147    {
148       int try = 0;
149       while (try < concurrent)
150       {
151          try++;
152          sprintf (ogname, "outgoing/smsq.%s.%s.%d", dir, queue, try);
153          if (!link (temp, ogname))
154          {                      // queued OK
155             unlink (temp);
156             return 1;
157          }
158       }
159    }
160    // failed to create call queue
161    unlink (temp);
162    return 2;
163 }
164
165 // Process received queue entries and run through a process, setting environment variables
166 static void rxqcheck (char *dir, char *queue, char *process)
167 {
168    unsigned char *p;
169    char dirname[100],
170      temp[100];
171    DIR *d;
172    int ql = strlen (queue);
173    struct dirent *fn;
174    sprintf (temp, "sms/.smsq-%d", getpid ());
175    sprintf (dirname, "sms/%s", dir);
176    d = opendir (dirname);
177    if (!d)
178       return;
179    while ((fn = readdir (d)))
180       if ((*fn->d_name != '.'
181            && ((!ql && (p = strchr (fn->d_name, '.'))) || (ql && !strncmp (fn->d_name, queue, ql) && fn->d_name[ql] == '.'))))
182       {                         /* process file */
183          char filename[NAME_MAX + 10];
184          char line[1000];
185          unsigned short ud[160];
186          unsigned char udl = 0;
187          FILE *f;
188          sprintf (filename, "sms/%s/%s", dir, fn->d_name);
189          if (rename (filename, temp))
190             continue;           // cannot access file
191          f = fopen (temp, "r");
192          unlink (temp);
193          if (!f)
194          {
195             perror (temp);
196             continue;
197          }
198          unsetenv ("oa");
199          unsetenv ("da");
200          unsetenv ("scts");
201          unsetenv ("pid");
202          unsetenv ("dcs");
203          unsetenv ("mr");
204          unsetenv ("srr");
205          unsetenv ("rp");
206          unsetenv ("vp");
207          unsetenv ("udh");
208          unsetenv ("ud");
209          unsetenv ("ude");
210          unsetenv ("ud8");
211          unsetenv ("ud16");
212          unsetenv ("morx");
213          unsetenv ("motx");
214          unsetenv ("queue");
215          if (*queue)
216             setenv ("queue", queue, 1);
217          setenv (dir, "", 1);
218          while (fgets (line, sizeof (line), f))
219          {
220             for (p = line; *p && *p != '\n' && *p != '\r'; p++);
221             *p = 0;             /* strip eoln */
222             p = line;
223             if (!*p || *p == ';')
224                continue;        /* blank line or comment, ignore */
225             while (isalnum (*p))
226             {
227                *p = tolower (*p);
228                p++;
229             }
230             while (isspace (*p))
231                *p++ = 0;
232             if (*p == '=')
233             {                   // =
234                *p++ = 0;
235                if (!strcmp (line, "oa") || !strcmp (line, "da") || !strcmp (line, "scts") || !strcmp (line, "pid")
236                    || !strcmp (line, "dcs") || !strcmp (line, "mr") || !strcmp (line, "vp"))
237                   setenv (line, p, 1);
238                else if ((!strcmp (line, "srr") || !strcmp (line, "rp")) && atoi (p))
239                   setenv (line, "", 1);
240                else if (!strcmp (line, "ud"))
241                {                // read the user data as UTF-8
242                   long v;
243                   udl = 0;
244                   while ((v = utf8decode (&p)) && udl < 160)
245                      if (v && v <= 0xFFFF)
246                         ud[udl++] = v;
247                }
248             } else if (*p == '#')
249             {
250                *p++ = 0;
251                if (*p == '#')
252                {                // ## 
253                   p++;
254                   if (!strcmp (line, "udh"))
255                      setenv (line, p, 1);
256                   else if (!strcmp (line, "ud"))
257                   {             // read user data UCS-2
258                      udl = 0;
259                      while (*p && udl < 160)
260                      {
261                         if (isxdigit (*p) && isxdigit (p[1]) && isxdigit (p[2]) && isxdigit (p[3]))
262                         {
263                            ud[udl++] =
264                               (((isalpha (*p) ? 9 : 0) + (*p & 0xF)) << 12) +
265                               (((isalpha (p[1]) ? 9 : 0) + (p[1] & 0xF)) << 8) +
266                               (((isalpha (p[2]) ? 9 : 0) + (p[2] & 0xF)) << 4) + ((isalpha (p[3]) ? 9 : 0) + (p[3] & 0xF));
267                            p += 4;
268                         } else
269                            break;
270                      }
271                   }
272                } else
273                {                // #
274                   if (!strcmp (line, "ud"))
275                   {             // read user data UCS-1
276                      udl = 0;
277                      while (*p && udl < 160)
278                      {
279                         if (isxdigit (*p) && isxdigit (p[1]))
280                         {
281                            ud[udl++] = (((isalpha (*p) ? 9 : 0) + (*p & 0xF)) << 4) + ((isalpha (p[1]) ? 9 : 0) + (p[1] & 0xF));
282                            p += 2;
283                         } else
284                            break;
285                      }
286                   }
287                }
288             }
289          }
290          fclose (f);
291          // set up user data variables
292          {
293             char temp[481];
294             int n,
295               p;
296             for (n = 0, p = 0; p < udl; p++)
297             {
298                unsigned short v = ud[p];
299                if (v)
300                {
301                   if (v < 0x80)
302                      temp[n++] = v;
303                   else if (v < 0x800)
304                   {
305                      temp[n++] = (0xC0 + (v >> 6));
306                      temp[n++] = (0x80 + (v & 0x3F));
307                   } else
308                   {
309                      temp[n++] = (0xE0 + (v >> 12));
310                      temp[n++] = (0x80 + ((v >> 6) & 0x3F));
311                      temp[n++] = (0x80 + (v & 0x3F));
312                   }
313                }
314             }
315             temp[n] = 0;
316             setenv ("ud", temp, 1);
317             for (n = 0, p = 0; p < udl; p++)
318             {
319                unsigned short v = ud[p];
320                if (v < ' ' || v == '\\')
321                {
322                   temp[n++] = '\\';
323                   if (v == '\\')
324                      temp[n++] = '\\';
325                   else if (v == '\n')
326                      temp[n++] = 'n';
327                   else if (v == '\r')
328                      temp[n++] = 'r';
329                   else if (v == '\t')
330                      temp[n++] = 't';
331                   else if (v == '\f')
332                      temp[n++] = 'f';
333                   else
334                   {
335                      temp[n++] = '0' + (v >> 6);
336                      temp[n++] = '0' + ((v >> 3) & 7);
337                      temp[n++] = '0' + (v & 7);
338                   }
339                } else if (v < 0x80)
340                   temp[n++] = v;
341                else if (v < 0x800)
342                {
343                   temp[n++] = (0xC0 + (v >> 6));
344                   temp[n++] = (0x80 + (v & 0x3F));
345                } else
346                {
347                   temp[n++] = (0xE0 + (v >> 12));
348                   temp[n++] = (0x80 + ((v >> 6) & 0x3F));
349                   temp[n++] = (0x80 + (v & 0x3F));
350                }
351             }
352             temp[n] = 0;
353             setenv ("ude", temp, 1);
354             for (p = 0; p < udl && ud[p] < 0x100; p++);
355             if (p == udl)
356             {
357                for (n = 0, p = 0; p < udl; p++)
358                {
359                   sprintf (temp + n, "%02X", ud[p]);
360                   n += 2;
361                }
362                setenv ("ud8", temp, 1);
363             }
364             for (n = 0, p = 0; p < udl; p++)
365             {
366                sprintf (temp + n, "%04X", ud[p]);
367                n += 4;
368             }
369             setenv ("ud16", temp, 1);
370          }
371          // run the command
372          system (process);
373       }
374    closedir (d);
375 }
376
377 // Main app
378 int
379 main (int argc, const char *argv[])
380 {
381    char c;
382    int mt = 0,
383       mo = 0,
384       tx = 0,
385       rx = 0,
386       nodial = 0,
387       nowait = 0,
388       concurrent = 1,
389       motxwait = 10,
390       motxdelay = 1,
391       motxretries = 10,
392       mttxwait = 10,
393       mttxdelay = 30,
394       mttxretries = 100,
395       mr = -1,
396       pid = -1,
397       dcs = -1,
398       srr = 0,
399       rp = 0,
400       vp = 0,
401       udl = 0,
402       utf8 = 0,
403       ucs1 = 0,
404       ucs2 = 0;
405    unsigned short ud[160];
406    unsigned char *uds = 0,
407       *udh = 0;
408    char *da = 0,
409       *oa = 0,
410       *queue = "",
411       *udfile = 0,
412       *process = 0,
413       *spooldir = "/var/spool/asterisk",
414       *motxchannel = "Local/1709400X",
415       *motxcallerid = 0,
416       *mttxchannel = 0,
417       *mttxcallerid = "080058752X0",
418       *defaultsubaddress = "9",
419       subaddress = 0,
420       *scts = 0;
421    poptContext optCon;          // context for parsing command-line options
422    const struct poptOption optionsTable[] = {
423       {"queue", 'q', POPT_ARG_STRING | POPT_ARGFLAG_SHOW_DEFAULT, &queue, 0, "Queue [inc sub address]", "number[-X]"},
424       {"da", 'd', POPT_ARG_STRING, &da, 0, "Destination address", "number"},
425       {"oa", 'o', POPT_ARG_STRING, &oa, 0, "Origination address", "number"},
426       {"ud", 'm', POPT_ARG_STRING, &uds, 0, "Message", "text"},
427       {"ud-file", 'f', POPT_ARG_STRING, &udfile, 0, "Message file", "filename"},
428       {"UTF-8", 0, POPT_ARG_NONE, &utf8, 0, "File treated as null terminated UTF-8 (default)", 0},
429       {"UCS-1", 0, POPT_ARG_NONE, &ucs1, 0, "File treated as UCS-1", 0},
430       {"UCS-2", 0, POPT_ARG_NONE, &ucs2, 0, "File treated as UCS-2", 0},
431       {"mt", 't', POPT_ARG_NONE, &mt, 0, "Mobile Terminated", 0},
432       {"mo", 0, POPT_ARG_NONE, &mo, 0, "Mobile Originated", 0},
433       {"tx", 0, POPT_ARG_NONE, &tx, 0, "Send message", 0},
434       {"rx", 'r', POPT_ARG_NONE, &rx, 0, "Queue for receipt", 0},
435       {"process", 'e', POPT_ARG_STRING, &process, 0, "Rx queue process command", "command"},
436       {"no-dial", 'x', POPT_ARG_NONE, &nodial, 0, "Do not dial", 0},
437       {"no-wait", 0, POPT_ARG_NONE, &nowait, 0, "Do not wait if already calling", 0},
438       {"concurrent", 0, POPT_ARG_INT | POPT_ARGFLAG_SHOW_DEFAULT, &concurrent, 0, "Number of concurrent calls to allow", "n"},
439       {"motx-channel", 0, POPT_ARG_STRING | POPT_ARGFLAG_SHOW_DEFAULT, &motxchannel, 0, "Channel for motx calls", "channel"},
440       {"motx-callerid", 0, POPT_ARG_STRING, &motxcallerid, 0,
441        "Caller ID for motx calls (default is queue name without sub address)", "number"},
442       {"motx-wait", 0, POPT_ARG_INT | POPT_ARGFLAG_SHOW_DEFAULT, &motxwait, 0, "Time to wait for motx call to answer",
443        "seconds"},
444       {"motx-delay", 0, POPT_ARG_INT | POPT_ARGFLAG_SHOW_DEFAULT, &motxdelay, 0, "Time between motx call retries", "seconds"},
445       {"motx-retries", 0, POPT_ARG_INT | POPT_ARGFLAG_SHOW_DEFAULT, &motxretries, 0, "Number of retries for motx call", "n"},
446       {"mttx-channel", 0, POPT_ARG_STRING, &mttxchannel, 0,
447        "Channel for mttx calls (default is Local/ and queue name without sub address)", "channel"},
448       {"mttx-callerid", 0, POPT_ARG_STRING | POPT_ARGFLAG_SHOW_DEFAULT, &mttxcallerid, 0,
449        "Caller ID for mttx calls (default is queue name without sub address)", "number"},
450       {"mttx-wait", 0, POPT_ARG_INT | POPT_ARGFLAG_SHOW_DEFAULT, &mttxwait, 0, "Time to wait for mttx call to answer",
451        "seconds"},
452       {"mttx-delay", 0, POPT_ARG_INT | POPT_ARGFLAG_SHOW_DEFAULT, &mttxdelay, 0, "Time between mttx call retries", "seconds"},
453       {"mttx-retries", 0, POPT_ARG_INT | POPT_ARGFLAG_SHOW_DEFAULT, &mttxretries, 0, "Number of retries for mttx call", "n"},
454       {"mr", 'n', POPT_ARG_INT, &mr, 0, "Message reference", "n"},
455       {"pid", 'p', POPT_ARG_INT, &pid, 0, "Protocol ID", "n"},
456       {"dcs", 'c', POPT_ARG_INT, &dcs, 0, "Data Coding Scheme", "n"},
457       {"udh", 0, POPT_ARG_STRING, &udh, 0, "User data header", "hex"},
458       {"srr", 0, POPT_ARG_NONE, &srr, 0, "Status Report Request", 0},
459       {"rp", 0, POPT_ARG_NONE, &rp, 0, "Return Path request", 0},
460       {"v", 0, POPT_ARG_INT, &vp, 0, "Validity Period", "seconds"},
461       {"scts", 0, POPT_ARG_STRING, &scts, 0, "Timestamp", "YYYY-MM-SSTHH:MM:SS"},
462       {"default-sub-address", 0, POPT_ARG_STRING | POPT_ARGFLAG_SHOW_DEFAULT, &defaultsubaddress, 0, "Default sub address", "X"},
463       {"spool-dir", 0, POPT_ARG_STRING | POPT_ARGFLAG_SHOW_DEFAULT, &spooldir, 0, "Asterisk spool dir", "dirname"},
464       POPT_AUTOHELP {NULL, 0, 0, NULL, 0}
465    };
466
467    optCon = poptGetContext (NULL, argc, argv, optionsTable, 0);
468    poptSetOtherOptionHelp (optCon, "<oa/da> <message>");
469
470    /* Now do options processing, get portname */
471    if ((c = poptGetNextOpt (optCon)) < -1)
472    {
473       /* an error occurred during option processing */
474       fprintf (stderr, "%s: %s\n", poptBadOption (optCon, POPT_BADOPTION_NOALIAS), poptStrerror (c));
475       return 1;
476    }
477    if (!ucs1 && !ucs2)
478       utf8 = 1;
479    if (utf8 + ucs1 + ucs2 > 1)
480    {
481       fprintf (stderr, "Pick one of UTF-8, UCS-1 or UCS-2 only\n");
482       return 1;
483    }
484    if (!udfile && (ucs1 || ucs2))
485    {
486       fprintf (stderr, "Command line arguments always treated as UTF-8\n");
487       return 1;
488    }
489    //  if (!where && poptPeekArg (optCon)) where = (char *) poptGetArg (optCon);
490    if (!mt && !mo && process)
491       mt = 1;
492    if (!mt && !mo && oa)
493       mt = 1;
494    if (!mt)
495       mo = 1;
496    if (mt && mo)
497    {
498       fprintf (stderr, "Cannot be --mt and --mo\n");
499       return 1;
500    }
501    if (!rx && !tx && process)
502       rx = 1;
503    if (!rx)
504       tx = 1;
505    if (tx && rx)
506    {
507       fprintf (stderr, "Cannot be --tx and --rx\n");
508       return 1;
509    }
510    if (rx)
511       nodial = 1;
512    if (uds && udfile)
513    {
514       fprintf (stderr, "Cannot have --ud and --ud-file\n");
515       return 1;
516    }
517    if (mo && !da && poptPeekArg (optCon))
518       da = (char *) poptGetArg (optCon);
519    if (mt && !oa && poptPeekArg (optCon))
520       oa = (char *) poptGetArg (optCon);
521    if (tx && oa && mo)
522    {
523       fprintf (stderr, "--oa makes no sense with --mo as CLI is used (i.e. queue name)\n");
524       return 1;
525    }
526    if (tx && da && mt)
527    {
528       fprintf (stderr, "--da makes no sense with --mt as called number is used (i.e. queue name)\n");
529       return 1;
530    }
531    if (da && strlen (da) > 20)
532    {
533       fprintf (stderr, "--da too long\n");
534       return 1;
535    }
536    if (oa && strlen (oa) > 20)
537    {
538       fprintf (stderr, "--oa too long\n");
539       return 1;
540    }
541    if (queue && strlen (queue) > 20)
542    {
543       fprintf (stderr, "--queue name too long\n");
544       return 1;
545    }
546    if (mo && scts)
547    {
548       fprintf (stderr, "scts is set my service centre\n");
549       return 1;
550    }
551    if (uds)
552    {                            /* simple user data command line option in \UTF-8 */
553       while (udl < 160 && *uds)
554       {
555          int v = utf8decode (&uds);
556          if (v > 0xFFFF)
557          {
558             fprintf (stderr, "Invalid character U+%X at %d\n", v, udl);
559             return 1;
560          }
561          ud[udl++] = v;
562       }
563    }
564    if (!uds && !udfile && poptPeekArg (optCon))
565    {                            /* multiple command line arguments in UTF-8 */
566       while (poptPeekArg (optCon) && udl < 160)
567       {
568          unsigned char *a = (char *) poptGetArg (optCon);
569          if (udl && udl < 160)
570             ud[udl++] = ' ';    /* space between arguments */
571          while (udl < 160 && *a)
572          {
573             int v = utf8decode (&a);
574             if (v > 0xFFFF)
575             {
576                fprintf (stderr, "Invalid character U+%X at %d\n", v, udl);
577                return 1;
578             }
579             ud[udl++] = v;
580          }
581       }
582    }
583    if (poptPeekArg (optCon))
584    {
585       fprintf (stderr, "Unknown argument %s\n", poptGetArg (optCon));
586       return 1;
587    }
588    if (udfile)
589    {                            // get message from file
590       unsigned char dat[1204],
591        *p = dat,
592          *e;
593       int f,
594         n;
595       if (*udfile)
596          f = open (udfile, O_RDONLY);
597       else
598          f = fileno (stdin);
599       if (f < 0)
600       {
601          perror (udfile);
602          return 1;
603       }
604       n = read (f, dat, sizeof (dat));
605       if (n < 0)
606       {
607          perror (udfile);
608          return 1;
609       }
610       if (*udfile)
611          close (f);
612       e = dat + n;
613       if (utf8)
614       {                         /* UTF-8 */
615          while (p < e && udl < 160 && *p)
616             ud[udl++] = utf8decode (&p);
617       } else if (ucs1)
618       {                         /* UCS-1 */
619          while (p < e && udl < 160)
620             ud[udl++] = *p++;
621       } else
622       {                         /* UCS-2 */
623          while (p + 1 < e && udl < 160)
624          {
625             ud[udl++] = (*p << 8) + p[1];
626             p += 2;
627          }
628       }
629    }
630    if (queue)
631    {
632       char *d = strrchr (queue, '-');
633       if (d && d[1])
634          subaddress = d[1];
635       else
636          subaddress = *defaultsubaddress;
637    }
638
639    if (chdir (spooldir))
640    {
641       perror (spooldir);
642       return 1;
643    }
644
645    if (oa || da)
646    {                            // send message
647       char temp[100],
648         queuename[100],
649        *dir = (mo ? rx ? "sms/morx" : "sms/motx" : rx ? "sms/mtrx" : "sms/mttx");
650       FILE *f;
651       sprintf (temp, "sms/.smsq-%d", getpid ());
652       mkdir ("sms", 0777);      // ensure directory exists
653       mkdir (dir, 0777);        // ensure directory exists
654       sprintf (queuename, "%s/%s.%ld-%d", dir, *queue ? queue : "0", (long)time (0), getpid ());
655       f = fopen (temp, "w");
656       if (!f)
657       {
658          perror (temp);
659          return 1;
660       }
661       if (oa)
662          fprintf (f, "oa=%s\n", oa);
663       if (da)
664          fprintf (f, "da=%s\n", da);
665       if (scts)
666          fprintf (f, "scts=%s\n", scts);
667       if (pid >= 0)
668          fprintf (f, "pid=%d\n", pid);
669       if (dcs >= 0)
670          fprintf (f, "dcs=%d\n", dcs);
671       if (mr >= 0)
672          fprintf (f, "mr=%d\n", mr);
673       if (srr)
674          fprintf (f, "srr=1\n");
675       if (rp)
676          fprintf (f, "rp=1\n");
677       if (udh)
678          fprintf (f, "udh#%s\n", udh);
679       if (vp > 0)
680          fprintf (f, "vp=%d\n", vp);
681       if (udl)
682       {
683          int p;
684          for (p = 0; p < udl && ud[p] < 0x100; p++);
685          if (p == udl)
686          {
687             for (p = 0; p < udl && ud[p] < 0x80 && ud[p] >= 0x20; p++);
688             if (p == udl)
689             {                   /* use text */
690                fprintf (f, "ud=");
691                for (p = 0; p < udl; p++)
692                   fputc (ud[p], f);
693             } else
694             {                   /* use one byte hex */
695                fprintf (f, "ud#");
696                for (p = 0; p < udl; p++)
697                   fprintf (f, "%02X", ud[p]);
698             }
699          } else
700          {                      /* use two byte hex */
701             fprintf (f, "ud##");
702             for (p = 0; p < udl; p++)
703                fprintf (f, "%04X", ud[p]);
704          }
705          fprintf (f, "\n");
706       }
707       fclose (f);
708       if (rename (temp, queuename))
709       {
710          perror (queuename);
711          unlink (temp);
712          return 1;
713       }
714    }
715
716    if (!nodial && tx && !process)
717    {                            // dial to send messages
718       char ret=0,
719         try = 3;
720       if (nowait)
721          try = 1;
722       while (try--)
723       {
724          if (mo)
725             ret = txqcheck ("motx", queue, subaddress, motxchannel, motxcallerid, motxwait, motxdelay, motxretries, concurrent);
726          else
727             ret = txqcheck ("mttx", queue, subaddress, mttxchannel, mttxcallerid, mttxwait, mttxdelay, mttxretries, concurrent);
728          if (ret < 2)
729             break;              // sent, or queued OK
730          if (try)
731             sleep (1);
732       }
733       if (ret == 2 && !nowait)
734          fprintf (stderr, "No call scheduled as already sending\n");
735    }
736    if (process)
737       rxqcheck (mo ? rx ? "morx" : "motx" : rx ? "mtrx" : "mttx", queue, process);
738
739    return 0;
740 }