root/trunk/client/revimage/decompress-test.c

/*
 * decompress-test.c
 *
 * $Id$
 *
 * Program to check that all compressed images in the current directory
 * are not corrupted. Try to test all files ending with 3 digits
 * 
 * Usage: decompress-test
 */
/*
 *  Linbox Rescue Server
 *  Copyright (C) 2002-2005 Linbox FAS, Free & Alter Soft
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#define _GNU_SOURCE
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <stddef.h>
#include <dirent.h>

#include "zlib.h"

#define INSIZE 2048

unsigned char BUFFER[24064];
unsigned char Bitmap[24064 - 2048];
unsigned char IN[INSIZE];
unsigned char zero[512];

typedef struct params_
{
  int bitindex;
  int fo;
  unsigned long long offset;
}
PARAMS;

int
eof (int fd)
{
  __off64_t pos, end;
  pos = lseek64 (fd, 0, SEEK_CUR);
  if (pos < 0)
    {
      fprintf (stderr, "Error LSEEK : eof,pos\n");
    }
  end = lseek64 (fd, 0, SEEK_END);
  if (end < 0)
    {
      fprintf (stderr, "Error LSEEK : eof,end\n");
    }
  if (lseek64 (fd, pos, SEEK_SET) < 0)
    {
      fprintf (stderr, "Error LSEEK, reseek\n");
    }
  if (end == pos)
    return 1;
  return 0;
}

void
fill (int fd, int bytes, int dir)
{
  int err = 0;
  int lg = bytes;

  if (eof (fd))
    {
      while (bytes > 512)
        {
          if (write (fd, zero, 512) != 512)
            {
              if (!err)
                {
                  err = 1;
                  fprintf (stderr, "Error FILL : write 512!=512\n");
                }
            }
          bytes -= 512;
        }
      if (write (fd, zero, bytes) != bytes)
        {
          fprintf (stderr, "Error FILL : %d bytes write...\n", bytes);
          err = 1;
        }
    }
  else
    {
      if (lseek64 (fd, bytes, dir) < 0)
        {
          fprintf (stderr, "Error FILL : skip error");
          err = 1;
        }
    }
  if (err)
    fprintf (stderr, "Error when filling %d bytes\n", lg);
}

void
flushToDisk (unsigned char *buff, unsigned char *bit, PARAMS * cp, int lg)
{
  unsigned char *ptr = buff;
  unsigned char mask[] = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 };
  int indx = cp->bitindex;

// printf("Enter : bitindex -> %d\n",indx);
  while (lg > 0)
    {
      while (!(bit[indx >> 3] & mask[indx & 7]))
        {
          indx++;
          cp->offset += 512;
          if (cp->fo)
            fill (cp->fo, 512, SEEK_CUR);
        }
//      printf("Write @offset : %lld\t",cp->offset);
//      {int i; for(i=0;i<15;i++) printf("%02x ",ptr[i]); printf("\n");}
      if (cp->fo)
        {
          if (write (cp->fo, ptr, 512) != 512)
            fprintf (stderr, "Flush Error : write 512!=512\n");
        }
      cp->offset += 512;
      ptr += 512;
      indx++;
      lg -= 512;
    }
// printf("Exit  : bitindex -> %d\n",indx);
  cp->bitindex = indx;
}

int
main (int argc, char *argv[])
{
  z_stream zptr;
  int state, l;
  int ret, firstpass, bitmaplg;
  FILE *fi;
  PARAMS currentparams;
  DIR *dp;
  struct dirent *ep;
  char *name;

  dp = opendir ("./");
  if (dp == NULL)
    {
      puts ("Couldn't open the directory.");
      exit (1);
    }
  else
    {
      while (ep = readdir (dp))
        {
          name = ep->d_name;
          l = strlen(name);
          if (l < 4) continue;
          if (!isdigit(name[l-1]) || !isdigit(name[l-2]) || !isdigit(name[l-3]) ) continue;       
          printf ("** Testing: %s **", name);

        start:
          state = Z_SYNC_FLUSH;
          firstpass = 1;
          bitmaplg = 0;

          zptr.zalloc = NULL;
          zptr.zfree = NULL;

          fi = fopen (name, "rb");
          if (fi == NULL)
            {
              printf ("Cannot open input file\n");
              exit (1);
            }
          zptr.avail_in = fread (IN, 1, INSIZE, fi);

          memset (zero, 0, 512);

          currentparams.fo = 0;
          currentparams.offset = 0;
          currentparams.bitindex = 0;

          zptr.next_in = (char *) IN;
          zptr.next_out = (char *) BUFFER;      // was dbuf.data;
          zptr.avail_out = 24064;

          inflateInit (&zptr);

          do
            {
//  if (inflateSyncPoint(&zptr)) printf("#");

              ret = inflate (&zptr, state);

//  printf("-> %d : %d / %d\n",ret ,zptr.avail_in ,zptr.avail_out );

              if ((ret == Z_OK) && (zptr.avail_out == 0))
                {
                  if (firstpass)
                    {
                      printf ("Params : *%s\n", BUFFER);
                      if (strstr (BUFFER, "BLOCKS="))
                        {
                          /* FILE *fo;
                          int i = 0;
                          sscanf (strstr (BUFFER, "BLOCKS=") + 7, "%d", &i);
                          fo = fopen ("/tmp/blocks", "wt");
                          fprintf (fo, "%d\n", i);
                          fclose (fo); */
                        }
                      if (strstr (BUFFER, "ALLOCTABLELG="))
                        sscanf (strstr (BUFFER, "ALLOCTABLELG=") + 13, "%d",
                                &bitmaplg);
                      memcpy (Bitmap, BUFFER + 2048, 24064 - 2048);
#if 0
                      {
                        int i;
                        for (i = 0; i < 256; i++)
                          {
                            if ((i & 15) == 0)
                              printf ("\n%04x : ", i);
                            printf ("%02X ", Bitmap[i]);
                          }
                        printf ("\n");
                      }
#endif
                      currentparams.bitindex = 0;
                      firstpass = 0;
                    }
                  else
                    {
                      //flushToDisk (BUFFER, Bitmap, &currentparams, 24064);
                    }

                  zptr.next_out = (char *) BUFFER;
                  zptr.avail_out = 24064;
                }

              if ((ret == Z_OK) && (zptr.avail_in == 0))
                {
                  zptr.avail_in = fread (IN, 1, INSIZE, fi);
                  zptr.next_in = (char *) IN;
                }
            }
          while (ret == Z_OK);

printf("ret=%d\n", ret);
          if (ret == Z_STREAM_END)
            {
              {
                if (firstpass)
                  {
                    printf ("Params : *%s*\n", BUFFER);
                    if (strstr (BUFFER, "BLOCKS="))
                      {
                        /* FILE *fo;
                        int i = 0;
                        sscanf (strstr (BUFFER, "BLOCKS=") + 7, "%d", &i);
                        fo = fopen ("/tmp/blocks", "wt");
                        fprintf (fo, "%d\n", i);
                        fclose (fo); */
                      }
                    if (strstr (BUFFER, "ALLOCTABLELG="))
                      sscanf (strstr (BUFFER, "ALLOCTABLELG=") + 13, "%d",
                              &bitmaplg);
                    memcpy (Bitmap, BUFFER + 2048, 24064 - 2048);
                    zptr.next_out = (char *) BUFFER;
                    zptr.avail_out = 24064;
                  }
              }

              //printf ("Flushing to EOF ... (%d bytes)\n",
                //      24064 - zptr.avail_out);
              //flushToDisk (BUFFER, Bitmap, &currentparams,
                //         24064 - zptr.avail_out);
              zptr.next_out = (char *) BUFFER;
              zptr.avail_out = 24064;
            }

          ret = inflate (&zptr, Z_FINISH);
          inflateEnd (&zptr);


          if (ret < 0)
            {
              printf ("Returned : %d\t", ret);
              printf ("(AvailIn : %d / ", zptr.avail_in);
              printf ("AvailOut: %d)\n", zptr.avail_out);
              printf ("(TotalIn : %ld / ", zptr.total_in);
              printf ("TotalOut: %ld)\n", zptr.total_out);
              fprintf (stderr, "ZLIB error, aborting...\n");
              exit(1);
              goto start;
            }

          /*printf ("Offset : %lld\n", currentparams.offset);
          printf ("Bitmap index : %d\n", currentparams.bitindex);*/

          if (bitmaplg)
            {
              if (bitmaplg * 8 > currentparams.bitindex)
                {
                  //printf ("Remaining bitmap : %d\n",
                  //      bitmaplg * 8 - currentparams.bitindex);
                  currentparams.offset +=
                    512 * (bitmaplg * 8 - currentparams.bitindex);
                  if (currentparams.fo)
                    {
                    //  fill (currentparams.fo,
                    //      512 * (bitmaplg * 8 - currentparams.bitindex),
                    //      SEEK_CUR);
                    }
                }
            }


          fclose (fi);
        }
    }
   (void) closedir (dp);
   puts("** Verified files are OK **");
   exit(0);
}