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