/* $Revision Header *** Header built automatically - do not edit! ***********
 *
 *	(C) Copyright 1992 by Torsten Jürgeleit
 *
 *	Name .....: tool.c
 *	Created ..: Wednesday 19-Feb-92 10:05:27
 *	Revision .: 2
 *
 *	Date        Author                 Comment
 *	=========   ====================   ====================
 *	27-Apr-92   Torsten Jürgeleit      add no library option
 *	11-Mar-92   Torsten Jürgeleit      argv[ARGUMENT_UNIT] is a (BYTE *)
 *	19-Feb-92   Torsten Jürgeleit      Created this file!
 *
 ****************************************************************************
 *
 *	Tool for manipulating hardblocks
 *
 * $Revision Header ********************************************************/

	/* Includes */

#include <exec/types.h>
#include <devices/hardblocks.h>
#include <libraries/arpbase.h>
#include <functions.h>
#include <stdlib.h>
#ifndef LINK_TEST
#include "hardblocks.h"
#else LINK_TEST
#include "hardblocks_link.h"
#endif LINK_TEST

	/* Defines */

#define DEFAULT_DEVICE		"scsi.device"
#define DEFAULT_UNIT		"0"

#define MAX_ARGUMENTS		11

#define ARGUMENT_DEVICE		0
#define ARGUMENT_UNIT		1
#define ARGUMENT_FILE		2
#define ARGUMENT_LOAD		3
#define ARGUMENT_RESTORE	4
#define ARGUMENT_DEFAULT	5
#define ARGUMENT_SHOW		6
#define ARGUMENT_OUTPUT		7
#define ARGUMENT_SAVE		8
#define ARGUMENT_BACKUP		9
#define ARGUMENT_REMOVE		10

	/* Externals */

IMPORT struct DOSBase   *DOSBase;

	/* Globals */

struct ArpBase	*ArpBase;
#ifndef LINK_TEST
struct Library	*HardBlocksBase;
#endif LINK_TEST

BYTE template[]  = "Device,Unit,FILE/k,LOAD/s,RESTORE/s,DEFAULT/s,SHOW/s,"
		   "OUTPUT/k,SAVE/s,BACKUP/s,REMOVE/s",
     xtra_help[] = "HBtool v1.1 - Copyright © 1992 Torsten Jürgeleit\n\n"
		   "Usage: HBtool [Device] [Unit] [FILE name] [LOAD]"
		   " [RESTORE] [DEFAULT] [SHOW] [OUTPUT file] [SAVE]"
		   " [BACKUP] [REMOVE]\n"
		   "\t[Device]      = device name (default: scsi.device)\n"
		   "\t[Unit]        = device unit num (default 0)\n"
		   "\t[FILE name]   = file to restore/save hardblocks\n"
		   "\t[LOAD]        = load hardblocks from device (default)\n"
		   "\t[RESTORE]     = restore hardblocks from file\n"
		   "\t[DEFAULT]     = create standard rigid disk block\n"
		   "\t[SHOW]        = show currently loaded hardblocks (default)\n"
		   "\t[OUTPUT file] = output file for show (default: NULL -> stdout)\n"
		   "\t[SAVE]        = save currently loaded hardblocks to device\n"
		   "\t[BACKUP]      = backup currently loaded hardblocks to file\n"
		   "\t[REMOVE]      = delete rigid disk block from device";

	/* Prototypes */

LONG _main(LONG alen, BYTE *aptr);
BOOL safety_check(BYTE *device, ULONG unit);

	/* Main routine - no startup code */

   LONG
_main(LONG alen, BYTE *aptr)
{
   LONG return_code = RETURN_FAIL;

   /* First open ARP library */
   if (!(ArpBase = OpenLibrary(ArpName, ArpVersion))) {
      Write(Output(), "Need ARP library V39+\n", 22L);
   } else {
#ifndef LINK_TEST
      if (!(HardBlocksBase = OpenLibrary(HardBlocksName,
						      HardBlocksVersion))) {
	 Puts("Need hardblocks library");
      } else {
#endif LINK_TEST
	 BYTE   *argv[MAX_ARGUMENTS];
	 USHORT i;

	 /* Clear argument array */
	 for (i = 0; i < MAX_ARGUMENTS; i++) {
	    argv[i] = NULL;
	 }

	 /* Parse command line arguments */
	 if (GADS(aptr, alen, &xtra_help[0], &argv[0], &template[0]) < 0) {
	    Puts(argv[0]);
	 } else {
	    struct RigidDiskBlock  rdb;
	    BPTR   fh;
	    BYTE   *device, *file = argv[ARGUMENT_FILE];
	    ULONG  unit;
	    USHORT error;

	    /* Install default arguments if not present */
	    if (!argv[ARGUMENT_DEVICE]) {
	       argv[ARGUMENT_DEVICE] = DEFAULT_DEVICE;
	    }
	    device = argv[ARGUMENT_DEVICE];
	    if (!argv[ARGUMENT_UNIT]) {
	       argv[ARGUMENT_UNIT] = DEFAULT_UNIT;
	    }
	    unit = Atol(argv[ARGUMENT_UNIT]);
	    if (!argv[ARGUMENT_LOAD] && !argv[ARGUMENT_RESTORE] &&
			!argv[ARGUMENT_DEFAULT] && !argv[ARGUMENT_REMOVE]) {
	       argv[ARGUMENT_LOAD] = (BYTE *)-1L;
	    }
	    if (!argv[ARGUMENT_SHOW] && !argv[ARGUMENT_SAVE] &&
			 !argv[ARGUMENT_BACKUP] && !argv[ARGUMENT_REMOVE]) {
	       argv[ARGUMENT_SHOW] = (BYTE *)-1L;
	    }

	    /* Get output file handle for show */
	    if (argv[ARGUMENT_SHOW]) {
	       BYTE *output = argv[ARGUMENT_OUTPUT];

	       if (!output) {
		  fh = Output();
	       } else {
		  if (!(fh = Open(output, (LONG)MODE_NEWFILE))) {
		     Printf("Can't open '%s'\n", output);
		     error = HBERR_FILE_OPEN_FAILED;
		  }
	       }
	    }

	    /* Load hardblocks from device */
	    if (!error && argv[ARGUMENT_LOAD]) {
	       Printf("Loading hardblocks from unit %ld of `%s'\n", unit,
								    device);
	       if (!(error = LoadHardBlocks(&rdb, device, unit))) {

		  /* Now play with hardblocks data */
		  if (argv[ARGUMENT_SHOW]) {
		     error = PrintHardBlocks(&rdb, fh);
		  }
		  if (!error && argv[ARGUMENT_BACKUP]) {
		     if (!file) {
			Printf("No backup file name\n");
			error = HBERR_FILE_OPEN_FAILED;
		     } else {
			Printf("Backup hardblocks to `%s'\n", file);
			error = BackupHardBlocks(&rdb, file);
		     }
		  }
		  FreeHardBlocks(&rdb);
	       }
	    }
	    
	    /* Restore hardblocks from file */
	    if (!error && argv[ARGUMENT_RESTORE]) {
	       if (!file) {
		  Printf("No restore file name\n");
		  error = HBERR_FILE_OPEN_FAILED;
	       } else {
		  Printf("Restoring hardblocks from `%s'\n", file);
		  if (!(error = RestoreHardBlocks(&rdb, file))) {

		     /* Now play with hardblocks data */
		     if (argv[ARGUMENT_SHOW]) {
			error = PrintHardBlocks(&rdb, fh);
		     }
		     if (!error && argv[ARGUMENT_SAVE]) {
			Printf("Saving hardblocks to unit %ld of"
						   " `%s'\n", unit, device);
			if (safety_check(device, unit) == TRUE) {
			   error = SaveHardBlocks(&rdb, device, unit);
			}
		     }
		     FreeHardBlocks(&rdb);
		  }
	       }
	    }

	    /* Create standard rigid disk block */
	    if (!error && argv[ARGUMENT_DEFAULT]) {
	       Printf("Creating standard rigid disk block for unit %ld"
						" of `%s'\n", unit, device);
	       if (!(error = InitRigidDiskBlock(&rdb, device, unit))) {

		  /* Now play with hardblocks data */
		  if (argv[ARGUMENT_SHOW]) {
		     error = PrintHardBlocks(&rdb, fh);
		  }
		  if (!error && argv[ARGUMENT_SAVE]) {
		     Printf("Saving hardblocks to unit %ld of `%s'\n", unit,
								    device);
		     if (safety_check(device, unit) == TRUE) {
			error = SaveHardBlocks(&rdb, device, unit);
		     }
		  }
		  if (!error && argv[ARGUMENT_BACKUP]) {
		     if (!file) {
			Printf("No backup file\n");
			error = HBERR_FILE_OPEN_FAILED;
		     } else {
			Printf("Backup hardblocks to `%s'\n", file);
			error = BackupHardBlocks(&rdb, file);
		     }
		  }
		  FreeHardBlocks(&rdb);
	       }
	    }

	    /* Delete rigid disk block */
	    if (!error && argv[ARGUMENT_REMOVE]) {
	       Printf("Removing hardblocks from unit %ld of `%s'\n", unit,
								    device);
	       if (safety_check(device, unit) == TRUE) {
		  error = RemoveHardBlocks(device, unit);
	       }
	    }

	    /* Close output file handle opened for show */
	    if (argv[ARGUMENT_SHOW] && argv[ARGUMENT_OUTPUT]) {
	       Close(fh);
	    }

	    /* Print error msg */
	    if (error) {
	       Printf("Error: primary=%d   secondary=%ld\n", error, IoErr());
	    } else {
	       return_code = RETURN_OK;
	    }
	 }
#ifndef LINK_TEST
	 CloseLibrary(HardBlocksBase);
      }
#endif LINK_TEST
      CloseLibrary(ArpBase);
   }

   /* MANX crt0.asm forget to close DOS library, so we have to do it */
   CloseLibrary(DOSBase);
   return(return_code);
}
	/* Safety check before any writing to device unit */

   STATIC BOOL
safety_check(BYTE *device, ULONG unit)
{
   BYTE buffer[MaxInputBuf];
   BOOL answer = FALSE;

   Printf("DANGER: Do you really want to change hardblocks on unit %ld of\n"
	  "        device `%s' (YES|NO)? ", unit, device);
   ReadLine(&buffer[0]);
   if (strcmp(&buffer[0], "YES")) {
      Puts("Change aborted");
   } else {
      answer = TRUE;
   }
   return(answer);
}