home *** CD-ROM | disk | FTP | other *** search
/ Mega Top 1 / os2_top1.zip / os2_top1 / APPS / ARCH / PAX20-2 / DISKACC2.C < prev    next >
C/C++ Source or Header  |  1993-12-24  |  4KB  |  194 lines
  1. /* DISKACC2.C
  2.  *
  3.  * Autor:    Kai Uwe Rommel
  4.  * Datum:    Thu 28-Dec-1989
  5.  * Stand:    Wed 22-Jul-1992
  6.  *
  7.  * Compiler: 32-bit OS/2
  8.  * System:   OS/2 ab 2.0
  9.  *
  10.  * Direct disk access library for OS/2 2.0 protected mode.
  11.  */
  12.  
  13.  
  14. #define INCL_DOSDEVICES
  15. #define INCL_DOSDEVIOCTL
  16. #define INCL_NOPM
  17. #include <os2.h>
  18. #include <string.h>
  19. #include <ctype.h>
  20.  
  21. #include "diskacc2.h"
  22.  
  23.  
  24. #define PHYSICAL     0x1000
  25. #define CATEGORY(x)  (((x) & PHYSICAL) ? IOCTL_PHYSICALDISK : IOCTL_DISK)
  26. #define HANDLE(x)    ((x) & ~PHYSICAL)
  27.  
  28.  
  29. #pragma pack(1)
  30.  
  31. typedef struct
  32. {
  33.   BYTE   bCommand;
  34.   USHORT usHead;
  35.   USHORT usCylinder;
  36.   USHORT usFirstSector;
  37.   USHORT cSectors;
  38.   struct
  39.   {
  40.     USHORT usSectorNumber;
  41.     USHORT usSectorSize;
  42.   }
  43.   TrackTable[64];
  44. }
  45. TRACK;
  46.  
  47.  
  48. ULONG DosDevIOCtl32(PVOID pData, ULONG cbData, PVOID pParms, ULONG cbParms,
  49.             ULONG usFunction, HFILE hDevice)
  50. {
  51.   ULONG ulParmLengthInOut = cbParms, ulDataLengthInOut = cbData;
  52.   return DosDevIOCtl(HANDLE(hDevice), CATEGORY(hDevice), usFunction,
  53.              pParms, cbParms, &ulParmLengthInOut, 
  54.              pData, cbData, &ulDataLengthInOut);
  55. }
  56.  
  57.  
  58. static int test_sector(int handle, int side, int track, int sector)
  59. {
  60.   char buffer[1024];
  61.   TRACK trk;
  62.  
  63.   trk.bCommand      = 0;
  64.   trk.usHead        = side;
  65.   trk.usCylinder    = track;
  66.   trk.usFirstSector = 0;
  67.   trk.cSectors      = 1;
  68.  
  69.   trk.TrackTable[0].usSectorNumber = sector;
  70.   trk.TrackTable[0].usSectorSize   = 512;
  71.  
  72.   return (DosDevIOCtl32(buffer, sizeof(buffer), &trk, sizeof(trk), 
  73.                         DSK_READTRACK, handle) == 0);
  74. }
  75.  
  76.  
  77. int DskOpen(char *drv, unsigned *sides, unsigned *tracks, unsigned *sectors)
  78. {
  79.   BIOSPARAMETERBLOCK bpb;
  80.   HFILE handle;
  81.   USHORT physical;
  82.   ULONG action;
  83.   BYTE cmd = 0;
  84.  
  85.   if ( isalpha(drv[0]) && drv[1] == ':' && drv[2] == 0 )
  86.   {
  87.     if ( DosOpen(drv, &handle, &action, 0L, FILE_NORMAL, FILE_OPEN,
  88.          OPEN_FLAGS_DASD | OPEN_FLAGS_FAIL_ON_ERROR |
  89.          OPEN_ACCESS_READWRITE | OPEN_SHARE_DENYREADWRITE, 0L) != 0 )
  90.       return -1;
  91.   }
  92.   else if ( drv[0] == '$' && isdigit(drv[1]) && drv[2] == ':' && drv[3] == 0 )
  93.   {
  94.     if ( DosPhysicalDisk(INFO_GETIOCTLHANDLE, &physical, sizeof(physical), 
  95.              drv + 1, strlen(drv + 1)) != 0 )
  96.       return -1;
  97.     handle = physical | PHYSICAL;
  98.   }
  99.   else
  100.     return -1;
  101.  
  102.  
  103.   if ( DosDevIOCtl32(&bpb, sizeof(bpb), &cmd, sizeof(cmd), 
  104.              DSK_GETDEVICEPARAMS, handle) != 0 
  105.        || DosDevIOCtl32(0L, 0, &cmd, sizeof(cmd), DSK_LOCKDRIVE, handle) != 0 )
  106.   {
  107.     if ( handle & PHYSICAL )
  108.       DosPhysicalDisk(INFO_FREEIOCTLHANDLE, NULL, 0, 
  109.               &physical, sizeof(physical));
  110.     else
  111.       DosClose(handle);
  112.     return -1;
  113.   }
  114.  
  115.   *sectors = bpb.usSectorsPerTrack;
  116.   *tracks  = bpb.cCylinders;
  117.   *sides   = bpb.cHeads;
  118.  
  119.   if ( *sectors >= 15 )
  120.     if ( !test_sector(handle, 0, 0, 15) )
  121.     {
  122.       if ( *sectors == 15 )
  123.         *tracks = 40;
  124.  
  125.       *sectors = 9;
  126.     }
  127.  
  128.   return handle;
  129. }
  130.  
  131.  
  132. int DskClose(int handle)
  133. {
  134.   BYTE cmd = 0;
  135.   USHORT physical = handle & ~PHYSICAL;
  136.  
  137.   DosDevIOCtl32(0L, 0, &cmd, sizeof(cmd), DSK_UNLOCKDRIVE, handle);
  138.  
  139.   if ( handle & PHYSICAL )
  140.     return DosPhysicalDisk(INFO_FREEIOCTLHANDLE, NULL, 0, 
  141.                &physical, sizeof(physical));
  142.   else
  143.     return DosClose(handle);
  144. }
  145.  
  146.  
  147. int DskRead(int handle, unsigned side, unsigned  track,
  148.             unsigned sector, unsigned nsects, void *buf)
  149. {
  150.   TRACK trk;
  151.   unsigned cnt;
  152.  
  153.   trk.bCommand      = 0;
  154.   trk.usHead        = side;
  155.   trk.usCylinder    = track;
  156.   trk.usFirstSector = 0;
  157.   trk.cSectors      = nsects;
  158.  
  159.   for ( cnt = 0; cnt < nsects; cnt++ )
  160.   {
  161.     trk.TrackTable[cnt].usSectorNumber = sector + cnt;
  162.     trk.TrackTable[cnt].usSectorSize   = 512;
  163.   }
  164.  
  165.   return DosDevIOCtl32(buf, nsects * 512, &trk, sizeof(trk), 
  166.                        DSK_READTRACK, handle);
  167. }
  168.  
  169.  
  170. int DskWrite(int handle, unsigned side, unsigned  track,
  171.              unsigned sector, unsigned nsects, void *buf)
  172. {
  173.   TRACK trk;
  174.   unsigned cnt;
  175.  
  176.   trk.bCommand      = 0;
  177.   trk.usHead        = side;
  178.   trk.usCylinder    = track;
  179.   trk.usFirstSector = 0;
  180.   trk.cSectors      = nsects;
  181.  
  182.   for ( cnt = 0; cnt < nsects; cnt++ )
  183.   {
  184.     trk.TrackTable[cnt].usSectorNumber = sector + cnt;
  185.     trk.TrackTable[cnt].usSectorSize   = 512;
  186.   }
  187.  
  188.   return DosDevIOCtl32(buf, nsects * 512, &trk, sizeof(trk), 
  189.                        DSK_WRITETRACK, handle);
  190. }
  191.  
  192.  
  193. /* Ende DISKACC2.C */
  194.