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