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