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