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