imm32: Updated implementation of the Imm{Get|Set}CompositionFont{A|W}.
[wine] / dlls / ntdll / tape.c
1 /*
2  * TAPE support
3  *
4  * Copyright 2006 Hans Leidekker
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <stdarg.h>
25 #include <stdio.h>
26 #ifdef HAVE_SYS_IOCTL_H
27 #include <sys/ioctl.h>
28 #endif
29 #ifdef HAVE_SYS_MTIO_H
30 #include <sys/mtio.h>
31 #endif
32
33 #if !defined(MTCOMPRESSION) && defined(MTCOMP)
34 #define MTCOMPRESSION MTCOMP
35 #endif
36 #if !defined(MTSETBLK) && defined(MTSETBSIZ)
37 #define MTSETBLK MTSETBSIZ
38 #endif
39 #if !defined(MTSETBLK) && defined(MTSRSZ)
40 #define MTSETBLK MTSRSZ
41 #endif
42 #ifndef MT_ST_BLKSIZE_MASK
43 #define MT_ST_BLKSIZE_MASK 0xffffff
44 #endif
45
46 /* Darwin 7.9.0 has MTSETBSIZ instead of MTSETBLK */
47 #if !defined(MTSETBLK) && defined(MTSETBSIZ)
48 #define MTSETBLK MTSETBSIZ
49 #endif
50
51 #define NONAMELESSUNION
52 #define NONAMELESSSTRUCT
53 #include "ntstatus.h"
54 #define WIN32_NO_STATUS
55 #include "windef.h"
56 #include "winternl.h"
57 #include "winioctl.h"
58 #include "ddk/ntddtape.h"
59 #include "ntdll_misc.h"
60 #include "wine/server.h"
61 #include "wine/debug.h"
62
63 WINE_DEFAULT_DEBUG_CHANNEL(tape);
64
65 static const char *io2str( DWORD io )
66 {
67     switch (io)
68     {
69 #define X(x)    case (x): return #x;
70     X(IOCTL_TAPE_CHECK_VERIFY);
71     X(IOCTL_TAPE_CREATE_PARTITION);
72     X(IOCTL_TAPE_ERASE);
73     X(IOCTL_TAPE_FIND_NEW_DEVICES);
74     X(IOCTL_TAPE_GET_DRIVE_PARAMS);
75     X(IOCTL_TAPE_GET_MEDIA_PARAMS);
76     X(IOCTL_TAPE_GET_POSITION);
77     X(IOCTL_TAPE_GET_STATUS);
78     X(IOCTL_TAPE_PREPARE);
79     X(IOCTL_TAPE_SET_DRIVE_PARAMS);
80     X(IOCTL_TAPE_SET_MEDIA_PARAMS);
81     X(IOCTL_TAPE_SET_POSITION);
82     X(IOCTL_TAPE_WRITE_MARKS);
83 #undef X
84     default: { static char tmp[32]; sprintf(tmp, "IOCTL_TAPE_%d\n", io); return tmp; }
85     }
86 }
87
88 /******************************************************************
89  *      TAPE_GetStatus
90  */
91 static NTSTATUS TAPE_GetStatus( int error )
92 {
93     if (!error) return STATUS_SUCCESS;
94     return FILE_GetNtStatus();
95 }
96
97 /******************************************************************
98  *      TAPE_CreatePartition
99  */
100 static NTSTATUS TAPE_CreatePartition( int fd, const TAPE_CREATE_PARTITION *data )
101 {
102 #ifdef HAVE_SYS_MTIO_H
103     struct mtop cmd;
104
105     TRACE( "fd: %d method: 0x%08x count: 0x%08x size: 0x%08x\n",
106            fd, data->Method, data->Count, data->Size );
107
108     if (data->Count > 1)
109     {
110         WARN( "Creating more than 1 partition is not supported\n" );
111         return STATUS_INVALID_PARAMETER;
112     }
113
114     switch (data->Method)
115     {
116 #ifdef MTMKPART
117     case TAPE_FIXED_PARTITIONS:
118     case TAPE_SELECT_PARTITIONS:
119         cmd.mt_op = MTMKPART;
120         cmd.mt_count = 0;
121         break;
122     case TAPE_INITIATOR_PARTITIONS:
123         cmd.mt_op = MTMKPART;
124         cmd.mt_count = data->Size;
125         break;
126 #endif
127     default:
128         ERR( "Unhandled method: 0x%08x\n", data->Method );
129         return STATUS_INVALID_PARAMETER;
130     }
131
132     return TAPE_GetStatus( ioctl( fd, MTIOCTOP, &cmd ) );
133 #else
134     FIXME( "Not implemented.\n" );
135     return STATUS_NOT_SUPPORTED;
136 #endif
137 }
138
139 /******************************************************************
140  *      TAPE_Erase
141  */
142 static NTSTATUS TAPE_Erase( int fd, const TAPE_ERASE *data )
143 {
144 #ifdef HAVE_SYS_MTIO_H
145     struct mtop cmd;
146
147     TRACE( "fd: %d type: 0x%08x immediate: 0x%02x\n",
148            fd, data->Type, data->Immediate );
149
150     switch (data->Type)
151     {
152     case TAPE_ERASE_LONG:
153         cmd.mt_op = MTERASE;
154         cmd.mt_count = 1;
155         break;
156     case TAPE_ERASE_SHORT:
157         cmd.mt_op = MTERASE;
158         cmd.mt_count = 0;
159         break;
160     default:
161         ERR( "Unhandled type: 0x%08x\n", data->Type );
162         return STATUS_INVALID_PARAMETER;
163     }
164
165     return TAPE_GetStatus( ioctl( fd, MTIOCTOP, &cmd ) );
166 #else
167     FIXME( "Not implemented.\n" );
168     return STATUS_NOT_SUPPORTED;
169 #endif
170 }
171
172 /******************************************************************
173  *      TAPE_GetDriveParams
174  */
175 static NTSTATUS TAPE_GetDriveParams( int fd, TAPE_GET_DRIVE_PARAMETERS *data )
176 {
177 #ifdef HAVE_SYS_MTIO_H
178     struct mtget get;
179     NTSTATUS status;
180
181     TRACE( "fd: %d\n", fd );
182
183     memset( data, 0, sizeof(TAPE_GET_DRIVE_PARAMETERS) );
184
185     status = TAPE_GetStatus( ioctl( fd, MTIOCGET, &get ) );
186     if (status != STATUS_SUCCESS)
187         return status;
188
189     data->ECC = FALSE;
190     data->Compression = FALSE;
191     data->DataPadding = FALSE;
192     data->ReportSetmarks = FALSE;
193 #ifdef HAVE_STRUCT_MTGET_MT_BLKSIZ
194     data->DefaultBlockSize = get.mt_blksiz;
195 #else
196     data->DefaultBlockSize = get.mt_dsreg & MT_ST_BLKSIZE_MASK;
197 #endif
198     data->MaximumBlockSize = data->DefaultBlockSize;
199     data->MinimumBlockSize = data->DefaultBlockSize;
200     data->MaximumPartitionCount = 1;
201
202     return status;
203 #else
204     FIXME( "Not implemented.\n" );
205     return STATUS_NOT_SUPPORTED;
206 #endif
207 }
208
209 /******************************************************************
210  *      TAPE_GetMediaParams
211  */
212 static NTSTATUS TAPE_GetMediaParams( int fd, TAPE_GET_MEDIA_PARAMETERS *data )
213 {
214 #ifdef HAVE_SYS_MTIO_H
215     struct mtget get;
216     NTSTATUS status;
217
218     TRACE( "fd: %d\n", fd );
219
220     memset( data, 0, sizeof(TAPE_GET_MEDIA_PARAMETERS) );
221
222     status = TAPE_GetStatus( ioctl( fd, MTIOCGET, &get ) );
223     if (status != STATUS_SUCCESS)
224         return status;
225
226     data->Capacity.u.LowPart = 1024 * 1024 * 1024;
227     data->Remaining.u.LowPart = 1024 * 1024 * 1024;
228 #ifdef HAVE_STRUCT_MTGET_MT_BLKSIZ
229     data->BlockSize = get.mt_blksiz;
230 #else
231     data->BlockSize = get.mt_dsreg & MT_ST_BLKSIZE_MASK;
232 #endif
233     data->PartitionCount = 1;
234 #ifdef HAVE_STRUCT_MTGET_MT_GSTAT
235     data->WriteProtected = (GMT_WR_PROT(get.mt_gstat) != 0);
236 #else
237     data->WriteProtected = 0;
238 #endif
239
240     return status;
241 #else
242     FIXME( "Not implemented.\n" );
243     return STATUS_NOT_SUPPORTED;
244 #endif
245 }
246
247 /******************************************************************
248  *      TAPE_GetPosition
249  */
250 static NTSTATUS TAPE_GetPosition( int fd, ULONG type, TAPE_GET_POSITION *data )
251 {
252 #ifdef HAVE_SYS_MTIO_H
253     struct mtget get;
254 #ifndef HAVE_STRUCT_MTGET_MT_BLKNO
255     struct mtpos pos;
256 #endif
257     NTSTATUS status;
258
259     TRACE( "fd: %d type: 0x%08x\n", fd, type );
260
261     memset( data, 0, sizeof(TAPE_GET_POSITION) );
262
263     status = TAPE_GetStatus( ioctl( fd, MTIOCGET, &get ) );
264     if (status != STATUS_SUCCESS)
265         return status;
266
267 #ifndef HAVE_STRUCT_MTGET_MT_BLKNO
268     status = TAPE_GetStatus( ioctl( fd, MTIOCPOS, &pos ) );
269     if (status != STATUS_SUCCESS)
270         return status;
271 #endif
272
273     switch (type)
274     {
275     case TAPE_ABSOLUTE_BLOCK:
276         data->Type = type;
277         data->Partition = get.mt_resid;
278 #ifdef HAVE_STRUCT_MTGET_MT_BLKNO
279         data->OffsetLow = get.mt_blkno;
280 #else
281         data->OffsetLow = pos.mt_blkno;
282 #endif
283         break;
284     case TAPE_LOGICAL_BLOCK:
285     case TAPE_PSEUDO_LOGICAL_BLOCK:
286         WARN( "Positioning type not supported\n" );
287         break;
288     default:
289         ERR( "Unhandled type: 0x%08x\n", type );
290         return STATUS_INVALID_PARAMETER;
291     }
292
293     return status;
294 #else
295     FIXME( "Not implemented.\n" );
296     return STATUS_NOT_SUPPORTED;
297 #endif
298 }
299
300 /******************************************************************
301  *      TAPE_Prepare
302  */
303 static NTSTATUS TAPE_Prepare( int fd, const TAPE_PREPARE *data )
304 {
305 #ifdef HAVE_SYS_MTIO_H
306     struct mtop cmd;
307
308     TRACE( "fd: %d type: 0x%08x immediate: 0x%02x\n",
309            fd, data->Operation, data->Immediate );
310
311     switch (data->Operation)
312     {
313 #ifdef MTLOAD
314     case TAPE_LOAD:
315         cmd.mt_op = MTLOAD;
316         break;
317 #endif
318 #ifdef MTUNLOAD
319     case TAPE_UNLOAD:
320         cmd.mt_op = MTUNLOAD;
321         break;
322 #endif
323 #ifdef MTRETEN
324     case TAPE_TENSION:
325         cmd.mt_op = MTRETEN;
326         break;
327 #endif
328 #ifdef MTLOCK
329     case TAPE_LOCK:
330         cmd.mt_op = MTLOCK;
331         break;
332 #endif
333 #ifdef MTUNLOCK
334     case TAPE_UNLOCK:
335         cmd.mt_op = MTUNLOCK;
336         break;
337 #endif
338     case TAPE_FORMAT:
339         /* Native ignores this if the drive doesn't support it */
340         return STATUS_SUCCESS;
341     default:
342         ERR( "Unhandled operation: 0x%08x\n", data->Operation );
343         return STATUS_INVALID_PARAMETER;
344     }
345
346     return TAPE_GetStatus( ioctl( fd, MTIOCTOP, &cmd ) );
347 #else
348     FIXME( "Not implemented.\n" );
349     return STATUS_NOT_SUPPORTED;
350 #endif
351 }
352
353 /******************************************************************
354  *      TAPE_SetDriveParams
355  */
356 static NTSTATUS TAPE_SetDriveParams( int fd, const TAPE_SET_DRIVE_PARAMETERS *data )
357 {
358 #if defined(HAVE_SYS_MTIO_H) && defined(MTCOMPRESSION)
359     struct mtop cmd;
360
361     TRACE( "fd: %d ECC: 0x%02x, compression: 0x%02x padding: 0x%02x\n",
362             fd, data->ECC, data->Compression, data->DataPadding );
363     TRACE( "setmarks: 0x%02x zonesize: 0x%08x\n",
364            data->ReportSetmarks, data->EOTWarningZoneSize );
365
366     if (data->ECC || data->DataPadding || data->ReportSetmarks ||
367         data->EOTWarningZoneSize ) WARN( "Setting not supported\n" );
368
369     cmd.mt_op = MTCOMPRESSION;
370     cmd.mt_count = data->Compression;
371
372     return TAPE_GetStatus( ioctl( fd, MTIOCTOP, &cmd ) );
373 #else
374     FIXME( "Not implemented.\n" );
375     return STATUS_NOT_SUPPORTED;
376 #endif
377 }
378         
379 /******************************************************************
380  *      TAPE_SetMediaParams
381  */
382 static NTSTATUS TAPE_SetMediaParams( int fd, const TAPE_SET_MEDIA_PARAMETERS *data )
383 {
384 #ifdef HAVE_SYS_MTIO_H
385     struct mtop cmd;
386
387     TRACE( "fd: %d blocksize: 0x%08x\n", fd, data->BlockSize );
388     
389     cmd.mt_op = MTSETBLK;
390     cmd.mt_count = data->BlockSize;
391
392     return TAPE_GetStatus( ioctl( fd, MTIOCTOP, &cmd ) );
393 #else
394     FIXME( "Not implemented.\n" );
395     return STATUS_NOT_SUPPORTED;
396 #endif
397 }
398         
399 /******************************************************************
400  *      TAPE_SetPosition
401  */
402 static NTSTATUS TAPE_SetPosition( int fd, const TAPE_SET_POSITION *data )
403 {
404 #ifdef HAVE_SYS_MTIO_H
405     struct mtop cmd;
406
407     TRACE( "fd: %d method: 0x%08x partition: 0x%08x offset: 0x%x%08x immediate: 0x%02x\n",
408            fd, data->Method, data->Partition, (DWORD)(data->Offset.QuadPart >> 32),
409            (DWORD)data->Offset.QuadPart, data->Immediate );
410
411     if (sizeof(cmd.mt_count) < sizeof(data->Offset.QuadPart) &&
412         (int)data->Offset.QuadPart != data->Offset.QuadPart)
413     {
414         ERR("Offset too large or too small\n");
415         return STATUS_INVALID_PARAMETER;
416     }
417
418     switch (data->Method)
419     {
420     case TAPE_REWIND:
421         cmd.mt_op = MTREW;
422         break;
423 #ifdef MTSEEK
424     case TAPE_ABSOLUTE_BLOCK:
425         cmd.mt_op = MTSEEK;
426         cmd.mt_count = data->Offset.QuadPart;
427         break;
428 #endif
429 #ifdef MTEOM
430     case TAPE_SPACE_END_OF_DATA:
431         cmd.mt_op = MTEOM;
432         break;
433 #endif
434     case TAPE_SPACE_FILEMARKS:
435         if (data->Offset.QuadPart >= 0) {
436             cmd.mt_op = MTFSF;
437             cmd.mt_count = data->Offset.QuadPart;
438         }
439         else {
440             cmd.mt_op = MTBSF;
441             cmd.mt_count = -data->Offset.QuadPart;
442         }
443         break;
444 #if defined(MTFSS) && defined(MTBSS)
445     case TAPE_SPACE_SETMARKS:
446         if (data->Offset.QuadPart >= 0) {
447             cmd.mt_op = MTFSS;
448             cmd.mt_count = data->Offset.QuadPart;
449         }
450         else {
451             cmd.mt_op = MTBSS;
452             cmd.mt_count = -data->Offset.QuadPart;
453         }
454         break;
455 #endif
456     case TAPE_LOGICAL_BLOCK:
457     case TAPE_PSEUDO_LOGICAL_BLOCK:
458     case TAPE_SPACE_RELATIVE_BLOCKS:
459     case TAPE_SPACE_SEQUENTIAL_FMKS:
460     case TAPE_SPACE_SEQUENTIAL_SMKS:
461         WARN( "Positioning method not supported\n" );
462         return STATUS_INVALID_PARAMETER;
463     default:
464         ERR( "Unhandled method: 0x%08x\n", data->Method );
465         return STATUS_INVALID_PARAMETER;
466     }
467
468     return TAPE_GetStatus( ioctl( fd, MTIOCTOP, &cmd ) );
469 #else
470     FIXME( "Not implemented.\n" );
471     return STATUS_NOT_SUPPORTED;
472 #endif
473 }
474
475 /******************************************************************
476  *      TAPE_WriteMarks
477  */
478 static NTSTATUS TAPE_WriteMarks( int fd, const TAPE_WRITE_MARKS *data )
479 {
480 #ifdef HAVE_SYS_MTIO_H
481     struct mtop cmd;
482
483     TRACE( "fd: %d type: 0x%08x count: 0x%08x immediate: 0x%02x\n",
484            fd, data->Type, data->Count, data->Immediate );
485
486     switch (data->Type)
487     {
488 #ifdef MTWSM
489     case TAPE_SETMARKS:
490         cmd.mt_op = MTWSM;
491         cmd.mt_count = data->Count;
492         break;
493 #endif
494     case TAPE_FILEMARKS:
495     case TAPE_SHORT_FILEMARKS:
496     case TAPE_LONG_FILEMARKS:
497         cmd.mt_op = MTWEOF;
498         cmd.mt_count = data->Count;
499         break;
500     default:
501         ERR( "Unhandled type: 0x%08x\n", data->Type );
502         return STATUS_INVALID_PARAMETER;
503     }
504
505     return TAPE_GetStatus( ioctl( fd, MTIOCTOP, &cmd ) );
506 #else
507     FIXME( "Not implemented.\n" );
508     return STATUS_NOT_SUPPORTED;
509 #endif
510 }
511
512 /******************************************************************
513  *              TAPE_DeviceIoControl
514  *
515  * SEE ALSO
516  *   NtDeviceIoControl.
517  */
518 NTSTATUS TAPE_DeviceIoControl( HANDLE device, HANDLE event,
519     PIO_APC_ROUTINE apc, PVOID apc_user, PIO_STATUS_BLOCK io_status,
520     ULONG io_control, LPVOID in_buffer, DWORD in_size,
521     LPVOID out_buffer, DWORD out_size )
522 {
523     DWORD sz = 0;
524     NTSTATUS status = STATUS_INVALID_PARAMETER;
525     int fd, needs_close;
526
527     TRACE( "%p %s %p %d %p %d %p\n", device, io2str(io_control),
528            in_buffer, in_size, out_buffer, out_size, io_status );
529
530     io_status->Information = 0;
531
532     if ((status = server_get_unix_fd( device, 0, &fd, &needs_close, NULL, NULL )))
533         goto error;
534
535     switch (io_control)
536     {
537     case IOCTL_TAPE_CREATE_PARTITION:
538         status = TAPE_CreatePartition( fd, (TAPE_CREATE_PARTITION *)in_buffer );
539         break;
540     case IOCTL_TAPE_ERASE:
541         status = TAPE_Erase( fd, (TAPE_ERASE *)in_buffer );
542         break;
543     case IOCTL_TAPE_GET_DRIVE_PARAMS:
544         status = TAPE_GetDriveParams( fd, (TAPE_GET_DRIVE_PARAMETERS *)out_buffer );
545         break;
546     case IOCTL_TAPE_GET_MEDIA_PARAMS:
547         status = TAPE_GetMediaParams( fd, (TAPE_GET_MEDIA_PARAMETERS *)out_buffer );
548         break;
549     case IOCTL_TAPE_GET_POSITION:
550         status = TAPE_GetPosition( fd, ((TAPE_GET_POSITION *)in_buffer)->Type,
551                                    (TAPE_GET_POSITION *)out_buffer );
552         break;
553     case IOCTL_TAPE_GET_STATUS:
554         status = FILE_GetNtStatus();
555         break;
556     case IOCTL_TAPE_PREPARE:
557         status = TAPE_Prepare( fd, (TAPE_PREPARE *)in_buffer );
558         break;
559     case IOCTL_TAPE_SET_DRIVE_PARAMS:
560         status = TAPE_SetDriveParams( fd, (TAPE_SET_DRIVE_PARAMETERS *)in_buffer );
561         break;
562     case IOCTL_TAPE_SET_MEDIA_PARAMS:
563         status = TAPE_SetMediaParams( fd, (TAPE_SET_MEDIA_PARAMETERS *)in_buffer );
564         break;
565     case IOCTL_TAPE_SET_POSITION:
566         status = TAPE_SetPosition( fd, (TAPE_SET_POSITION *)in_buffer );
567         break;
568     case IOCTL_TAPE_WRITE_MARKS:
569         status = TAPE_WriteMarks( fd, (TAPE_WRITE_MARKS *)in_buffer );
570         break;
571
572     case IOCTL_TAPE_CHECK_VERIFY:
573     case IOCTL_TAPE_FIND_NEW_DEVICES:
574         break;
575     default:
576         FIXME( "Unsupported IOCTL %x (type=%x access=%x func=%x meth=%x)\n",
577                io_control, io_control >> 16, (io_control >> 14) & 3,
578                (io_control >> 2) & 0xfff, io_control & 3 );
579         break;
580     }
581
582     if (needs_close) close( fd );
583
584 error:
585     io_status->u.Status = status;
586     io_status->Information = sz;
587     if (event) NtSetEvent( event, NULL );
588     return status;
589 }