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