backends/innxbatch.c

   1 /*  $Id: innxbatch.c 6351 2003-05-19 02:00:06Z rra $
   2 **
   3 **  Transmit batches to remote site, using the XBATCH command
   4 **  Modelled after innxmit.c and nntpbatch.c
   5 **
   6 **  Invocation:
   7 **      innxbatch [options] <serverhost> <file> ...
   8 #ifdef FROMSTDIN
   9 **      innxbatch -i <serverhost>
  10 #endif FROMSTDIN
  11 **  will connect to serverhost's nntp port, and transfer the named files,
  12 **  with an xbatch command for every file. Files that have been sent
  13 **  successfully are unlink()ed. In case of any error, innxbatch terminates
  14 **  and leaves any remaining files untouched, for later transmission.
  15 **  Options:
  16 **      -D      increase debug level
  17 **      -v      report statistics to stdout
  18 #ifdef FROMSTDIN
  19 **      -i      read batch file names from stdin instead from command line.
  20 **              For each successfully transmitted batch, an OK is printed on
  21 **              stdout, to indicate that another file name is expected.
  22 #endif
  23 **      -t      Timeout for connection attempt
  24 **      -T      Timeout for batch transfers.
  25 **  We do not use any file locking. At worst, a batch could be transmitted
  26 **  twice in parallel by two independant invocations of innxbatch.
  27 **  To prevent this, innxbatch should be invoked by a shell script that uses
  28 **  shlock(1) to achieve mutual exclusion.
  29 */
  30
  31 #include "config.h"
  32 #include "clibrary.h"
  33 #include "portable/socket.h"
  34 #include "portable/time.h"
  35 #include <ctype.h>
  36 #include <errno.h>
  37 #include <fcntl.h>
  38 #include <setjmp.h>
  39 #include <signal.h>
  40 #include <syslog.h>
  41 #include <sys/stat.h>
  42
  43 /* Needed on AIX 4.1 to get fd_set and friends. */
  44 #ifdef HAVE_SYS_SELECT_H
  45 # include <sys/select.h>
  46 #endif
  47
  48 #include "inn/innconf.h"
  49 #include "inn/messages.h"
  50 #include "inn/timer.h"
  51 #include "libinn.h"
  52 #include "nntp.h"
  53
  54 /*
  55 ** Syslog formats - collected together so they remain consistent
  56 */
  57 static char     STAT1[] =
  58         "%s stats offered %lu accepted %lu refused %lu rejected %lu";
  59 static char     STAT2[] = "%s times user %.3f system %.3f elapsed %.3f";
  60 static char     CANT_CONNECT[] = "%s connect failed %s";
  61 static char     CANT_AUTHENTICATE[] = "%s authenticate failed %s";
  62 static char     XBATCH_FAIL[] = "%s xbatch failed %s";
  63 static char     UNKNOWN_REPLY[] = "Unknown reply after sending batch -- %s";
  64 static char     CANNOT_UNLINK[] = "cannot unlink %s: %m";
  65 /*
  66 **  Global variables.
  67 */
  68 static bool             Debug = 0;
  69 static bool             STATprint;
  70 static char             *REMhost;
  71 static double           STATbegin;
  72 static double           STATend;
  73 static char             *XBATCHname;
  74 static int              FromServer;
  75 static int              ToServer;
  76 static sig_atomic_t     GotAlarm;
  77 static sig_atomic_t     GotInterrupt;
  78 static sig_atomic_t     JMPyes;
  79 static jmp_buf          JMPwhere;
  80 static unsigned long    STATaccepted;
  81 static unsigned long    STAToffered;
  82 static unsigned long    STATrefused;
  83 static unsigned long    STATrejected;
  84
  85 /*
  86 **  Send a line to the server. \r\n will be appended
  87 */
  88 static bool
  89 REMwrite(int fd, char *p)
  90 {
  91   int           i;
  92   int           err;
  93   char          *dest;
  94   static char           buff[NNTP_STRLEN];
  95
  96   for (dest = buff, i = 0; p[i]; ) *dest++ = p[i++];
  97   *dest++ = '\r';
  98   *dest++ = '\n';
  99   *dest++ = '\0';
 100
 101   for (dest = buff, i+=2; i; dest += err, i -= err) {
 102     err = write(fd, dest, i);
 103     if (err < 0) {
 104       syswarn("cannot write %s to %s", dest, REMhost);
 105       return false;
 106     }
 107   }
 108   if (Debug)
 109     fprintf(stderr, "> %s\n", p);
 110
 111   return true;
 112 }
 113
 114 /*
 115 **  Print transfer statistics, clean up, and exit.
 116 */
 117 static void
 118 ExitWithStats(int x)
 119 {
 120   static char           QUIT[] = "quit";
 121   double                usertime;
 122   double                systime;
 123
 124   REMwrite(ToServer, QUIT);
 125
 126   STATend = TMRnow_double();
 127   if (GetResourceUsage(&usertime, &systime) < 0) {
 128     usertime = 0;
 129     systime = 0;
 130   }
 131
 132   if (STATprint) {
 133     printf(STAT1,
 134         REMhost, STAToffered, STATaccepted, STATrefused, STATrejected);
 135     printf("\n");
 136     printf(STAT2, REMhost, usertime, systime, STATend - STATbegin);
 137     printf("\n");
 138   }
 139
 140   syslog(L_NOTICE, STAT1,
 141          REMhost, STAToffered, STATaccepted, STATrefused, STATrejected);
 142   syslog(L_NOTICE, STAT2, REMhost, usertime, systime, STATend - STATbegin);
 143
 144   exit(x);
 145   /* NOTREACHED */
 146 }
 147
 148
 149 /*
 150 **  Clean up the NNTP escapes from a line.
 151 */
 152 static char *
 153 REMclean(char *buff)
 154 {
 155     char        *p;
 156
 157     if ((p = strchr(buff, '\r')) != NULL)
 158         *p = '\0';
 159     if ((p = strchr(buff, '\n')) != NULL)
 160         *p = '\0';
 161
 162     /* The dot-escape is only in text, not command responses. */
 163     return buff;
 164 }
 165
 166
 167 /*
 168 **  Read a line of input, with timeout. We expect only answer lines, so
 169 **  we ignore \r\n-->\n mapping and the dot escape.
 170 **  Return true if okay, *or we got interrupted.*
 171 */
 172 static bool
 173 REMread(char *start, int size)
 174 {
 175   char *p, *h;
 176   struct timeval t;
 177   fd_set rmask;
 178   int i;
 179
 180   for (p = start; size; ) {
 181     FD_ZERO(&rmask);
 182     FD_SET(FromServer, &rmask);
 183     t.tv_sec = 10 * 60;
 184     t.tv_usec = 0;
 185     i = select(FromServer + 1, &rmask, NULL, NULL, &t);
 186     if (GotInterrupt) return true;
 187     if (i < 0) {
 188       if (errno == EINTR) continue;
 189       else return false;
 190     }
 191     if (i == 0 || !FD_ISSET(FromServer, &rmask)) return false;
 192     i = read(FromServer, p, size-1);
 193     if (GotInterrupt) return true;
 194     if (i <= 0) return false;
 195     h = p;
 196     p += i;
 197     size -= i;
 198     for ( ; h < p; h++) {
 199       if (h > start && '\n' == *h && '\r' == h[-1]) {
 200         *h = h[-1] = '\0';
 201         size = 0;
 202       }
 203     }
 204   }
 205
 206   if (Debug)
 207     fprintf(stderr, "< %s\n", start);
 208
 209   return true;
 210 }
 211
 212
 213 /*
 214 **  Handle the interrupt.
 215 */
 216 static void
 217 Interrupted(void)
 218 {
 219   warn("interrupted");
 220   ExitWithStats(1);
 221 }
 222
 223
 224 /*
 225 **  Send a whole xbatch to the server. Uses the global variables
 226 **  REMbuffer & friends
 227 */
 228 static bool
 229 REMsendxbatch(int fd, char *buf, int size)
 230 {
 231   char  *p;
 232   int           i;
 233   int           err;
 234
 235   for (i = size, p = buf; i; p += err, i -= err) {
 236     err = write(fd, p, i);
 237     if (err < 0) {
 238       syswarn("cannot write xbatch to %s", REMhost);
 239       return false;
 240     }
 241   }
 242   if (GotInterrupt) Interrupted();
 243   if (Debug)
 244     fprintf(stderr, "> [%d bytes of xbatch]\n", size);
 245
 246   /* What did the remote site say? */
 247   if (!REMread(buf, size)) {
 248     syswarn("no reply after sending xbatch");
 249     return false;
 250   }
 251   if (GotInterrupt) Interrupted();
 252
 253   /* Parse the reply. */
 254   switch (atoi(buf)) {
 255   default:
 256     warn("unknown reply after sending batch -- %s", buf);
 257     syslog(L_ERROR, UNKNOWN_REPLY, buf);
 258     return false;
 259     /* NOTREACHED */
 260     break;
 261   case NNTP_RESENDIT_VAL:
 262   case NNTP_GOODBYE_VAL:
 263     syslog(L_NOTICE, XBATCH_FAIL, REMhost, buf);
 264     STATrejected++;
 265     return false;
 266     /* NOTREACHED */
 267     break;
 268   case NNTP_OK_XBATCHED_VAL:
 269     STATaccepted++;
 270     if (Debug) fprintf(stderr, "will unlink(%s)\n", XBATCHname);
 271     if (unlink(XBATCHname)) {
 272       /* probably another incarantion was faster, so avoid further duplicate
 273        * work
 274        */
 275       syswarn("cannot unlink %s", XBATCHname);
 276       syslog(L_NOTICE, CANNOT_UNLINK, XBATCHname);
 277       return false;
 278     }
 279     break;
 280   }
 281
 282   /* Article sent */
 283   return true;
 284 }
 285
 286 /*
 287 **  Mark that we got interrupted.
 288 */
 289 static RETSIGTYPE
 290 CATCHinterrupt(int s)
 291 {
 292     GotInterrupt = true;
 293
 294     /* Let two interrupts kill us. */
 295     xsignal(s, SIG_DFL);
 296 }
 297
 298
 299 /*
 300 **  Mark that the alarm went off.
 301 */
 302 /* ARGSUSED0 */
 303 static RETSIGTYPE
 304 CATCHalarm(int s UNUSED)
 305 {
 306     GotAlarm = true;
 307     if (JMPyes)
 308         longjmp(JMPwhere, 1);
 309 }
 310
 311
 312 /*
 313 **  Print a usage message and exit.
 314 */
 315 static void
 316 Usage(void)
 317 {
 318     warn("Usage: innxbatch [-Dv] [-t#] [-T#] host file ...");
 319 #ifdef FROMSTDIN
 320     warn("       innxbatch [-Dv] [-t#] [-T#] -i host");
 321 #endif
 322     exit(1);
 323 }
 324
 325
 326 int
 327 main(int ac, char *av[])
 328 {
 329   int                   i;
 330   char                  *p;
 331   FILE                  *From;
 332   FILE                  *To;
 333   char                  buff[NNTP_STRLEN];
 334   RETSIGTYPE            (*old)(int) = NULL;
 335   unsigned int          ConnectTimeout;
 336   unsigned int          TotalTimeout;
 337   struct stat           statbuf;
 338   int                   fd;
 339   int                   err;
 340   char                  *XBATCHbuffer = NULL;
 341   int                   XBATCHbuffersize = 0;
 342   int                   XBATCHsize;
 343
 344   openlog("innxbatch", L_OPENLOG_FLAGS | LOG_PID, LOG_INN_PROG);
 345   message_program_name = "innxbatch";
 346
 347   /* Set defaults. */
 348   if (!innconf_read(NULL))
 349       exit(1);
 350   ConnectTimeout = 0;
 351   TotalTimeout = 0;
 352   umask(NEWSUMASK);
 353
 354   /* Parse JCL. */
 355   while ((i = getopt(ac, av, "Dit:T:v")) != EOF)
 356     switch (i) {
 357     default:
 358       Usage();
 359       /* NOTREACHED */
 360       break;
 361     case 'D':
 362       Debug++;
 363       break;
 364 #ifdef FROMSTDIN
 365     case 'i':
 366       FromStdin = true;
 367       break;
 368 #endif
 369     case 't':
 370       ConnectTimeout = atoi(optarg);
 371       break;
 372     case 'T':
 373       TotalTimeout = atoi(optarg);
 374       break;
 375     case 'v':
 376       STATprint = true;
 377       break;
 378     }
 379   ac -= optind;
 380   av += optind;
 381
 382   /* Parse arguments; host and filename. */
 383   if (ac < 2)
 384     Usage();
 385   REMhost = av[0];
 386   ac--;
 387   av++;
 388
 389   /* Open a connection to the remote server. */
 390   if (ConnectTimeout) {
 391     GotAlarm = false;
 392     old = xsignal(SIGALRM, CATCHalarm);
 393     JMPyes = true;
 394     if (setjmp(JMPwhere))
 395       die("cannot connect to %s: timed out", REMhost);
 396     alarm(ConnectTimeout);
 397   }
 398   if (NNTPconnect(REMhost, NNTP_PORT, &From, &To, buff) < 0 || GotAlarm) {
 399     i = errno;
 400     warn("cannot connect to %s: %s", REMhost,
 401          buff[0] ? REMclean(buff): strerror(errno));
 402     if (GotAlarm)
 403       syslog(L_NOTICE, CANT_CONNECT, REMhost, "timeout");
 404     else
 405       syslog(L_NOTICE, CANT_CONNECT, REMhost,
 406              buff[0] ? REMclean(buff) : strerror(i));
 407     exit(1);
 408   }
 409
 410   if (Debug)
 411     fprintf(stderr, "< %s\n", REMclean(buff));
 412   if (NNTPsendpassword(REMhost, From, To) < 0 || GotAlarm) {
 413     i = errno;
 414     syswarn("cannot authenticate with %s", REMhost);
 415     syslog(L_ERROR, CANT_AUTHENTICATE,
 416            REMhost, GotAlarm ? "timeout" : strerror(i));
 417     /* Don't send quit; we want the remote to print a message. */
 418     exit(1);
 419   }
 420   if (ConnectTimeout) {
 421     alarm(0);
 422     xsignal(SIGALRM, old);
 423     JMPyes = false;
 424   }
 425
 426   /* We no longer need standard I/O. */
 427   FromServer = fileno(From);
 428   ToServer = fileno(To);
 429
 430 #if     defined(SOL_SOCKET) && defined(SO_SNDBUF) && defined(SO_RCVBUF)
 431   i = 24 * 1024;
 432   if (setsockopt(ToServer, SOL_SOCKET, SO_SNDBUF, (char *)&i, sizeof i) < 0)
 433     perror("cant setsockopt(SNDBUF)");
 434   if (setsockopt(FromServer, SOL_SOCKET, SO_RCVBUF, (char *)&i, sizeof i) < 0)
 435     perror("cant setsockopt(RCVBUF)");
 436 #endif  /* defined(SOL_SOCKET) && defined(SO_SNDBUF) && defined(SO_RCVBUF) */
 437
 438   GotInterrupt = false;
 439   GotAlarm = false;
 440
 441   /* Set up signal handlers. */
 442   xsignal(SIGHUP, CATCHinterrupt);
 443   xsignal(SIGINT, CATCHinterrupt);
 444   xsignal(SIGTERM, CATCHinterrupt);
 445   xsignal(SIGPIPE, SIG_IGN);
 446   if (TotalTimeout) {
 447     xsignal(SIGALRM, CATCHalarm);
 448     alarm(TotalTimeout);
 449   }
 450
 451   /* Start timing. */
 452   STATbegin = TMRnow_double();
 453
 454   /* main loop over all specified files */
 455   for (XBATCHname = *av; ac && (XBATCHname = *av); av++, ac--) {
 456
 457     if (Debug) fprintf(stderr, "will work on %s\n", XBATCHname);
 458
 459     if (GotAlarm) {
 460       warn("timed out");
 461       ExitWithStats(1);
 462     }
 463     if (GotInterrupt) Interrupted();
 464
 465     if ((fd = open(XBATCHname, O_RDONLY, 0)) < 0) {
 466       syswarn("cannot open %s, skipping", XBATCHname);
 467       continue;
 468     }
 469
 470     if (fstat(fd, &statbuf)) {
 471       syswarn("cannot stat %s, skipping", XBATCHname);
 472       close(i);
 473       continue;
 474     }
 475
 476     XBATCHsize = statbuf.st_size;
 477     if (XBATCHsize == 0) {
 478       warn("batch file %s is zero length, skipping", XBATCHname);
 479       close(i);
 480       unlink(XBATCHname);
 481       continue;
 482     } else if (XBATCHsize > XBATCHbuffersize) {
 483       XBATCHbuffersize = XBATCHsize;
 484       if (XBATCHbuffer) free(XBATCHbuffer);
 485       XBATCHbuffer = xmalloc(XBATCHsize);
 486     }
 487
 488     err = 0; /* stupid compiler */
 489     for (i = XBATCHsize, p = XBATCHbuffer; i; i -= err, p+= err) {
 490       err = read(fd, p, i);
 491       if (err < 0) {
 492         syswarn("error reading %s, skipping", XBATCHname);
 493         break;
 494       } else if (0 == err) {
 495         syswarn("unexpected EOF reading %s, truncated", XBATCHname);
 496         XBATCHsize = p - XBATCHbuffer;
 497         break;
 498       }
 499     }
 500     close(fd);
 501     if (err < 0)
 502       continue;
 503
 504     if (GotInterrupt) Interrupted();
 505
 506     /* Offer the xbatch. */
 507     snprintf(buff, sizeof(buff), "xbatch %d", XBATCHsize);
 508     if (!REMwrite(ToServer, buff)) {
 509       syswarn("cannot offer xbatch to %s", REMhost);
 510       ExitWithStats(1);
 511     }
 512     STAToffered++;
 513     if (GotInterrupt) Interrupted();
 514
 515     /* Does he want it? */
 516     if (!REMread(buff, (int)sizeof buff)) {
 517       syswarn("no reply to XBATCH %d from %s", XBATCHsize, REMhost);
 518       ExitWithStats(1);
 519     }
 520     if (GotInterrupt) Interrupted();
 521
 522     /* Parse the reply. */
 523     switch (atoi(buff)) {
 524     default:
 525       warn("unknown reply to %s -- %s", XBATCHname, buff);
 526       ExitWithStats(1);
 527       /* NOTREACHED */
 528       break;
 529     case NNTP_RESENDIT_VAL:
 530     case NNTP_GOODBYE_VAL:
 531       /* Most likely out of space -- no point in continuing. */
 532       syslog(L_NOTICE, XBATCH_FAIL, REMhost, buff);
 533       ExitWithStats(1);
 534       /* NOTREACHED */
 535     case NNTP_CONT_XBATCH_VAL:
 536       if (!REMsendxbatch(ToServer, XBATCHbuffer, XBATCHsize))
 537         ExitWithStats(1);
 538       /* NOTREACHED */
 539       break;
 540     case NNTP_SYNTAX_VAL:
 541     case NNTP_BAD_COMMAND_VAL:
 542       warn("server %s seems not to understand XBATCH: %s", REMhost, buff);
 543       syslog(L_FATAL, XBATCH_FAIL, REMhost, buff);
 544       break;
 545     }
 546   }
 547   ExitWithStats(0);
 548   /* NOTREACHED */
 549   return 0;
 550 }