source: trunk/src/lbatest/readsect.c@ 107

/******************************************************************************

  readsect.c - simple (dumb) HD sector read program

  Author: Markus Thielen

  Compilation (Watcom): wcl386 -bt=os2 readsect.c

  Copyright (c) 2010 by thi.guten Software development, www.thiguten.de

   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

******************************************************************************/

/*---- includes -------------------------------------------------------------*/

#define INCL_DOS
#define INCL_ERRORS
#define INCL_DOSDEVICES
#define INCL_DOSDEVIOCTL
#include <os2.h>
#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>
#include <stdarg.h>
#include <ctype.h>
#include <string.h>
#include <errno.h>

#define SECTOR_SIZE        512
#define SECTORS_PER_READ   4


/*--- function prototypes ---------------------------------------------------*/

void          usage            (void);

int           read_sectors     (char *drv, unsigned long sectors_to_read, 
                                unsigned long sectors_per_read, FILE *fpo);

void          log              (char *fmt, ...);


/*--- global data -----------------------------------------------------------*/

char *log_fn = NULL;


/*--- start of code ---------------------------------------------------------*/

/******************************************************************************
 * main()
 */
int main(int argc, char **argv)
{
  char drv[50];
  char *output;
  FILE *fpo; /* output file */
  int ret;
  unsigned long sectors_to_read;
  unsigned long loop_sectors_start;
  unsigned long i;
  unsigned long sectors_per_read = 1;

  if (argc < 4) {
    usage();
    return -1;
  }

  if (isalpha(argv[1][0])) {
    sprintf(drv, "\\\\.\\%c", toupper(argv[1][0]));
  } else if (isdigit(argv[1][0])) {
    sprintf(drv, "\\\\.\\Physical_Disk%c", argv[1][0]);
  } else {
    usage();
    return -1;
  }

  /* get sectors to read */
  sectors_to_read = strtoul(argv[2], NULL, 10);

  /* get output file */
  output = argv[3];
  if (*output == '-' && output[1] == 0) {
    /* use stdout */
    fpo = stdout;
  } else {
    fpo = fopen(output, "wb");
    if (!fpo) {
      perror("Failed to open output file");
      return(-1);
    }
  }

  if (argc > 4) {
    if (*argv[4] == '-') {
      /* use a loop from 1 sectors to number specfied */
      loop_sectors_start = 1;
      sectors_per_read = (unsigned long) atoi(argv[4] + 1);
      log("Looping sector count from 1 to %u; not using output file\n",
             sectors_per_read);
      if (fpo && fpo != stdin) {
        fclose(fpo);
        fpo = NULL;
      }

    } else {
      /* just one run */
      sectors_per_read = (unsigned long) atoi(argv[4]);
      loop_sectors_start = sectors_per_read;
    }
    if (sectors_per_read == 0) {
      sectors_per_read = SECTORS_PER_READ;
    }
  }

  if (argc > 5) {
    /* optional log file name */
    log_fn = argv[5];
    unlink(log_fn);
  }

  /* go */
  for (i = loop_sectors_start; i <= sectors_per_read; i++) {
    ret = read_sectors(drv, sectors_to_read, i, fpo);
  }

  if (fpo && fpo != stdout) {
    fclose(fpo);
  }

  log("\nDone\n");
  return ret;

}

/******************************************************************************
 * read_sectors() - read sectors and dump to output file
 */
int read_sectors(char *drv, unsigned long sectors_to_read, 
                 unsigned long sectors_per_read, FILE *fpo)
{
  unsigned long ret;
  HFILE hf_disk;
  unsigned long action;
  unsigned long cb_read;
  char *buf;
  int rc = 0;
  unsigned long cb_take;
  unsigned long sectors_take;
  unsigned long sectors_read = 0;

  buf = calloc(SECTOR_SIZE, sectors_per_read);
  log("\nusing %u sectors per read\n", sectors_per_read);

  /* open drive */
  log("Getting handle for drive %s\n", drv);
  ret = DosOpen(drv, &hf_disk, &action, 0, 0, 
                OPEN_ACTION_OPEN_IF_EXISTS,
                OPEN_SHARE_DENYNONE | OPEN_ACCESS_READONLY,
                NULL);
  if (ret != NO_ERROR) {
    fprintf(stderr, "Failed to open disk %s for reading: %d\n", drv, ret);
    return -1;
  }

  /* go... */
  while (sectors_read < sectors_to_read) {

    sectors_take = min(sectors_to_read - sectors_read, sectors_per_read);
    cb_take = SECTOR_SIZE * sectors_take;

    log("\rReading %u sector(s) (%u sectors read)...",
           sectors_take, sectors_read);
    ret = DosRead(hf_disk, buf, cb_take, &cb_read);
    if (ret != NO_ERROR) {
      fprintf(stderr, "\nFailed to read from disk %s, code %d\n", drv, ret);
      rc = -1;
      break;
    }

    if (cb_read == 0) {
      break;
    }

    if (cb_read != cb_take) {
      log("\n\nRead only %u instead of %u bytes...\n\n", cb_read, cb_take);
      break;
    }

    sectors_read += cb_read / SECTOR_SIZE;
    if (fpo && fwrite(buf, 1, cb_read, fpo) != cb_read) {
      perror("Failed to write to output file");
      rc = -1;
      break;
    }

  }

  DosClose(hf_disk);
  free(buf);

  return rc;
}

/******************************************************************************
 * usage() - print usage summary to STDOUT
 */
void usage(void)
{
  printf("readsect.exe - read HD sectors and store them to an output file.\n"
         "Call with a drive letter (for logical drive) or 1-based disk number (for\n"
         "physical drive)\n\n"
         "Usage:\n\n"
         "readsect <drive letter|number> <number of sectors> <outfile>\n"
         "         [read buffer size] [log file]\n"
         "where:\n"
         "drive letter         drive letter of logical drive to read from\n"
         "drive number         1-based physical disk number to read from\n"
         "number of sectors    number of sectors to read (e.g. 1024)\n"
         "outfile              path and filename of output file\n"
         "read buffer size     optional buffer size in number of sectors (512 byte)\n"
         "                      (default is %d sectors)\n"
         "log file             optional log file name\n",
         SECTORS_PER_READ);
}


/*******************************************************************************
 * log() - log a string to the log file (if any)
 */
void log(char *fmt, ...)
{
  va_list arglist;
  FILE *fp;
  char buf[500];

  /* assemble arguments */
  va_start(arglist, fmt);
  vsprintf(buf, fmt, arglist);

  if (log_fn && (fp = fopen(log_fn, "a")) != NULL) {
    /* write string to log file */
    fprintf(fp, buf);
    fflush(fp);
    fclose(fp);
  }

  /* write to stdout */
  printf(buf);

}