mariadb/isam/isamchk.c

/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
   
   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

/* Descript, check and repair of ISAM tables */

#include "isamdef.h"

#include <m_ctype.h>
#include <stdarg.h>
#include <getopt.h>
#ifdef HAVE_SYS_VADVICE_H
#include <sys/vadvise.h>
#endif
#ifdef HAVE_SYS_MMAN_H
#include <sys/mman.h>
#endif
SET_STACK_SIZE(9000)			/* Minimum stack size for program */

#define T_VERBOSE	1
#define T_SILENT	2
#define T_DESCRIPT	4
#define T_EXTEND	8
#define T_INFO		16
#define T_REP		32
#define T_OPT		64		/* Not currently used */
#define T_FORCE_CREATE	128
#define T_WRITE_LOOP	256
#define T_UNPACK	512
#define T_STATISTICS	1024
#define T_VERY_SILENT	2048
#define T_SORT_RECORDS	4096
#define T_SORT_INDEX	8192
#define T_WAIT_FOREVER	16384
#define T_REP_BY_SORT	32768


#define O_NEW_INDEX	1		/* Bits set in out_flag */
#define O_NEW_DATA	2

#if defined(_MSC_VER) && !defined(__WIN__)
#define USE_BUFFER_INIT		250L*1024L
#define READ_BUFFER_INIT	((uint) 32768-MALLOC_OVERHEAD)
#define SORT_BUFFER_INIT	(uint) (65536L-MALLOC_OVERHEAD)
#define MIN_SORT_BUFFER		(1024*16-MALLOC_OVERHEAD)
#else
#define USE_BUFFER_INIT		(((1024L*512L-MALLOC_OVERHEAD)/IO_SIZE)*IO_SIZE)
#define READ_BUFFER_INIT	(1024L*256L-MALLOC_OVERHEAD)
#define SORT_BUFFER_INIT	(2048L*1024L-MALLOC_OVERHEAD)
#define MIN_SORT_BUFFER		(4096-MALLOC_OVERHEAD)
#endif

#define NEAD_MEM	((uint) 10*4*(IO_SIZE+32)+32) /* Nead for recursion */
#define MAXERR			20
#define BUFFERS_WHEN_SORTING	16		/* Alloc for sort-key-tree */
#define WRITE_COUNT		MY_HOW_OFTEN_TO_WRITE
#define INDEX_TMP_EXT		".TMM"
#define DATA_TMP_EXT		".TMD"
#define MYF_RW	MYF(MY_NABP | MY_WME | MY_WAIT_IF_FULL)

#define UPDATE_TIME		1
#define UPDATE_STAT		2
#define UPDATE_SORT		4

typedef struct st_sort_key_blocks {		/* Used when sorting */
  uchar *buff,*end_pos;
  uchar lastkey[N_MAX_POSSIBLE_KEY_BUFF];
  uint last_length;
  int inited;
} SORT_KEY_BLOCKS;

typedef struct st_sort_info {
  N_INFO *info;
  enum data_file_type new_data_file_type;
  SORT_KEY_BLOCKS *key_block,*key_block_end;
  uint key,find_length;
  ulong pos,max_pos,filepos,start_recpos,filelength,dupp,max_records,unique,
    buff_length;
  my_bool fix_datafile;
  char *record,*buff;
  N_KEYDEF *keyinfo;
  N_KEYSEG *keyseg;
} SORT_INFO;

enum options {OPT_CHARSETS_DIR=256};

static ulong	use_buffers=0,read_buffer_length=0,write_buffer_length=0,
		sort_buffer_length=0,sort_key_blocks=0,crc=0,unique_count=0;
static uint testflag=0,out_flag=0,warning_printed=0,error_printed=0,
	    rep_quick=0,verbose=0,opt_follow_links=1;
static uint opt_sort_key=0,total_files=0,max_level=0,max_key=N_MAXKEY;
static ulong keydata=0,totaldata=0,key_blocks=0;
static ulong new_file_pos=0,record_checksum=0,key_file_blocks=0,decode_bits;
static ulong total_records=0,total_deleted=0;
static ulong search_after_block=NI_POS_ERROR;
static byte *record_buff;
static char **defaults_alloc;
static const char *type_names[]=
{ "?","text","binary", "short", "long", "float",
  "double","number","unsigned short",
  "unsigned long","longlong","ulonglong","int24",
  "uint24","int8","?",},
  *packed_txt="packed ",
  *diff_txt="stripped ",
  *field_pack[]={"","no endspace", "no prespace",
		 "no zeros", "blob", "constant", "table-lookup",
		 "always zero","?","?",};

static char temp_filename[FN_REFLEN], *isam_file_name, *default_charset; 
static IO_CACHE read_cache;
static SORT_INFO sort_info;
static int tmpfile_createflag=O_RDWR | O_TRUNC | O_EXCL;

static const char *load_default_groups[]= { "isamchk",0 };

	/* Functions defined in this file */

extern int main(int argc,char * *argv);
extern void print_error _VARARGS((const char *fmt,...));
static void print_warning _VARARGS((const char *fmt,...));
static void print_info _VARARGS((const char *fmt,...));
static int nisamchk(char *filename);
static void get_options(int *argc,char * * *argv);
static int chk_del(N_INFO *info,uint testflag);
static int check_k_link(N_INFO *info,uint nr);
static int chk_size(N_INFO *info);
static int chk_key(N_INFO *info);
static int chk_index(N_INFO *info,N_KEYDEF *keyinfo,ulong page,uchar *buff,
		     ulong *keys,uint level);
static uint isam_key_length(N_INFO *info,N_KEYDEF *keyinfo);
static unsigned long calc_checksum(ulong count);
static int chk_data_link(N_INFO *info,int extend);
static int rep(N_INFO *info,char *name);
static int writekeys(N_INFO *info,byte *buff,ulong filepos);
static void descript(N_INFO *info,char *name);
static int movepoint(N_INFO *info,byte *record,ulong oldpos,ulong newpos,
		     uint prot_key);
static void lock_memory(void);
static int flush_blocks(File file);
static int sort_records(N_INFO *,my_string,uint,int);
static int sort_index(N_INFO *info,my_string name);
static int sort_record_index(N_INFO *info,N_KEYDEF *keyinfo,ulong page,
			     uchar *buff,uint sortkey,File new_file);
static int sort_one_index(N_INFO *info,N_KEYDEF *keyinfo,uchar *buff,
			  File new_file);
static int change_to_newfile(const char * filename,const char * old_ext,
			     const char * new_ext);
static int lock_file(File file,ulong start,int lock_type,const char* filetype,
		     const char *filename);
static int filecopy(File to,File from,ulong start,ulong length,
		    const char * type);

static void print_version(void);
static int rep_by_sort(N_INFO *info,my_string name);
static int sort_key_read(void *key);
static int sort_get_next_record(void);
static int sort_write_record(void);
static int sort_key_cmp(const void *not_used, const void *a,const void *b);
static int sort_key_write(const void *a);
static ulong get_record_for_key(N_INFO *info,N_KEYDEF *keyinfo,
				uchar *key);
static int sort_insert_key(reg1 SORT_KEY_BLOCKS *key_block,uchar *key,
			   ulong prev_block);
static int sort_delete_record(void);
static void usage(void);
static int flush_pending_blocks(void);
static SORT_KEY_BLOCKS	*alloc_key_blocks(uint blocks,uint buffer_length);
static int test_if_almost_full(N_INFO *info);
static int recreate_database(N_INFO **info,char *filename);
static void save_integer(byte *pos,uint pack_length,ulong value);
static int write_data_suffix(N_INFO *info);
static int update_state_info(N_INFO *info,uint update);


	/* Main program */

int main(argc,argv)
int argc;
char **argv;
{
  int error;
  MY_INIT(argv[0]);

  get_options(&argc,(char***) &argv);
  nisam_quick_table_bits=(uint) decode_bits;
  error=0;
  while (--argc >= 0)
  {
    error|= nisamchk(*(argv++));
    VOID(fflush(stdout));
    VOID(fflush(stderr));
    if ((error_printed | warning_printed) && (testflag & T_FORCE_CREATE) &&
	(!(testflag & (T_REP | T_REP_BY_SORT | T_SORT_RECORDS |
		       T_SORT_INDEX))))
    {
      testflag|=T_REP;
      error|=nisamchk(argv[-1]);
      testflag&= ~T_REP;
      VOID(fflush(stdout));
      VOID(fflush(stderr));
    }
    if (argc && (!(testflag & T_SILENT) || testflag & T_INFO))
    {
      puts("\n---------\n");
      VOID(fflush(stdout));
    }
  }
  if (total_files > 1)
  {					/* Only if descript */
    if (!(testflag & T_SILENT) || testflag & T_INFO)
      puts("\n---------\n");
    printf("\nTotal of all %d ISAM-files:\nData records: %8lu   Deleted blocks: %8lu\n",total_files,total_records,total_deleted);
  }
  free_defaults(defaults_alloc);
  my_end(testflag & T_INFO ? MY_CHECK_ERROR | MY_GIVE_INFO : MY_CHECK_ERROR);
  exit(error);
#ifndef _lint
  return 0;				/* No compiler warning */
#endif
} /* main */


static CHANGEABLE_VAR changeable_vars[] = {
  { "key_buffer_size",(long*) &use_buffers,(long) USE_BUFFER_INIT,
    (long) MALLOC_OVERHEAD, (long) ~0L,(long) MALLOC_OVERHEAD,(long) IO_SIZE },
  { "read_buffer_size", (long*) &read_buffer_length,(long) READ_BUFFER_INIT,
      (long) MALLOC_OVERHEAD,(long) ~0L,(long) MALLOC_OVERHEAD,(long) 1L },
  { "write_buffer_size", (long*) &write_buffer_length,(long) READ_BUFFER_INIT,
      (long) MALLOC_OVERHEAD,(long) ~0L,(long) MALLOC_OVERHEAD,(long) 1L },
  { "sort_buffer_size",(long*) &sort_buffer_length,(long) SORT_BUFFER_INIT,
      (long) (MIN_SORT_BUFFER+MALLOC_OVERHEAD),(long) ~0L,
      (long) MALLOC_OVERHEAD,(long) 1L },
  { "sort_key_blocks",(long*) &sort_key_blocks,BUFFERS_WHEN_SORTING,4L,100L,0L,
    1L },
  { "decode_bits",(long*) &decode_bits,9L,4L,17L,0L,1L },
  { NullS,(long*) 0,0L,0L,0L,0L,0L,} };


static struct option long_options[] =
{
  {"analyze",          no_argument,       0, 'a'},
  {"character-sets-dir", required_argument, 0, OPT_CHARSETS_DIR},
#ifndef DBUG_OFF
  {"debug",            required_argument, 0, '#'},
#endif
  {"default-character-set", required_argument, 0, 'C'},
  {"description",      no_argument,       0, 'd'},
  {"extend-check",     no_argument,       0, 'e'},
  {"information",      no_argument,       0, 'i'},
  {"force",            no_argument,       0, 'f'},
  {"help",             no_argument,       0, '?'},
  {"keys-used",        required_argument, 0, 'k'},
  {"no-symlinks",      no_argument,       0, 'l'},
  {"quick",            no_argument,       0, 'q'},
  {"recover",          no_argument,       0, 'r'},
  {"safe-recover",     no_argument,       0, 'o'},
  {"block-search",     required_argument, 0, 'b'},
  {"set-variable",     required_argument, 0, 'O'},
  {"silent",           no_argument,       0, 's'},
  {"sort-index",       no_argument,       0, 'S'},
  {"sort-records",     required_argument, 0, 'R'},
  {"unpack",           no_argument,       0, 'u'},
  {"verbose",          no_argument,       0, 'v'},
  {"version",          no_argument,       0, 'V'},
  {"wait",             no_argument,       0, 'w'},
  {0, 0, 0, 0}
};

static void print_version(void)
{
  printf("%s  Ver 5.15 for %s at %s\n",my_progname,SYSTEM_TYPE,
	 MACHINE_TYPE);
}

static void usage(void)
{
  uint i;
  print_version();
  puts("TCX Datakonsult AB, by Monty, for your professional use");
  puts("This software comes with NO WARRANTY: see the PUBLIC for details.\n");
  puts("Description, check and repair of ISAM tables.");
  puts("Used without options all tables on the command will be checked for errors");
  printf("Usage: %s [OPTIONS] tables[.ISM]\n", my_progname);
  puts("\n\
  -a, --analyze	      Analyze distribution of keys. Will make some joins in\n\
		      MySQL faster.\n\
  -#, --debug=...     Output debug log. Often this is 'd:t:o,filename`\n\
  --character-sets-dir=...\n\
                      Directory where character sets are\n\
  -C, --default-character-set=...\n\
                      Set the default character set\n\
  -d, --description   Prints some information about table.\n\
  -e, --extend-check  Check the table VERY thoroughly.  One need use this\n\
                      only in extreme cases as isamchk should normally find\n\
                      all errors even without this switch\n\
  -f, --force         Overwrite old temporary files.\n\
		      If one uses -f when checking tables (running isamchk\n\
		      without -r), isamchk will automatically restart with\n\
		      -r on any wrong table.\n\
  -?, --help          Display this help and exit.\n\
  -i, --information   Print statistics information about the table\n\
  -k, --keys-used=#   Used with '-r'. Tell ISAM to update only the first\n\
		      # keys.  This can be used to get faster inserts!\n\
  -l, --no-symlinks   Do not follow symbolic links when repairing. Normally\n\
		      isamchk repairs the table a symlink points at.\n\
  -q, --quick         Used with -r to get a faster repair. (The data file\n\
                      isn't touched.) One can give a second '-q' to force\n\
                      isamchk to modify the original datafile.");
  puts("\
  -r, --recover       Can fix almost anything except unique keys that aren't\n\
                      unique.\n\
  -o, --safe-recover  Uses old recovery method; slower than '-r' but can\n\
		      handle a couple of cases that '-r' cannot handle.\n\
  -O, --set-variable var=option\n\
		      Change the value of a variable.\n\
  -s, --silent	      Only print errors.  One can use two -s to make isamchk\n\
		      very silent\n\
  -S, --sort-index    Sort index blocks.  This speeds up 'read-next' in\n\
		      applications\n\
  -R, --sort-records=#\n\
		      Sort records according to an index.  This makes your\n\
		      data much more localized and may speed up things\n\
		      (It may be VERY slow to do a sort the first time!)\n\
  -u, --unpack        Unpack file packed with pack_isam.\n\
  -v, --verbose       Print more information. This can be used with\n\
                      -d and -e. Use many -v for more verbosity!\n\
  -V, --version       Print version and exit.\n\
  -w, --wait          Wait if table is locked.");
  print_defaults("my",load_default_groups);
  printf("\nPossible variables for option --set-variable (-O) are:\n");
  for (i=0; changeable_vars[i].name ; i++)
    printf("%-20s  current value: %lu\n",
           changeable_vars[i].name,
           *changeable_vars[i].varptr);
}

	/* Check table */

static int nisamchk(my_string filename)
{
  int error,lock_type,recreate;
  N_INFO *info;
  File datafile;
  char fixed_name[FN_REFLEN];
  ISAM_SHARE *share;
  DBUG_ENTER("nisamchk");

  out_flag=error=warning_printed=error_printed=recreate=0;
  datafile=0;
  isam_file_name=filename;			/* For error messages */
  if (!(info=nisam_open(filename,
		     (testflag & T_DESCRIPT) ? O_RDONLY : O_RDWR,
		     (testflag & T_WAIT_FOREVER) ? HA_OPEN_WAIT_IF_LOCKED :
		     (testflag & T_DESCRIPT) ? HA_OPEN_IGNORE_IF_LOCKED :
		     HA_OPEN_ABORT_IF_LOCKED)))
  {
    /* Avoid twice printing of isam file name */
    error_printed=1;
    switch (my_errno) {
    case HA_ERR_CRASHED:
      print_error("'%s' is not a ISAM-table",filename);
      break;
    case HA_ERR_OLD_FILE:
      print_error("'%s' is a old type of ISAM-table", filename);
      break;
    case HA_ERR_END_OF_FILE:
      print_error("Couldn't read compleat header from '%s'", filename);
      break;
    case EAGAIN:
      print_error("'%s' is locked. Use -w to wait until unlocked",filename);
      break;
    case ENOENT:
      print_error("File '%s' doesn't exist",filename);
      break;
    case EACCES:
      print_error("You don't have permission to use '%s'",filename);
      break;
    default:
      print_error("%d when opening ISAM-table '%s'",
		  my_errno,filename);
      break;
    }
    DBUG_RETURN(1);
  }
  share=info->s;
  share->base.options&= ~HA_OPTION_READ_ONLY_DATA; /* We are modifing it */
  share->r_locks=0;
  if ((testflag & (T_REP_BY_SORT | T_REP | T_STATISTICS |
		   T_SORT_RECORDS | T_SORT_INDEX)) &&
      ((testflag & T_UNPACK && share->data_file_type == COMPRESSED_RECORD) ||
       share->state_length != sizeof(share->state) ||
       uint2korr(share->state.header.base_info_length) !=
       sizeof(share->base) ||
       (max_key && ! share->state.keys && share->base.keys) ||
       test_if_almost_full(info) ||
       info->s->state.header.file_version[3] != nisam_file_magic[3]))
  {
    if (recreate_database(&info,filename))
    {
      VOID(fprintf(stderr,
		   "ISAM-table '%s' is not fixed because of errors\n",
	      filename));
      return(-1);
    }
    recreate=1;
    if (!(testflag & (T_REP | T_REP_BY_SORT)))
    {
      testflag|=T_REP_BY_SORT;			/* if only STATISTICS */
      if (!(testflag & T_SILENT))
	printf("- '%s' has old table-format. Recreating index\n",filename);
      if (!rep_quick)
	rep_quick=1;
    }
    share=info->s;
    share->r_locks=0;
  }

  if (testflag & T_DESCRIPT)
  {
    total_files++;
    total_records+=share->state.records; total_deleted+=share->state.del;
    descript(info,filename);
  }
  else
  {
    if (testflag & (T_REP+T_REP_BY_SORT+T_OPT+T_SORT_RECORDS+T_SORT_INDEX))
      lock_type = F_WRLCK;			/* table is changed */
    else
      lock_type= F_RDLCK;
    if (info->lock_type == F_RDLCK)
      info->lock_type=F_UNLCK;			/* Read only table */
    if (_nisam_readinfo(info,lock_type,0))
    {
      print_error("Can't lock indexfile of '%s', error: %d",
		  filename,my_errno);
      error_printed=0;
      goto end2;
    }
    share->w_locks++;				/* Mark (for writeinfo) */
    if (lock_file(info->dfile,0L,lock_type,"datafile of",filename))
      goto end;
    info->lock_type= F_EXTRA_LCK;		/* Simulate as locked */
    info->tmp_lock_type=lock_type;
    datafile=info->dfile;
    if (testflag & (T_REP+T_REP_BY_SORT+T_SORT_RECORDS+T_SORT_INDEX))
    {
      if (testflag & (T_REP+T_REP_BY_SORT))
	share->state.keys=min(share->base.keys,max_key);
      VOID(fn_format(fixed_name,filename,"",N_NAME_IEXT,
		     4+ (opt_follow_links ? 16 : 0)));

      if (rep_quick && (error=chk_del(info,testflag & ~T_VERBOSE)))
	print_error("Quick-recover aborted; Run recovery without switch 'q'");
      else
      {
	if (testflag & T_REP_BY_SORT &&
	    (share->state.keys || (rep_quick && !max_key && ! recreate)))
	  error=rep_by_sort(info,fixed_name);
	else if (testflag & (T_REP | T_REP_BY_SORT))
	  error=rep(info,fixed_name);
      }
      if (!error && testflag & T_SORT_RECORDS)
      {
	if (out_flag & O_NEW_DATA)
	{			/* Change temp file to org file */
	  VOID(lock_file(datafile,0L,F_UNLCK,"datafile of",filename));
	  VOID(my_close(datafile,MYF(MY_WME)));    /* Close old file */
	  VOID(my_close(info->dfile,MYF(MY_WME))); /* Close new file */
	  error|=change_to_newfile(fixed_name,N_NAME_DEXT,DATA_TMP_EXT);
	  if ((info->dfile=my_open(fn_format(temp_filename,fixed_name,"",
					     N_NAME_DEXT,2+4),
				   O_RDWR | O_SHARE,
				   MYF(MY_WME))) <= 0 ||
	      lock_file(info->dfile,0L,F_WRLCK,"datafile",temp_filename))
	    error=1;
	  out_flag&= ~O_NEW_DATA; /* We are using new datafile */
	  read_cache.file=info->dfile;
	}
	if (! error)
	  error=sort_records(info,fixed_name,opt_sort_key,
			     test(!(testflag & T_REP)));
	datafile=info->dfile;	/* This is now locked */
      }
      if (!error && testflag & T_SORT_INDEX)
	error=sort_index(info,fixed_name);
    }
    else
    {
      if (!(testflag & T_SILENT) || testflag & T_INFO)
	printf("Checking ISAM file: %s\n",filename);
      if (!(testflag & T_SILENT))
	printf("Data records: %7ld   Deleted blocks: %7ld\n",
	       share->state.records,share->state.del);
      share->state.keys=min(share->state.keys,max_key);
      error =chk_size(info);
      error|=chk_del(info,testflag);
      error|=chk_key(info);
      if (!rep_quick)
      {
	if (testflag & T_EXTEND)
	  VOID(init_key_cache(use_buffers,(uint) NEAD_MEM));
	VOID(init_io_cache(&read_cache,datafile,(uint) read_buffer_length,
			  READ_CACHE,share->pack.header_length,1,
			  MYF(MY_WME)));
	lock_memory();
	error|=chk_data_link(info,testflag & T_EXTEND);
	error|=flush_blocks(share->kfile);
	VOID(end_io_cache(&read_cache));
      }
    }
  }
end:
  if (!(testflag & T_DESCRIPT))
  {
    if (info->update & (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED))
      error|=update_state_info(info,
			       ((testflag & (T_REP | T_REP_BY_SORT)) ?
				UPDATE_TIME | UPDATE_STAT : 0) |
			       ((testflag & T_SORT_RECORDS) ?
				UPDATE_SORT : 0));
    VOID(lock_file(share->kfile,0L,F_UNLCK,"indexfile",filename));
    if (datafile > 0)
      VOID(lock_file(datafile,0L,F_UNLCK,"datafile of",filename));
    info->update&= ~(HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);
  }
  share->w_locks--;
end2:
  if (datafile && datafile != info->dfile)
    VOID(my_close(datafile,MYF(MY_WME)));
  if (nisam_close(info))
  {
    print_error("%d when closing ISAM-table '%s'",my_errno,filename);
    DBUG_RETURN(1);
  }
  if (error == 0)
  {
    if (out_flag & O_NEW_DATA)
      error|=change_to_newfile(fixed_name,N_NAME_DEXT,DATA_TMP_EXT);
    if (out_flag & O_NEW_INDEX)
      error|=change_to_newfile(fixed_name,N_NAME_IEXT,INDEX_TMP_EXT);
  }
  VOID(fflush(stdout)); VOID(fflush(stderr));
  if (error_printed)
  {
    if (testflag & (T_REP+T_REP_BY_SORT+T_SORT_RECORDS+T_SORT_INDEX))
      VOID(fprintf(stderr,
		   "ISAM-table '%s' is not fixed because of errors\n",
		   filename));
    else if (! (error_printed & 2) && !(testflag & T_FORCE_CREATE))
      VOID(fprintf(stderr,
      "ISAM-table '%s' is corrupted\nFix it using switch \"-r\" or \"-o\"\n",
	      filename));
  }
  else if (warning_printed &&
	   ! (testflag & (T_REP+T_REP_BY_SORT+T_SORT_RECORDS+T_SORT_INDEX+
			  T_FORCE_CREATE)))
    VOID(fprintf(stderr, "ISAM-table '%s' is useable but should be fixed\n",
	    filename));
  VOID(fflush(stderr));
  DBUG_RETURN(error);
} /* nisamchk */


	 /* Read options */

static void get_options(register int *argc,register char ***argv)
{
  int c,option_index=0;

  load_defaults("my",load_default_groups,argc,argv);
  defaults_alloc=  *argv;
  set_all_changeable_vars(changeable_vars);
  if (isatty(fileno(stdout)))
    testflag|=T_WRITE_LOOP;
  while ((c=getopt_long(*argc,*argv,"adeif?lqrosSuvVw#:b:k:O:R:C:",
			long_options, &option_index)) != EOF)
  {
    switch(c) {
    case 'a':
      testflag|= T_STATISTICS;
      break;
    case 'C':
      default_charset=optarg;
      break;
    case OPT_CHARSETS_DIR:
      charsets_dir = optarg;
      break;
    case 'b':
      search_after_block=strtoul(optarg,NULL,10);
      break;
    case 's':				/* silent */
      if (testflag & T_SILENT)
	testflag|=T_VERY_SILENT;
      testflag|= T_SILENT;
      testflag&= ~T_WRITE_LOOP;
      break;
    case 'w':
      testflag|= T_WAIT_FOREVER;
      break;
    case 'd':				/* description if isam-file */
      testflag|= T_DESCRIPT;
      break;
    case 'e':				/* extend check */
      testflag|= T_EXTEND;
      break;
    case 'i':
      testflag|= T_INFO;
      break;
    case 'f':
      tmpfile_createflag= O_RDWR | O_TRUNC;
      testflag|=T_FORCE_CREATE;
      break;
    case 'k':
      max_key= (uint) atoi(optarg);
      break;
    case 'l':
      opt_follow_links=0;
      break;
    case 'r':				/* Repair table */
      testflag= (testflag & ~T_REP) | T_REP_BY_SORT;
      break;
    case 'o':
      testflag= (testflag & ~T_REP_BY_SORT) | T_REP;
      my_disable_async_io=1;	        /* More safety */
      break;
    case 'q':
      rep_quick++;
      break;
    case 'u':
      testflag|= T_UNPACK | T_REP_BY_SORT;
      break;
    case 'v':				/* Verbose */
      testflag|= T_VERBOSE;
      verbose++;
      break;
    case 'O':
      if (set_changeable_var(optarg, changeable_vars))
      {
	usage();
	exit(1);
      }
      break;
    case 'R':				/* Sort records */
      testflag|= T_SORT_RECORDS;
      opt_sort_key=(uint) atoi(optarg)-1;
      if (opt_sort_key >= N_MAXKEY)
      {
	fprintf(stderr,
		"The value of the sort key is bigger than max key: %d.\n",
		N_MAXKEY);
	exit(1);
      }
      break;
    case 'S':                         /* Sort index */
      testflag|= T_SORT_INDEX;
      break;
    case '#':
      DBUG_PUSH(optarg ? optarg : "d:t:o,/tmp/isamchk.trace");
      break;
    case 'V':
      print_version();
      exit(0);
    case '?':
      usage();
      exit(0);
    }
  }
  (*argc)-=optind;
  (*argv)+=optind;
  if (*argc == 0)
  {
    usage();
    exit(-1);
  }
  if ((testflag & T_UNPACK) && (rep_quick || (testflag & T_SORT_RECORDS)))
  {
    VOID(fprintf(stderr,
		 "%s: --unpack can't be used with --quick or --sort-records\n",
		 my_progname));
    exit(1);
  }
  if (default_charset)
  {
    if (set_default_charset_by_name(default_charset, MYF(MY_WME)))
      exit(1);
  }
  return;
} /* get options */


	/* Check delete links */

static int chk_del(info,test_flag)
reg1 N_INFO *info;
uint test_flag;
{
  reg2 ulong i;
  uint j,delete_link_length;
  ulong empty,next_link;
  uchar buff[8];
  DBUG_ENTER("chk_del");
  if (!(test_flag & T_SILENT)) puts("- check delete-chain");

  record_checksum=0L;
  key_file_blocks=info->s->base.keystart;
  for (j =0 ; j < info->s->state.keys ; j++)
    if (check_k_link(info,j))
      goto wrong;
  delete_link_length=(info->s->base.options & HA_OPTION_PACK_RECORD) ? 8 : 5;

  next_link=info->s->state.dellink;
  if (info->s->state.del == 0)
  {
    if (test_flag & T_VERBOSE)
    {
      puts("No recordlinks");
    }
  }
  else
  {
    if (test_flag & T_VERBOSE)
      printf("Recordlinks:    ");
    empty=0;
    for (i= info->s->state.del ; i > 0L && next_link != NI_POS_ERROR ; i--)
    {
      if (test_flag & T_VERBOSE) printf("%10lu",next_link);
      if (next_link >= info->s->state.data_file_length)
	goto wrong;
      if (my_pread(info->dfile,(char*) buff,delete_link_length,
		  next_link,MYF(MY_NABP)))
      {
	if (test_flag & T_VERBOSE) puts("");
	print_error("Can't read delete-link at filepos: %lu",
		    (ulong) next_link);
	DBUG_RETURN(1);
      }
      if (*buff != '\0')
      {
	if (test_flag & T_VERBOSE) puts("");
	print_error("Record at pos: %lu is not remove-marked",
		    (ulong) next_link);
	goto wrong;
      }
      if (info->s->base.options & HA_OPTION_PACK_RECORD)
      {
	next_link=uint4korr(buff+4);
	empty+=uint3korr(buff+1);
      }
      else
      {
	record_checksum+=next_link;
	next_link=uint4korr(buff+1);
	empty+=info->s->base.reclength;
      }
      if (next_link == (uint32) ~0)	/* Fix for 64 bit long */
	next_link=NI_POS_ERROR;
    }
    if (empty != info->s->state.empty)
    {
      if (test_flag & T_VERBOSE) puts("");
      print_warning("Not used space is supposed to be: %lu but is: %lu",
		    (ulong) info->s->state.empty,(ulong) empty);
      info->s->state.empty=empty;
    }
    if (i != 0 || next_link != NI_POS_ERROR)
      goto wrong;

    if (test_flag & T_VERBOSE) puts("\n");
  }
  DBUG_RETURN(0);
wrong:
  if (test_flag & T_VERBOSE) puts("");
  print_error("delete-link-chain corrupted");
  DBUG_RETURN(1);
} /* chk_del */


	/* Kontrollerar l{nkarna i nyckelfilen */

static int check_k_link(info,nr)
register N_INFO *info;
uint nr;
{
  ulong next_link,records;
  DBUG_ENTER("check_k_link");

  if (testflag & T_VERBOSE)
    printf("index %2d:       ",nr+1);

  next_link=info->s->state.key_del[nr];
  records= (info->s->state.key_file_length /
	    info->s->keyinfo[nr].base.block_length);
  while (next_link != NI_POS_ERROR && records > 0)
  {
    if (testflag & T_VERBOSE) printf("%10lu",next_link);
    if (next_link > info->s->state.key_file_length ||
	next_link & (info->s->blocksize-1))
      DBUG_RETURN(1);
    if (my_pread(info->s->kfile,(char*) &next_link,sizeof(long),next_link,
		 MYF(MY_NABP)))
      DBUG_RETURN(1);
    records--;
    key_file_blocks+=info->s->keyinfo[nr].base.block_length;
  }
  if (testflag & T_VERBOSE)
  {
    if (next_link != NI_POS_ERROR)
      printf("%10lu\n",next_link);
    else
      puts("");
  }
  DBUG_RETURN (next_link != NI_POS_ERROR);
} /* check_k_link */


	/* Kontrollerar storleken p} filerna */

static int chk_size(register N_INFO *info)
{
  int error=0;
  register my_off_t skr,size;
  DBUG_ENTER("chk_size");

  if (!(testflag & T_SILENT)) puts("- check file-size");

  size=my_seek(info->s->kfile,0L,MY_SEEK_END,MYF(0));
  if ((skr=(my_off_t) info->s->state.key_file_length) != size)
  {
    if (skr > size)
    {
      error=1;
      print_error("Size of indexfile is: %-8lu        Should be: %lu",
		  (ulong) size, (ulong)  skr);
    }
    else
      print_warning("Size of indexfile is: %-8lu      Should be: %lu",
		    (ulong) size,(ulong) skr);
  }
  if (!(testflag & T_VERY_SILENT) &&
      ! (info->s->base.options & HA_OPTION_COMPRESS_RECORD) &&
      info->s->state.key_file_length >
      (ulong) (ulong_to_double(info->s->base.max_key_file_length)*0.9))
    print_warning("Keyfile is almost full, %10lu of %10lu used",
		  info->s->state.key_file_length,
		  info->s->base.max_key_file_length-1);

  size=my_seek(info->dfile,0L,MY_SEEK_END,MYF(0));
  skr=(my_off_t) info->s->state.data_file_length;
  if (info->s->base.options & HA_OPTION_COMPRESS_RECORD)
    skr+= MEMMAP_EXTRA_MARGIN;
#ifdef USE_RELOC
  if (info->data_file_type == STATIC_RECORD &&
      skr < (my_off_t) info->s->base.reloc*info->s->base.min_pack_length)
    skr=(my_off_t) info->s->base.reloc*info->s->base.min_pack_length;
#endif
  if (skr != size)
  {
    info->s->state.data_file_length=(ulong) size; /* Skipp other errors */
    if (skr > size && skr != size + MEMMAP_EXTRA_MARGIN)
    {
      error=1;
      print_error("Size of datafile is: %-8lu         Should be: %lu",
		  (ulong) size,(ulong) skr);
    }
    else
    {
      print_warning("Size of datafile is: %-8lu       Should be: %lu",
		    (ulong) size,(ulong) skr);

    }
  }
  if (!(testflag & T_VERY_SILENT) &&
      !(info->s->base.options & HA_OPTION_COMPRESS_RECORD) &&
      info->s->state.data_file_length >
      (ulong) (ulong_to_double(info->s->base.max_data_file_length)*0.9))
    print_warning("Datafile is almost full, %10lu of %10lu used",
		  info->s->state.data_file_length,
		  info->s->base.max_data_file_length-1);
  DBUG_RETURN(error);
} /* chk_size */


	/* Kontrollerar nycklarna */

static int chk_key(info)
register N_INFO *info;
{
  uint key;
  ulong keys,all_keydata,all_totaldata,key_totlength,length,
	init_checksum,old_record_checksum;
  ISAM_SHARE *share=info->s;
  N_KEYDEF *keyinfo;
  DBUG_ENTER("chk_key");

  if (!(testflag & T_SILENT)) puts("- check index reference");

  all_keydata=all_totaldata=key_totlength=old_record_checksum=0;
  init_checksum=record_checksum;
  if (!(share->base.options &
	(HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)))
    old_record_checksum=calc_checksum(share->state.records+share->state.del-1)*
      share->base.reclength;
  for (key= 0,keyinfo= &share->keyinfo[0]; key < share->state.keys ;
       key++,keyinfo++)
  {
    record_checksum=init_checksum;
    unique_count=0L;
    if ((!(testflag & T_SILENT)) && share->state.keys >1)
      printf ("- check data record references index: %d\n",key+1);
    if (share->state.key_root[key] == NI_POS_ERROR &&
	share->state.records == 0)
      continue;
    if (!_nisam_fetch_keypage(info,keyinfo,share->state.key_root[key],info->buff,
			   0))
    {
      print_error("Can't read indexpage from filepos: %lu",
		  (ulong) share->state.key_root[key]);
      DBUG_RETURN(-1);
    }
    key_file_blocks+=keyinfo->base.block_length;
    keys=keydata=totaldata=key_blocks=0; max_level=0;
    if (chk_index(info,keyinfo,share->state.key_root[key],info->buff,&keys,1))
      DBUG_RETURN(-1);
    if (keys != share->state.records)
    {
      print_error("Found %lu keys of %lu",(ulong) keys,
		  (ulong) share->state.records);
      DBUG_RETURN(-1);
    }
    if (!key && (share->base.options &
		 (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)))
      old_record_checksum=record_checksum;
    else if (old_record_checksum != record_checksum)
    {
      if (key)
	print_error("Key %u doesn't point at same records that key 1",
		    key+1);
      else
	print_error("Key 1 doesn't point at all records");
      DBUG_RETURN(-1);
    }
    length=(ulong) isam_key_length(info,keyinfo)*keys + key_blocks*2;
    if (testflag & T_INFO && totaldata != 0L && keys != 0L)
      printf("Key: %2d:  Keyblocks used: %3d%%  Packed: %4d%%  Max levels: %2d\n",
	     key+1,
	     (int) (keydata*100.0/totaldata),
	     (int) ((long) (length-keydata)*100.0/(double) length),
	     max_level);
    all_keydata+=keydata; all_totaldata+=totaldata; key_totlength+=length;
    share->base.rec_per_key[key]=
      unique_count ? ((share->state.records+unique_count/2)/
		      unique_count) : 1L;
  }
  if (testflag & T_INFO)
  {
    if (all_totaldata != 0L && share->state.keys != 1)
      printf("Total:    Keyblocks used: %3d%%  Packed: %4d%%\n\n",
	     (int) (all_keydata*100.0/all_totaldata),
	     (int) ((long) (key_totlength-all_keydata)*100.0/
		    (double) key_totlength));
    else if (all_totaldata != 0L && share->state.keys)
      puts("");
  }
  if (key_file_blocks != share->state.key_file_length)
    print_warning("Some data are unreferenced in keyfile");
  record_checksum-=init_checksum;		/* Remove delete links */
  if (testflag & T_STATISTICS)
    DBUG_RETURN(update_state_info(info,UPDATE_STAT));
  DBUG_RETURN(0);
} /* chk_key */


	/* Check if index is ok */

static int chk_index(info,keyinfo,page,buff,keys,level)
N_INFO *info;
N_KEYDEF *keyinfo;
ulong page,*keys;
uchar *buff;
uint level;
{
  int flag;
  uint used_length,comp_flag,nod_flag;
  uchar key[N_MAX_POSSIBLE_KEY_BUFF],*temp_buff,*keypos,*endpos;
  ulong next_page,record;
  DBUG_ENTER("chk_index");
  DBUG_DUMP("buff",(byte*) buff,getint(buff));

  if (!(temp_buff=(uchar*) my_alloca((uint) keyinfo->base.block_length)))
  {
    print_error("Not Enough memory");
    DBUG_RETURN(-1);
  }

  if (keyinfo->base.flag & HA_NOSAME)
    comp_flag=SEARCH_FIND;			/* Not dupplicates */
  else
    comp_flag=SEARCH_SAME;			/* Keys in positionorder */
  nod_flag=test_if_nod(buff);
  used_length=getint(buff);
  keypos=buff+2+nod_flag;
  endpos=buff+used_length;

  keydata+=used_length; totaldata+=keyinfo->base.block_length;	/* INFO */
  key_blocks++;
  if (level > max_level)
    max_level=level;

  if (used_length > keyinfo->base.block_length)
  {
    print_error("Wrong pageinfo at page: %lu",(ulong) page);
    goto err;
  }
  for ( ;; )
  {
    if (nod_flag)
    {
      next_page=_nisam_kpos(nod_flag,keypos);
      if (next_page > info->s->state.key_file_length ||
	  (nod_flag && (next_page & (info->s->blocksize -1))))
      {
	my_off_t max_length=my_seek(info->s->kfile,0L,MY_SEEK_END,MYF(0));
	print_error("Wrong pagepointer: %lu at page: %lu",
		    (ulong) next_page,(ulong) page);

	if (next_page+info->s->blocksize > max_length)
	  goto err;
	info->s->state.key_file_length=(ulong) (max_length &
						~ (my_off_t)
						(info->s->blocksize-1));
      }
      if (!_nisam_fetch_keypage(info,keyinfo,next_page,temp_buff,0))
      {
	print_error("Can't read key from filepos: %lu",(ulong) next_page);
	goto err;
      }
      key_file_blocks+=keyinfo->base.block_length;
      if (chk_index(info,keyinfo,next_page,temp_buff,keys,level+1))
	goto err;
    }
    if (keypos >= endpos ||
	(*keyinfo->get_key)(keyinfo,nod_flag,&keypos,key) == 0)
      break;
    if ((*keys)++ &&
	(flag=_nisam_key_cmp(keyinfo->seg,info->lastkey,key,0,comp_flag)) >=0)
    {
      DBUG_DUMP("old",(byte*) info->lastkey,
		_nisam_keylength(keyinfo,info->lastkey));
      DBUG_DUMP("new",(byte*) key,_nisam_keylength(keyinfo,key));

      if (comp_flag == SEARCH_FIND && flag == 0)
	print_error("Found dupplicated key at page %lu",(ulong) page);
      else
	print_error("Key in wrong position at page %lu",(ulong) page);
      goto err;
    }
    if (testflag & T_STATISTICS)
    {
      if (*keys == 1L ||
	  _nisam_key_cmp(keyinfo->seg,info->lastkey,key,0,SEARCH_FIND))
	unique_count++;
    }
    VOID(_nisam_move_key(keyinfo,(uchar*) info->lastkey,key));
    record= _nisam_dpos(info,nod_flag,keypos);
    if (record >= info->s->state.data_file_length)
    {
      print_error("Found key at page %lu that points to record outside datafile",page);
      DBUG_PRINT("test",("page: %lu  record: %lu  filelength: %lu",
			 (ulong) page,(ulong) record,
			 (ulong) info->s->state.data_file_length));
      DBUG_DUMP("key",(byte*) info->lastkey,info->s->base.max_key_length);
      goto err;
    }
    record_checksum+=record;
  }
  if (keypos != endpos)
  {
    print_error("Keyblock size at page %lu is not correct.  Block length: %d  key length: %d",(ulong) page, used_length, (keypos - buff));
    goto err;
  }
  my_afree((byte*) temp_buff);
  DBUG_RETURN(0);
 err:
  my_afree((byte*) temp_buff);
  DBUG_RETURN(1);
} /* chk_index */


	/* Calculate a checksum of 1+2+3+4...N = N*(N+1)/2 without overflow */

static ulong calc_checksum(count)
ulong count;
{
  ulong sum,a,b;
  DBUG_ENTER("calc_checksum");

  sum=0;
  a=count; b=count+1;
  if (a & 1)
    b>>=1;
  else
    a>>=1;
  while (b)
  {
    if (b & 1)
      sum+=a;
    a<<=1; b>>=1;
  }
  DBUG_PRINT("exit",("sum: %lx",sum));
  DBUG_RETURN(sum);
} /* calc_checksum */


	/* Calc length of key in normal isam */

static uint isam_key_length(info,keyinfo)
N_INFO *info;
reg1 N_KEYDEF *keyinfo;
{
  uint length;
  N_KEYSEG *keyseg;
  DBUG_ENTER("isam_key_length");

  length= info->s->rec_reflength;
  for (keyseg=keyinfo->seg ; keyseg->base.type ; keyseg++)
    length+= keyseg->base.length;

  DBUG_PRINT("exit",("length: %d",length));
  DBUG_RETURN(length);
} /* key_length */


	/* Check that record-link is ok */

static int chk_data_link(info,extend)
reg1 N_INFO *info;
int extend;
{
  int	error,got_error,flag;
  uint	key,left_length,b_type;
  ulong records,del_blocks,used,empty,pos,splitts,start_recpos,
	del_length,link_used,intern_record_checksum,start_block;
  byte	*record,*to;
  N_KEYDEF *keyinfo;
  BLOCK_INFO block_info;
  DBUG_ENTER("chk_data_link");

  if (! (info->s->base.options & (HA_OPTION_PACK_RECORD |
			       HA_OPTION_COMPRESS_RECORD)) &&
      ! extend)
    DBUG_RETURN(0);

  if (!(testflag & T_SILENT))
  {
    if (extend)
      puts("- check records and index references");
    else
      puts("- check record links");
  }

  if (!(record= (byte*) my_alloca(info->s->base.reclength)))
  {
    print_error("Not Enough memory");
    DBUG_RETURN(-1);
  }
  records=used=link_used=splitts=del_blocks=del_length=
    intern_record_checksum=crc=0L;
  LINT_INIT(left_length);  LINT_INIT(start_recpos);  LINT_INIT(to);
  got_error=error=0;
  empty=pos=info->s->pack.header_length;

  while (pos < info->s->state.data_file_length)
  {
    switch (info->s->data_file_type) {
    case STATIC_RECORD:
      if (my_b_read(&read_cache,(byte*) record,info->s->base.reclength))
	goto err;
      start_recpos=pos;
      pos+=info->s->base.reclength;
      splitts++;
      if (*record == '\0')
      {
	del_blocks++;
	del_length+=info->s->base.reclength;
	continue;					/* Record removed */
      }
      used+=info->s->base.reclength;
      break;
    case DYNAMIC_RECORD:
      flag=block_info.second_read=0;
      block_info.next_filepos=pos;
      do
      {
	if (_nisam_read_cache(&read_cache,(byte*) block_info.header,
			  (start_block=block_info.next_filepos),
			  sizeof(block_info.header),test(! flag) | 2))
	  goto err;
	b_type=_nisam_get_block_info(&block_info,-1,start_block);
	if (b_type & (BLOCK_DELETED | BLOCK_ERROR | BLOCK_SYNC_ERROR |
		      BLOCK_FATAL_ERROR))
	{
	  if (b_type & BLOCK_SYNC_ERROR)
	  {
	    if (flag)
	    {
	      print_error("Unexpected byte: %d at link: %lu",
			  (int) block_info.header[0],(ulong) start_block);
	      goto err2;
	    }
	    pos=block_info.filepos+block_info.block_len;
	    goto next;
	  }
	  if (b_type & BLOCK_DELETED)
	  {
	    if (block_info.block_len < info->s->base.min_block_length ||
		block_info.block_len-4 > (uint) info->s->base.max_pack_length)
	    {
	      print_error("Deleted block with impossible length %u at %lu",
			 block_info.block_len,(ulong) pos);
	      goto err2;
	    }
	    del_blocks++;
	    del_length+=block_info.block_len;
	    pos=block_info.filepos+block_info.block_len;
	    splitts++;
	    goto next;
	  }
	  print_error("Wrong bytesec: %d-%d-%d at linkstart: %lu",
		      block_info.header[0],block_info.header[1],
		      block_info.header[2],(ulong) start_block);
	  goto err2;
	}
	if (info->s->state.data_file_length < block_info.filepos+
	    block_info.block_len)
	{
	  print_error("Recordlink that points outside datafile at %lu",
		      (ulong) pos);
	  got_error=1;
	  break;
	}
	splitts++;
	if (!flag++)				/* First block */
	{
	  start_recpos=pos;
	  pos=block_info.filepos+block_info.block_len;
	  if (block_info.rec_len > (uint) info->s->base.max_pack_length)
	  {
	    print_error("Found too long record at %lu",(ulong) start_recpos);
	    got_error=1;
	    break;
	  }
	  if (info->s->base.blobs)
	  {
	    if (!(to=fix_rec_buff_for_blob(info,block_info.rec_len)))
	    {
	      print_error("Not enough memory for blob at %lu",
			  (ulong) start_recpos);
	      got_error=1;
	      break;
	    }
	  }
	  else
	    to= info->rec_buff;
	  left_length=block_info.rec_len;
	}
	if (left_length < block_info.data_len)
	{
	  print_error("Found too long record at %lu",(ulong) start_recpos);
	  got_error=1; break;
	}
	if (_nisam_read_cache(&read_cache,(byte*) to,block_info.filepos,
			  (uint) block_info.data_len, test(flag == 1)))
	  goto err;
	to+=block_info.data_len;
	link_used+= block_info.filepos-start_block;
	used+= block_info.filepos - start_block + block_info.data_len;
	empty+=block_info.block_len-block_info.data_len;
	left_length-=block_info.data_len;
	if (left_length)
	{
	  if (b_type & BLOCK_LAST)
	  {
	    print_error("Record link to short for record at %lu",
			(ulong) start_recpos);
	    got_error=1;
	    break;
	  }
	  if (info->s->state.data_file_length < block_info.next_filepos)
	  {
	    print_error("Found next-recordlink that points outside datafile at %lu",
			(ulong) block_info.filepos);
	    got_error=1;
	    break;
	  }
	}
      } while (left_length);
      if (! got_error)
      {
	if (_nisam_rec_unpack(info,record,info->rec_buff,block_info.rec_len) ==
	    MY_FILE_ERROR)
	{
	  print_error("Found wrong record at %lu",(ulong) start_recpos);
	  got_error=1;
	}
	if (testflag & (T_EXTEND | T_VERBOSE))
	{
	  if (_nisam_rec_check(info,record))
	  {
	    print_error("Found wrong packed record at %lu",
			(ulong) start_recpos);
	    got_error=1;
	  }
	}
      }
      else if (!flag)
	pos=block_info.filepos+block_info.block_len;
      break;
    case COMPRESSED_RECORD:
      if (_nisam_read_cache(&read_cache,(byte*) block_info.header,pos, 3,1))
	goto err;
      start_recpos=pos;
      splitts++;
      VOID(_nisam_pack_get_block_info(&block_info,info->s->pack.ref_length,-1,
				   start_recpos));
      pos=start_recpos+info->s->pack.ref_length+block_info.rec_len;
      if (block_info.rec_len < (uint) info->s->min_pack_length ||
	  block_info.rec_len > (uint) info->s->max_pack_length)
      {
	print_error("Found block with wrong recordlength: %d at %lu",
		    block_info.rec_len,(ulong) start_recpos);
	got_error=1;
	break;
      }
      if (_nisam_read_cache(&read_cache,(byte*) info->rec_buff,
			block_info.filepos, block_info.rec_len,1))
	goto err;
      if (_nisam_pack_rec_unpack(info,record,info->rec_buff,block_info.rec_len))
      {
	print_error("Found wrong record at %lu",(ulong) start_recpos);
	got_error=1;
      }
      crc^=checksum(record,info->s->base.reclength);
      link_used+=info->s->pack.ref_length;
      used+=block_info.rec_len+info->s->pack.ref_length;
    }
    if (! got_error)
    {
      intern_record_checksum+=start_recpos;
      records++;
      if (testflag & T_WRITE_LOOP && records % WRITE_COUNT == 0)
      {
	printf("%lu\r",(ulong) records); VOID(fflush(stdout));
      }

      if (extend)
      {
	for (key=0,keyinfo= info->s->keyinfo; key<info->s->state.keys;
	     key++,keyinfo++)
	{
	  VOID(_nisam_make_key(info,key,info->lastkey,record,start_recpos));
	  if (_nisam_search(info,keyinfo,info->lastkey,0,SEARCH_SAME,
			 info->s->state.key_root[key]))
	  {
	    print_error("Record at: %10lu  Can't find key for index: %2d",
			start_recpos,key+1);
	    if (error++ > MAXERR || !(testflag & T_VERBOSE))
	      goto err2;
	  }
	}
      }
    }
    else
    {
      got_error=0;
      if (error++ > MAXERR || !(testflag & T_VERBOSE))
	goto err2;
    }
  next:;				/* Next record */
  }
  if (testflag & T_WRITE_LOOP)
  {
    VOID(fputs("          \r",stdout)); VOID(fflush(stdout));
  }
  if (records != info->s->state.records)
  {
    print_error("Record-count is not ok; is %-10lu   Should be: %lu",
		(ulong) records,(ulong) info->s->state.records);
    error=1;
  }
  else if (record_checksum != intern_record_checksum && info->s->state.keys)
  {
    print_error("Keypointers and records dosen't match");
    error=1;
  }
  if (used+empty+del_length != info->s->state.data_file_length)
  {
    print_warning("Found %lu record-data and %lu unused data and %lu deleted-data\nTotal %lu, Should be: %lu",
		  (ulong) used,(ulong) empty,(ulong) del_length,
		  (ulong) (used+empty+del_length),
		  (ulong) info->s->state.data_file_length);
  }
  if (del_blocks != info->s->state.del)
  {
    print_warning("Found %10lu deleted blocks       Should be: %lu",
		  (ulong) del_blocks,(ulong) info->s->state.del);
  }
  if (splitts != info->s->state.splitt)
  {
    print_warning("Found %10lu parts                Should be: %lu parts",
		  (ulong) splitts,(ulong) info->s->state.splitt);
  }
  if ((info->s->base.options & HA_OPTION_COMPRESS_RECORD) &&
      crc != info->s->state.uniq)
    print_warning("Wrong checksum for records; Restore uncompressed table");

  if (testflag & T_INFO)
  {
    if (warning_printed || error_printed)
      puts("");
    if (used != 0 && ! error_printed)
    {
      printf("Records:%17lu    M.recordlength:%8lu   Packed:%14.0f%%\n",
	     records, (used-link_used)/records,
	     (info->s->base.blobs ? 0 :
	      (ulong_to_double(info->s->base.reclength*records)-used)/
	      ulong_to_double(info->s->base.reclength*records)*100.0));
      printf("Recordspace used:%8.0f%%   Empty space:%11d%%  Blocks/Record: %6.2f\n",
	     (ulong_to_double(used-link_used)/ulong_to_double(used-link_used+empty)*100.0),
	     (!records ? 100 : (int) (ulong_to_double(del_length+empty)/used*100.0)),
	     ulong_to_double(splitts - del_blocks) / records);
    }
    printf("Record blocks:%12lu    Delete blocks:%10lu\n",
	   splitts-del_blocks,del_blocks);
    printf("Record data:  %12lu    Deleted data :%10lu\n",
	   used-link_used,del_length);
    printf("Lost space:   %12lu    Linkdata:    %10lu\n",
	   empty,link_used);
  }
  my_afree((gptr) record);
  DBUG_RETURN (error);
 err:
  print_error("got error: %d when reading datafile",my_errno);
 err2:
  my_afree((gptr) record);
  DBUG_RETURN(1);
} /* chk_data_link */


	/* Recover old table by reading each record and writing all keys */
	/* Save new datafile-name in temp_filename */

static int rep(info,name)
reg1 N_INFO *info;
my_string name;
{
  int error,got_error;
  uint i;
  ulong start_records,new_header_length,del;
  File new_file;
  ISAM_SHARE *share=info->s;
  DBUG_ENTER("rep");

  start_records=share->state.records;
  new_header_length=(testflag & T_UNPACK) ? 0L : share->pack.header_length;
  got_error=1;
  new_file= -1;
  if (!(testflag & T_SILENT))
  {
    printf("- recovering ISAM-table '%s'\n",name);
    printf("Data records: %lu\n",(ulong) share->state.records);
  }

  VOID(init_key_cache(use_buffers,NEAD_MEM));
  if (init_io_cache(&read_cache,info->dfile,(uint) read_buffer_length,
		   READ_CACHE,share->pack.header_length,1,MYF(MY_WME)))
    goto err;
  if (!rep_quick)
    if (init_io_cache(&info->rec_cache,-1,(uint) write_buffer_length,
		      WRITE_CACHE, new_header_length, 1,
		      MYF(MY_WME | MY_WAIT_IF_FULL)))
      goto err;
  info->opt_flag|=WRITE_CACHE_USED;
  sort_info.start_recpos=0;
  sort_info.buff=0; sort_info.buff_length=0;
  if (!(sort_info.record=(byte*) my_alloca((uint) share->base.reclength)))
  {
    print_error("Not Enough memory");
    goto err;
  }

  if (!rep_quick)
  {
    if ((new_file=my_create(fn_format(temp_filename,name,"",DATA_TMP_EXT,
				      2+4),
			    0,tmpfile_createflag,MYF(0))) < 0)
    {
      print_error("Can't create new tempfile: '%s'",temp_filename);
      goto err;
    }
    if (filecopy(new_file,info->dfile,0L,new_header_length,"datafile-header"))
      goto err;
    share->state.dellink= NI_POS_ERROR;
    info->rec_cache.file=new_file;
    if (testflag & T_UNPACK)
      share->base.options&= ~HA_OPTION_COMPRESS_RECORD;
  }

  sort_info.info=info;
  sort_info.pos=sort_info.max_pos=share->pack.header_length;
  sort_info.filepos=new_header_length;
  read_cache.end_of_file=sort_info.filelength=(ulong)
    my_seek(info->dfile,0L,MY_SEEK_END,MYF(0));
  sort_info.dupp=0;
  sort_info.fix_datafile= (my_bool) (! rep_quick);
  sort_info.max_records=LONG_MAX;
  if ((sort_info.new_data_file_type=share->data_file_type) ==
      COMPRESSED_RECORD && testflag & T_UNPACK)
  {
    if (share->base.options & HA_OPTION_PACK_RECORD)
      sort_info.new_data_file_type = DYNAMIC_RECORD;
    else
      sort_info.new_data_file_type = STATIC_RECORD;
  }

  del=share->state.del;
  share->state.records=share->state.del=share->state.empty=
    share->state.splitt=0;
  info->update= (short) (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);
  for (i=0 ; i < N_MAXKEY ; i++)
    share->state.key_del[i]=share->state.key_root[i]= NI_POS_ERROR;
  share->state.key_file_length=share->base.keystart;

  lock_memory();				/* Everything is alloced */
  while (!(error=sort_get_next_record()))
  {
    if (writekeys(info,(byte*) sort_info.record,sort_info.filepos))
    {
      if (my_errno != HA_ERR_FOUND_DUPP_KEY) goto err;
      DBUG_DUMP("record",(byte*) sort_info.record,share->base.pack_reclength);
      print_info("Dupplicate key %2d for record at %10lu against new record at %10lu",info->errkey+1,sort_info.start_recpos,info->int_pos);
      if (testflag & T_VERBOSE)
      {
	VOID(_nisam_make_key(info,(uint) info->errkey,info->lastkey,
		     sort_info.record,0L));
	_nisam_print_key(stdout,share->keyinfo[info->errkey].seg,info->lastkey);
      }
      sort_info.dupp++;
      if (rep_quick == 1)
      {
	error_printed=1;
	goto err;
      }
      continue;
    }
    if (sort_write_record())
      goto err;
  }
  if (error > 0 || write_data_suffix(info) ||
      flush_io_cache(&info->rec_cache) || read_cache.error < 0)
    goto err;

  if (testflag & T_WRITE_LOOP)
  {
    VOID(fputs("          \r",stdout)); VOID(fflush(stdout));
  }
  if (my_chsize(share->kfile,share->state.key_file_length,MYF(0)))
  {
    print_warning("Can't change size of indexfile, error: %d",my_errno);
    goto err;
  }

  if (rep_quick && del+sort_info.dupp != share->state.del)
  {
    print_error("Couldn't fix table with quick recovery: Found wrong number of deleted records");
    print_error("Run recovery again without -q");
    got_error=1;
    goto err;
  }

  if (!rep_quick)
  {
    info->dfile=new_file;
    share->state.data_file_length=sort_info.filepos;
    share->state.splitt=share->state.records;		/* Only hole records */
    out_flag|=O_NEW_DATA;				/* Data in new file */
    share->state.version=(ulong) time((time_t*) 0);	/* Force reopen */
  }
  else
    share->state.data_file_length=sort_info.max_pos;

  if (!(testflag & T_SILENT))
  {
    if (start_records != share->state.records)
      printf("Data records: %lu\n",(ulong) share->state.records);
    if (sort_info.dupp)
      print_warning("%lu records have been removed",(ulong) sort_info.dupp);
  }

  got_error=0;
err:
  if (got_error)
  {
    if (! error_printed)
      print_error("%d for record at pos %lu",my_errno,
		  (ulong) sort_info.start_recpos);
    if (new_file >= 0)
    {
      VOID(my_close(new_file,MYF(0)));
      VOID(my_delete(temp_filename,MYF(MY_WME)));
    }
  }
  if (sort_info.record)
  {
    my_afree(sort_info.record);
  }
  my_free(sort_info.buff,MYF(MY_ALLOW_ZERO_PTR));
  VOID(end_io_cache(&read_cache));
  info->opt_flag&= ~(READ_CACHE_USED | WRITE_CACHE_USED);
  VOID(end_io_cache(&info->rec_cache));
  got_error|=flush_blocks(share->kfile);
  if (!got_error && testflag & T_UNPACK)
  {
    share->state.header.options[0]&= (uchar) ~HA_OPTION_COMPRESS_RECORD;
    share->pack.header_length=0;
    share->data_file_type=sort_info.new_data_file_type;
  }
  DBUG_RETURN(got_error);
} /* rep */


	/* Uppdaterar nyckelfilen i samband med reparation */

static int writekeys(register N_INFO *info,byte *buff,ulong filepos)
{
  register uint i;
  uchar *key;
  DBUG_ENTER("writekeys");

  key=info->lastkey+info->s->base.max_key_length;
  for (i=0 ; i < info->s->state.keys ; i++)
  {
    VOID(_nisam_make_key(info,i,key,buff,filepos));
    if (_nisam_ck_write(info,i,key)) goto err;
  }
  DBUG_RETURN(0);

 err:
  if (my_errno == HA_ERR_FOUND_DUPP_KEY)
  {
    info->errkey=(int) i;			/* This key was found */
    while ( i-- > 0 )
    {
      VOID(_nisam_make_key(info,i,key,buff,filepos));
      if (_nisam_ck_delete(info,i,key)) break;
    }
  }
  DBUG_PRINT("error",("errno: %d",my_errno));
  DBUG_RETURN(-1);
} /* writekeys */


	 /* Write info about table */

static void descript(info,name)
reg1 N_INFO *info;
my_string name;
{
  uint key,field,start,len;
  reg3 N_KEYDEF *keyinfo;
  reg2 N_KEYSEG *keyseg;
  reg4 const char *text;
  char buff[40],length[10],*pos,*end;
  enum en_fieldtype type;
  ISAM_SHARE *share=info->s;
  DBUG_ENTER("describe");

  printf("\nISAM file:     %s\n",name);
  if (testflag & T_VERBOSE)
  {
    printf("Isam-version:  %d\n",(int) share->state.header.file_version[3]);
    if (share->base.create_time)
    {
      get_date(buff,1,share->base.create_time);
      printf("Creation time: %s\n",buff);
    }
    if (share->base.isamchk_time)
    {
      get_date(buff,1,share->base.isamchk_time);
      printf("Recover time:  %s\n",buff);
    }
  }
  printf("Data records:        %10lu  Deleted blocks:     %10lu\n",
	 share->state.records,share->state.del);
  if (testflag & T_SILENT)
    DBUG_VOID_RETURN;				/* This is enough */

  if (testflag & T_VERBOSE)
  {
#ifdef USE_RELOC
    printf("Init-relocation:     %10lu\n",share->base.reloc);
#endif
    printf("Datafile  Parts:     %10lu  Deleted data:       %10lu\n",
	   share->state.splitt,share->state.empty);
    printf("Datafile pointer (bytes):%6d  Keyfile pointer (bytes):%6d\n",
	   share->rec_reflength,share->base.key_reflength);
    if (info->s->base.reloc == 1L && info->s->base.records == 1L)
      puts("This is a one-record table");
    else
    {
      if (share->base.max_data_file_length != NI_POS_ERROR ||
	  share->base.max_key_file_length != NI_POS_ERROR)
	printf("Max datafile length: %10lu  Max keyfile length: %10lu\n",
	       share->base.max_data_file_length-1,
	       share->base.max_key_file_length-1);
    }
  }

  printf("Recordlength:        %10d\n",(int) share->base.reclength);
  VOID(fputs("Record format: ",stdout));
  if (share->base.options & HA_OPTION_COMPRESS_RECORD)
    puts("Compressed");
  else if (share->base.options & HA_OPTION_PACK_RECORD)
    puts("Packed");
  else
    puts("Fixed length");
  if (share->state.keys != share->base.keys)
    printf("Using only %d keys of %d possibly keys\n",share->state.keys,
	   share->base.keys);

  puts("\ntable description:");
  printf("Key Start Len Index   Type");
  if (testflag & T_VERBOSE)
    printf("                       Root  Blocksize    Rec/key");
  VOID(putchar('\n'));

  for (key=0, keyinfo= &share->keyinfo[0] ; key < share->base.keys;
       key++,keyinfo++)
  {
    keyseg=keyinfo->seg;
    if (keyinfo->base.flag & HA_NOSAME) text="unique ";
    else text="multip.";

    pos=buff;
    if (keyseg->base.flag & HA_REVERSE_SORT)
      *pos++ = '-';
    pos=strmov(pos,type_names[keyseg->base.type]);
    *pos++ = ' ';
    *pos=0;
    if (keyinfo->base.flag & HA_PACK_KEY)
      pos=strmov(pos,packed_txt);
    if (keyseg->base.flag & HA_SPACE_PACK)
      pos=strmov(pos,diff_txt);
    printf("%-4d%-6d%-3d %-8s%-21s",
	   key+1,keyseg->base.start+1,keyseg->base.length,text,buff);
    if (testflag & T_VERBOSE)
      printf(" %9ld  %9d  %9ld",
	     share->state.key_root[key],keyinfo->base.block_length,
	     share->base.rec_per_key[key]);
    VOID(putchar('\n'));
    while ((++keyseg)->base.type)
    {
      pos=buff;
      if (keyseg->base.flag & HA_REVERSE_SORT)
	*pos++ = '-';
      pos=strmov(pos,type_names[keyseg->base.type]);
      *pos++= ' ';
      if (keyseg->base.flag & HA_SPACE_PACK)
	pos=strmov(pos,diff_txt);
      *pos=0;
      printf("    %-6d%-3d         %-24s\n",
	     keyseg->base.start+1,keyseg->base.length,buff);
    }
  }
  if (verbose > 1)
  {
    printf("\nField Start Length Type");
    if (share->base.options & HA_OPTION_COMPRESS_RECORD)
      printf("                         Huff tree  Bits");
    VOID(putchar('\n'));
    start=1;
    for (field=0 ; field < share->base.fields ; field++)
    {
      if (share->base.options & HA_OPTION_COMPRESS_RECORD)
	type=share->rec[field].base_type;
      else
	type=(enum en_fieldtype) share->rec[field].base.type;
      end=strmov(buff,field_pack[type]);
#ifndef NOT_PACKED_DATABASES
      if (share->base.options & HA_OPTION_COMPRESS_RECORD)
      {
	if (share->rec[field].pack_type & PACK_TYPE_SELECTED)
	  end=strmov(end,", not_always");
	if (share->rec[field].pack_type & PACK_TYPE_SPACE_FIELDS)
	  end=strmov(end,", no empty");
	if (share->rec[field].pack_type & PACK_TYPE_ZERO_FILL)
	{
	  sprintf(end,", zerofill(%d)",share->rec[field].space_length_bits);
	  end=strend(end);
	}
      }
      if (buff[0] == ',')
	strmov(buff,buff+2);
#endif
      len=(uint) (int2str((long) share->rec[field].base.length,length,10) -
		  length);
      if (type == FIELD_BLOB)
      {
	length[len]='+';
	VOID(int2str((long) sizeof(char*),length+len+1,10));
      }
      printf("%-6d%-6d%-7s%-35s",field+1,start,length,buff);
#ifndef NOT_PACKED_DATABASES
      if (share->base.options & HA_OPTION_COMPRESS_RECORD)
      {
	if (share->rec[field].huff_tree)
	  printf("%3d    %2d",
		 (uint) (share->rec[field].huff_tree-share->decode_trees)+1,
		 share->rec[field].huff_tree->quick_table_bits);
      }
#endif
      VOID(putchar('\n'));
      start+=share->rec[field].base.length;
      if (type == FIELD_BLOB)
	start+=sizeof(char*);
    }
  }
  DBUG_VOID_RETURN;
} /* describe */


	/* Change all key-pointers that points to a records */

static int movepoint(info,record,oldpos,newpos,prot_key)
register N_INFO *info;
byte *record;
ulong oldpos,newpos;
uint prot_key;
{
  register uint i;
  uchar *key;
  DBUG_ENTER("movepoint");

  key=info->lastkey+info->s->base.max_key_length;
  for (i=0 ; i < info->s->state.keys; i++)
  {
    if (i != prot_key)
    {
      VOID(_nisam_make_key(info,i,key,record,oldpos));
      if (info->s->keyinfo[i].base.flag & HA_NOSAME)
      {					/* Change pointer direct */
	uint nod_flag;
	N_KEYDEF *keyinfo;
	keyinfo=info->s->keyinfo+i;
	if (_nisam_search(info,keyinfo,key,USE_HOLE_KEY,
		       (uint) (SEARCH_SAME | SEARCH_SAVE_BUFF),
		       info->s->state.key_root[i]))
	  DBUG_RETURN(-1);
	nod_flag=test_if_nod(info->buff);
	_nisam_dpointer(info,info->int_keypos-nod_flag-
		     info->s->rec_reflength,newpos);
	if (_nisam_write_keypage(info,keyinfo,info->int_pos,info->buff))
	  DBUG_RETURN(-1);
      }
      else
      {					/* Change old key to new */
	if (_nisam_ck_delete(info,i,key))
	  DBUG_RETURN(-1);
	VOID(_nisam_make_key(info,i,key,record,newpos));
	if (_nisam_ck_write(info,i,key))
	  DBUG_RETURN(-1);
      }
    }
  }
  DBUG_RETURN(0);
} /* movepoint */


	/* Tell system that we want all memory for our cache */

static void lock_memory(void)
{
#ifdef SUN_OS				/* Key-cacheing thrases on sun 4.1 */
  int success;

  success = mlockall(MCL_CURRENT);	/* or plock(DATLOCK); */

  if (geteuid() == 0 && success != 0)
    print_warning("Failed to lock memory. errno %d",my_errno);
#endif
} /* lock_memory */


	/* Flush all changed blocks to disk */

static int flush_blocks(file)
File file;
{
  if (flush_key_blocks(file,FLUSH_RELEASE))
  {
    print_error("%d when trying to write bufferts",my_errno);
    return(1);
  }
  end_key_cache();
  return 0;
} /* flush_blocks */


	/* Sort records according to one key */

static int sort_records(info,name,sort_key,write_info)
register N_INFO *info;
my_string name;
uint sort_key;
int write_info;
{
  int got_error;
  uint key;
  N_KEYDEF *keyinfo;
  File new_file;
  uchar *temp_buff;
  ulong old_record_count;
  ISAM_SHARE *share=info->s;
  DBUG_ENTER("sort_records");

  keyinfo= &share->keyinfo[sort_key];
  got_error=1;
  temp_buff=0; record_buff=0;
  new_file= -1;

  if (sort_key >= share->state.keys)
  {
    print_error("Can't sort table '%s' on key %d. It has only %d keys",
		name,sort_key+1,share->state.keys);
    error_printed=0;
    DBUG_RETURN(-1);
  }
  if (!(testflag & T_SILENT))
  {
    printf("- Sorting records in ISAM-table '%s'\n",name);
    if (write_info)
      printf("Data records: %7lu   Deleted: %7lu\n",
	     share->state.records,share->state.del);
  }
  if (share->state.key_root[sort_key] == NI_POS_ERROR)
    DBUG_RETURN(0);				/* Nothing to do */

  init_key_cache(use_buffers,NEAD_MEM);
  if (init_io_cache(&info->rec_cache,-1,(uint) write_buffer_length,
		   WRITE_CACHE,share->pack.header_length,1,
		   MYF(MY_WME | MY_WAIT_IF_FULL)))
    goto err;
  info->opt_flag|=WRITE_CACHE_USED;

  if (!(temp_buff=(uchar*) my_alloca((uint) keyinfo->base.block_length)))
  {
    print_error("Not Enough memory");
    goto err;
  }
  if (!(record_buff=(byte*) my_alloca((uint) share->base.reclength)))
  {
    print_error("Not Enough memory");
    goto err;
  }
  if ((new_file=my_create(fn_format(temp_filename,name,"",DATA_TMP_EXT,2+4),
			  0,tmpfile_createflag,MYF(0))) <= 0)
  {
    print_error("Can't create new tempfile: '%s'",temp_filename);
    goto err;
  }
  if (filecopy(new_file,info->dfile,0L,share->pack.header_length,
	       "datafile-header"))
    goto err;
  info->rec_cache.file=new_file;		/* Use this file for cacheing*/

  lock_memory();
  for (key=0 ; key < share->state.keys ; key++)
    share->keyinfo[key].base.flag|= HA_SORT_ALLOWS_SAME;

  if (my_pread(share->kfile,(byte*) temp_buff,
	       (uint) keyinfo->base.block_length,
	       share->state.key_root[sort_key],
	       MYF(MY_NABP+MY_WME)))
  {
    print_error("Can't read indexpage from filepos: %lu",
		(ulong) share->state.key_root[sort_key]);
    goto err;
  }

  /* Setup param for sort_write_record */
  bzero((char*) &sort_info,sizeof(sort_info));
  sort_info.info=info;
  sort_info.new_data_file_type=share->data_file_type;
  sort_info.fix_datafile=1;
  sort_info.filepos=share->pack.header_length;
  sort_info.record=record_buff;
  old_record_count=share->state.records;
  share->state.records=0;

  if (sort_record_index(info,keyinfo,share->state.key_root[sort_key],temp_buff,
			sort_key,new_file) ||
      write_data_suffix(info) ||
      flush_io_cache(&info->rec_cache))
    goto err;

  if (share->state.records != old_record_count)
  {
    print_error("found %lu of %lu records",
		(ulong) share->state.records,(ulong) old_record_count);
    goto err;
  }

	/* Put same locks as old file */
  if (lock_file(new_file,0L,F_WRLCK,"tempfile",temp_filename))
    goto err;
  VOID(lock_file(info->dfile,0L,F_UNLCK,"datafile of",name));
  VOID(my_close(info->dfile,MYF(MY_WME)));
  out_flag|=O_NEW_DATA;				/* Data in new file */

  info->dfile=new_file;				/* Use new indexfile */
  share->state.del=share->state.empty=0;
  share->state.dellink= NI_POS_ERROR;
  share->state.data_file_length=sort_info.filepos;
  share->state.splitt=share->state.records;	/* Only hole records */
  share->state.version=(ulong) time((time_t*) 0);

  info->update= (short) (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);

  if (testflag & T_WRITE_LOOP)
  {
    VOID(fputs("          \r",stdout)); VOID(fflush(stdout));
  }
  got_error=0;

err:
  if (got_error && new_file >= 0)
  {
    VOID(my_close(new_file,MYF(MY_WME)));
    VOID(my_delete(temp_filename,MYF(MY_WME)));
  }
  if (temp_buff)
  {
    my_afree((gptr) temp_buff);
  }
  if (record_buff)
  {
    my_afree(record_buff);
  }
  info->opt_flag&= ~(READ_CACHE_USED | WRITE_CACHE_USED);
  VOID(end_io_cache(&info->rec_cache));
  share->base.sortkey=sort_key;
  DBUG_RETURN(flush_blocks(share->kfile) | got_error);
} /* sort_records */


	 /* Sort records recursive using one index */

static int sort_record_index(info,keyinfo,page,buff,sort_key,new_file)
N_INFO *info;
N_KEYDEF *keyinfo;
ulong page;
uchar *buff;
uint sort_key;
File new_file;
{
  uint	nod_flag,used_length;
  uchar *temp_buff,*keypos,*endpos;
  ulong next_page,rec_pos;
  uchar lastkey[N_MAX_KEY_BUFF];
  DBUG_ENTER("sort_record_index");

  nod_flag=test_if_nod(buff);
  temp_buff=0;

  if (nod_flag)
  {
    if (!(temp_buff=(uchar*) my_alloca((uint) keyinfo->base.block_length)))
    {
      print_error("Not Enough memory");
      DBUG_RETURN(-1);
    }
  }
  used_length=getint(buff);
  keypos=buff+2+nod_flag;
  endpos=buff+used_length;
  for ( ;; )
  {
    _sanity(__FILE__,__LINE__);
    if (nod_flag)
    {
      next_page=_nisam_kpos(nod_flag,keypos);
      if (my_pread(info->s->kfile,(byte*) temp_buff,
		  (uint) keyinfo->base.block_length, next_page,
		   MYF(MY_NABP+MY_WME)))
      {
	print_error("Can't read keys from filepos: %lu",(ulong) next_page);
	goto err;
      }
      if (sort_record_index(info,keyinfo,next_page,temp_buff,sort_key,
			    new_file))
	goto err;
    }
    _sanity(__FILE__,__LINE__);
    if (keypos >= endpos ||
	(*keyinfo->get_key)(keyinfo,nod_flag,&keypos,lastkey) == 0)
      break;
    rec_pos= _nisam_dpos(info,nod_flag,keypos);

    if ((*info->s->read_rnd)(info,record_buff,rec_pos,0))
    {
      print_error("%d when reading datafile",my_errno);
      goto err;
    }
    if (rec_pos != sort_info.filepos)
    {
      _nisam_dpointer(info,keypos-nod_flag-info->s->rec_reflength,
		   sort_info.filepos);
      if (movepoint(info,record_buff,rec_pos,sort_info.filepos,sort_key))
      {
	print_error("%d when updating key-pointers",my_errno);
	goto err;
      }
    }
    if (sort_write_record())
      goto err;
  }
  bzero((byte*) buff+used_length,keyinfo->base.block_length-used_length);
  if (my_pwrite(info->s->kfile,(byte*) buff,(uint) keyinfo->base.block_length,
		page,MYF_RW))
  {
    print_error("%d when updating keyblock",my_errno);
    goto err;
  }
  if (temp_buff)
    my_afree((gptr) temp_buff);
  DBUG_RETURN(0);
err:
  if (temp_buff)
    my_afree((gptr) temp_buff);
  DBUG_RETURN(1);
} /* sort_record_index */


	/* Sort index for more efficent reads */

static int sort_index(info,name)
register N_INFO *info;
my_string name;
{
  reg2 uint key;
  reg1 N_KEYDEF *keyinfo;
  File new_file;
  ulong index_pos[N_MAXKEY];
  DBUG_ENTER("sort_index");

  if (!(testflag & T_SILENT))
    printf("- Sorting index for ISAM-table '%s'\n",name);

  if ((new_file=my_create(fn_format(temp_filename,name,"",INDEX_TMP_EXT,2+4),
			  0,tmpfile_createflag,MYF(0))) <= 0)
  {
    print_error("Can't create new tempfile: '%s'",temp_filename);
    DBUG_RETURN(-1);
  }
  if (filecopy(new_file,info->s->kfile,0L,(ulong) info->s->base.keystart,
	       "headerblock"))
    goto err;

  new_file_pos=info->s->base.keystart;
  for (key= 0,keyinfo= &info->s->keyinfo[0]; key < info->s->state.keys ;
       key++,keyinfo++)
  {
    if (info->s->state.key_root[key] != NI_POS_ERROR)
    {
      index_pos[key]=new_file_pos;		/* Write first block here */
      if (!_nisam_fetch_keypage(info,keyinfo,info->s->state.key_root[key],
			     info->buff,0))
      {
	print_error("Can't read indexpage from filepos: %lu",
		    (ulong) info->s->state.key_root[key]);
	goto err;
      }
      if (sort_one_index(info,keyinfo,info->buff,new_file))
	goto err;
    }
    else
      index_pos[key]= NI_POS_ERROR;		/* No blocks */
  }

	/* Put same locks as old file */
  if (lock_file(new_file,0L,F_WRLCK,"tempfile",temp_filename))
    goto err;
  info->s->state.version=(ulong) time((time_t*) 0);
  VOID(_nisam_writeinfo(info,1));			/* This unlocks table */
  VOID(my_close(info->s->kfile,MYF(MY_WME)));
  out_flag|=O_NEW_INDEX;			/* Data in new file */

  info->s->kfile=new_file;
  info->s->state.key_file_length=new_file_pos;
  info->update= (short) (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);
  for (key=0 ; key < info->s->state.keys ; key++)
  {
    info->s->state.key_root[key]=index_pos[key];
    info->s->state.key_del[key]= NI_POS_ERROR;
  }
  DBUG_RETURN(0);

err:
  VOID(my_close(new_file,MYF(MY_WME)));
  VOID(my_delete(temp_filename,MYF(MY_WME)));
  DBUG_RETURN(-1);
} /* sort_index */


	 /* Sort records recursive using one index */

static int sort_one_index(info,keyinfo,buff,new_file)
N_INFO *info;
N_KEYDEF *keyinfo;
uchar *buff;
File new_file;
{
  uint length,nod_flag,used_length;
  uchar *temp_buff,*keypos,*endpos;
  ulong new_page_pos,next_page;
  DBUG_ENTER("sort_one_index");

  temp_buff=0;
  new_page_pos=new_file_pos;
  new_file_pos+=keyinfo->base.block_length;

  if ((nod_flag=test_if_nod(buff)))
  {
    if (!(temp_buff=(uchar*) my_alloca((uint) keyinfo->base.block_length)))
    {
      print_error("Not Enough memory");
      DBUG_RETURN(-1);
    }

    used_length=getint(buff);
    keypos=buff+2+nod_flag;
    endpos=buff+used_length;
    for ( ;; )
    {
      if (nod_flag)
      {
	next_page=_nisam_kpos(nod_flag,keypos);
	_nisam_kpointer(info,keypos-nod_flag,new_file_pos); /* Save new pos */
	if (!_nisam_fetch_keypage(info,keyinfo,next_page,temp_buff,0))
	{
	  print_error("Can't read keys from filepos: %lu",
		      (ulong) next_page);
	  goto err;
	}
	if (sort_one_index(info,keyinfo,temp_buff,new_file))
	  goto err;
      }
      if (keypos >= endpos ||
	  ((*keyinfo->get_key)(keyinfo,nod_flag,&keypos,info->lastkey)) == 0)
	break;
    }
    my_afree((gptr) temp_buff);
  }

	/* Fill block with zero and write it to new file */

  length=getint(buff);
  bzero((byte*) buff+length,keyinfo->base.block_length-length);
  if (my_pwrite(new_file,(byte*) buff,(uint) keyinfo->base.block_length,
		new_page_pos,MYF(MY_NABP | MY_WAIT_IF_FULL)))
  {
    print_error("Can't write indexblock, error: %d",my_errno);
    goto err;
  }
  DBUG_RETURN(0);
err:
  if (temp_buff)
    my_afree((gptr) temp_buff);
  DBUG_RETURN(1);
} /* sort_one_index */


	/* Change to use new file */
	/* Copy stats from old file to new file, deletes orginal and */
	/* changes new file name to old file name */

static int change_to_newfile(filename,old_ext,new_ext)
const char *filename,*old_ext,*new_ext;
{
  char old_filename[FN_REFLEN],new_filename[FN_REFLEN];

  return my_redel(fn_format(old_filename,filename,"",old_ext,2+4),
		  fn_format(new_filename,filename,"",new_ext,2+4),
		  MYF(MY_WME+MY_LINK_WARNING));
} /* change_to_newfile */


	/* Locks a hole file */
	/* Gives error-message if file can't be locked */

static int lock_file(file,start,lock_type,filetype,filename)
File file;
ulong start;
int lock_type;
const char *filetype,*filename;
{
#ifndef NO_LOCKING
  if (my_lock(file,lock_type,start,F_TO_EOF,
	      testflag & T_WAIT_FOREVER ? MYF(MY_SEEK_NOT_DONE) :
	      MYF(MY_SEEK_NOT_DONE |  MY_DONT_WAIT)))
  {
    print_error(" %d when %s %s '%s'",my_errno,
		lock_type == F_UNLCK ? "unlocking": "locking",
		filetype,filename);
    error_printed=2;		/* Don't give that data is crashed */
    return 1;
  }
#endif
  return 0;
} /* lock_file */


	/* Copy a block between two files */

static int filecopy(File to,File from,ulong start,ulong length,
		    const char *type)
{
  char tmp_buff[IO_SIZE],*buff;
  ulong buff_length;
  DBUG_ENTER("filecopy");

  buff_length=min(write_buffer_length,length);
  if (!(buff=my_malloc(buff_length,MYF(0))))
  {
    buff=tmp_buff; buff_length=IO_SIZE;
  }

  VOID(my_seek(from,start,MY_SEEK_SET,MYF(0)));
  while (length > buff_length)
  {
    if (my_read(from,(byte*) buff,buff_length,MYF(MY_NABP)) ||
	my_write(to,(byte*) buff,buff_length,MYF(MY_NABP | MY_WAIT_IF_FULL)))
      goto err;
    length-= buff_length;
  }
  if (my_read(from,(byte*) buff,(uint) length,MYF(MY_NABP)) ||
      my_write(to,(byte*) buff,(uint) length,MYF(MY_NABP | MY_WAIT_IF_FULL)))
    goto err;
  if (buff != tmp_buff)
    my_free(buff,MYF(0));
  DBUG_RETURN(0);
err:
  if (buff != tmp_buff)
    my_free(buff,MYF(0));
  print_error("Can't copy %s to tempfile, error %d",type,my_errno);
  DBUG_RETURN(1);
}


	/* Fix table using sorting */
	/* saves new table in temp_filename */

static int rep_by_sort(info,name)
reg1 N_INFO *info;
my_string name;
{
  int got_error;
  uint i,length;
  ulong start_records,new_header_length,del;
  File new_file;
  SORT_PARAM sort_param;
  ISAM_SHARE *share=info->s;
  DBUG_ENTER("rep_by_sort");

  start_records=share->state.records;
  got_error=1;
  new_file= -1;
  new_header_length=(testflag & T_UNPACK) ? 0 : share->pack.header_length;
  if (!(testflag & T_SILENT))
  {
    printf("- recovering ISAM-table '%s'\n",name);
    printf("Data records: %lu\n",(ulong) start_records);
  }
  bzero((char*) &sort_info,sizeof(sort_info));
  if (!(sort_info.key_block=alloc_key_blocks((uint) sort_key_blocks,
					     share->base.max_block))
      || init_io_cache(&read_cache,info->dfile,(uint) read_buffer_length,
		      READ_CACHE,share->pack.header_length,1,MYF(MY_WME)) ||
      (! rep_quick &&
       init_io_cache(&info->rec_cache,info->dfile,(uint) write_buffer_length,
		    WRITE_CACHE,new_header_length,1,
		    MYF(MY_WME | MY_WAIT_IF_FULL))))
    goto err;
  sort_info.key_block_end=sort_info.key_block+sort_key_blocks;
  info->opt_flag|=WRITE_CACHE_USED;
  info->rec_cache.file=info->dfile;		/* for sort_delete_record */

  if (!(sort_info.record=(byte*) my_alloca((uint) share->base.reclength)))
  {
    print_error("Not enough memory for extra record");
    goto err;
  }
  if (!rep_quick)
  {
    if ((new_file=my_create(fn_format(temp_filename,name,"",DATA_TMP_EXT,
				      2+4),
			    0,tmpfile_createflag,MYF(0))) < 0)
    {
      print_error("Can't create new tempfile: '%s'",temp_filename);
      goto err;
    }
    if (filecopy(new_file,info->dfile,0L,new_header_length,"datafile-header"))
      goto err;
    if (testflag & T_UNPACK)
      share->base.options&= ~HA_OPTION_COMPRESS_RECORD;
    share->state.dellink= NI_POS_ERROR;
    info->rec_cache.file=new_file;
  }

  info->update= (short) (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);
  for (i=0 ; i < N_MAXKEY ; i++)
    share->state.key_del[i]=share->state.key_root[i]= NI_POS_ERROR;
  share->state.key_file_length=share->base.keystart;

  sort_info.info=info;
  if ((sort_info.new_data_file_type=share->data_file_type) ==
      COMPRESSED_RECORD && testflag & T_UNPACK)
  {
    if (share->base.options & HA_OPTION_PACK_RECORD)
      sort_info.new_data_file_type = DYNAMIC_RECORD;
    else
      sort_info.new_data_file_type = STATIC_RECORD;
  }

  sort_info.filepos=new_header_length;
  sort_info.dupp=0;
  read_cache.end_of_file=sort_info.filelength=
    (ulong) my_seek(read_cache.file,0L,MY_SEEK_END,MYF(0));

  if (share->data_file_type == DYNAMIC_RECORD)
    length=max(share->base.min_pack_length+1,share->base.min_block_length);
  else if (share->data_file_type == COMPRESSED_RECORD)
    length=share->base.min_block_length;
  else
    length=share->base.reclength;
  sort_param.max_records=sort_info.max_records=sort_info.filelength/length+1;
  sort_param.key_cmp=sort_key_cmp;
  sort_param.key_write=sort_key_write;
  sort_param.key_read=sort_key_read;
  sort_param.lock_in_memory=lock_memory;
  del=share->state.del;

  for (sort_info.key=0 ; sort_info.key < share->state.keys ; sort_info.key++)
  {
    if ((!(testflag & T_SILENT)))
      printf ("- Fixing index %d\n",sort_info.key+1);
    sort_info.max_pos=sort_info.pos=share->pack.header_length;
    sort_info.keyinfo=share->keyinfo+sort_info.key;
    sort_info.keyseg=sort_info.keyinfo->seg;
    sort_info.fix_datafile= (my_bool) (sort_info.key == 0 && ! rep_quick);
    sort_info.unique=0;
    sort_param.key_length=share->rec_reflength;
    for (i=0 ; sort_info.keyseg[i].base.type ; i++)
      sort_param.key_length+=sort_info.keyseg[i].base.length+
	(sort_info.keyseg[i].base.flag & HA_SPACE_PACK ? 1 : 0);
    share->state.records=share->state.del=share->state.empty=share->state.splitt=0;

    if (_create_index_by_sort(&sort_param,
			      (pbool) (!(testflag & T_VERBOSE)),
			      (uint) sort_buffer_length))
      goto err;
		/* Set for next loop */
    sort_param.max_records=sort_info.max_records=share->state.records;
    share->base.rec_per_key[sort_info.key]=
      sort_info.unique ? ((sort_info.max_records+sort_info.unique/2)/
			   sort_info.unique)
      : 1L;

    if (sort_info.fix_datafile)
    {
      info->dfile=new_file;
      share->state.data_file_length=sort_info.filepos;
      share->state.splitt=share->state.records; /* Only hole records */
      share->state.version=(ulong) time((time_t*) 0);
      out_flag|=O_NEW_DATA;			/* Data in new file */
      read_cache.end_of_file=sort_info.filepos;
      if (write_data_suffix(info) || end_io_cache(&info->rec_cache))
	goto err;
      share->data_file_type=sort_info.new_data_file_type;
      share->pack.header_length=new_header_length;
    }
    else
      share->state.data_file_length=sort_info.max_pos;

    if (flush_pending_blocks())
      goto err;

    read_cache.file=info->dfile;		/* re-init read cache */
    reinit_io_cache(&read_cache,READ_CACHE,share->pack.header_length,1,1);
  }

  if (testflag & T_WRITE_LOOP)
  {
    VOID(fputs("          \r",stdout)); VOID(fflush(stdout));
  }

  if (rep_quick && del+sort_info.dupp != share->state.del)
  {
    print_error("Couldn't fix table with quick recovery: Found wrong number of deleted records");
    print_error("Run recovery again without -q");
    got_error=1;
    goto err;
  }

  if (rep_quick != 1)
  {
    ulong skr=share->state.data_file_length+
      (share->base.options & HA_OPTION_COMPRESS_RECORD ?
       MEMMAP_EXTRA_MARGIN : 0);
#ifdef USE_RELOC
    if (share->data_file_type == STATIC_RECORD &&
	skr < share->base.reloc*share->base.min_pack_length)
      skr=share->base.reloc*share->base.min_pack_length;
#endif
    if (skr != sort_info.filelength)
      if (my_chsize(info->dfile,skr,MYF(0)))
	print_warning("Can't change size of datafile,  error: %d",my_errno);
  }
  if (my_chsize(share->kfile,share->state.key_file_length,MYF(0)))
    print_warning("Can't change size of indexfile, error: %d",my_errno);

  if (!(testflag & T_SILENT))
  {
    if (start_records != share->state.records)
      printf("Data records: %lu\n",(ulong) share->state.records);
    if (sort_info.dupp)
      print_warning("%lu records have been removed",(ulong) sort_info.dupp);
  }
  got_error=0;

err:
  if (got_error)
  {
    if (! error_printed)
      print_error("%d when fixing table",my_errno);
    if (new_file >= 0)
    {
      VOID(end_io_cache(&info->rec_cache));
      VOID(my_close(new_file,MYF(0)));
      VOID(my_delete(temp_filename,MYF(MY_WME)));
    }
  }
  if (sort_info.key_block)
    my_free((gptr) sort_info.key_block,MYF(0));
  if (sort_info.record)
  {
    my_afree(sort_info.record);
  }
  VOID(end_io_cache(&read_cache));
  VOID(end_io_cache(&info->rec_cache));
  info->opt_flag&= ~(READ_CACHE_USED | WRITE_CACHE_USED);
  if (!got_error && testflag & T_UNPACK)
  {
    share->state.header.options[0]&= (uchar) ~HA_OPTION_COMPRESS_RECORD;
    share->pack.header_length=0;
  }
  DBUG_RETURN(got_error);
} /* rep_by_sort */


	/* Read next record and return next key */

static int sort_key_read(key)
void *key;
{
  int error;
  N_INFO *info;
  DBUG_ENTER("sort_key_read");

  info=sort_info.info;

  if ((error=sort_get_next_record()))
    DBUG_RETURN(error);
  if (info->s->state.records == sort_info.max_records)
  {
    print_error("Found too many records; Can`t continue");
    DBUG_RETURN(1);
  }
  VOID(_nisam_make_key(info,sort_info.key,key,sort_info.record,
		    sort_info.filepos));
  DBUG_RETURN(sort_write_record());
} /* sort_key_read */


	/* Read next record from file using parameters in sort_info */
	/* Return -1 if end of file, 0 if ok and > 0 if error */

static int sort_get_next_record()
{
  int searching;
  uint found_record,b_type,left_length;
  ulong pos;
  byte *to;
  BLOCK_INFO block_info;
  N_INFO *info;
  ISAM_SHARE *share;
  DBUG_ENTER("sort_get_next_record");

  info=sort_info.info;
  share=info->s;
  switch (share->data_file_type) {
  case STATIC_RECORD:
    for (;;)
    {
      if (my_b_read(&read_cache,sort_info.record,share->base.reclength))
	DBUG_RETURN(-1);
      sort_info.start_recpos=sort_info.pos;
      if (!sort_info.fix_datafile)
	sort_info.filepos=sort_info.pos;
      sort_info.max_pos=(sort_info.pos+=share->base.reclength);
      share->state.splitt++;
      if (*sort_info.record)
	DBUG_RETURN(0);
      if (!sort_info.fix_datafile)
      {
	share->state.del++;
	share->state.empty+=share->base.reclength;
      }
    }
  case DYNAMIC_RECORD:
    LINT_INIT(to);
    pos=sort_info.pos;
    searching=(sort_info.fix_datafile && (testflag & T_EXTEND));
    for (;;)
    {
      found_record=block_info.second_read= 0;
      left_length=1;
      do
      {
	if (pos > sort_info.max_pos)
	  sort_info.max_pos=pos;
	if (found_record && pos == search_after_block)
	  print_info("Block: %lu used by record at %lu",
		     search_after_block,
		     sort_info.start_recpos);
	if (_nisam_read_cache(&read_cache,(byte*) block_info.header,pos,
			  BLOCK_INFO_HEADER_LENGTH, test(! found_record) | 2))
	{
	  if (found_record)
	  {
	    print_info("Can't read whole record at %lu (errno: %d)",
		       (ulong) sort_info.start_recpos,errno);
	    goto try_next;
	  }
	  DBUG_RETURN(-1);
	}
	if (searching && ! sort_info.fix_datafile)
	{
	  error_printed=1;
	  DBUG_RETURN(1);	/* Something wrong with data */
	}
	if (((b_type=_nisam_get_block_info(&block_info,-1,pos)) &
	     (BLOCK_ERROR | BLOCK_FATAL_ERROR)) ||
	    ((b_type & BLOCK_FIRST) &&
	     (block_info.rec_len < (uint) share->base.min_pack_length ||
	      block_info.rec_len > (uint) share->base.max_pack_length)))
	{
	  uint i;
	  if (testflag & T_VERBOSE || searching == 0)
	    print_info("Wrong bytesec: %3d-%3d-%3d at %10lu; Skipped",
		       block_info.header[0],block_info.header[1],
		       block_info.header[2],pos);
	  if (found_record)
	    goto try_next;
	  block_info.second_read=0;
	  searching=1;
	  for (i=1 ; i < 11 ; i++) /* Skipp from read string */
	    if (block_info.header[i] >= 1 && block_info.header[i] <= 16)
	      break;
	  pos+=(ulong) i;
	  continue;
	}
	if (block_info.block_len+ (uint) (block_info.filepos-pos) <
	    share->base.min_block_length ||
	    block_info.block_len-4 > (uint) share->base.max_pack_length)
	{
	  if (!searching)
	    print_info("Found block with impossible length %u at %lu; Skipped",
		       block_info.block_len+ (uint) (block_info.filepos-pos),
		       (ulong) pos);
	  if (found_record)
	    goto try_next;
	  searching=1;
	  pos++;
	  block_info.second_read=0;
	  continue;
	}
	if (b_type & (BLOCK_DELETED | BLOCK_SYNC_ERROR))
	{
	  if (!sort_info.fix_datafile && (b_type & BLOCK_DELETED))
	  {
	    share->state.empty+=block_info.block_len;
	    share->state.del++;
	    share->state.splitt++;
	  }
	  if (found_record)
	    goto try_next;
	  /* Check if impossible big deleted block */
	  if (block_info.block_len > share->base.max_pack_length +4)
	    searching=1;
	  if (searching)
	    pos++;
	  else
	    pos=block_info.filepos+block_info.block_len;
	  block_info.second_read=0;
	  continue;
	}

	share->state.splitt++;
	if (! found_record++)
	{
	  sort_info.find_length=left_length=block_info.rec_len;
	  sort_info.start_recpos=pos;
	  if (!sort_info.fix_datafile)
	    sort_info.filepos=sort_info.start_recpos;
	  if (sort_info.fix_datafile && (testflag & T_EXTEND))
	    sort_info.pos=block_info.filepos+1;
	  else
	    sort_info.pos=block_info.filepos+block_info.block_len;
	  if (share->base.blobs)
	  {
	    if (!(to=fix_rec_buff_for_blob(info,block_info.rec_len)))
	    {
	      print_error("Not enough memory for blob at %lu",
			  (ulong) sort_info.start_recpos);
	      DBUG_RETURN(-1);
	    }
	  }
	  else
	    to= info->rec_buff;
	}
	if (left_length < block_info.data_len || ! block_info.data_len)
	{
	  print_info("Found block with too small length at %lu; Skipped",
		     (ulong) sort_info.start_recpos);
	  goto try_next;
	}
	if (block_info.filepos + block_info.data_len > read_cache.end_of_file)
	{
	  print_info("Found block that points outside data file at %lu",
		     (ulong) sort_info.start_recpos);
	  goto try_next;
	}
	if (_nisam_read_cache(&read_cache,to,block_info.filepos,
			   block_info.data_len, test(found_record == 1)))
	{
	  print_info("Read error for block at: %lu (error: %d); Skipped",
		     (ulong) block_info.filepos,my_errno);
	  goto try_next;
	}
	left_length-=block_info.data_len;
	to+=block_info.data_len;
	pos=block_info.next_filepos;
	if (pos == NI_POS_ERROR && left_length)
	{
	  print_info("Wrong block with wrong total length starting at %lu",
		     (ulong) sort_info.start_recpos);
	  goto try_next;
	}
	if (pos + BLOCK_INFO_HEADER_LENGTH > read_cache.end_of_file)
	{
	  print_info("Found link that points at %lu (outside data file) at %lu",
		     (ulong) pos,(ulong) sort_info.start_recpos);
	  goto try_next;
	}
      } while (left_length);

      if (_nisam_rec_unpack(info,sort_info.record,info->rec_buff,
			 sort_info.find_length) != MY_FILE_ERROR)
      {
	if (read_cache.error < 0)
	  DBUG_RETURN(1);
	if ((testflag & (T_EXTEND | T_REP)) || searching)
	{
	  if (_nisam_rec_check(info, sort_info.record))
	  {
	    print_info("Found wrong packed record at %lu",
		       (ulong) sort_info.start_recpos);
	    goto try_next;
	  }
	}
	DBUG_RETURN(0);
      }
    try_next:
      pos=sort_info.start_recpos+1;
      searching=1;
    }
  case COMPRESSED_RECORD:
    for (searching=0 ;; searching=1, sort_info.pos++)
    {
      if (_nisam_read_cache(&read_cache,(byte*) block_info.header,sort_info.pos,
			share->pack.ref_length,1))
	DBUG_RETURN(-1);
      if (searching && ! sort_info.fix_datafile)
      {
	error_printed=1;
	DBUG_RETURN(1);		/* Something wrong with data */
      }
      sort_info.start_recpos=sort_info.pos;
      VOID(_nisam_pack_get_block_info(&block_info,share->pack.ref_length,-1,
				   sort_info.pos));
      if (!block_info.rec_len &&
	  sort_info.pos + MEMMAP_EXTRA_MARGIN == read_cache.end_of_file)
	DBUG_RETURN(-1);
      if (block_info.rec_len < (uint) share->min_pack_length ||
	  block_info.rec_len > (uint) share->max_pack_length)
      {
	if (! searching)
	  print_info("Found block with wrong recordlength: %d at %lu\n",
		     block_info.rec_len, (ulong) sort_info.pos);
	continue;
      }
      if (_nisam_read_cache(&read_cache,(byte*) info->rec_buff,
			block_info.filepos, block_info.rec_len,1))
      {
	if (! searching)
	  print_info("Couldn't read hole record from %lu",
		     (ulong) sort_info.pos);
	continue;
      }
      if (_nisam_pack_rec_unpack(info,sort_info.record,info->rec_buff,
			      block_info.rec_len))
      {
	if (! searching)
	  print_info("Found wrong record at %lu",(ulong) sort_info.pos);
	continue;
      }
      if (!sort_info.fix_datafile)
	sort_info.filepos=sort_info.pos;
      sort_info.max_pos=(sort_info.pos+=share->pack.ref_length+
			 block_info.rec_len);
      share->state.splitt++;
      info->packed_length=block_info.rec_len;
      DBUG_RETURN(0);
    }
  }
  DBUG_RETURN(1);		/* Impossible */
}


	/* Write record to new file */

static int sort_write_record()
{
  int flag;
  uint block_length,reclength;
  byte *from;
  uchar *block_buff[3];
  N_INFO *info;
  ISAM_SHARE *share;
  DBUG_ENTER("sort_write_record");

  info=sort_info.info;
  share=info->s;
  if (sort_info.fix_datafile)
  {
    switch (sort_info.new_data_file_type) {
    case STATIC_RECORD:
      if (my_b_write(&info->rec_cache,sort_info.record, share->base.reclength))
      {
	print_error("%d when writing to datafile",my_errno);
	DBUG_RETURN(1);
      }
      sort_info.filepos+=share->base.reclength;
      break;
    case DYNAMIC_RECORD:
      if (! info->blobs)
	from=info->rec_buff;
      else
      {
	/* must be sure that local buffer is big enough */
	reclength=info->s->base.pack_reclength+
	  _calc_total_blob_length(info,sort_info.record)+
	  ALIGN_SIZE(MAX_DYN_BLOCK_HEADER)+N_SPLITT_LENGTH+
	  DYN_DELETE_BLOCK_HEADER;
	if (sort_info.buff_length < reclength)
	{
	  if (!(sort_info.buff=my_realloc(sort_info.buff, (uint) reclength,
					  MYF(MY_FREE_ON_ERROR |
					      MY_ALLOW_ZERO_PTR))))
	    DBUG_RETURN(1);
	  sort_info.buff_length=reclength;
	}
	from=sort_info.buff+ALIGN_SIZE(MAX_DYN_BLOCK_HEADER);
      }
      reclength=_nisam_rec_pack(info,from,sort_info.record);
      block_length=reclength+ 3 +test(reclength > 65532L);
      if (block_length < share->base.min_block_length)
	block_length=share->base.min_block_length;
      flag=0;
      info->update|=HA_STATE_WRITE_AT_END;
      if (_nisam_write_part_record(info,0L,block_length,NI_POS_ERROR,
				&from,&reclength,&flag))
      {
	print_error("%d when writing to datafile",my_errno);
	DBUG_RETURN(1);
      }
      sort_info.filepos+=block_length;
      break;
    case COMPRESSED_RECORD:
      reclength=info->packed_length;
      save_integer((byte*) block_buff,share->pack.ref_length,reclength);
      if (my_b_write(&info->rec_cache,(byte*) block_buff,share->pack.ref_length)
	  || my_b_write(&info->rec_cache,(byte*) info->rec_buff,reclength))
      {
	print_error("%d when writing to datafile",my_errno);
	DBUG_RETURN(1);
      }
      sort_info.filepos+=reclength+share->pack.ref_length;
      break;
    }
  }
  share->state.records++;
  if (testflag & T_WRITE_LOOP && share->state.records % WRITE_COUNT == 0)
  {
    printf("%lu\r",(ulong) share->state.records); VOID(fflush(stdout));
  }
  DBUG_RETURN(0);
} /* sort_write_record */


	/* Compare two keys from _create_index_by_sort */

static int sort_key_cmp(const void *not_used __attribute__((unused)),
			const void *a,const void *b)
{
  return (_nisam_key_cmp(sort_info.keyseg,*((uchar**) a),*((uchar**) b),0,
		      SEARCH_SAME));
} /* sort_key_cmp */


static int sort_key_write(a)
const void *a;
{
  int cmp=sort_info.key_block->inited ?
    _nisam_key_cmp(sort_info.keyseg,sort_info.key_block->lastkey,(uchar*) a,
	       0,SEARCH_FIND) : -1L;
  if ((sort_info.keyinfo->base.flag & HA_NOSAME) &&
      cmp == 0)
  {
    sort_info.dupp++;
    print_warning("Dupplicate key for record at %10lu against record at %10lu",
		  sort_info.info->lastpos=get_record_for_key(sort_info.info,
							     sort_info.keyinfo,
							     (uchar*) a),
		  get_record_for_key(sort_info.info,sort_info.keyinfo,
				     sort_info.key_block->lastkey));
    if (testflag & T_VERBOSE)
      _nisam_print_key(stdout,sort_info.keyseg,(uchar*) a);
    return(sort_delete_record());
  }
  if (cmp)
    sort_info.unique++;
#ifndef DBUG_OFF
  if (cmp > 0)
  {
    print_error("Fatal intern error: Keys are not in order from sort");
    return(1);
  }
#endif
  return (sort_insert_key(sort_info.key_block,(uchar*) a,NI_POS_ERROR));
} /* sort_key_write */


	/* get pointer to record from a key */

static ulong get_record_for_key(info,keyinfo,key)
N_INFO *info;
N_KEYDEF *keyinfo;
uchar *key;
{
  return _nisam_dpos(info,0,key+_nisam_keylength(keyinfo,key));
} /* get_record_for_key */


	/* Insert a key in sort-key-blocks */

static int sort_insert_key(key_block,key,prev_block)
reg1 SORT_KEY_BLOCKS *key_block;
uchar *key;
ulong prev_block;
{
  uint a_length,t_length,nod_flag;
  ulong filepos;
  uchar *anc_buff,*lastkey;
  S_PARAM s_temp;
  N_INFO *info;
  DBUG_ENTER("sort_insert_key");

  anc_buff=key_block->buff;
  info=sort_info.info;
  lastkey=key_block->lastkey;
  nod_flag= (key_block == sort_info.key_block ? 0 :
	     sort_info.info->s->base.key_reflength);

  if (!key_block->inited)
  {
    key_block->inited=1;
    if (key_block == sort_info.key_block_end)
    {
      print_error("To many keyblocklevels; Try increasing sort_key_blocks");
      DBUG_RETURN(1);
    }
    a_length=2+nod_flag;
    key_block->end_pos=anc_buff+2;
    lastkey=0;					/* No previous key in block */
  }
  else
    a_length=getint(anc_buff);

	/* Save pointer to previous block */
  if (nod_flag)
    _nisam_kpointer(info,key_block->end_pos,prev_block);

  t_length=_nisam_get_pack_key_length(sort_info.keyinfo,nod_flag,
				   (uchar*) 0,lastkey,key,&s_temp);
  _nisam_store_key(sort_info.keyinfo,key_block->end_pos+nod_flag,&s_temp);
  a_length+=t_length;
  putint(anc_buff,a_length,nod_flag);
  key_block->end_pos+=t_length;
  if (a_length <= sort_info.keyinfo->base.block_length)
  {
    VOID(_nisam_move_key(sort_info.keyinfo,key_block->lastkey,key));
    key_block->last_length=a_length-t_length;
    DBUG_RETURN(0);
  }

	/* Fill block with end-zero and write filled block */
  putint(anc_buff,key_block->last_length,nod_flag);
  bzero((byte*) anc_buff+key_block->last_length,
	sort_info.keyinfo->base.block_length- key_block->last_length);
  if ((filepos=_nisam_new(info,sort_info.keyinfo)) == NI_POS_ERROR)
    return 1;
  if (my_pwrite(info->s->kfile,(byte*) anc_buff,
		(uint) sort_info.keyinfo->base.block_length,filepos,MYF_RW))
    DBUG_RETURN(1);
  DBUG_DUMP("buff",(byte*) anc_buff,getint(anc_buff));

	/* Write separator-key to block in next level */
  if (sort_insert_key(key_block+1,key_block->lastkey,filepos))
    DBUG_RETURN(1);

	/* clear old block and write new key in it */
  key_block->inited=0;
  DBUG_RETURN(sort_insert_key(key_block,key,prev_block));
} /* sort_insert_key */


	/* Delete record when we found a dupplicated key */

static int sort_delete_record()
{
  uint i;
  int old_file,error;
  uchar *key;
  N_INFO *info;
  DBUG_ENTER("sort_delete_record");

  if (rep_quick == 1)
  {
    VOID(fputs("Quick-recover aborted; Run recovery without switch 'q' or with switch -qq\n",stderr));
    error_printed=1;
    DBUG_RETURN(1);
  }
  info=sort_info.info;
  if (info->s->base.options & HA_OPTION_COMPRESS_RECORD)
  {
    VOID(fputs("Recover aborted; Can't run standard recovery on compressed tables\nwith errors in data-file\nUse switch '--safe-recover' to fix it\n",stderr));
    error_printed=1;
    DBUG_RETURN(1);
  }

  old_file=info->dfile;
  info->dfile=info->rec_cache.file;
  if (sort_info.key)
  {
    key=info->lastkey+info->s->base.max_key_length;
    if ((*info->s->read_rnd)(info,sort_info.record,info->lastpos,0) < 0)
    {
      print_error("Can't read record to be removed");
      info->dfile=old_file;
      DBUG_RETURN(1);
    }

    for (i=0 ; i < sort_info.key ; i++)
    {
      VOID(_nisam_make_key(info,i,key,sort_info.record,info->lastpos));
      if (_nisam_ck_delete(info,i,key))
      {
	print_error("Can't delete key %d from record to be removed",i+1);
	info->dfile=old_file;
	DBUG_RETURN(1);
      }
    }
  }
  error=flush_io_cache(&info->rec_cache) || (*info->s->delete_record)(info);
  info->dfile=old_file;				/* restore actual value */
  info->s->state.records--;
  DBUG_RETURN(error);
} /* sort_delete_record */


	/* Fix all pending blocks and flush everything to disk */

static int flush_pending_blocks()
{
  uint nod_flag,length;
  ulong filepos;
  N_INFO *info;
  SORT_KEY_BLOCKS *key_block;
  DBUG_ENTER("flush_pending_blocks");

  filepos= NI_POS_ERROR;			/* if empty file */
  info=sort_info.info;
  nod_flag=0;
  for (key_block=sort_info.key_block ; key_block->inited ; key_block++)
  {
    key_block->inited=0;
    length=getint(key_block->buff);
    if (nod_flag)
      _nisam_kpointer(info,key_block->end_pos,filepos);
    if ((filepos=_nisam_new(info,sort_info.keyinfo)) == NI_POS_ERROR)
      DBUG_RETURN(1);
    bzero((byte*) key_block->buff+length,
	  sort_info.keyinfo->base.block_length-length);
    if (my_pwrite(info->s->kfile,(byte*) key_block->buff,
		 (uint) sort_info.keyinfo->base.block_length,filepos,MYF_RW))
      DBUG_RETURN(1);
    DBUG_DUMP("buff",(byte*) key_block->buff,length);
    nod_flag=1;
  }
  info->s->state.key_root[sort_info.key]=filepos;	/* Last is root for tree */
  DBUG_RETURN(0);
} /* flush_pending_blocks */


	/* alloc space and pointers for key_blocks */

static SORT_KEY_BLOCKS *alloc_key_blocks(blocks,buffer_length)
uint blocks,buffer_length;
{
  reg1 uint i;
  SORT_KEY_BLOCKS *block;
  DBUG_ENTER("alloc_key_blocks");

  if (!(block=(SORT_KEY_BLOCKS*) my_malloc((sizeof(SORT_KEY_BLOCKS)+
					    buffer_length+IO_SIZE)*blocks,
					   MYF(0))))
  {
    print_error("Not Enough memory for sort-key-blocks");
    return(0);
  }
  for (i=0 ; i < blocks ; i++)
  {
    block[i].inited=0;
    block[i].buff=(uchar*) (block+blocks)+(buffer_length+IO_SIZE)*i;
  }
  DBUG_RETURN(block);
} /* alloc_key_blocks */


	/* print warnings and errors */
	/* VARARGS */

static void print_info(const char * fmt,...)
{
  va_list args;

  va_start(args,fmt);
  VOID(vfprintf(stdout, fmt, args));
  VOID(fputc('\n',stdout));
  va_end(args);
  return;
}

/* VARARGS */

static void print_warning(const char * fmt,...)
{
  va_list args;
  DBUG_ENTER("print_warning");

  if (!warning_printed && !error_printed)
  {
    fflush(stdout);
    if (testflag & T_SILENT)
      fprintf(stderr,"%s: ISAM file %s\n",my_progname,isam_file_name);
  }
  warning_printed=1;
  va_start(args,fmt);
  fprintf(stderr,"%s: warning: ",my_progname);
  VOID(vfprintf(stderr, fmt, args));
  VOID(fputc('\n',stderr));
  va_end(args);
  DBUG_VOID_RETURN;
}

/* VARARGS */

void print_error(const char *fmt,...)
{
  va_list args;
  DBUG_ENTER("print_error");
  DBUG_PRINT("enter",("format: %s",fmt));

  if (!warning_printed && !error_printed)
  {
    fflush(stdout);
    if (testflag & T_SILENT)
      fprintf(stderr,"%s: ISAM file %s\n",my_progname,isam_file_name);
  }
  error_printed|=1;
  va_start(args,fmt);
  fprintf(stderr,"%s: error: ",my_progname);
  VOID(vfprintf(stderr, fmt, args));
  VOID(fputc('\n',stderr));
  va_end(args);
  DBUG_VOID_RETURN;
}

	/* Check if file is almost full */

static int test_if_almost_full(info)
N_INFO *info;
{
  double diff= 0.9;
  if (info->s->base.options & HA_OPTION_COMPRESS_RECORD)
  {						/* Fix problem with pack_isam */
    diff=1.0;
    if (info->s->base.rec_reflength == 4)
      info->s->base.max_data_file_length= (uint32) ~0L;
    else
      info->s->base.max_data_file_length=
	1L << (info->s->base.rec_reflength);
  }
  return (my_seek(info->s->kfile,0L,MY_SEEK_END,MYF(0)) >
	  (ulong) (info->s->base.max_key_file_length*diff) ||
	   my_seek(info->dfile,0L,MY_SEEK_END,MYF(0)) >
	   (ulong) (info->s->base.max_data_file_length*diff));
}

	/* Recreate table with bigger more alloced record-data */

static int recreate_database(org_info,filename)
N_INFO **org_info;
char *filename;
{
  int error;
  N_INFO info;
  ISAM_SHARE share;
  N_KEYDEF *keyinfo;
  N_RECINFO *recinfo,*rec,*end;
  uint unpack;
  ulong max_records;
  char name[FN_REFLEN];

  error=1;					/* Default error */
  info= **org_info;
  share= *(*org_info)->s;
  unpack= (share.base.options & HA_OPTION_COMPRESS_RECORD) &&
    (testflag & T_UNPACK);
  if (!(keyinfo=(N_KEYDEF*) my_alloca(sizeof(N_KEYDEF)*share.base.keys)))
    return 0;
  memcpy((byte*) keyinfo,(byte*) share.keyinfo,
	 (size_t) (sizeof(N_KEYDEF)*share.base.keys));
  if (!(recinfo=(N_RECINFO*)
	my_alloca(sizeof(N_RECINFO)*(share.base.fields+1))))
  {
    my_afree((gptr) keyinfo);
    return 1;
  }
  memcpy((byte*) recinfo,(byte*) share.rec,
	 (size_t) (sizeof(N_RECINFO)*(share.base.fields+1)));
  for (rec=recinfo,end=recinfo+share.base.fields; rec != end ; rec++)
  {
    if (rec->base.type == (int) FIELD_BLOB)
      rec->base.length+=sizeof(char*);
    else if (unpack && !(share.base.options & HA_OPTION_PACK_RECORD))
      rec->base.type=(int) FIELD_NORMAL;
  }

  if (share.base.options & HA_OPTION_COMPRESS_RECORD)
    share.base.records=max_records=share.state.records;
  else if (share.base.min_pack_length)
    max_records=(ulong) (my_seek(info.dfile,0L,MY_SEEK_END,MYF(0)) /
			 (ulong) share.base.min_pack_length);
  else
    max_records=0;
  unpack= (share.base.options & HA_OPTION_COMPRESS_RECORD) &&
    (testflag & T_UNPACK);
  share.base.options&= ~HA_OPTION_TEMP_COMPRESS_RECORD;
  VOID(nisam_close(*org_info));
  if (nisam_create(fn_format(name,filename,"",N_NAME_IEXT,
			  4+ (opt_follow_links ? 16 : 0)),
		   share.base.keys,keyinfo,recinfo,
		   max(max_records,share.base.records),share.base.reloc,
		   HA_DONT_TOUCH_DATA,
		   share.base.options |
		   (unpack ? HA_OPTION_TEMP_COMPRESS_RECORD
		    : 0),
		   (ulong) my_seek(info.dfile,0L,MY_SEEK_END,MYF(0))))
  {
    print_error("Got error %d when trying to recreate indexfile",my_errno);
    goto end;
  }
  *org_info=nisam_open(name,O_RDWR,
		(testflag & T_WAIT_FOREVER) ? HA_OPEN_WAIT_IF_LOCKED :
		(testflag & T_DESCRIPT) ? HA_OPEN_IGNORE_IF_LOCKED :
		HA_OPEN_ABORT_IF_LOCKED);
  if (!*org_info)
  {
    print_error("Got error %d when trying to open re-created indexfile",
		my_errno);
    goto end;
  }
  /* We are modifing */
  (*org_info)->s->base.options&= ~HA_OPTION_READ_ONLY_DATA;
  VOID(_nisam_readinfo(*org_info,F_WRLCK,0));
  (*org_info)->s->state.records=share.state.records;
  if (share.base.create_time)
    (*org_info)->s->base.create_time=share.base.create_time;
  (*org_info)->s->state.uniq=(*org_info)->this_uniq=
    share.state.uniq;
  (*org_info)->s->state.del=share.state.del;
  (*org_info)->s->state.dellink=share.state.dellink;
  (*org_info)->s->state.empty=share.state.empty;
  (*org_info)->s->state.data_file_length=share.state.data_file_length;
  if (update_state_info(*org_info,UPDATE_TIME | UPDATE_STAT))
    goto end;
  error=0;
end:
  my_afree((gptr) keyinfo);
  my_afree((gptr) recinfo);
  return error;
}

	/* Store long in 1,2,3 or 4 bytes */

static void save_integer(pos,pack_length,value)
byte *pos;
uint pack_length;
ulong value;
{
  switch (pack_length) {
  case 4: int4store(pos,value); break;
  case 3: int3store(pos,value); break;
  case 2: int2store(pos,(uint) value); break;
  case 1: pos[0]= (char) (uchar) value; break;
  default: break;
  }
  return;
}

	/* write suffix to data file if neaded */

static int write_data_suffix(info)
N_INFO *info;
{
  if (info->s->base.options & HA_OPTION_COMPRESS_RECORD &&
      sort_info.fix_datafile)
  {
    char buff[MEMMAP_EXTRA_MARGIN];
    bzero(buff,sizeof(buff));
    if (my_b_write(&info->rec_cache,buff,sizeof(buff)))
    {
      print_error("%d when writing to datafile",my_errno);
      return 1;
    }
    read_cache.end_of_file+=sizeof(buff);
  }
  return 0;
}


	/* Update state and isamchk_time of indexfile */

static int update_state_info(info,update)
N_INFO *info;
uint update;
{
  ISAM_SHARE *share=info->s;
  uint base_pos=uint2korr(info->s->state.header.base_pos);

  if (update & (UPDATE_STAT | UPDATE_SORT | UPDATE_TIME))
  {
    if (offsetof(N_BASE_INFO,rec_per_key) >
	uint2korr(share->state.header.base_info_length))
    {
      VOID(fputs("Internal error: Trying to change base of old table\n",
		 stderr));
    }
    else
    {
      if (update & UPDATE_TIME)
      {
	share->base.isamchk_time= (long) time((time_t*) 0);
	if (!share->base.create_time)
	  share->base.create_time=share->base.isamchk_time;
	if (my_pwrite(share->kfile,(gptr) &share->base.create_time,
		      sizeof(long)*2,
		      base_pos+offsetof(N_BASE_INFO,create_time),
		      MYF(MY_NABP)))
	  goto err;
      }
      if (update & (UPDATE_STAT | UPDATE_SORT))
      {
	if (my_pwrite(share->kfile,(gptr) share->base.rec_per_key,
		      sizeof(long)*share->state.keys+sizeof(uint),
		      base_pos+offsetof(N_BASE_INFO,rec_per_key),
		      MYF(MY_NABP)))
	  goto err;
      }
    }
  }
  {						/* Force update of status */
    int error;
    uint r_locks=share->r_locks,w_locks=share->w_locks;
    share->r_locks=share->w_locks=0;
    error=_nisam_writeinfo(info,2);
    share->r_locks=r_locks; share->w_locks=w_locks;
    if (!error)
      return 0;
  }
err:
  print_error("%d when updateing keyfile",my_errno);
  return 1;
}