source: trunk/src/kernel32/stubs.cpp@ 7462

Last change on this file since 7462 was 7457, checked in by sandervl, 24 years ago

preliminary work on overlapped serial comm IO
File size: 77.8 KB
Line 
1/* $Id: stubs.cpp,v 1.34 2001-11-26 14:54:03 sandervl Exp $
2 *
3 * Win32 KERNEL32 Subsystem for OS/2
4 *
5 * 1998/05/19 PH Patrick Haller (haller@zebra.fh-weingarten.de)
6 *
7 * @(#) Stubs.H 1.0.0 1998/05/19 PH start
8 *
9 * Project Odin Software License can be found in LICENSE.TXT
10 *
11 */
12
13/*****************************************************************************
14 * Includes *
15 *****************************************************************************/
16#include <os2win.h>
17#include <winnls.h>
18#include "unicode.h"
19#include "handlemanager.h"
20#include <string.h>
21
22#include "stubs.h"
23
24#define DBG_LOCALLOG DBG_stubs
25#include "dbglocal.h"
26
27
28/*****************************************************************************
29 * Defines *
30 *****************************************************************************/
31
32
33// For DefineDosDevice
34
35#define DDD_RAW_TARGET_PATH 0x00000001
36#define DDD_REMOVE_DEFINITION 0x00000002
37#define DDD_EXACT_MATCH_ON_REMOVE 0x00000004
38#define DDD_NO_BROADCAST_SYSTEM 0x00000008
39
40
41// For Backup functions
42
43//
44// Stream Ids
45//
46
47#define BACKUP_INVALID 0x00000000
48#define BACKUP_DATA 0x00000001
49#define BACKUP_EA_DATA 0x00000002
50#define BACKUP_SECURITY_DATA 0x00000003
51#define BACKUP_ALTERNATE_DATA 0x00000004
52#define BACKUP_LINK 0x00000005
53#define BACKUP_PROPERTY_DATA 0x00000006
54
55//
56// Stream Attributes
57//
58
59#define STREAM_NORMAL_ATTRIBUTE 0x00000000
60#define STREAM_MODIFIED_WHEN_READ 0x00000001
61#define STREAM_CONTAINS_SECURITY 0x00000002
62#define STREAM_CONTAINS_PROPERTIES 0x00000004
63
64
65// Locale
66#define LCID DWORD
67
68/*
69 * Locale Dependent Mapping Flags.
70 */
71
72#define LCMAP_LOWERCASE 0x00000100 /* lower case letters */
73#define LCMAP_UPPERCASE 0x00000200 /* upper case letters */
74#define LCMAP_SORTKEY 0x00000400 /* WC sort key (normalize) */
75#define LCMAP_BYTEREV 0x00000800 /* byte reversal */
76
77#define LCMAP_HIRAGANA 0x00100000 /* map katakana to hiragana */
78#define LCMAP_KATAKANA 0x00200000 /* map hiragana to katakana */
79#define LCMAP_HALFWIDTH 0x00400000 /* map double byte to single byte */
80#define LCMAP_FULLWIDTH 0x00800000 /* map single byte to double byte */
81
82#define LCMAP_LINGUISTIC_CASING 0x01000000 /* use linguistic rules for casing */
83
84#define LCMAP_SIMPLIFIED_CHINESE 0x02000000 /* map traditional chinese to simplified chinese */
85#define LCMAP_TRADITIONAL_CHINESE 0x04000000 /* map simplified chinese to traditional chinese */
86
87
88
89/*
90 * Locale Enumeration Flags.
91 */
92#define LCID_INSTALLED 0x00000001 /* installed locale ids */
93#define LCID_SUPPORTED 0x00000002 /* supported locale ids */
94
95
96
97// For FindFirstFileEx
98
99#define FIND_FIRST_EX_CASE_SENSITIVE 0x00000001
100
101/*****************************************************************************
102 * Structures *
103 *****************************************************************************/
104
105 // For FindFirstFileEx
106
107typedef enum _FINDEX_INFO_LEVELS {
108 FindExInfoStandard,
109 FindExInfoMaxInfoLevel
110} FINDEX_INFO_LEVELS;
111
112typedef enum _FINDEX_SEARCH_OPS {
113 FindExSearchNameMatch,
114 FindExSearchLimitToDirectories,
115 FindExSearchLimitToDevices,
116 FindExSearchMaxSearchOp
117} FINDEX_SEARCH_OPS;
118
119 // For Backup funtions
120
121typedef struct _WIN32_STREAM_ID {
122
123 DWORD dwStreamId;
124 DWORD dwStreamAttributes;
125 LARGE_INTEGER Size;
126 DWORD dwStreamNameSize;
127// WCHAR cStreamName[ ] ; /* @@@PH */
128 WCHAR cStreamName[1] ;
129} WIN32_STREAM_ID;
130
131
132//
133// File structures
134//
135
136//typedef struct _OVERLAPPED {
137// DWORD Internal;
138// DWORD InternalHigh;
139// DWORD Offset;
140// DWORD OffsetHigh;
141// HANDLE hEvent;
142//} OVERLAPPED, *LPOVERLAPPED;
143
144//typedef struct _SECURITY_ATTRIBUTES {
145// DWORD nLength;
146// LPVOID lpSecurityDescriptor;
147// BOOL bInheritHandle;
148//} SECURITY_ATTRIBUTES, *PSECURITY_ATTRIBUTES, *LPSECURITY_ATTRIBUTES;
149
150//typedef struct _PROCESS_INFORMATION {
151// HANDLE hProcess;
152// HANDLE hThread;
153// DWORD dwProcessId;
154// DWORD dwThreadId;
155//} PROCESS_INFORMATION, *PPROCESS_INFORMATION, *LPPROCESS_INFORMATION;
156
157// For Fiber functions
158
159typedef VOID (WINAPI *PFIBER_START_ROUTINE)(
160 LPVOID lpFiberParameter
161 );
162typedef PFIBER_START_ROUTINE LPFIBER_START_ROUTINE;
163
164// For Enum CalendarInfo & EnumSystemCodePages see winnls.h
165
166/*
167 * Calendar type constant.
168 */
169typedef DWORD CALTYPE;
170
171/*
172 * Calendar ID.
173 */
174typedef DWORD CALID;
175
176
177/*****************************************************************************
178 * Prototypes *
179 *****************************************************************************/
180
181void WIN32API CommonUnimpStub()
182{
183 dprintf(("STUB: KERNEL32.17!!"));
184}
185
186/*****************************************************************************
187 * Name : BOOL WIN32API AreFileApisANSI (VOID)
188 * Purpose : The AreFileApisANSI function determines whether a set of Win32
189 * file functions is using the ANSI or OEM character set code page.
190 * This function is useful for 8-bit console input and output
191 * operations.
192 * Parameters: NONE
193 * Variables :
194 * Result : If the set of Win32 file functions is using the ANSI code page,
195 * the return value is nonzero.
196 * If the set of Win32 file functions is using the OEM code page,
197 * the return value is zero.
198 * Remark :
199 * Status : UNTESTED STUB
200 *
201 * Author : Markus Montkowski [Thu, 1998/02/19 11:46]
202 *****************************************************************************/
203
204BOOL WIN32API AreFileApisANSI (VOID)
205{
206
207 dprintf(("KERNEL32:AreFileApisANSI() not implemented - TRUE\n"
208 ));
209
210 return (TRUE);
211}
212
213/*****************************************************************************
214 * Name : BOOL WIN32API BackupRead(
215 * Purpose : The BackupRead function reads data associated with a specified
216 * file or directory into a buffer. You use this function to back
217 * up a file or directory.
218 * Parameters: HANDLE hFile handle to file or directory
219 * LPBYTE lpBuffer pointer to buffer to read to
220 * DWORD nNumberOfBytesToRead number of bytes to read
221 * LPDWORD lpNumberOfBytesRead pointer to variable to receive
222 * number of bytes read
223 * BOOL bAbort termination type
224 * BOOL bProcessSecurity process security flag
225 * LPVOID *lpContext pointer to pointer to internal
226 * context information
227 * Variables :
228 * Result : 0 on Error Nonzero if OK
229 * Remark : BackupRead processes all of the data pertaining to an opened
230 * object as a series of discrete byte streams. Each stream is
231 * preceded by a 32-bit aligned WIN32_STREAM_ID structure.
232 * Streams must be processed in the same order in which they were
233 * written to the tape. This ordering enables applications to
234 * compare the data backed up against the data on the source device.
235 * The data returned by BackupRead is to be used only as input to
236 * the BackupWrite function. This data is returned as one large data
237 * stream divided into substreams. The substreams are separated
238 * by WIN32_STREAM_ID headers.
239 *
240 * If an error occurs while BackupRead is reading, the calling
241 * process can skip the bad data by calling the BackupSeek function.
242 * Status : UNTESTED STUB
243 *
244 * Author : Markus Montkowski [Thu, 1998/05/19 11:46]
245 *****************************************************************************/
246
247BOOL WIN32API BackupRead(
248 HANDLE hFile, // handle to file or directory
249 LPBYTE lpBuffer, // pointer to buffer to read to
250 DWORD nNumberOfBytesToRead, // number of bytes to read
251 LPDWORD lpNumberOfBytesRead, // pointer to variable to receive number of bytes read
252 BOOL bAbort, // termination type
253 BOOL bProcessSecurity, // process security flag
254 LPVOID *lpContext // pointer to pointer to internal context information
255)
256{
257
258 dprintf(("KERNEL32:BackupRead(%08x,%08x,%08x,%08x,%08x,%08x,%08x) not implemented\n",
259 hFile, lpBuffer, nNumberOfBytesToRead, lpNumberOfBytesRead,
260 bAbort, bProcessSecurity, lpContext
261 ));
262
263 return (FALSE);
264}
265/*****************************************************************************
266 * Name : BOOL WIN32API BackupSeek()
267 * Purpose : The BackupSeek function seeks forward in a data stream initially
268 * accessed by using the BackupRead or BackupWrite function.
269 * Parameters: HANDLE hFile handle to open file
270 * DWORD dwLowBytesToSeek low-order 32 bits of number of bytes
271 * DWORD dwHighBytesToSeek high-order 32 bits of number of bytes
272 * LPDWORD lpdwLowByteSeeked pointer to number of bytes function seeks
273 * LPDWORD lpdwHighByteSeeked pointer to number of bytes function seeks
274 * LPVOID *lpContext pointer to internal context information
275 *
276 * Variables :
277 * Result : If the function could seek the requested amount, the function
278 * returns nonzero.
279 * If the function could not seek the requested amount, the function
280 * returns zero.
281 * Remark : Applications use the BackUpSeek function to skip portions of a
282 * data stream that cause errors. This function does not seek across
283 * stream headers. If an application attempts to seek past the end
284 * of a substream, the function fails, the lpdwLowByteSeeked and
285 * lpdwHighByteSeeked parameters indicate the actual number of bytes
286 * the function seeks, and the file position is placed at the start
287 * of the next stream header.
288 * Status : UNTESTED STUB
289 *
290 * Author : Markus Montkowski [Thu, 1998/05/19 11:46]
291 *****************************************************************************/
292
293BOOL WIN32API BackupSeek( HANDLE hFile, DWORD dwLowBytesToSeek,
294 DWORD dwHighBytesToSeek,
295 LPDWORD lpdwLowByteSeeked,
296 LPDWORD lpdwHighByteSeeked,LPVOID *lpContext)
297{
298
299 dprintf(("KERNEL32:BackupSeek(%08x,%08x,%08x,%08x,%08x,08x) not implemented\n",
300 hFile, dwLowBytesToSeek,dwHighBytesToSeek,
301 lpdwLowByteSeeked, lpdwHighByteSeeked, lpContext));
302
303 return (FALSE);
304}
305
306/*****************************************************************************
307 * Name : BOOL WIN32API BackupWrite
308 * Purpose : The BackupWrite function writes a stream of data from a buffer to
309 * a specified file or directory. The data must be divided into
310 * substreams separated by WIN32_STREAM_ID structures. You use this
311 * function to restore a file or directory that has been backed up.
312 * Parameters: HANDLE hFile handle to file or directory
313 * LPBYTE lpBuffer pointer to buffer containing data
314 * to write
315 * DWORD nNumberOfBytesToWrite number of bytes to write
316 * LPDWORD lpNumberOfBytesWritten pointer to variable to receive
317 * number of bytes written
318 * BOOL bAbort termination type
319 * BOOL bProcessSecurity process security
320 * LPVOID *lpContext pointer to pointer to internal
321 * context information
322 *
323 * Variables :
324 * Result : If the function succeeds, the return value is nonzero.
325 * If the function fails, the return value is zero,
326 * indicating that an I/O error occurred.
327 * To get extended error information, call GetLastError.
328 * Remark :
329 * Status : UNTESTED STUB
330 *
331 * Author : Markus Montkowski [Thu, 1998/05/19 11:46]
332 *****************************************************************************/
333
334BOOL WIN32API BackupWrite( HANDLE hFile, LPBYTE lpBuffer,
335 DWORD nNumberOfBytesToWrite,
336 LPDWORD lpNumberOfBytesWritten,
337 BOOL bAbort, BOOL bProcessSecurity,
338 LPVOID *lpContext)
339{
340
341 dprintf(("KERNEL32:BackupWrite(%08x,%0x8,%08x,%08x,%08x,%08x,%08x) not implemented\n",
342 hFile, lpBuffer, nNumberOfBytesToWrite,
343 lpNumberOfBytesWritten, bAbort, bProcessSecurity, lpContext));
344
345 return (FALSE);
346}
347
348/*****************************************************************************
349 * Name : HANDLE WIN32API BeginUpdateResourceA
350 * Purpose : The BeginUpdateResource function returns a handle that can be
351 * used by the UpdateResource function to add, delete, or replace
352 * resources in an executable file.
353 * Parameters: LPCSTR pFileName pointer to file in which to
354 * update resources
355 * BOOL bDeleteExistingResources deletion option
356 *
357 * Variables :
358 * Result : If the function succeeds, the return value is a handle that can
359 * be used by the UpdateResource and EndUpdateResource functions.
360 * The return value is NULL if the specified file is not an
361 * executable file, the executable file is already loaded,
362 * the file does not exist, or the file cannot be opened for writing.
363 * To get extended error information, call GetLastError
364 * Remark :
365 * Status : UNTESTED STUB
366 *
367 * Author : Markus Montkowski [Thu, 1998/05/19 11:46]
368 *****************************************************************************/
369
370HANDLE WIN32API BeginUpdateResourceA( LPCSTR pFileName,
371 BOOL bDeleteExistingResources)
372{
373
374 dprintf(("KERNEL32: BeginUpdateResource(%08x,%08x) not implemented\n",
375 pFileName, bDeleteExistingResources
376 ));
377
378 return (NULL);
379}
380
381/*****************************************************************************
382 * Name : HANDLE WIN32API BeginUpdateResourceW
383 * Purpose : The BeginUpdateResource function returns a handle that can be
384 * used by the UpdateResource function to add, delete, or replace
385 * resources in an executable file.
386 * Parameters: LPCWSTR pFileName pointer to file in which to
387 * update resources
388 * BOOL bDeleteExistingResources deletion option
389 *
390 * Variables :
391 * Result : If the function succeeds, the return value is a handle that can
392 * be used by the UpdateResource and EndUpdateResource functions.
393 * The return value is NULL if the specified file is not an
394 * executable file, the executable file is already loaded,
395 * the file does not exist, or the file cannot be opened for writing.
396 * To get extended error information, call GetLastError
397 * Remark :
398 * Status : UNTESTED STUB
399 *
400 * Author : Markus Montkowski [Thu, 1998/05/19 11:46]
401 *****************************************************************************/
402
403HANDLE WIN32API BeginUpdateResourceW( LPCWSTR pFileName,
404 BOOL bDeleteExistingResources)
405{
406
407 dprintf(("KERNEL32: BeginUpdateResource(%08x,%08x) not implemented\n",
408 pFileName, bDeleteExistingResources
409 ));
410
411 return (NULL);
412}
413
414/*****************************************************************************
415 * Name : BOOL CancelWaitableTimer
416 * Purpose : The CancelWaitableTimer function sets the specified "waitable"
417 * timer to the inactive state.
418 * Parameters: HANDLE hTimer handle to a timer object
419 * Variables :
420 * Result : If the function succeeds, the return value is nonzero.
421 * If the function fails, the return value is zero.
422 * To get extended error information, call GetLastError.
423 * Remark : The CancelWaitableTimer function does not change the signaled
424 * state of the timer. It stops the timer before it can be set to
425 * the signaled state. Therefore, threads performing a wait
426 * operation on the timer remain waiting until they time out or
427 * the timer is reactivated and its state is set to signaled.
428 *
429 * To reactivate the timer, call the SetWaitableTimer function.
430 * Status : UNTESTED STUB
431 *
432 * Author : Markus Montkowski [Thu, 1998/05/19 11:46]
433 *****************************************************************************/
434
435BOOL WIN32API CancelWaitableTimer(HANDLE hTimer)
436{
437
438 dprintf(("KERNEL32:CancelWaitableTimer(%08x) not implemented\n",
439 hTimer
440 ));
441
442 return (FALSE);
443}
444
445
446/*****************************************************************************
447 * Name : LPVOID WIN32API CreateFiber
448 * Purpose : The CreateFiber function allocates a fiber object, assigns it a
449 * stack, and sets up execution to begin at the specified
450 * start address, typically the fiber function.
451 * This function does not schedule the fiber.
452 * Parameters: DWORD dwStackSize initial thread stack size, in bytes
453 * LPFIBER_START_ROUTINE lpStartAddress pointer to fiber function
454 * LPVOID lpParameter argument for new fiber
455 * Variables :
456 * Result : If the function succeeds, the return value is the address of
457 * the fiber.
458 * If the function fails, the return value is NULL.
459 * Remark : Before a thread can schedule a fiber using the SwitchToFiber
460 * function, it must call the ConvertThreadToFiber function so there
461 * is a fiber associated with the thread.
462 * The fiber function is of type FIBER_START_ROUTINE.
463 * It accepts a single value of type PVOID (fiber data) and does not
464 * return a value. The prototype for this function is as follows:
465 *
466 * VOID WINAPI FiberFunc( PVOID lpParameter );
467 *
468 * Status : UNTESTED STUB
469 *
470 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
471 *****************************************************************************/
472
473LPVOID WIN32API CreateFiber( DWORD dwStackSize,
474 LPFIBER_START_ROUTINE lpStartAddress,
475 LPVOID lpParameter)
476{
477
478 dprintf(("KERNEL32:CreateFiber(%08x,%08x,%08x) not implemented\n",
479 dwStackSize, lpStartAddress,lpParameter
480 ));
481
482 return (NULL);
483}
484
485
486/*****************************************************************************
487 * Name : HANDLE WIN32API CreateIoCompletionPort
488 * Purpose : The CreateIoCompletionPort function can associate an instance of
489 * an opened file with a newly created or an existing input/output
490 * completion port; or it can create an input/output completion port
491 * without associating it with a file.
492 * Associating an instance of an opened file with an input/output
493 * completion port lets an application receive notification of the
494 * completion of asynchronous input/output operations involving that
495 * file.
496 * Parameters: HANDLE FileHandle file handle to associate with I/O
497 * completion port. Must be created
498 * with flag FILE_FLAG_OVERLAPPED !
499 * HANDLE ExistingCompletionPort optional handle to existing
500 * I/O completion port
501 * DWORD CompletionKey per-file completion key for
502 * I/O completion packets
503 * DWORD NumberOfConcurrentThreads number of threads allowed to
504 * execute concurrently
505 * Variables :
506 * Result : If the function succeeds, the return value is the handle to the
507 * I/O completion port that is associated with the specified file.
508 * This return value is not NULL.
509 * If the function fails, the return value is NULL.
510 * Remark : The Win32 I/O system can be instructed to send I/O completion
511 * notification packets to input/output completion ports, where they
512 * are queued up. The CreateIoCompletionPort function provides a
513 * mechanism for this.
514 * When you perform an input/output operation with a file handle
515 * that has an associated input/output completion port, the
516 * I/O system sends a completion notification packet to the
517 * completion port when the I/O operation completes.
518 * The I/O completion port places the completion packet in a
519 * first-in-first-out queue.
520 * Use the GetQueuedCompletionStatus function to retrieve these
521 * queued I/O completion packets.
522 * Threads in the same process can use the PostQueuedCompletionStatus
523 * function to place I/O completion notification packets in a
524 * completion port's queue. This allows you to use the port to
525 * receive communications from other threads of the process,
526 * in addition to receiving I/O completion notification packets
527 * from the Win32 I/O system.
528 * Status : UNTESTED STUB
529 *
530 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
531 *****************************************************************************/
532
533HANDLE WIN32API CreateIoCompletionPort( HANDLE FileHandle,
534 HANDLE ExistingCompletionPort,
535 DWORD CompletionKey,
536 DWORD NumberOfConcurrentThreads)
537{
538
539 dprintf(("KERNEL32: CreateIoCompletionPort(%08x,%08x,%08x,%08x) not implemented\n",
540 FileHandle, ExistingCompletionPort, CompletionKey,
541 NumberOfConcurrentThreads
542 ));
543
544 return (NULL);
545}
546
547/*****************************************************************************
548 * Name : HANDLE WIN32API CreateRemoteThread
549 * Purpose : The CreateRemoteThread function creates a thread that runs in
550 * the address space of another process.
551 * Parameters: HANDLE hProcess handle to process to create thread in
552 * LPSECURITY_ATTRIBUTES lpThreadAttributes pointer to thread
553 * security attributes
554 * DWORD dwStackSize initial thread stack size, in bytes
555 * LPTHREAD_START_ROUTINE lpStartAddress pointer to thread function
556 * LPVOID lpParameter pointer to argument for new thread
557 * DWORD dwCreationFlags creation flags
558 * LPDWORD lpThreadId pointer to returned thread identifier
559 * Variables :
560 * Result : If the function succeeds, the return value is a handle to
561 * the new thread.
562 * If the function fails, the return value is NULL.
563 * Remark :
564 * Status : UNTESTED STUB
565 *
566 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
567 *****************************************************************************/
568
569HANDLE WIN32API CreateRemoteThread( HANDLE hProcess,
570 LPSECURITY_ATTRIBUTES lpThreadAttributes,
571 DWORD dwStackSize,
572 LPTHREAD_START_ROUTINE lpStartAddress,
573 LPVOID lpParameter,DWORD dwCreationFlags,
574 LPDWORD lpThreadId )
575{
576
577 dprintf(("KERNEL32: CreateRemoteThread(%08x,%08x,%08x,%08x,%08x,%08x,%08x) not implemented\n",
578 hProcess, lpThreadAttributes, dwStackSize, lpStartAddress,
579 lpParameter, dwCreationFlags, lpThreadId
580 ));
581
582 return (NULL);
583}
584/*****************************************************************************
585 * Name : DWORD WIN32API CreateTapePartition
586 * Purpose : The CreateTapePartition function reformats a tape.
587 * Parameters: HANDLE hDevice handle to open device
588 * DWORD dwPartitionMethode type of new partition
589 * DWORD dwCount number of new partitions to create
590 * DWORD dwSize size of new partition, in megabytes
591 * Variables :
592 * Result : If the function succeeds, the return value is NO_ERROR.
593 * If the function fails, it may return one of the following
594 * error codes:
595 * Error Description
596 * ERROR_BEGINNING_OF_MEDIA An attempt to access data before
597 * the beginning-of-medium marker failed.
598 * ERROR_BUS_RESET A reset condition was detected on the bus.
599 * ERROR_END_OF_MEDIA The end-of-tape marker was reached
600 * during an operation.
601 * ERROR_FILEMARK_DETECTED A filemark was reached during an operation.
602 * ERROR_SETMARK_DETECTED A setmark was reached during an operation.
603 * ERROR_NO_DATA_DETECTED The end-of-data marker was reached
604 * during an operation.
605 * ERROR_PARTITION_FAILURE The tape could not be partitioned.
606 * ERROR_INVALID_BLOCK_LENGTH The block size is incorrect on a
607 * new tape in a multivolume partition.
608 * ERROR_DEVICE_NOT_PARTITIONED The partition information could not
609 * be found when a tape was being loaded.
610 * ERROR_MEDIA_CHANGED The tape that was in the drive has
611 * been replaced or removed.
612 * ERROR_NO_MEDIA_IN_DRIVE There is no media in the drive.
613 * ERROR_NOT_SUPPORTED The tape driver does not support a
614 * requested function.
615 * ERROR_UNABLE_TO_LOCK_MEDIA An attempt to lock the ejection
616 * mechanism failed.
617 * ERROR_UNABLE_TO_UNLOAD_MEDIA An attempt to unload the tape failed.
618 * ERROR_WRITE_PROTECT The media is write protected.
619 * Remark : Creating partitions reformats the tape. All previous information
620 * recorded on the tape is destroyed.
621 * Errorcodes are defined in winerror.h
622 * Status : UNTESTED STUB
623 *
624 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
625 *****************************************************************************/
626
627DWORD WIN32API CreateTapePartition( HANDLE hDevice, DWORD dwPartitionMethod,
628 DWORD dwCount, DWORD dwSize)
629{
630
631 dprintf(("KERNEL32: CreateTapePartition(%08x,%08x,%08x,%08x) not implemented - ERROR_NOT_SUPPORTED\n",
632 hDevice, dwPartitionMethod, dwCount, dwSize
633 ));
634
635 return (ERROR_NOT_SUPPORTED);
636}
637/*****************************************************************************
638 * Name : HANDLE WIN23API CreateWaitableTimerA
639 * Purpose : The CreateWaitableTimerA function creates a "waitable" timer object.
640 * Parameters: LPSECURITY_ATTRIBUTES lpTimerAttributes pointer to security attributes
641 * BOOL bManualReset flag for manual reset state
642 * LPCTSTR lpTimerName pointer to timer object name
643 * Variables :
644 * Result : If the function succeeds, the return value is a handle to the
645 * timer object. If the named timer object exists before the
646 * function call, GetLastError returns ERROR_ALREADY_EXISTS.
647 * Otherwise, GetLastError returns zero.
648 * If the function fails, the return value is NULL
649 * Remark :
650 * Status : UNTESTED STUB
651 *
652 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
653 *****************************************************************************/
654
655HANDLE WIN32API CreateWaitableTimerA( LPSECURITY_ATTRIBUTES lpTimerAttributes,
656 BOOL bManualReset, LPCSTR lpTimerName)
657{
658
659 dprintf(("KERNEL32: CreateWaitableTimer(%08x,%08x,%08x) not implemented\n",
660 lpTimerAttributes, bManualReset, lpTimerName
661 ));
662
663 return (NULL);
664}
665
666/*****************************************************************************
667 * Name : HANDLE WIN23API CreateWaitableTimerW
668 * Purpose : The CreateWaitableTimerW function creates a "waitable" timer object.
669 * Parameters: LPSECURITY_ATTRIBUTES lpTimerAttributes pointer to security attributes
670 * BOOL bManualReset flag for manual reset state
671 * LPCTSTR lpTimerName pointer to timer object name
672 * Variables :
673 * Result : If the function succeeds, the return value is a handle to the
674 * timer object. If the named timer object exists before the
675 * function call, GetLastError returns ERROR_ALREADY_EXISTS.
676 * Otherwise, GetLastError returns zero.
677 * If the function fails, the return value is NULL
678 * Remark :
679 * Status : UNTESTED STUB
680 *
681 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
682 *****************************************************************************/
683
684HANDLE WIN32API CreateWaitableTimerW( LPSECURITY_ATTRIBUTES lpTimerAttributes,
685 BOOL bManualReset, LPCWSTR lpTimerName)
686{
687
688 dprintf(("KERNEL32: CreateWaitableTimer(%08x,%08x,%08x) not implemented\n",
689 lpTimerAttributes, bManualReset, lpTimerName
690 ));
691
692 return (NULL);
693}
694
695/*****************************************************************************
696 * Name : BOOL WIN32API DebugActiveProcess
697 * Purpose : The DebugActiveProcess function allows a debugger to attach to
698 * an active process and then debug it.
699 * Parameters: DWORD dwProcessId process to be debugged
700 * Variables :
701 * Result : If the function succeeds, the return value is nonzero.
702 * If the function fails, the return value is zero
703 * Remark :
704 * Status : UNTESTED STUB
705 *
706 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
707 *****************************************************************************/
708
709BOOL WIN32API DebugActiveProcess(DWORD dwProcessId)
710{
711
712 dprintf(("KERNEL32:DebugActiveProcess(%08x) not implemented\n",
713 dwProcessId
714 ));
715
716 return (FALSE);
717}
718
719/*****************************************************************************
720 * Name : BOOL WIN32API DefineDosDeviceA
721 * Purpose : The DefineDosDeviceA function lets an application define,
722 * redefine, or delete MS-DOS device names.
723 * MS-DOS device names are stored as symbolic links in the object
724 * name space in 32-bit versions of Windows. The code that converts
725 * an MS-DOS path into a corresponding path in 32-bit versions of
726 * Windows uses these symbolic links to map MS-DOS devices and drive
727 * letters. The DefineDosDevice function provides a mechanism
728 * whereby a Win32-based application can modify the symbolic links
729 * used to implement the MS-DOS device name space.
730 * Parameters: DWORD dwFlags flags specifying aspects of device definition
731 * LPCSTR lpDeviceName pointer to MS-DOS device name string
732 * LPCSTR lpTargetPath pointer to MS-DOS or path string for
733 * 32-bit Windows
734 * Variables :
735 * Result : If the function succeeds, the return value is nonzero.
736 * If the function fails, the return value is zero
737 * Remark :
738 * Status : UNTESTED STUB
739 *
740 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
741 *****************************************************************************/
742
743BOOL WIN32API DefineDosDeviceA( DWORD dwFlags, LPCSTR lpDeviceName,
744 LPCSTR lpTargetPath )
745{
746
747 dprintf(("KERNEL32: DefineDosDeviceA(%08x,%08x,%08x) not implemented\n",
748 dwFlags, lpDeviceName, lpTargetPath
749 ));
750
751 return (FALSE);
752}
753
754/*****************************************************************************
755 * Name : BOOL WIN32API DefineDosDeviceW
756 * Purpose : UNICODE version of DefineDosDeviceA
757 * Parameters: DWORD dwFlags flags specifying aspects of device definition
758 * LPCSTR lpDeviceName pointer to MS-DOS device name string
759 * LPCSTR lpTargetPath pointer to MS-DOS or path string for
760 * 32-bit Windows
761 * Variables :
762 * Result : If the function succeeds, the return value is nonzero.
763 * If the function fails, the return value is zero
764 * Remark :
765 * Status : UNTESTED STUB
766 *
767 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
768 *****************************************************************************/
769
770BOOL WIN32API DefineDosDeviceW( DWORD dwFlags, LPCWSTR lpDeviceName,
771 LPCWSTR lpTargetPath )
772{
773
774 dprintf(("KERNEL32: DefineDosDeviceW(%08x,%08x,%08x) not implemented\n",
775 dwFlags, lpDeviceName, lpTargetPath
776 ));
777
778 return (FALSE);
779}
780
781/*****************************************************************************
782 * Name : VOID WIN32API DeleteFiber
783 * Purpose : The DeleteFiber function deletes an existing fiber
784 * Parameters: LPVOID lpFiber pointer to the fiber to delete
785 * Variables :
786 * Result : No returnvalue
787 * Remark : The DeleteFiber function deletes all data associated with the
788 * fiber. This data includes the stack, a subset of the registers,
789 * and the fiber data. If the currently running fiber calls
790 * DeleteFiber, the ExitThread function is called and the thread
791 * terminates. If the currently running fiber is deleted by another
792 * thread, the thread associated with the fiber is likely to
793 * terminate abnormally because the fiber stack has been freed.
794 * Status : UNTESTED STUB
795 *
796 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
797 *****************************************************************************/
798
799VOID WIN32API DeleteFiber(LPVOID lpFiber)
800{
801
802 dprintf(("KERNEL32: DeleteFiber(%08x) not implemented\n",
803 lpFiber
804 ));
805}
806/*****************************************************************************
807 * Name : BOOL WIN3API EndUpdateResourceA
808 * Purpose : The EndUpdateResourceA function ends a resource update
809 * in an executable file.
810 * Parameters: HANDLE hUpdate update-file handle
811 * BOOL fDiscard write flag
812 * Variables :
813 * Result : If the function succeeds and the accumulated resource
814 * modifications specified by calls to the UpdateResource function
815 * are written to the specified executable file,
816 * the return value is nonzero.
817 * If the function fails, the return value is zero
818 * Remark :
819 * Status : UNTESTED STUB
820 *
821 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
822 *****************************************************************************/
823
824BOOL WIN32API EndUpdateResourceA(HANDLE hUpdate,BOOL fDiscard)
825{
826
827 dprintf(("KERNEL32:EndUpdateResourceA(%08x,%08x)not implemented\n",
828 hUpdate, fDiscard
829 ));
830
831 return (FALSE);
832}
833
834/*****************************************************************************
835 * Name : BOOL WIN3API EndUpdateResourceW
836 * Purpose : The EndUpdateResourceW function ends a resource update
837 * in an executable file.
838 * Parameters: HANDLE hUpdate update-file handle
839 * BOOL fDiscard write flag
840 * Variables :
841 * Result : If the function succeeds and the accumulated resource
842 * modifications specified by calls to the UpdateResource function
843 * are written to the specified executable file,
844 * the return value is nonzero.
845 * If the function fails, the return value is zero
846 * Remark :
847 * Status : UNTESTED STUB
848 *
849 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
850 *****************************************************************************/
851
852BOOL WIN32API EndUpdateResourceW(HANDLE hUpdate,BOOL fDiscard)
853{
854
855 dprintf(("KERNEL32:EndUpdateResourceW(%08x,%08x) not implemented\n",
856 hUpdate, fDiscard
857 ));
858
859 return (FALSE);
860}
861
862
863/*****************************************************************************
864 * Name : DWORD WIN32API EraseTape
865 * Purpose : The EraseTape function erases all or part of a tape.
866 * Parameters: HANDLE hDevice handle to open device
867 * DWORD dwEraseType type of erasure to perform
868 * BOOL bImmediate return after erase operation begins
869 * Variables :
870 * Result : If the function succeeds, the return value is NO_ERROR.
871 * If the function fails, the return value is like in
872 * CreateTapePartition
873 * Remark : Some tape devices do not support certain tape operations. To de
874 * termine your tape device's capabilities, see your tape device
875 * documentation and use the GetTapeParameters function
876 * Status : UNTESTED STUB
877 *
878 * Author : Markus Montkowski [Tha, 1998/05/21 20:57]
879 *****************************************************************************/
880
881DWORD WIN32API EraseTape( HANDLE hDevice, DWORD dwEraseType, BOOL bImmediate)
882{
883
884 dprintf(("KERNEL32: EraseTape(%08x,%08x,%08x) not implemented - ERROR_NOT_SUPPORTED\n",
885 hDevice, dwEraseType, bImmediate
886 ));
887
888 return (ERROR_NOT_SUPPORTED);
889}
890
891
892/*****************************************************************************
893 * Name : HANDLE WIN32API FindFirstFileExA
894 * Purpose : The FindFirstFileExA function searches a directory for a file
895 * whose name and attributes match those specified in the
896 * function call.
897 * Parameters: LPCSTR lpFileName pointer to the name of the file
898 * to search for
899 * FINDEX_INFO_LEVELS fInfoLevelId information level of the returned data
900 * LPVOID lpFindFileData pointer to the returned information
901 * FINDEX_SEARCH_OPS fSearchOp type of filtering to perform
902 * LPVOID lpSearchFilter pointer to search criteria
903 * DWORD dwAdditionalFlags additional search control flags
904 * Variables :
905 * Result : If the function succeeds, the return value is a search handle
906 * that can be used in a subsequent call to the FindNextFile or
907 * FindClose functions.
908 * If the function fails, the return value is INVALID_HANDLE_VALUE
909 * Remark :
910 * Status : UNTESTED STUB
911 *
912 * Author : Markus Montkowski [Tha, 1998/05/21 20:57]
913 *****************************************************************************/
914
915HANDLE WIN32API FindFirstFileExA( LPCSTR lpFileName,
916 FINDEX_INFO_LEVELS fInfoLevelId,
917 LPVOID lpFindFileData,
918 FINDEX_SEARCH_OPS fSearchOp,
919 LPVOID lpSearchFilter,
920 DWORD dwAdditionalFlags)
921{
922
923 dprintf(("KERNEL32: FindFirstFileExA(%08x,%08x,%08x,%08x,%08x,%08x)not implemented - INVALID_HANDLE_VALUE\n",
924 lpFileName,
925 fInfoLevelId,
926 lpFindFileData,
927 fSearchOp,
928 lpSearchFilter,
929 dwAdditionalFlags
930 ));
931
932 return (INVALID_HANDLE_VALUE);
933}
934
935/*****************************************************************************
936 * Name : HANDLE WIN32API FindFirstFileExW
937 * Purpose : The FindFirstFileExW function searches a directory for a file
938 * whose name and attributes match those specified in the
939 * function call.
940 * Parameters: LPCWSTR lpFileName pointer to the name of the file
941 * to search for
942 * FINDEX_INFO_LEVELS fInfoLevelId information level of the returned data
943 * LPVOID lpFindFileData pointer to the returned information
944 * FINDEX_SEARCH_OPS fSearchOp type of filtering to perform
945 * LPVOID lpSearchFilter pointer to search criteria
946 * DWORD dwAdditionalFlags additional search control flags
947 * Variables :
948 * Result : If the function succeeds, the return value is a search handle
949 * that can be used in a subsequent call to the FindNextFile or
950 * FindClose functions.
951 * If the function fails, the return value is INVALID_HANDLE_VALUE
952 * Remark :
953 * Status : UNTESTED STUB
954 *
955 * Author : Markus Montkowski [Tha, 1998/05/21 20:57]
956 *****************************************************************************/
957
958HANDLE WIN32API FindFirstFileExW( LPCWSTR lpFileName,
959 FINDEX_INFO_LEVELS fInfoLevelId,
960 LPVOID lpFindFileData,
961 FINDEX_SEARCH_OPS fSearchOp,
962 LPVOID lpSearchFilter,
963 DWORD dwAdditionalFlags)
964{
965
966 dprintf(("KERNEL32: FindFirstFileExW(%08x,%08x,%08x,%08x,%08x,%08x)not implemented - INVALID_HANDLE_VALUE\n",
967 lpFileName,
968 fInfoLevelId,
969 lpFindFileData,
970 fSearchOp,
971 lpSearchFilter,
972 dwAdditionalFlags
973 ));
974
975 return (INVALID_HANDLE_VALUE);
976}
977
978/*****************************************************************************
979 * Name : int WIN32API FoldStringA
980 * Purpose : The FoldStringW function maps one string to another, performing
981 * a specified transformation option.
982 * Parameters: DWORD dwMapFlags, // mapping transformation options
983 * LPCSTR lpSrcStr, // pointer to source string
984 * int cchSrc, // size of source string, in bytes or characters
985 * LPSTR lpDestStr, // pointer to destination buffer
986 * int cchDest // size of destination buffer, in bytes or characters
987 * Variables :
988 * Result : If the function succeeds, the return value is the number of bytes
989 * (ANSI version) or characters (Unicode version) written to the
990 * destination buffer, or if the cchDest parameter is zero,
991 * the number of bytes or characters required to hold the mapped
992 * string.
993 * If the function fails, the return value is zero
994 * Remark :
995 * Status : UNTESTED STUB
996 *
997 * Author : Markus Montkowski [Tha, 1998/05/21 20:57]
998 *****************************************************************************/
999
1000int WIN32API FoldStringA( DWORD dwMapFlags, LPCSTR lpSrcStr,
1001 int cchSrc, LPSTR lpDestStr, int cchDest)
1002{
1003
1004 dprintf(("KERNEL32: FoldStringA(%08x,%08x,%08x,%08x,%08x) not implemented\n",
1005 dwMapFlags, lpSrcStr, cchSrc, lpDestStr, cchDest
1006 ));
1007
1008 return (0);
1009}
1010
1011/*****************************************************************************
1012 * Name : int WIN32API FoldStringW
1013 * Purpose : The FoldStringW function maps one string to another, performing
1014 * a specified transformation option.
1015 * Parameters: DWORD dwMapFlags, // mapping transformation options
1016 * LPCSTR lpSrcStr, // pointer to source string
1017 * int cchSrc, // size of source string, in bytes or characters
1018 * LPSTR lpDestStr, // pointer to destination buffer
1019 * int cchDest // size of destination buffer, in bytes or characters
1020 * Variables :
1021 * Result : If the function succeeds, the return value is the number of bytes
1022 * (ANSI version) or characters (Unicode version) written to the
1023 * destination buffer, or if the cchDest parameter is zero,
1024 * the number of bytes or characters required to hold the mapped
1025 * string.
1026 * If the function fails, the return value is zero
1027 * Remark :
1028 * Status : UNTESTED STUB
1029 *
1030 * Author : Markus Montkowski [Tha, 1998/05/21 20:57]
1031 *****************************************************************************/
1032
1033int WIN32API FoldStringW( DWORD dwMapFlags, LPCWSTR lpSrcStr,
1034 int cchSrc, LPWSTR lpDestStr, int cchDest)
1035{
1036
1037 dprintf(("KERNEL32: FoldStringA(%08x,%08x,%08x,%08x,%08x) not implemented\n",
1038 dwMapFlags, lpSrcStr, cchSrc, lpDestStr, cchDest
1039 ));
1040
1041 return (0);
1042}
1043
1044
1045/*****************************************************************************
1046 * Name : DWORD GetHandleInformation
1047 * Purpose : The GetHandleInformation function obtains information about certain
1048 * properties of an object handle. The information is obtained as a set of bit flags.
1049 * Parameters: HANDLE hObject
1050 * LPDWORD lpdwFlags
1051 * Variables :
1052 * Result : TRUE / FALSE
1053 * Remark :
1054 * Status : UNTESTED STUB
1055 *
1056 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1057 *****************************************************************************/
1058
1059BOOL WIN32API GetHandleInformation(HANDLE hObject,
1060 LPDWORD lpdwFlags)
1061{
1062 dprintf(("KERNEL32: GetHandleInformation (%08xh, %08xh) not implemented\n",
1063 hObject,
1064 lpdwFlags));
1065
1066 return (FALSE);
1067}
1068
1069
1070
1071
1072/*****************************************************************************
1073 * Name : BOOL GetQueuedCompletionStatus
1074 * Purpose : The GetQueuedCompletionStatus function attempts to dequeue an
1075 * I/O completion packet from a specified input/output completion
1076 * port. If there is no completion packet queued, the function waits
1077 * for a pending input/output operation associated with the completion
1078 * port to complete. The function returns when it can dequeue a
1079 * completion packet, or optionally when the function times out. If
1080 * the function returns because of an I/O operation completion, it
1081 * sets several variables that provide information about the operation.
1082 * Parameters: HANDLE CompletionPort the I/O completion port of interest
1083 * LPDWORD lpNumberOfBytesTransferred to receive number of bytes transferred during I/O
1084 * LPDWORD lpCompletionKey to receive file's completion key
1085 * LPOVERLAPPED * lpOverlapped to receive pointer to OVERLAPPED structure
1086 * DWORD dwMilliseconds optional timeout value
1087 * Variables :
1088 * Result : TRUE / FALSE
1089 * Remark :
1090 * Status : UNTESTED STUB
1091 *
1092 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1093 *****************************************************************************/
1094
1095BOOL WIN32API GetQueuedCompletionStatus(HANDLE CompletionPort,
1096 LPDWORD lpNumberOfBytesTransferred,
1097 LPDWORD lpCompletionKey,
1098 LPOVERLAPPED *lpOverlapped,
1099 DWORD dwMilliseconds)
1100{
1101 dprintf(("Kernel32: GetQueuedCompletionStatus(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.",
1102 CompletionPort,
1103 lpNumberOfBytesTransferred,
1104 lpCompletionKey,
1105 lpOverlapped,
1106 dwMilliseconds));
1107
1108 return (FALSE);
1109}
1110
1111
1112
1113/*****************************************************************************
1114 * Name : BOOL GetSystemTimeAdjustment
1115 * Purpose : The GetSystemTimeAdjustment function determines whether the system
1116 * is applying periodic time adjustments to its time-of-day clock
1117 * at each clock interrupt, along with the value and period of any
1118 * such adjustments. Note that the period of such adjustments is
1119 * equivalent to the time period between clock interrupts.
1120 * Parameters: PDWORD lpTimeAdjustment
1121 * size, in 100-nanosecond units, of a periodic time adjustment
1122 * PDWORD lpTimeIncrement
1123 * time, in 100-nanosecond units, between periodic time adjustments
1124 * PBOOL lpTimeAdjustmentDisabled
1125 * whether periodic time adjustment is disabled or enabled
1126 * Variables :
1127 * Result : TRUE / FALSE
1128 * Remark :
1129 * Status : UNTESTED STUB
1130 *
1131 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1132 *****************************************************************************/
1133
1134BOOL WIN32API GetSystemTimeAdjustment(PDWORD lpTimeAdjustment,
1135 PDWORD lpTimeIncrement,
1136 PBOOL lpTimeAdjustmentDisabled)
1137{
1138 dprintf(("KERNEL32: GetSystemTimeAdjustment(%08xh,%08xh,%08xh) not implemented.\n",
1139 lpTimeAdjustment,
1140 lpTimeIncrement,
1141 lpTimeAdjustmentDisabled));
1142
1143 return (FALSE);
1144}
1145
1146
1147/*****************************************************************************
1148 * Name : BOOL GetTapeParameters
1149 * Purpose : The GetTapeParameters function retrieves information that
1150 * describes the tape or the tape drive.
1151 * Parameters: HANDLE hDevice handle of open device
1152 * DWORD dwOperation type of information requested
1153 * LPDWORD lpdwSize address of returned information
1154 * LPVOID lpTapeInformation tape media or drive information
1155 * Variables :
1156 * Result : API returncode
1157 * Remark :
1158 * Status : UNTESTED STUB
1159 *
1160 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1161 *****************************************************************************/
1162
1163DWORD WIN32API GetTapeParameters(HANDLE hDevice,
1164 DWORD dwOperation,
1165 LPDWORD lpdwSize,
1166 LPVOID lpTapeInformation)
1167{
1168 dprintf(("KERNEL32: GetTapeParameters(%08xh,%08xh,%08xh,%08xh) not implemented - ERROR_NOT_SUPPORTED.\n",
1169 hDevice,
1170 dwOperation,
1171 lpdwSize,
1172 lpTapeInformation));
1173
1174 return (ERROR_NOT_SUPPORTED);
1175}
1176
1177
1178/*****************************************************************************
1179 * Name : BOOL GetTapePosition
1180 * Purpose : The GetTapePosition function retrieves the current address of
1181 * the tape, in logical or absolute blocks.
1182 * Parameters: HANDLE hDevice handle of open device
1183 * DWORD dwPositionType type of address to obtain
1184 * LPDWORD lpdwPartition address of current tape partition
1185 * LPDWORD lpdwOffsetLow address of low-order 32 bits of tape position
1186 * LPDWORD lpdwOffsetHigh address of high-order 32 bits of tape position
1187 * Variables :
1188 * Result : TRUE / FALSE
1189 * Remark :
1190 * Status : UNTESTED STUB
1191 *
1192 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1193 *****************************************************************************/
1194
1195DWORD WIN32API GetTapePosition(HANDLE hDevice,
1196 DWORD dwPositionType,
1197 LPDWORD lpdwPartition,
1198 LPDWORD lpdwOffsetLow,
1199 LPDWORD lpdwOffsetHigh)
1200{
1201 dprintf(("KERNEL32: OS2GetTapePosition(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented - ERROR_NOT_SUPPORTED.\n",
1202 hDevice,
1203 dwPositionType,
1204 lpdwPartition,
1205 lpdwOffsetLow,
1206 lpdwOffsetHigh));
1207
1208 return (ERROR_NOT_SUPPORTED);
1209}
1210
1211
1212/*****************************************************************************
1213 * Name : BOOL GetTapeStatus
1214 * Purpose : The GetTapeStatus function indicates whether the tape device is
1215 * ready to process tape commands.
1216 * Parameters: HANDLE hDevice handle of open device
1217 * Variables :
1218 * Result : API returncode
1219 * Remark :
1220 * Status : UNTESTED STUB
1221 *
1222 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1223 *****************************************************************************/
1224
1225DWORD WIN32API GetTapeStatus(HANDLE hDevice)
1226{
1227 dprintf(("KERNEL32: OS2GetTapeStatus(%08xh) not implemented - ERROR_NOT_SUPPORTED.\n",
1228 hDevice));
1229
1230 return (ERROR_NOT_SUPPORTED);
1231}
1232
1233
1234/*****************************************************************************
1235 * Name : BOOL GetThreadSelectorEntry
1236 * Purpose : The GetThreadSelectorEntry function retrieves a descriptor table
1237 * entry for the specified selector and thread.
1238 * Parameters: HANDLE hThread handle of thread that contains selector
1239 * DWORD dwSelector number of selector value to look up
1240 * LPLDT_ENTRY lpSelectorEntry address of selector entry structure
1241 * Variables :
1242 * Result : TRUE / FALSE
1243 * Remark :
1244 * Status : UNTESTED STUB
1245 *
1246 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1247 *****************************************************************************/
1248
1249BOOL WIN32API GetThreadSelectorEntry(HANDLE hThread,
1250 DWORD dwSelector,
1251 LPLDT_ENTRY lpSelectorEntry)
1252{
1253 dprintf(("KERNEL32: GetThreadSelectorEntry(%08xh,%08xh,%08xh) not implemented.\n",
1254 hThread,
1255 dwSelector,
1256 lpSelectorEntry));
1257
1258 return (FALSE);
1259}
1260
1261
1262/*****************************************************************************
1263 * Name : BOOL GetThreadTimes
1264 * Purpose : The GetThreadTimes function obtains timing information about a specified thread.
1265 * Parameters: HANDLE hThread specifies the thread of interest
1266 * LPFILETIME lpCreationTime when the thread was created
1267 * LPFILETIME lpExitTime when the thread exited
1268 * LPFILETIME lpKernelTime time the thread has spent in kernel mode
1269 * LPFILETIME lpUserTime time the thread has spent in user mode
1270 * Variables :
1271 * Result : TRUE / FALSE
1272 * Remark :
1273 * Status : UNTESTED STUB
1274 *
1275 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1276 *****************************************************************************/
1277
1278BOOL WIN32API GetThreadTimes(HANDLE hThread,
1279 LPFILETIME lpCreationTime,
1280 LPFILETIME lpExitTime,
1281 LPFILETIME lpKernelTime,
1282 LPFILETIME lpUserTime)
1283{
1284 dprintf(("Kernel32: GetThreadTimes(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1285 hThread,
1286 lpCreationTime,
1287 lpExitTime,
1288 lpKernelTime,
1289 lpUserTime));
1290
1291 return (FALSE);
1292}
1293
1294
1295
1296/*****************************************************************************
1297 * Name : BOOL PostQueuedCompletionStatus
1298 * Purpose : The PostQueuedCompletionStatus function lets you post an I/O
1299 * completion packet to an I/O completion port. The I/O completion
1300 * packet will satisfy an outstanding call to the GetQueuedCompletionStatus
1301 * function. The GetQueuedCompletionStatus function returns with the three
1302 * values passed as the second, third, and fourth parameters of the call
1303 * to PostQueuedCompletionStatus.
1304 * Parameters: HANDLE CompletionPort handle to an I/O completion port
1305 * DWORD dwNumberOfBytesTransferred
1306 * DWORD dwCompletionKey
1307 * LPOVERLAPPED lpOverlapped
1308 * Variables :
1309 * Result : TRUE / FALSE
1310 * Remark :
1311 * Status : UNTESTED STUB
1312 *
1313 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1314 *****************************************************************************/
1315
1316BOOL WIN32API PostQueuedCompletionStatus(HANDLE CompletionPort,
1317 DWORD dwNumberOfBytesTransferred,
1318 DWORD dwCompletionKey,
1319 LPOVERLAPPED lpOverlapped)
1320{
1321 dprintf(("Kernel32: PostQueuedCompletionStatus(%08xh,%08xh,%08xh,%08xh) not implemented.",
1322 CompletionPort,
1323 dwNumberOfBytesTransferred,
1324 dwCompletionKey,
1325 lpOverlapped));
1326
1327 return (FALSE);
1328}
1329
1330
1331/*****************************************************************************
1332 * Name : DWORD PrepareTape
1333 * Purpose : The PrepareTape function prepares the tape to be accessed or removed.
1334 * Parameters: HANDLE hDevice handle of open device
1335 * DWORD dwOperation preparation method
1336 * BOOL bImmediate return after operation begins
1337 * Variables :
1338 * Result : API returncode
1339 * Remark :
1340 * Status : UNTESTED STUB
1341 *
1342 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1343 *****************************************************************************/
1344
1345DWORD WIN32API PrepareTape(HANDLE hDevice,
1346 DWORD dwOperation,
1347 BOOL bImmediate)
1348{
1349 dprintf(("Kernel32: PrepareTape(%08xh,%08xh,%08xh) not implemented - ERROR_NOT_SUPPORTED.\n",
1350 hDevice,
1351 dwOperation,
1352 bImmediate));
1353
1354 return (ERROR_NOT_SUPPORTED);
1355}
1356
1357
1358/*****************************************************************************
1359 * Name : DWORD QueryDosDeviceA
1360 * Purpose : The QueryDosDevice function lets an application obtain information
1361 * about MS-DOS device names. The function can obtain the current
1362 * mapping for a particular MS-DOS device name. The function can also
1363 * obtain a list of all existing MS-DOS device names.
1364 * MS-DOS device names are stored as symbolic links in the Windows NT
1365 * object name space. The code that converts an MS-DOS path into a
1366 * corresponding Windows NT path uses these symbolic links to map
1367 * MS-DOS devices and drive letters. The QueryDosDevice function
1368 * provides a mechanism whereby a Win32-based application can query
1369 * the names of the symbolic links used to implement the MS-DOS device
1370 * namespace as well as the value of each specific symbolic link.
1371 * Parameters: LPCTSTR lpDeviceName address of MS-DOS device name string
1372 * LPTSTR lpTargetPath ddress of buffer for storing query results
1373 * DWORD ucchMax maximum storage capacity of buffer
1374 * Variables :
1375 * Result : pointer to lpTargetPath
1376 * Remark :
1377 * Status : UNTESTED STUB
1378 *
1379 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1380 *****************************************************************************/
1381
1382DWORD WIN32API QueryDosDeviceA(LPCTSTR lpDeviceName,
1383 LPTSTR lpTargetPath,
1384 DWORD ucchMax)
1385{
1386 dprintf(("Kernel32: QueryDosDeviceA(%s,%08xh,%08xh) not implemented.\n",
1387 lpDeviceName,
1388 lpTargetPath,
1389 ucchMax));
1390
1391 return (0);
1392}
1393
1394
1395/*****************************************************************************
1396 * Name : DWORD QueryDosDeviceW
1397 * Purpose : The QueryDosDevice function lets an application obtain information
1398 * about MS-DOS device names. The function can obtain the current
1399 * mapping for a particular MS-DOS device name. The function can also
1400 * obtain a list of all existing MS-DOS device names.
1401 * MS-DOS device names are stored as symbolic links in the Windows NT
1402 * object name space. The code that converts an MS-DOS path into a
1403 * corresponding Windows NT path uses these symbolic links to map
1404 * MS-DOS devices and drive letters. The QueryDosDevice function
1405 * provides a mechanism whereby a Win32-based application can query
1406 * the names of the symbolic links used to implement the MS-DOS device
1407 * namespace as well as the value of each specific symbolic link.
1408 * Parameters: LPCTSTR lpDeviceName address of MS-DOS device name string
1409 * LPTSTR lpTargetPath ddress of buffer for storing query results
1410 * DWORD ucchMax maximum storage capacity of buffer
1411 * Variables :
1412 * Result : pointer to lpTargetPath
1413 * Remark :
1414 * Status : UNTESTED STUB
1415 *
1416 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1417 *****************************************************************************/
1418
1419DWORD WIN32API QueryDosDeviceW(LPCWSTR lpDeviceName,
1420 LPWSTR lpTargetPath,
1421 DWORD ucchMax)
1422{
1423 dprintf(("Kernel32: QueryDosDeviceW(%s,%08xh,%08xh) not implemented.\n",
1424 lpDeviceName,
1425 lpTargetPath,
1426 ucchMax));
1427
1428 return (0);
1429}
1430
1431
1432/*****************************************************************************
1433 * Name : DWORD ReadProcessMemory
1434 * Purpose : The ReadProcessMemory function reads memory in a specified process.
1435 * The entire area to be read must be accessible, or the operation fails.
1436 * Parameters: HANDLE hProcess handle of the process whose memory is read
1437 * LPCVOID lpBaseAddress address to start reading
1438 * LPVOID lpBuffer address of buffer to place read data
1439 * DWORD cbRead number of bytes to read
1440 * LPDWORD lpNumberOfBytesRead address of number of bytes read
1441 * Variables :
1442 * Result : TRUE / FALSE
1443 * Remark :
1444 * Status : UNTESTED STUB
1445 *
1446 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1447 *****************************************************************************/
1448
1449DWORD WIN32API ReadProcessMemory(HANDLE hProcess,
1450 LPCVOID lpBaseAddress,
1451 LPVOID lpBuffer,
1452 DWORD cbRead,
1453 LPDWORD lpNumberOfBytesRead)
1454{
1455 dprintf(("Kernel32: ReadProcessMemory(%08xh,%08xh,%08xh,%08xh,%08xh) not completely implemented",
1456 hProcess,
1457 lpBaseAddress,
1458 lpBuffer,
1459 cbRead,
1460 lpNumberOfBytesRead));
1461
1462 // do some (faked) access check
1463 if(hProcess != GetCurrentProcess())
1464 {
1465 dprintf(("WARNING: ReadProcessMemory: can't read memory from other processes!"));
1466 SetLastError(ERROR_ACCESS_DENIED);
1467 return FALSE;
1468 }
1469
1470 if(IsBadReadPtr(lpBaseAddress, cbRead)) {
1471 dprintf(("ERROR: ReadProcessMemory bad source pointer!"));
1472 if(lpNumberOfBytesRead)
1473 *lpNumberOfBytesRead = 0;
1474 SetLastError(ERROR_ACCESS_DENIED);
1475 return FALSE;
1476 }
1477 // FIXME: check this, if we ever run win32 binaries in different addressspaces
1478 // ... and add a sizecheck
1479 memcpy(lpBuffer,lpBaseAddress,cbRead);
1480 if(lpNumberOfBytesRead)
1481 *lpNumberOfBytesRead = cbRead;
1482
1483 SetLastError(ERROR_SUCCESS);
1484 return TRUE;
1485}
1486
1487/*****************************************************************************
1488 * Name : DWORD WriteProcessMemory
1489 * Purpose : The WriteProcessMemory function writes memory in a specified
1490 * process. The entire area to be written to must be accessible,
1491 * or the operation fails.
1492 * Parameters: HANDLE hProcess handle of process whose memory is written to
1493 * LPVOID lpBaseAddress address to start writing to
1494 * LPVOID lpBuffer address of buffer to write data to
1495 * DWORD cbWrite number of bytes to write
1496 * LPDWORD lpNumberOfBytesWritten actual number of bytes written
1497 * Variables :
1498 * Result : TRUE / FALSE
1499 * Remark :
1500 * Status : UNTESTED STUB
1501 *
1502 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1503 *****************************************************************************/
1504
1505BOOL WIN32API WriteProcessMemory(HANDLE hProcess,
1506 LPCVOID lpBaseAddress,
1507 LPVOID lpBuffer,
1508 DWORD cbWrite,
1509 LPDWORD lpNumberOfBytesWritten)
1510{
1511 // do some (faked) access check
1512 if(hProcess != GetCurrentProcess())
1513 {
1514 dprintf(("Kernel32: WriteProcessMemory(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented (different process!!)",
1515 hProcess, lpBaseAddress, lpBuffer, cbWrite, lpNumberOfBytesWritten));
1516 SetLastError(ERROR_ACCESS_DENIED);
1517 return FALSE;
1518 }
1519 dprintf(("Kernel32: WriteProcessMemory(%08xh,%08xh,%08xh,%08xh,%08xh))",
1520 hProcess,lpBaseAddress, lpBuffer, cbWrite, lpNumberOfBytesWritten));
1521
1522 if(IsBadWritePtr((LPVOID)lpBaseAddress, cbWrite))
1523 {
1524 dprintf(("ERROR: WriteProcessMemory bad destination pointer!"));
1525 if(lpNumberOfBytesWritten)
1526 *lpNumberOfBytesWritten = 0;
1527 SetLastError(ERROR_ACCESS_DENIED);
1528 return FALSE;
1529 }
1530
1531 // FIXME: check this, if we ever run win32 binaries in different addressspaces
1532 // ... and add a sizecheck
1533 memcpy((void*)lpBaseAddress,lpBuffer,cbWrite);
1534 if(lpNumberOfBytesWritten)
1535 *lpNumberOfBytesWritten = cbWrite;
1536
1537 SetLastError(ERROR_SUCCESS);
1538 return TRUE;
1539}
1540
1541
1542/*****************************************************************************
1543 * Name : BOOL SetComputerNameA
1544 * Purpose : The SetComputerNameA function sets the computer name to be used
1545 * the next time the system is restarted.
1546 * Parameters: LPCTSTR lpszName address of new computer name
1547 * Variables :
1548 * Result : TRUE / FALSE
1549 * Remark :
1550 * Status : UNTESTED STUB
1551 *
1552 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1553 *****************************************************************************/
1554
1555BOOL WIN32API SetComputerNameA(LPCTSTR lpszName)
1556{
1557 dprintf(("Kernel32: SetComputerNameA(%s) not implemented.\n",
1558 lpszName));
1559
1560 return (FALSE);
1561}
1562
1563
1564/*****************************************************************************
1565 * Name : BOOL SetComputerNameW
1566 * Purpose : The SetComputerNameW function sets the computer name to be used
1567 * the next time the system is restarted.
1568 * Parameters: LPCTSTR lpszName address of new computer name
1569 * Variables :
1570 * Result : TRUE / FALSE
1571 * Remark :
1572 * Status : UNTESTED STUB
1573 *
1574 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1575 *****************************************************************************/
1576
1577BOOL WIN32API SetComputerNameW(LPCWSTR lpszName)
1578{
1579 dprintf(("Kernel32: SetComputerNameW(%s) not implemented.\n",
1580 lpszName));
1581
1582 return (FALSE);
1583}
1584
1585
1586/*****************************************************************************
1587 * Name : VOID SetFileApisToOEM
1588 * Purpose : The SetFileApisToOEM function causes a set of Win32 file functions
1589 * to use the OEM character set code page. This function is useful
1590 * for 8-bit console input and output operations.
1591 * Parameters: VOID
1592 * Variables :
1593 * Result :
1594 * Remark :
1595 * Status : UNTESTED STUB
1596 *
1597 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1598 *****************************************************************************/
1599
1600VOID WIN32API SetFileApisToOEM(VOID)
1601{
1602 dprintf(("Kernel32: SetFileApisToOEM() not implemented.\n"));
1603}
1604
1605
1606/*****************************************************************************
1607 * Name : BOOL SetHandleInformation
1608 * Purpose : The SetHandleInformation function sets certain properties of an
1609 * object handle. The information is specified as a set of bit flags.
1610 * Parameters: HANDLE hObject handle to an object
1611 * DWORD dwMask specifies flags to change
1612 * DWORD dwFlags specifies new values for flags
1613 * Variables :
1614 * Result : TRUE / FALSE
1615 * Remark :
1616 * Status : UNTESTED STUB
1617 *
1618 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1619 *****************************************************************************/
1620
1621BOOL WIN32API SetHandleInformation(HANDLE hObject,
1622 DWORD dwMask,
1623 DWORD dwFlags)
1624{
1625 dprintf(("KERNEL32: SetHandleInformation(%08xh,%08xh,%08xh) not implemented.\n",
1626 hObject,
1627 dwMask,
1628 dwFlags));
1629
1630 return (FALSE);
1631}
1632
1633/*****************************************************************************
1634 * Name : BOOL SetSystemPowerState
1635 * Purpose : The SetSystemPowerState function suspends the system by shutting
1636 * power down. Depending on the ForceFlag parameter, the function
1637 * either suspends operation immediately or requests permission from
1638 * all applications and device drivers before doing so.
1639 * Parameters: BOOL fSuspend
1640 * BOOL fForce
1641 * Variables :
1642 * Result : TRUE / FALSE
1643 * Remark :
1644 * Status : UNTESTED STUB
1645 *
1646 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1647 *****************************************************************************/
1648
1649BOOL WIN32API SetSystemPowerState(BOOL fSuspend,
1650 BOOL fForce)
1651{
1652 dprintf(("KERNEL32: SetSystemPowerState(%08xh,%08xh) not implemented.\n",
1653 fSuspend,
1654 fForce));
1655
1656 return (FALSE);
1657}
1658
1659
1660/*****************************************************************************
1661 * Name : BOOL SetSystemTimeAdjustment
1662 * Purpose : The SetSystemTimeAdjustment function tells the system to enable
1663 * or disable periodic time adjustments to its time of day clock.
1664 * Such time adjustments are used to synchronize the time of day
1665 * with some other source of time information. When periodic time
1666 * adjustments are enabled, they are applied at each clock interrupt.
1667 * Parameters: DWORD dwTimeAdjustment
1668 * BOOL bTimeAdjustmentDisabled
1669 * Variables :
1670 * Result : TRUE / FALSE
1671 * Remark :
1672 * Status : UNTESTED STUB
1673 *
1674 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1675 *****************************************************************************/
1676
1677BOOL WIN32API SetSystemTimeAdjustment(DWORD dwTimeAdjustment,
1678 BOOL bTimeAdjustmentDisabled)
1679{
1680 dprintf(("KERNEL32: SetSystemTimeAdjustment(%08xh,%08xh) not implemented.\n",
1681 dwTimeAdjustment,
1682 bTimeAdjustmentDisabled));
1683
1684 return (FALSE);
1685}
1686
1687
1688/*****************************************************************************
1689 * Name : DWORD SetTapeParameters
1690 * Purpose : The SetTapeParameters function either specifies the block size
1691 * of a tape or configures the tape device.
1692 * Parameters: HANDLE hDevice handle of open device
1693 * DWORD dwOperation type of information to set
1694 * LPVOID lpTapeInformation address of buffer with information to set
1695 * Variables :
1696 * Result : API returncode
1697 * Remark :
1698 * Status : UNTESTED STUB
1699 *
1700 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1701 *****************************************************************************/
1702
1703BOOL WIN32API SetTapeParameters(HANDLE hDevice,
1704 DWORD dwOperation,
1705 LPVOID lpTapeInformation)
1706{
1707 dprintf(("KERNEL32: SetTapeParameters(%08xh,%08xh,%08xh) not implemented - ERROR_NOT_SUPPORTED.\n",
1708 hDevice,
1709 dwOperation,
1710 lpTapeInformation));
1711
1712 return (ERROR_NOT_SUPPORTED);
1713}
1714
1715
1716/*****************************************************************************
1717 * Name : DWORD SetTapePosition
1718 * Purpose : The SetTapePosition sets the tape position on the specified device.
1719 * Parameters: HANDLE hDevice handle of open device
1720 * DWORD dwPositionMethod type of positioning to perform
1721 * DWORD dwPartition new tape partition
1722 * DWORD dwOffsetLow low-order 32 bits of tape position
1723 * DWORD dwOffsetHigh high-order 32 bits of tape position
1724 * BOOL bImmediate return after operation begins
1725 * Variables :
1726 * Result : API returncode
1727 * Remark :
1728 * Status : UNTESTED STUB
1729 *
1730 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1731 *****************************************************************************/
1732
1733BOOL WIN32API SetTapePosition(HANDLE hDevice,
1734 DWORD dwPositionMethod,
1735 DWORD dwPartition,
1736 DWORD dwOffsetLow,
1737 DWORD dwOffsetHigh,
1738 BOOL bImmediate)
1739{
1740 dprintf(("KERNEL32: SetTapePosition(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented - ERROR_NOT_SUPPORTED.\n",
1741 hDevice,
1742 dwPositionMethod,
1743 dwPartition,
1744 dwOffsetLow,
1745 dwOffsetHigh,
1746 bImmediate));
1747
1748 return (ERROR_NOT_SUPPORTED);
1749}
1750
1751
1752
1753
1754/*****************************************************************************
1755 * Name : BOOL UpdateResourceA
1756 * Purpose : The UpdateResourceA function adds, deletes, or replaces a resource
1757 * in an executable file.
1758 * Parameters: HANDLE hUpdateFile update-file handle
1759 * LPCTSTR lpszType address of resource type to update
1760 * LPCTSTR lpszName address of resource name to update
1761 * WORD IDLanguage language identifier of resource
1762 * LPVOID lpvData address of resource data
1763 * DWORD cbData length of resource data, in bytes
1764 * Variables :
1765 * Result : TRUE / FALSE
1766 * Remark :
1767 * Status : UNTESTED STUB
1768 *
1769 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1770 *****************************************************************************/
1771
1772BOOL WIN32API UpdateResourceA(HANDLE hUpdateFile,
1773 LPCTSTR lpszType,
1774 LPCTSTR lpszName,
1775 WORD IDLanguage,
1776 LPVOID lpvData,
1777 DWORD cbData)
1778{
1779 dprintf(("KERNEL32: UpdateResourceA(%08xh,%s,%s,%08xh,%08xh,%08xh) not implemented.\n",
1780 hUpdateFile,
1781 lpszType,
1782 lpszName,
1783 IDLanguage,
1784 lpvData,
1785 cbData));
1786
1787 return (FALSE);
1788}
1789
1790
1791/*****************************************************************************
1792 * Name : BOOL UpdateResourceW
1793 * Purpose : The UpdateResourceW function adds, deletes, or replaces a resource
1794 * in an executable file.
1795 * Parameters: HANDLE hUpdateFile update-file handle
1796 * LPCTSTR lpszType address of resource type to update
1797 * LPCTSTR lpszName address of resource name to update
1798 * WORD IDLanguage language identifier of resource
1799 * LPVOID lpvData address of resource data
1800 * DWORD cbData length of resource data, in bytes
1801 * Variables :
1802 * Result : TRUE / FALSE
1803 * Remark :
1804 * Status : UNTESTED STUB
1805 *
1806 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1807 *****************************************************************************/
1808
1809BOOL WIN32API UpdateResourceW(HANDLE hUpdateFile,
1810 LPCWSTR lpszType,
1811 LPCWSTR lpszName,
1812 WORD IDLanguage,
1813 LPVOID lpvData,
1814 DWORD cbData)
1815{
1816 dprintf(("KERNEL32: UpdateResourceW(%08xh,%s,%s,%08xh,%08xh,%08xh) not implemented.\n",
1817 hUpdateFile,
1818 lpszType,
1819 lpszName,
1820 IDLanguage,
1821 lpvData,
1822 cbData));
1823
1824 return (FALSE);
1825}
1826
1827/*****************************************************************************
1828 * Name : BOOL WriteTapemark
1829 * Purpose : The WriteTapemark function writes a specified number of filemarks,
1830 * setmarks, short filemarks, or long filemarks to a tape device.
1831 * These tapemarks divide a tape partition into smaller areas.
1832 * Parameters: HANDLE hDevice handle of open device
1833 * DWORD dwTapemarkType type of tapemarks to write
1834 * DWORD dwTapemarkCount number of tapemarks to write
1835 * BOOL bImmediate return after write begins
1836 * Variables :
1837 * Result : API returncode
1838 * Remark :
1839 * Status : UNTESTED STUB
1840 *
1841 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1842 *****************************************************************************/
1843
1844DWORD WIN32API WriteTapemark(HANDLE hDevice,
1845 DWORD dwTapemarkType,
1846 DWORD dwTapemarkCount,
1847 BOOL bImmediate)
1848{
1849 dprintf(("KERNEL32: WriteTapemark(%08xh,%08xh,%08xh,%08xh) not implemented - ERROR_NOT_SUPPORTED.\n",
1850 hDevice,
1851 dwTapemarkType,
1852 dwTapemarkCount,
1853 bImmediate));
1854
1855 return (ERROR_NOT_SUPPORTED);
1856}
1857
1858
1859/*****************************************************************************
1860 * Name : DWORD CmdBatNotification
1861 * Purpose : Unknown, used by /winnt/cmd.exe
1862 * Parameters: Unknown (wrong)
1863 * Variables :
1864 * Result : Unknown
1865 * Remark :
1866 * Status : UNTESTED STUB
1867 *
1868 * Author : Patrick Haller [Tue, 1999/06/08 21:44]
1869 *****************************************************************************/
1870
1871DWORD WIN32API CmdBatNotification(DWORD x1)
1872{
1873 dprintf(("KERNEL32: CmdBatNotification(%08xh) not implemented\n",
1874 x1));
1875
1876 return (0);
1877}
1878
1879
1880/*****************************************************************************
1881 * Name : DWORD GetVDMCurrentDirectories
1882 * Purpose : Unknown, used by /winnt/cmd.exe
1883 * Parameters: Unknown (wrong)
1884 * Variables :
1885 * Result : Unknown
1886 * Remark :
1887 * Status : UNTESTED STUB
1888 *
1889 * Author : Patrick Haller [Tue, 1999/06/08 21:44]
1890 *****************************************************************************/
1891
1892DWORD WIN32API GetVDMCurrentDirectories(DWORD x1)
1893{
1894 dprintf(("KERNEL32: GetVDMCurrentDirectories(%08xh) not implemented\n",
1895 x1));
1896
1897 return (0);
1898}
1899
1900
1901/*****************************************************************************
1902 * Name : DWORD SetThreadPriorityBoost
1903 * Purpose : Unknown
1904 * Parameters: Unknown (wrong)
1905 * Variables :
1906 * Result : Unknown
1907 * Remark :
1908 * Status : UNTESTED STUB
1909 *
1910 * Author : Patrick Haller [Tue, 1999/06/08 21:44]
1911 *****************************************************************************/
1912
1913DWORD WIN32API SetThreadPriorityBoost(DWORD x1,
1914 DWORD x2)
1915{
1916 dprintf(("KERNEL32: SetThreadPriorityBoost(%08xh, %08xh) not implemented\n",
1917 x1,
1918 x2));
1919
1920 return (0);
1921}
Note: See TracBrowser for help on using the repository browser.