source: trunk/athena/bin/discuss/server/recover.c @ 23271

/*
 *
 *      Copyright (C) 1988, 1989, 1991 by the Massachusetts Institute of
 *      Technology.
 *      Developed by the MIT Student Information Processing Board (SIPB).
 *      For copying information, see the file mit-copyright.h in this release.
 *
 */
/*
 *
 * recover -- program to recover a meeting from the transaction file.
 *            this program is linked to a server so it can use the
 *            privileged procedures of create_mtg, and the like.
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/file.h>
#include <sys/stat.h>
#if HAVE_FCNTL_H
#include <fcntl.h>
#endif
#include <unistd.h>
#include <discuss/types.h>
#include <discuss/dsc_et.h>
#include <discuss/tfile.h>
#include <discuss/interface.h>
#include "mtg.h"

#define min(a, b) (a < b ? a : b)

static trn_base tb;
static trn_hdr th;
static int tempf;
static int trnf;
static int trnfsize;
static int num_trns;
static int current_pos;
static char *mtg_name, *location, *chairman, *trn_file;
static int *trn_pos;
static int found_eof;
static int do_byteswap;
static char *temp_dir = "/tmp";

tfile unix_tfile ();
static fsize(),read_trn_hdr(),read_last_trn(),save_trn();

extern char rpc_caller[];
extern int has_privs, use_zephyr;

#ifndef __GNUC__
#define inline
#endif

static inline short Sshort(P_s)
        short   P_s;
{
    union {
        short s;
        char c[2];
    } x1, x2;
    x1.s = P_s;
    x2.c[0] = x1.c[1];
    x2.c[1] = x1.c[0];
    return x2.s;
}

static inline long Slong(P_l)
        long    P_l;
{
    union {
        long l;
        char c[4];
    } x1, x2;
    x1.l = P_l;
    x2.c[0] = x1.c[3];
    x2.c[1] = x1.c[2];
    x2.c[2] = x1.c[1];
    x2.c[3] = x1.c[0];
    return x2.l;
}

#define S(X) \
    (sizeof(X)==4               \
     ? (X = Slong(X))           \
     : (sizeof(X)==2            \
        ? (X = Sshort(X))       \
        : (sizeof(X)==1         \
           ? 0                  \
           : abort())))

main (argc, argv)
int argc;
char **argv;
{
     int i;

     has_privs = TRUE;
     use_zephyr = 0;

#if defined(__APPLE__) && defined(__MACH__)
     add_error_table(&et_dsc_error_table);
#else
     initialize_dsc_error_table();
#endif

     for (i = 1; i < argc; i++) {
          if (*argv[i] == '-') switch (argv[i][1]) {
          case 'c':
               if (++i < argc)
                    chairman = argv[i];
               continue;

          case 'n':
               if (++i < argc)
                    mtg_name = argv[i];
               continue;

           case 't':
               if (++i < argc)
                   temp_dir = argv[i];
               continue;

          default:
               goto lusage;
          }
          if (trn_file == NULL)
               trn_file = argv[i];
          else if (location == NULL)
               location = argv[i];
          else goto lusage;
     }

     if (trn_file == NULL || location == NULL)
          goto lusage;                                  /* required */

     if ((trnf = open (trn_file, O_RDONLY, 0)) < 0) {
          fprintf (stderr, "Can't open transaction file %s\n", trn_file);
          exit(1);
     }

     trnfsize = fsize (trnf);
     read_header();                             /* check meeting */


     /* search for last transaction, which gives us our best toehold into
        the meeting.  This is done by searching from the end of the meeting
        for unique. */
     read_last_trn();                           /* read last_trn into th */

     trn_pos = (int *) malloc (sizeof(int) * th.current);
     if (trn_pos == NULL) {
          fprintf (stderr, "Can't allocate memory for transaction positions\n");
          exit(1);
     }

     /* zero out array */
     num_trns = th.current;
     for (i = 0; i <= num_trns; i++) {
          trn_pos[i] = 0;
     }

     /* loop to fill out transaction position array */
     while (current_pos != 0) {
          read_trn_hdr (current_pos);
          trn_pos [th.current] = current_pos;

          current_pos = th.prev_trn;
     }

     create_temp();

     for (i = 1; i <= num_trns; i++) {
          if (trn_pos [i] != 0)
               save_trn (trn_pos [i]);
          else {
               int result;

               expunge_trn(location, i, &result);
               if (result != 0) {
                    fprintf(stderr, "Error expunging transaction [%04d]: %s\n", i, error_message(result));
                    exit(1);
               }
          }
     }

     exit (0);

lusage:
     fprintf(stderr, "usage: recover trn_file mtg_name {-c chairman} {-n name}\n");
     exit (1);
}

read_header()
{
     int result;
     int pos;

     lseek(trnf,0,SEEK_SET);                            /* rewind file */
     if (read (trnf, &tb, sizeof (trn_base)) < sizeof (trn_base)) {
          fprintf (stderr, "Can't read trn_base\n");
          exit(1);
     }

     if (tb.unique != TRN_BASE_UNIQUE) {
             /*
              * Try byte swapping the arguments before giving up.
              */
             S(tb.unique);
             if (tb.unique == TRN_BASE_UNIQUE)
                     do_byteswap++;
             else {
                     fprintf (stderr, "Invalid trn_base unique\n");
                     exit(1);
             }
     }

     if (do_byteswap) {
             S(tb.version);
             S(tb.date_created);
             S(tb.long_name_addr);
             S(tb.chairman_addr);
             S(tb.long_name_len);
             S(tb.chairman_len);
             S(tb.public_flag);
     }
             
     if (tb.version != TRN_BASE_1) {
          fprintf (stderr, "Invalid trn_base version\n");
          exit(1);
     }

     /* read the chairman */
     if (chairman == NULL) {
          if (tb.chairman_len > 255) {
               fprintf (stderr, "Unreasonable chairman length: %d\n",
                        tb.chairman_len);
               exit(1);
          }
          chairman = malloc (tb.chairman_len);
          if (lseek(trnf, tb.chairman_addr, SEEK_SET) < 0) {
no_chairman:
               fprintf (stderr, "Can't read chairman\n");
               exit(1);
          }
          
          if (read (trnf, chairman, tb.chairman_len) < tb.chairman_len)
               goto no_chairman;
     }
          
     /* read the long name */
     if (mtg_name == NULL) {
          if (tb.long_name_len > 255) {
               fprintf (stderr, "Unreasonable long_name length\n");
               exit(1);
          }
          mtg_name = malloc (tb.long_name_len);
          if (lseek(trnf, tb.long_name_addr, SEEK_SET) < 0) {
no_long_name:
               fprintf (stderr, "Can't read long_name\n");
               exit(1);
          }
          
          if (read (trnf, mtg_name, tb.long_name_len) < tb.long_name_len)
               goto no_long_name;
     }

     strcpy (rpc_caller, chairman);
     /* got the params, now create the meeting */
     create_mtg_priv (location, mtg_name, tb.public_flag, tb.date_created, chairman, NULL, &result);
     if (result != 0) {
          fprintf (stderr, "Couldn't create meeting, %s", error_message(result));
          exit(1);
     }

     pos = sizeof (tb) + tb.long_name_len + tb.chairman_len;
     if (pos == trnfsize) {
          fprintf (stderr, "Empty meeting\n");
          exit (0);
     }
}

/*
 *
 * read_trn_hdr () -- Procedure to read a transaction header, erroring out
 *                    if not kosher.
 *
 */
static
read_trn_hdr (position)
int position;
{
     if (lseek (trnf, position, SEEK_SET) < 0) {
no_read:
          fprintf (stderr, "Can't find transaction at %d\n", position);
          exit (1);
     }

     if (read (trnf, &th, sizeof (th)) != sizeof (th))
          goto no_read;

     if (do_byteswap) {
             S(th.version);
             S(th.unique);
             S(th.current);
             S(th.orig_pref);
             S(th.date_entered);
             S(th.num_lines);
             S(th.num_chars);
             S(th.prev_trn);
             S(th.subject_addr);
             S(th.author_addr);
             S(th.text_addr);
             S(th.subject_len);
             S(th.author_len);
     }
     
     /* safety checks */
     if (th.version != TRN_HDR_1) {
          fprintf (stderr, "Invalid trn_hdr version at %d\n", position);
          exit(1);
     }

     if (th.unique != TRN_HDR_UNIQUE) {
          fprintf (stderr, "Invalid trn_hdr unique\n");
          exit(1);
     }

     if (th.current <= 0 || th.author_len < 0 || th.subject_len < 0 || th.num_chars < 0 || th.num_lines < 0) {
          fprintf (stderr, "Negative number\n");
          exit(1);
     }

     if (th.author_addr+th.author_len > trnfsize || th.subject_addr+th.subject_len > trnfsize || th.text_addr+th.num_chars > trnfsize) {
          fprintf (stderr, "Field past file\n");
          exit(1);
     }

     return;
}
/*
 *
 * maybe_read_trn_hdr -- procedure to try to read a transaction header,
 *                       returning true if successful.
 *
 */
static
maybe_read_trn_hdr(position)
int position;
{
     if (lseek (trnf, position, SEEK_SET) < 0) {
          return (FALSE);
     }

     if (read (trnf, &th, sizeof (th)) != sizeof (th))
          return (FALSE);

     if (do_byteswap) {
             S(th.version);
             S(th.unique);
             S(th.current);
             S(th.orig_pref);
             S(th.date_entered);
             S(th.num_lines);
             S(th.num_chars);
             S(th.prev_trn);
             S(th.subject_addr);
             S(th.author_addr);
             S(th.text_addr);
             S(th.subject_len);
             S(th.author_len);
     }       
     
     /* safety checks */
     if (th.version != TRN_HDR_1) {
          return (FALSE);
     }

     if (th.unique != TRN_HDR_UNIQUE) {
          return (FALSE);
     }

     if (th.current <= 0 || th.author_len < 0 || th.subject_len < 0 || th.num_chars < 0 || th.num_lines < 0) {
          return (FALSE);
     }

     if (th.author_addr+th.author_len > trnfsize || th.subject_addr+th.subject_len > trnfsize || th.text_addr+th.num_chars > trnfsize) {
          return (FALSE);
     }

     return (TRUE);
}

/*
 *
 * read_last_trn -- brute force routine to just try reading transactions until
 *                  get a success.
 *
 */
static
read_last_trn ()
{
     current_pos = trnfsize - sizeof (th) - 2;

     while (current_pos > sizeof (tb)) {
          if (maybe_read_trn_hdr (current_pos))
               return;
          current_pos--;
     }
}

static
save_trn (position)
int position;
{
     char *th_subject, *th_author, *th_signature;
     tfile tf;
     int tfs,tocopy;
     trn_nums result_trn;
     int result;
     char buffer[512];

     read_trn_hdr (position);

     th_subject = malloc (th.subject_len);
     lseek (trnf, th.subject_addr, SEEK_SET);
     read (trnf, th_subject, th.subject_len);
          
     th_author = malloc (th.author_len);
     lseek (trnf, th.author_addr, SEEK_SET);
     read (trnf, th_author, th.author_len);

     th_signature = NULL;
     if (strlen (th_author) + 1 != th.author_len) {
          th_signature = th_author + strlen(th_author) + 1;
     }

     /* start temp file */
     ftruncate(tempf,0);
     lseek(tempf,0,SEEK_SET);

     lseek(trnf, th.text_addr, SEEK_SET);
     tfs = th.num_chars;
     while (tfs > 0) {
          tocopy = min (512, tfs);
          read (trnf, buffer, tocopy);
          write (tempf, buffer, tocopy);
          tfs -= tocopy;
     }

     lseek(tempf,0,SEEK_SET);

     tf = unix_tfile (tempf);

     add_trn_priv (location, tf, th_subject, th_signature, th.orig_pref, th.current, th_author, th.date_entered, 0, &result_trn, &result);
     if (result != 0) {
          fprintf (stderr, "Couldn't add transaction %d; %s", th.current, error_message(result));
          exit(1);
     }

     free(th_author);
     free(th_subject);
     tdestroy (tf);
     printf ("Added transaction %d\n", th.current);
     return;
}

/*
 *
 * fsize () -- Routine to find out the size of a file.
 *
 */
static
fsize (d)
int d;
{
     struct stat buf;

     if (fstat (d, &buf) < 0)
          return (0);

     return (buf.st_size);
}

/*
 *
 * new_string (s)  --   Routine to create a copy of the given string, using
 *                      malloc.
 *
 */
static
char *new_string (s)
char *s;
{
     int len;
     char *newstr;

     len = strlen (s) + 1;
     newstr = malloc (len);
     strcpy (newstr, s);
     return (newstr);
}

/*
 *
 * create_temp () -- Create temp file, and let it be tempf.
 *
 */
create_temp()
{
     char *filename;

     filename = malloc (strlen (temp_dir) + 10);
     strcpy (filename, temp_dir);
     strcat (filename, "/rcXXXXXX");
     mktemp (filename);

     tempf = open (filename, O_RDWR | O_CREAT, 0700);
     if (tempf < 0) {
          fprintf (stderr, "Cannot open temp file `%s'\n", filename);
          exit (1);
     }
}