tools/adflib/adf_dump.c

   1 /*
   2  * ADF Library
   3  *
   4  * adf_dump.c
   5  *
   6  * Amiga Dump File specific routines
   7  */
   8
   9 #include<stdio.h>
  10 #include<stdlib.h>
  11 #include<errno.h>
  12
  13 #include"adf_defs.h"
  14 #include"adf_str.h"
  15 #include"adf_disk.h"
  16 #include"adf_nativ.h"
  17 #include"adf_err.h"
  18
  19 extern struct Env adfEnv;
  20
  21 /*
  22  * adfInitDumpDevice
  23  *
  24  */
  25 RETCODE adfInitDumpDevice(struct Device* dev, char* name, BOOL ro)
  26 {
  27     struct nativeDevice* nDev;
  28     long size;
  29
  30     nDev = (struct nativeDevice*)dev->nativeDev;
  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     dev->size = size;
  67
  68     return RC_OK;
  69 }
  70
  71
  72 /*
  73  * adfReadDumpSector
  74  *
  75  */
  76 RETCODE adfReadDumpSector(struct Device *dev, long n, int size, unsigned char* buf)
  77 {
  78     struct nativeDevice* nDev;
  79     int r;
  80 //puts("adfReadDumpSector");
  81     nDev = (struct nativeDevice*)dev->nativeDev;
  82     r = fseek(nDev->fd, 512*n, SEEK_SET);
  83 //printf("nnn=%ld size=%d\n",n,size);
  84     if (r==-1)
  85         return RC_ERROR;
  86 //puts("123");
  87     if ((r=fread(buf, 1, size, nDev->fd))!=size) {
  88 //printf("rr=%d\n",r);
  89         return RC_ERROR;
  90 }
  91 //puts("1234");
  92
  93     return RC_OK;
  94 }
  95
  96
  97 /*
  98  * adfWriteDumpSector
  99  *
 100  */
 101 RETCODE adfWriteDumpSector(struct Device *dev, long n, int size, unsigned char* buf)
 102 {
 103     struct nativeDevice* nDev;
 104     int r;
 105
 106     nDev = (struct nativeDevice*)dev->nativeDev;
 107
 108     r=fseek(nDev->fd, 512*n, SEEK_SET);
 109     if (r==-1)
 110         return RC_ERROR;
 111
 112     if ( fwrite(buf, 1, size, nDev->fd)!=(unsigned int)(size) )
 113         return RC_ERROR;
 114 //puts("adfWriteDumpSector");
 115     return RC_OK;
 116 }
 117
 118
 119 /*
 120  * adfReleaseDumpDevice
 121  *
 122  */
 123 RETCODE adfReleaseDumpDevice(struct Device *dev)
 124 {
 125     struct nativeDevice* nDev;
 126
 127     if (!dev->nativeDev)
 128                 return RC_ERROR;
 129
 130     nDev = (struct nativeDevice*)dev->nativeDev;
 131     fclose(nDev->fd);
 132
 133     free(nDev);
 134
 135     return RC_OK;
 136 }
 137
 138
 139 /*
 140  * adfCreateHdFile
 141  *
 142  */
 143 RETCODE adfCreateHdFile(struct Device* dev, char* volName, int volType)
 144 {
 145
 146     if (dev==NULL) {
 147         (*adfEnv.eFct)("adfCreateHdFile : dev==NULL");
 148         return RC_ERROR;
 149     }
 150     dev->volList =(struct Volume**) malloc(sizeof(struct Volume*));
 151     if (!dev->volList) {
 152                 (*adfEnv.eFct)("adfCreateHdFile : unknown device type");
 153         return RC_ERROR;
 154     }
 155
 156     dev->volList[0] = adfCreateVol( dev, 0L, (long)dev->cylinders, volName, volType );
 157     if (dev->volList[0]==NULL) {
 158         free(dev->volList);
 159         return RC_ERROR;
 160     }
 161
 162     dev->nVol = 1;
 163     dev->devType = DEVTYPE_HARDFILE;
 164
 165     return RC_OK;
 166 }
 167
 168
 169 /*
 170  * adfCreateDumpDevice
 171  *
 172  * returns NULL if failed
 173  */
 174     struct Device*
 175 adfCreateDumpDevice(char* filename, long cylinders, long heads, long sectors)
 176 {
 177     struct Device* dev;
 178     unsigned char buf[LOGICAL_BLOCK_SIZE];
 179     struct nativeDevice* nDev;
 180 //    long i;
 181     int r;
 182
 183     dev=(struct Device*)malloc(sizeof(struct Device));
 184     if (!dev) {
 185         (*adfEnv.eFct)("adfCreateDumpDevice : malloc dev");
 186         return NULL;
 187     }
 188     nDev = (struct nativeDevice*)malloc(sizeof(struct nativeDevice));
 189     if (!nDev) {
 190         free(dev);
 191         (*adfEnv.eFct)("adfCreateDumpDevice : malloc nDev");
 192         return NULL;
 193     }
 194     dev->nativeDev = nDev;
 195
 196     nDev->fd = (FILE*)fopen(filename,"wb");
 197     if (!nDev->fd) {
 198         free(nDev); free(dev);
 199         (*adfEnv.eFct)("adfCreateDumpDevice : fopen");
 200         return NULL;
 201     }
 202
 203 /*    for(i=0; i<cylinders*heads*sectors; i++)
 204         fwrite(buf, sizeof(unsigned char), 512 , nDev->fd);
 205 */
 206     r=fseek(nDev->fd, ((cylinders*heads*sectors)-1)*LOGICAL_BLOCK_SIZE, SEEK_SET);
 207     if (r==-1) {
 208         fclose(nDev->fd); free(nDev); free(dev);
 209         (*adfEnv.eFct)("adfCreateDumpDevice : fseek");
 210         return NULL;
 211     }
 212
 213     fwrite(buf, LOGICAL_BLOCK_SIZE, 1, nDev->fd);
 214
 215     fclose(nDev->fd);
 216
 217     nDev->fd=(FILE*)fopen(filename,"rb+");
 218     if (!nDev->fd) {
 219         free(nDev); free(dev);
 220         (*adfEnv.eFct)("adfCreateDumpDevice : fopen");
 221         return NULL;
 222     }
 223     dev->cylinders = cylinders;
 224     dev->heads = heads;
 225     dev->sectors = sectors;
 226     dev->size = cylinders*heads*sectors* LOGICAL_BLOCK_SIZE;
 227
 228     if (dev->size==80*11*2*LOGICAL_BLOCK_SIZE)
 229         dev->devType = DEVTYPE_FLOPDD;
 230     else if (dev->size==80*22*2*LOGICAL_BLOCK_SIZE)
 231         dev->devType = DEVTYPE_FLOPHD;
 232         else
 233         dev->devType = DEVTYPE_HARDDISK;
 234
 235     dev->nVol = 0;
 236     dev->isNativeDev = FALSE;
 237     dev->readOnly = FALSE;
 238
 239     return(dev);
 240 }
 241
 242 /*##################################################################################*/
 243