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/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 }