tools/adflib/adf_dump.c

   1 /*
   2  * ADF Library
   3  *
   4  * adf_dump.c
   5  *
   6  * Amiga Dump File specific routines
   7  */
   8
   9 #define _FILE_OFFSET_BITS 64
  10
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <errno.h>
  14
  15 #include "adf_defs.h"
  16 #include "adf_str.h"
  17 #include "adf_disk.h"
  18 #include "adf_nativ.h"
  19 #include "adf_err.h"
  20
  21 extern struct Env adfEnv;
  22
  23 /*
  24  * adfInitDumpDevice
  25  *
  26  */
  27 RETCODE adfInitDumpDevice(struct Device* dev, char* name, BOOL ro)
  28 {
  29     struct nativeDevice* nDev;
  30     long size;
  31
  32     nDev = (struct nativeDevice*)malloc(sizeof(struct nativeDevice));
  33     if (!nDev) {
  34         (*adfEnv.eFct)("adfInitDumpDevice : malloc");
  35         return RC_MALLOC;
  36     }
  37     dev->nativeDev = nDev;
  38
  39     dev->readOnly = ro;
  40     errno = 0;
  41     if (!ro) {
  42         nDev->fd = fopen(name,"rb+");
  43         /* force read only */
  44         if (!nDev->fd && (errno==EACCES || errno==EROFS) ) {
  45             nDev->fd = fopen(name,"rb");
  46             dev->readOnly = TRUE;
  47             if (nDev->fd)
  48                 (*adfEnv.wFct)("myInitDevice : fopen, read-only mode forced");
  49         }
  50     }
  51     else
  52         /* read only requested */
  53         nDev->fd = fopen(name,"rb");
  54
  55     if (!nDev->fd) {
  56         free(nDev);
  57         (*adfEnv.eFct)("myInitDevice : fopen");
  58         return RC_ERROR;
  59     }
  60
  61     /* determines size */
  62     fseek(nDev->fd, 0, SEEK_END);
  63     size = ftell(nDev->fd);
  64     fseek(nDev->fd, 0, SEEK_SET);
  65
  66     /* Let's make some guesses about geometry...
  67      */
  68     dev->size = size;
  69     if (size <= (11 * 80 * 512 * 2)) {
  70         dev->sectors = 11;
  71         dev->heads = 2;
  72     } else {
  73         dev->sectors = 128;
  74         dev->heads   = 4;
  75     }
  76     dev->cylinders = dev->size / 512 / dev->sectors / dev->heads;
  77
  78     return RC_OK;
  79 }
  80
  81
  82 /*
  83  * adfReadDumpSector
  84  *
  85  */
  86 RETCODE adfReadDumpSector(struct Device *dev, SECTNUM n, int size, unsigned char* buf)
  87 {
  88     struct nativeDevice* nDev;
  89     int r;
  90     long seek = 512 * (long)n;
  91
  92 // printf("R 0x%08lx\n", seek);
  93     nDev = (struct nativeDevice*)dev->nativeDev;
  94     r = fseek(nDev->fd, seek, SEEK_SET);
  95 //printf("nnn=%ld size=%d\n",n,size);
  96     if (r==-1)
  97         return RC_ERROR;
  98 //puts("123");
  99     if ((r=fread(buf, 1, size, nDev->fd))!=size) {
 100 //printf("rr=%d\n",r);
 101         return RC_ERROR;
 102 }
 103 //puts("1234");
 104
 105     return RC_OK;
 106 }
 107
 108
 109 /*
 110  * adfWriteDumpSector
 111  *
 112  */
 113 RETCODE adfWriteDumpSector(struct Device *dev, SECTNUM n, int size, unsigned char* buf)
 114 {
 115     struct nativeDevice* nDev;
 116     int r;
 117     long seek = 512 * (long)n;
 118
 119     nDev = (struct nativeDevice*)dev->nativeDev;
 120
 121 // printf("W 0x%08lx\n", seek);
 122     r=fseek(nDev->fd, seek, SEEK_SET);
 123     if (r==-1)
 124         return RC_ERROR;
 125
 126     if ( fwrite(buf, 1, size, nDev->fd)!=(unsigned int)(size) )
 127         return RC_ERROR;
 128
 129     return RC_OK;
 130 }
 131
 132
 133 /*
 134  * adfReleaseDumpDevice
 135  *
 136  */
 137 RETCODE adfReleaseDumpDevice(struct Device *dev)
 138 {
 139     struct nativeDevice* nDev;
 140
 141     if (!dev->nativeDev)
 142                 return RC_ERROR;
 143
 144     nDev = (struct nativeDevice*)dev->nativeDev;
 145     fclose(nDev->fd);
 146
 147     free(nDev);
 148
 149     return RC_OK;
 150 }
 151
 152
 153 /*
 154  * adfCreateHdFile
 155  *
 156  */
 157 RETCODE adfCreateHdFile(struct Device* dev, char* volName, int volType)
 158 {
 159
 160     if (dev==NULL) {
 161         (*adfEnv.eFct)("adfCreateHdFile : dev==NULL");
 162         return RC_ERROR;
 163     }
 164     dev->volList =(struct Volume**) malloc(sizeof(struct Volume*));
 165     if (!dev->volList) {
 166                 (*adfEnv.eFct)("adfCreateHdFile : unknown device type");
 167         return RC_ERROR;
 168     }
 169
 170     dev->volList[0] = adfCreateVol( dev, 0L, (long)dev->cylinders, 2, volName, volType );
 171     if (dev->volList[0]==NULL) {
 172         free(dev->volList);
 173         return RC_ERROR;
 174     }
 175
 176     dev->nVol = 1;
 177     dev->devType = DEVTYPE_HARDFILE;
 178
 179     return RC_OK;
 180 }
 181
 182
 183 /*
 184  * adfCreateDumpDevice
 185  *
 186  * returns NULL if failed
 187  */
 188     struct Device*
 189 adfCreateDumpDevice(char* filename, long cylinders, long heads, long sectors)
 190 {
 191     struct Device* dev;
 192     unsigned char buf[LOGICAL_BLOCK_SIZE];
 193     struct nativeDevice* nDev;
 194 //    long i;
 195     int r;
 196
 197     dev=(struct Device*)malloc(sizeof(struct Device));
 198     if (!dev) {
 199         (*adfEnv.eFct)("adfCreateDumpDevice : malloc dev");
 200         return NULL;
 201     }
 202     nDev = (struct nativeDevice*)malloc(sizeof(struct nativeDevice));
 203     if (!nDev) {
 204         free(dev);
 205         (*adfEnv.eFct)("adfCreateDumpDevice : malloc nDev");
 206         return NULL;
 207     }
 208     dev->nativeDev = nDev;
 209
 210     nDev->fd = (FILE*)fopen(filename,"wb");
 211     if (!nDev->fd) {
 212         free(nDev); free(dev);
 213         (*adfEnv.eFct)("adfCreateDumpDevice : fopen");
 214         return NULL;
 215     }
 216
 217 /*    for(i=0; i<cylinders*heads*sectors; i++)
 218         fwrite(buf, sizeof(unsigned char), 512 , nDev->fd);
 219 */
 220     r=fseek(nDev->fd, ((cylinders*heads*sectors)-1)*LOGICAL_BLOCK_SIZE, SEEK_SET);
 221     if (r==-1) {
 222         fclose(nDev->fd); free(nDev); free(dev);
 223         (*adfEnv.eFct)("adfCreateDumpDevice : fseek");
 224         return NULL;
 225     }
 226
 227     fwrite(buf, LOGICAL_BLOCK_SIZE, 1, nDev->fd);
 228
 229     fclose(nDev->fd);
 230
 231     nDev->fd=(FILE*)fopen(filename,"rb+");
 232     if (!nDev->fd) {
 233         free(nDev); free(dev);
 234         (*adfEnv.eFct)("adfCreateDumpDevice : fopen");
 235         return NULL;
 236     }
 237     dev->cylinders = cylinders;
 238     dev->heads = heads;
 239     dev->sectors = sectors;
 240     dev->size = cylinders*heads*sectors* LOGICAL_BLOCK_SIZE;
 241
 242     if (dev->size==80*11*2*LOGICAL_BLOCK_SIZE)
 243         dev->devType = DEVTYPE_FLOPDD;
 244     else if (dev->size==80*22*2*LOGICAL_BLOCK_SIZE)
 245         dev->devType = DEVTYPE_FLOPHD;
 246         else
 247         dev->devType = DEVTYPE_HARDDISK;
 248
 249     dev->nVol = 0;
 250     dev->isNativeDev = FALSE;
 251     dev->readOnly = FALSE;
 252
 253     return(dev);
 254 }
 255
 256 /*##################################################################################*/
 257