reactos/lib/kernel32/file/tape.c

   1 /* $Id$
   2  *
   3  * COPYRIGHT:       See COPYING in the top level directory
   4  * PROJECT:         ReactOS system libraries
   5  * FILE:            lib/kernel32/file/tape.c
   6  * PURPOSE:         Tape functions
   7  * PROGRAMMER:      Ariadne ( ariadne@xs4all.nl)
   8  * UPDATE HISTORY:
   9  *                  Created 01/11/98
  10  */
  11
  12 /* INCLUDES *****************************************************************/
  13
  14 #include <k32.h>
  15
  16 #define NDEBUG
  17 #include "../include/debug.h"
  18
  19 /* FUNCTIONS ****************************************************************/
  20
  21 /*
  22  * @implemented
  23  */
  24 DWORD STDCALL
  25 CreateTapePartition (HANDLE hDevice,
  26                      DWORD dwPartitionMethod,
  27                      DWORD dwCount,
  28                      DWORD dwSize)
  29 {
  30   TAPE_CREATE_PARTITION TapeCreatePartition;
  31   IO_STATUS_BLOCK IoStatusBlock;
  32   DWORD ErrorCode;
  33   NTSTATUS Status;
  34
  35   TapeCreatePartition.Method = dwPartitionMethod;
  36   TapeCreatePartition.Count = dwCount;
  37   TapeCreatePartition.Size = dwSize;
  38
  39   Status = NtDeviceIoControlFile (hDevice,
  40                                   NULL,
  41                                   NULL,
  42                                   NULL,
  43                                   &IoStatusBlock,
  44                                   IOCTL_TAPE_CREATE_PARTITION,
  45                                   &TapeCreatePartition,
  46                                   sizeof(TAPE_CREATE_PARTITION),
  47                                   NULL,
  48                                   0);
  49   if (!NT_SUCCESS(Status))
  50     {
  51       ErrorCode = RtlNtStatusToDosError(Status);
  52       SetLastError (ErrorCode);
  53       return ErrorCode;
  54     }
  55
  56   return ERROR_SUCCESS;
  57 }
  58
  59
  60 /*
  61  * @implemented
  62  */
  63 DWORD STDCALL
  64 EraseTape (HANDLE hDevice,
  65            DWORD dwEraseType,
  66            BOOL bImmediate)
  67 {
  68   TAPE_ERASE TapeErase;
  69   IO_STATUS_BLOCK IoStatusBlock;
  70   DWORD ErrorCode;
  71   NTSTATUS Status;
  72
  73   TapeErase.Type = dwEraseType;
  74   TapeErase.Immediate = (BOOLEAN)bImmediate;
  75
  76   Status = NtDeviceIoControlFile (hDevice,
  77                                   NULL,
  78                                   NULL,
  79                                   NULL,
  80                                   &IoStatusBlock,
  81                                   IOCTL_TAPE_ERASE,
  82                                   &TapeErase,
  83                                   sizeof(TAPE_ERASE),
  84                                   NULL,
  85                                   0);
  86   if (!NT_SUCCESS(Status))
  87     {
  88       ErrorCode = RtlNtStatusToDosError(Status);
  89       SetLastError (ErrorCode);
  90       return ErrorCode;
  91     }
  92
  93   return ERROR_SUCCESS;
  94 }
  95
  96
  97 /*
  98  * @implemented
  99  */
 100 DWORD STDCALL
 101 GetTapeParameters (HANDLE hDevice,
 102                    DWORD dwOperation,
 103                    LPDWORD lpdwSize,
 104                    LPVOID lpTapeInformation)
 105 {
 106   IO_STATUS_BLOCK IoStatusBlock;
 107   DWORD ErrorCode;
 108   NTSTATUS Status;
 109
 110   if (dwOperation == GET_TAPE_MEDIA_INFORMATION)
 111     {
 112       if (*lpdwSize < sizeof(TAPE_GET_MEDIA_PARAMETERS))
 113         {
 114           *lpdwSize = sizeof(TAPE_GET_MEDIA_PARAMETERS);
 115           return ERROR_MORE_DATA;
 116         }
 117
 118       Status = NtDeviceIoControlFile (hDevice,
 119                                       NULL,
 120                                       NULL,
 121                                       NULL,
 122                                       &IoStatusBlock,
 123                                       IOCTL_TAPE_GET_MEDIA_PARAMS,
 124                                       NULL,
 125                                       0,
 126                                       lpTapeInformation,
 127                                       sizeof(TAPE_GET_MEDIA_PARAMETERS));
 128     }
 129   else if (dwOperation == GET_TAPE_DRIVE_INFORMATION)
 130     {
 131       if (*lpdwSize < sizeof(TAPE_GET_DRIVE_PARAMETERS))
 132         {
 133           *lpdwSize = sizeof(TAPE_GET_DRIVE_PARAMETERS);
 134           return ERROR_MORE_DATA;
 135         }
 136
 137       Status = NtDeviceIoControlFile (hDevice,
 138                                       NULL,
 139                                       NULL,
 140                                       NULL,
 141                                       &IoStatusBlock,
 142                                       IOCTL_TAPE_GET_DRIVE_PARAMS,
 143                                       NULL,
 144                                       0,
 145                                       lpTapeInformation,
 146                                       sizeof(TAPE_GET_DRIVE_PARAMETERS));
 147     }
 148   else
 149     {
 150       return ERROR_INVALID_FUNCTION;
 151     }
 152
 153   if (!NT_SUCCESS(Status))
 154     {
 155       ErrorCode = RtlNtStatusToDosError(Status);
 156       SetLastError (ErrorCode);
 157       return ErrorCode;
 158     }
 159
 160   return ERROR_SUCCESS;
 161 }
 162
 163
 164 /*
 165  * @implemented
 166  */
 167 DWORD STDCALL
 168 GetTapePosition (HANDLE hDevice,
 169                  DWORD dwPositionType,
 170                  LPDWORD lpdwPartition,
 171                  LPDWORD lpdwOffsetLow,
 172                  LPDWORD lpdwOffsetHigh)
 173 {
 174   TAPE_GET_POSITION TapeGetPosition;
 175   IO_STATUS_BLOCK IoStatusBlock;
 176   DWORD ErrorCode;
 177   NTSTATUS Status;
 178
 179   TapeGetPosition.Type = dwPositionType;
 180
 181   Status = NtDeviceIoControlFile (hDevice,
 182                                   NULL,
 183                                   NULL,
 184                                   NULL,
 185                                   &IoStatusBlock,
 186                                   IOCTL_TAPE_GET_POSITION,
 187                                   &TapeGetPosition,
 188                                   sizeof(TAPE_GET_POSITION),
 189                                   &TapeGetPosition,
 190                                   sizeof(TAPE_GET_POSITION));
 191   if (!NT_SUCCESS(Status))
 192     {
 193       *lpdwPartition = 0;
 194       *lpdwOffsetLow = 0;
 195       *lpdwOffsetHigh = 0;
 196
 197       ErrorCode = RtlNtStatusToDosError(Status);
 198       SetLastError (ErrorCode);
 199       return ErrorCode;
 200     }
 201
 202   *lpdwPartition = TapeGetPosition.Partition;
 203   *lpdwOffsetLow = TapeGetPosition.Offset.u.LowPart;
 204   *lpdwOffsetHigh = TapeGetPosition.Offset.u.HighPart;
 205
 206   return ERROR_SUCCESS;
 207 }
 208
 209
 210 /*
 211  * @implemented
 212  */
 213 DWORD STDCALL
 214 GetTapeStatus (HANDLE hDevice)
 215 {
 216   IO_STATUS_BLOCK IoStatusBlock;
 217   DWORD ErrorCode;
 218   NTSTATUS Status;
 219
 220   Status = NtDeviceIoControlFile (hDevice,
 221                                   NULL,
 222                                   NULL,
 223                                   NULL,
 224                                   &IoStatusBlock,
 225                                   IOCTL_TAPE_GET_STATUS,
 226                                   NULL,
 227                                   0,
 228                                   NULL,
 229                                   0);
 230   if (!NT_SUCCESS(Status))
 231     {
 232       ErrorCode = RtlNtStatusToDosError(Status);
 233       SetLastError (ErrorCode);
 234       return ErrorCode;
 235     }
 236
 237   return ERROR_SUCCESS;
 238 }
 239
 240
 241 /*
 242  * @implemented
 243  */
 244 DWORD STDCALL
 245 PrepareTape (HANDLE hDevice,
 246              DWORD dwOperation,
 247              BOOL bImmediate)
 248 {
 249   TAPE_PREPARE TapePrepare;
 250   IO_STATUS_BLOCK IoStatusBlock;
 251   DWORD ErrorCode;
 252   NTSTATUS Status;
 253
 254   TapePrepare.Operation = dwOperation;
 255   TapePrepare.Immediate = (BOOLEAN)bImmediate;
 256
 257   Status = NtDeviceIoControlFile (hDevice,
 258                                   NULL,
 259                                   NULL,
 260                                   NULL,
 261                                   &IoStatusBlock,
 262                                   IOCTL_TAPE_PREPARE,
 263                                   &TapePrepare,
 264                                   sizeof(TAPE_PREPARE),
 265                                   NULL,
 266                                   0);
 267   if (!NT_SUCCESS(Status))
 268     {
 269       ErrorCode = RtlNtStatusToDosError(Status);
 270       SetLastError (ErrorCode);
 271       return ErrorCode;
 272     }
 273
 274   return ERROR_SUCCESS;
 275 }
 276
 277
 278 /*
 279  * @implemented
 280  */
 281 DWORD STDCALL
 282 SetTapeParameters (HANDLE hDevice,
 283                    DWORD dwOperation,
 284                    LPVOID lpTapeInformation)
 285 {
 286   IO_STATUS_BLOCK IoStatusBlock;
 287   DWORD ErrorCode;
 288   NTSTATUS Status;
 289
 290   if (dwOperation == SET_TAPE_MEDIA_INFORMATION)
 291     {
 292       Status = NtDeviceIoControlFile (hDevice,
 293                                       NULL,
 294                                       NULL,
 295                                       NULL,
 296                                       &IoStatusBlock,
 297                                       IOCTL_TAPE_SET_MEDIA_PARAMS,
 298                                       lpTapeInformation,
 299                                       sizeof(TAPE_SET_MEDIA_PARAMETERS),
 300                                       NULL,
 301                                       0);
 302     }
 303   else if (dwOperation == SET_TAPE_DRIVE_INFORMATION)
 304     {
 305       Status = NtDeviceIoControlFile (hDevice,
 306                                       NULL,
 307                                       NULL,
 308                                       NULL,
 309                                       &IoStatusBlock,
 310                                       IOCTL_TAPE_SET_DRIVE_PARAMS,
 311                                       lpTapeInformation,
 312                                       sizeof(TAPE_SET_DRIVE_PARAMETERS),
 313                                       NULL,
 314                                       0);
 315     }
 316   else
 317     {
 318       return ERROR_INVALID_FUNCTION;
 319     }
 320
 321   if (!NT_SUCCESS(Status))
 322     {
 323       ErrorCode = RtlNtStatusToDosError(Status);
 324       SetLastError (ErrorCode);
 325       return ErrorCode;
 326     }
 327
 328   return ERROR_SUCCESS;
 329 }
 330
 331
 332 /*
 333  * @implemented
 334  */
 335 DWORD STDCALL
 336 SetTapePosition (HANDLE hDevice,
 337                  DWORD dwPositionMethod,
 338                  DWORD dwPartition,
 339                  DWORD dwOffsetLow,
 340                  DWORD dwOffsetHigh,
 341                  BOOL bImmediate)
 342 {
 343   TAPE_SET_POSITION TapeSetPosition;
 344   IO_STATUS_BLOCK IoStatusBlock;
 345   DWORD ErrorCode;
 346   NTSTATUS Status;
 347
 348   TapeSetPosition.Method = dwPositionMethod;
 349   TapeSetPosition.Partition = dwPartition;
 350   TapeSetPosition.Offset.u.LowPart = dwOffsetLow;
 351   TapeSetPosition.Offset.u.HighPart = dwOffsetHigh;
 352   TapeSetPosition.Immediate = (BOOLEAN)bImmediate;
 353
 354   Status = NtDeviceIoControlFile (hDevice,
 355                                   NULL,
 356                                   NULL,
 357                                   NULL,
 358                                   &IoStatusBlock,
 359                                   IOCTL_TAPE_SET_POSITION,
 360                                   &TapeSetPosition,
 361                                   sizeof(TAPE_SET_POSITION),
 362                                   NULL,
 363                                   0);
 364   if (!NT_SUCCESS(Status))
 365     {
 366       ErrorCode = RtlNtStatusToDosError(Status);
 367       SetLastError (ErrorCode);
 368       return ErrorCode;
 369     }
 370
 371   return ERROR_SUCCESS;
 372 }
 373
 374
 375 /*
 376  * @implemented
 377  */
 378 DWORD STDCALL
 379 WriteTapemark (HANDLE hDevice,
 380                DWORD dwTapemarkType,
 381                DWORD dwTapemarkCount,
 382                BOOL bImmediate)
 383 {
 384   TAPE_WRITE_MARKS TapeWriteMarks;
 385   IO_STATUS_BLOCK IoStatusBlock;
 386   DWORD ErrorCode;
 387   NTSTATUS Status;
 388
 389   TapeWriteMarks.Type = dwTapemarkType;
 390   TapeWriteMarks.Count = dwTapemarkCount;
 391   TapeWriteMarks.Immediate = (BOOLEAN)bImmediate;
 392
 393   Status = NtDeviceIoControlFile (hDevice,
 394                                   NULL,
 395                                   NULL,
 396                                   NULL,
 397                                   &IoStatusBlock,
 398                                   IOCTL_TAPE_WRITE_MARKS,
 399                                   &TapeWriteMarks,
 400                                   sizeof(TAPE_WRITE_MARKS),
 401                                   NULL,
 402                                   0);
 403   if (!NT_SUCCESS(Status))
 404     {
 405       ErrorCode = RtlNtStatusToDosError(Status);
 406       SetLastError (ErrorCode);
 407       return ErrorCode;
 408     }
 409
 410   return ERROR_SUCCESS;
 411 }
 412
 413 /* EOF */