1 /*
2 * Tape handling functions
3 *
4 * Copyright 1999 Chris Morgan <cmorgan@wpi.edu>
5 * James Abbatiello <abbeyj@wpi.edu>
6 * Copyright 2006 Hans Leidekker
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23 #include <stdarg.h>
24
25 #include "ntstatus.h"
26 #define WIN32_NO_STATUS
27 #include "windef.h"
28 #include "winternl.h"
29 #include "winbase.h"
30 #include "winerror.h"
31 #include "winioctl.h"
32 #include "ddk/ntddtape.h"
33
34 #include "wine/debug.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(tape);
37
38 static DWORD set_error_from_status( NTSTATUS status )
39 {
40 DWORD error = RtlNtStatusToDosError( status );
41
42 SetLastError( error );
43 return error;
44 }
45
46 /************************************************************************
47 * BackupRead (KERNEL32.@)
48 *
49 * Backup a file or directory.
50 */
51 BOOL WINAPI BackupRead( HANDLE file, LPBYTE buffer, DWORD to_read,
52 LPDWORD read, BOOL abort, BOOL security, LPVOID *context )
53 {
54 FIXME( "(%p, %p, %d, %p, %d, %d, %p)\n", file, buffer,
55 to_read, read, abort, security, context );
56 SetLastError( ERROR_NOT_SUPPORTED );
57 return FALSE;
58 }
59
60
61 /************************************************************************
62 * BackupSeek (KERNEL32.@)
63 *
64 * Seek forward in a backup stream.
65 */
66 BOOL WINAPI BackupSeek( HANDLE file, DWORD seek_low, DWORD seek_high,
67 LPDWORD seeked_low, LPDWORD seeked_high, LPVOID *context )
68 {
69 FIXME( "(%p, %d, %d, %p, %p, %p)\n", file, seek_low,
70 seek_high, seeked_low, seeked_high, context );
71 SetLastError( ERROR_NOT_SUPPORTED );
72 return FALSE;
73 }
74
75
76 /************************************************************************
77 * BackupWrite (KERNEL32.@)
78 *
79 * Restore a file or directory.
80 */
81 BOOL WINAPI BackupWrite( HANDLE file, LPBYTE buffer, DWORD to_write,
82 LPDWORD written, BOOL abort, BOOL security, LPVOID *context )
83 {
84 FIXME( "(%p, %p, %d, %p, %d, %d, %p)\n", file, buffer,
85 to_write, written, abort, security, context );
86 SetLastError( ERROR_NOT_SUPPORTED );
87 return FALSE;
88 }
89
90
91 /************************************************************************
92 * CreateTapePartition (KERNEL32.@)
93 *
94 * Format a tape.
95 */
96 DWORD WINAPI CreateTapePartition( HANDLE device, DWORD method,
97 DWORD count, DWORD size )
98 {
99 NTSTATUS status;
100 TAPE_CREATE_PARTITION part;
101 IO_STATUS_BLOCK io;
102
103 TRACE( "(%p, %d, %d, %d)\n", device, method, count, size );
104
105 part.Method = method;
106 part.Count = count;
107 part.Size = size;
108
109 status = NtDeviceIoControlFile( device, NULL, NULL, NULL, &io,
110 IOCTL_TAPE_CREATE_PARTITION, &part, sizeof(TAPE_CREATE_PARTITION), NULL, 0 );
111
112 return set_error_from_status( status );
113 }
114
115
116 /************************************************************************
117 * EraseTape (KERNEL32.@)
118 *
119 * Erase a tape.
120 */
121 DWORD WINAPI EraseTape( HANDLE device, DWORD type, BOOL immediate )
122 {
123 NTSTATUS status;
124 TAPE_ERASE erase;
125 IO_STATUS_BLOCK io;
126
127 TRACE( "(%p, %d, %d)\n", device, type, immediate );
128
129 erase.Type = type;
130 erase.Immediate = immediate;
131
132 status = NtDeviceIoControlFile( device, NULL, NULL, NULL, &io,
133 IOCTL_TAPE_ERASE, &erase, sizeof(TAPE_ERASE), NULL, 0 );
134
135 return set_error_from_status( status );
136 }
137
138
139 /************************************************************************
140 * GetTapeParameters (KERNEL32.@)
141 *
142 * Retrieve information about a tape or tape drive.
143 */
144 DWORD WINAPI GetTapeParameters( HANDLE device, DWORD operation,
145 LPDWORD size, LPVOID info )
146 {
147 NTSTATUS status = STATUS_INVALID_PARAMETER;
148 IO_STATUS_BLOCK io;
149
150 TRACE( "(%p, %d, %p, %p)\n", device, operation, size, info );
151
152 switch (operation)
153 {
154 case GET_TAPE_DRIVE_INFORMATION:
155 status = NtDeviceIoControlFile( device, NULL, NULL, NULL, &io,
156 IOCTL_TAPE_GET_DRIVE_PARAMS, NULL, 0, info, *size );
157 break;
158 case GET_TAPE_MEDIA_INFORMATION:
159 status = NtDeviceIoControlFile( device, NULL, NULL, NULL, &io,
160 IOCTL_TAPE_GET_MEDIA_PARAMS, NULL, 0, info, *size );
161 break;
162 default:
163 ERR( "Unhandled operation: 0x%08x\n", operation );
164 }
165
166 return set_error_from_status( status );
167 }
168
169
170 /************************************************************************
171 * GetTapePosition (KERNEL32.@)
172 *
173 * Retrieve the current tape position.
174 */
175 DWORD WINAPI GetTapePosition( HANDLE device, DWORD type, LPDWORD partition,
176 LPDWORD offset_low, LPDWORD offset_high )
177 {
178 NTSTATUS status;
179 TAPE_GET_POSITION in, out;
180 IO_STATUS_BLOCK io;
181
182 TRACE( "(%p, %d, %p, %p, %p)\n", device, type, partition, offset_low,
183 offset_high );
184
185 memset( &in, 0, sizeof(TAPE_GET_POSITION) );
186 in.Type = type;
187
188 status = NtDeviceIoControlFile( device, NULL, NULL, NULL, &io,
189 IOCTL_TAPE_GET_POSITION, &in, sizeof(TAPE_GET_POSITION),
190 &out, sizeof(TAPE_GET_POSITION) );
191
192 if (status != STATUS_SUCCESS)
193 return set_error_from_status( status );
194
195 *partition = out.Partition;
196 *offset_low = out.OffsetLow;
197 *offset_high = out.OffsetHigh;
198
199 return set_error_from_status( status );
200 }
201
202
203 /************************************************************************
204 * GetTapeStatus (KERNEL32.@)
205 *
206 * Determine if the tape device is ready for operation.
207 */
208 DWORD WINAPI GetTapeStatus( HANDLE device )
209 {
210 NTSTATUS status;
211 IO_STATUS_BLOCK io;
212
213 TRACE( "(%p)\n", device );
214
215 status = NtDeviceIoControlFile( device, NULL, NULL, NULL, &io,
216 IOCTL_TAPE_GET_STATUS, NULL, 0, NULL, 0 );
217
218 return set_error_from_status( status );
219 }
220
221
222 /************************************************************************
223 * PrepareTape (KERNEL32.@)
224 *
225 * Prepare a tape for operation.
226 */
227 DWORD WINAPI PrepareTape( HANDLE device, DWORD operation, BOOL immediate )
228 {
229 NTSTATUS status;
230 TAPE_PREPARE prep;
231 IO_STATUS_BLOCK io;
232
233 TRACE( "(%p, %d, %d)\n", device, operation, immediate );
234
235 prep.Operation = operation;
236 prep.Immediate = immediate;
237
238 status = NtDeviceIoControlFile( device, NULL, NULL, NULL, &io,
239 IOCTL_TAPE_PREPARE, &prep, sizeof(TAPE_PREPARE), NULL, 0 );
240
241 return set_error_from_status( status );
242 }
243
244
245 /************************************************************************
246 * SetTapeParameters (KERNEL32.@)
247 *
248 * Configure a tape or tape device.
249 */
250 DWORD WINAPI SetTapeParameters( HANDLE device, DWORD operation, LPVOID info )
251 {
252 NTSTATUS status = STATUS_INVALID_PARAMETER;
253 IO_STATUS_BLOCK io;
254
255 TRACE( "(%p, %d, %p)\n", device, operation, info );
256
257 switch (operation)
258 {
259 case SET_TAPE_DRIVE_INFORMATION:
260 status = NtDeviceIoControlFile( device, NULL, NULL, NULL, &io,
261 IOCTL_TAPE_SET_DRIVE_PARAMS, info, sizeof(TAPE_SET_DRIVE_PARAMETERS),
262 NULL, 0 );
263 break;
264 case SET_TAPE_MEDIA_INFORMATION:
265 status = NtDeviceIoControlFile( device, NULL, NULL, NULL, &io,
266 IOCTL_TAPE_SET_MEDIA_PARAMS, info, sizeof(TAPE_SET_MEDIA_PARAMETERS),
267 NULL, 0 );
268 break;
269 default:
270 ERR( "Unhandled operation: 0x%08x\n", operation );
271 }
272
273 return set_error_from_status( status );
274 }
275
276
277 /************************************************************************
278 * SetTapePosition (KERNEL32.@)
279 *
280 * Set the tape position on a given device.
281 */
282 DWORD WINAPI SetTapePosition( HANDLE device, DWORD method, DWORD partition,
283 DWORD offset_low, DWORD offset_high, BOOL immediate )
284 {
285 NTSTATUS status;
286 TAPE_SET_POSITION pos;
287 IO_STATUS_BLOCK io;
288
289 TRACE( "(%p, %d, %d, %d, %d, %d)\n", device, method, partition,
290 offset_low, offset_high, immediate );
291
292 pos.Method = method;
293 pos.Partition = partition;
294 pos.Offset.u.LowPart = offset_low;
295 pos.Offset.u.HighPart = offset_high;
296 pos.Immediate = immediate;
297
298 status = NtDeviceIoControlFile( device, NULL, NULL, NULL, &io,
299 IOCTL_TAPE_SET_POSITION, &pos, sizeof(TAPE_SET_POSITION), NULL, 0 );
300
301 return set_error_from_status( status );
302 }
303
304
305 /************************************************************************
306 * WriteTapemark (KERNEL32.@)
307 *
308 * Write tapemarks on a tape.
309 */
310 DWORD WINAPI WriteTapemark( HANDLE device, DWORD type, DWORD count,
311 BOOL immediate )
312 {
313 NTSTATUS status;
314 TAPE_WRITE_MARKS marks;
315 IO_STATUS_BLOCK io;
316
317 TRACE( "(%p, %d, %d, %d)\n", device, type, count, immediate );
318
319 marks.Type = type;
320 marks.Count = count;
321 marks.Immediate = immediate;
322
323 status = NtDeviceIoControlFile( device, NULL, NULL, NULL, &io,
324 IOCTL_TAPE_WRITE_MARKS, &marks, sizeof(TAPE_WRITE_MARKS), NULL, 0 );
325
326 return set_error_from_status( status );
327 }
328
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.