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