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