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 #ifdef SOLARIS
  13 #include <solaris-compat/compat.h>
  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 }