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

Last change on this file since 7159 was 6646, checked in by bird, 24 years ago

Added $Id:$ keyword.
File size: 81.0 KB
Line 
1/* $Id: stubs.cpp,v 1.32 2001-09-05 12:58:00 bird 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 WIN32API CancelIo
416 * Purpose : The CancelIO function cancels all pending input and output
417 * (I/O) operations that were issued by the calling thread for
418 * the specified file handle. The function does not cancel
419 * I/O operations issued for the file handle by other threads.
420 * Parameters: HANDLE hFile file handle for which to cancel I/O
421 * Variables :
422 * Result : If the function succeeds, the return value is nonzero All pending
423 * I/O operations issued by the calling thread for the file handle
424 * were successfully canceled.
425 * If the function fails, the return value is zero.
426 * To get extended error information, call GetLastError.
427 * Remark : If there are any I/O operations in progress for the specified
428 * file handle, and they were issued by the calling thread, the
429 * CancelIO function cancels them.
430 * Note that the I/O operations must have been issued as
431 * overlapped I/O. If they were not, the I/O operations would not
432 * have returned to allow the thread to call the CancelIO function.
433 * Calling the CancelIO function with a file handle that was not
434 * opened with FILE_FLAG_OVERLAPPED does nothing.
435 * All I/O operations that are canceled will complete with the
436 * error ERROR_OPERATION_ABORTED. All completion notifications
437 * for the I/O operations will occur normally.
438 * Status : UNTESTED STUB
439 *
440 * Author : Markus Montkowski [Thu, 1998/05/19 11:46]
441 *****************************************************************************/
442
443BOOL WIN32API CancelIo(HANDLE hFile)
444{
445
446 dprintf(("KERNEL32:CancelIo(%08x) not implemented\n",
447 hFile
448 ));
449
450 return (FALSE);
451}
452
453/*****************************************************************************
454 * Name : BOOL CancelWaitableTimer
455 * Purpose : The CancelWaitableTimer function sets the specified "waitable"
456 * timer to the inactive state.
457 * Parameters: HANDLE hTimer handle to a timer object
458 * Variables :
459 * Result : If the function succeeds, the return value is nonzero.
460 * If the function fails, the return value is zero.
461 * To get extended error information, call GetLastError.
462 * Remark : The CancelWaitableTimer function does not change the signaled
463 * state of the timer. It stops the timer before it can be set to
464 * the signaled state. Therefore, threads performing a wait
465 * operation on the timer remain waiting until they time out or
466 * the timer is reactivated and its state is set to signaled.
467 *
468 * To reactivate the timer, call the SetWaitableTimer function.
469 * Status : UNTESTED STUB
470 *
471 * Author : Markus Montkowski [Thu, 1998/05/19 11:46]
472 *****************************************************************************/
473
474BOOL WIN32API CancelWaitableTimer(HANDLE hTimer)
475{
476
477 dprintf(("KERNEL32:CancelWaitableTimer(%08x) not implemented\n",
478 hTimer
479 ));
480
481 return (FALSE);
482}
483
484
485/*****************************************************************************
486 * Name : LPVOID WIN32API CreateFiber
487 * Purpose : The CreateFiber function allocates a fiber object, assigns it a
488 * stack, and sets up execution to begin at the specified
489 * start address, typically the fiber function.
490 * This function does not schedule the fiber.
491 * Parameters: DWORD dwStackSize initial thread stack size, in bytes
492 * LPFIBER_START_ROUTINE lpStartAddress pointer to fiber function
493 * LPVOID lpParameter argument for new fiber
494 * Variables :
495 * Result : If the function succeeds, the return value is the address of
496 * the fiber.
497 * If the function fails, the return value is NULL.
498 * Remark : Before a thread can schedule a fiber using the SwitchToFiber
499 * function, it must call the ConvertThreadToFiber function so there
500 * is a fiber associated with the thread.
501 * The fiber function is of type FIBER_START_ROUTINE.
502 * It accepts a single value of type PVOID (fiber data) and does not
503 * return a value. The prototype for this function is as follows:
504 *
505 * VOID WINAPI FiberFunc( PVOID lpParameter );
506 *
507 * Status : UNTESTED STUB
508 *
509 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
510 *****************************************************************************/
511
512LPVOID WIN32API CreateFiber( DWORD dwStackSize,
513 LPFIBER_START_ROUTINE lpStartAddress,
514 LPVOID lpParameter)
515{
516
517 dprintf(("KERNEL32:CreateFiber(%08x,%08x,%08x) not implemented\n",
518 dwStackSize, lpStartAddress,lpParameter
519 ));
520
521 return (NULL);
522}
523
524
525/*****************************************************************************
526 * Name : HANDLE WIN32API CreateIoCompletionPort
527 * Purpose : The CreateIoCompletionPort function can associate an instance of
528 * an opened file with a newly created or an existing input/output
529 * completion port; or it can create an input/output completion port
530 * without associating it with a file.
531 * Associating an instance of an opened file with an input/output
532 * completion port lets an application receive notification of the
533 * completion of asynchronous input/output operations involving that
534 * file.
535 * Parameters: HANDLE FileHandle file handle to associate with I/O
536 * completion port. Must be created
537 * with flag FILE_FLAG_OVERLAPPED !
538 * HANDLE ExistingCompletionPort optional handle to existing
539 * I/O completion port
540 * DWORD CompletionKey per-file completion key for
541 * I/O completion packets
542 * DWORD NumberOfConcurrentThreads number of threads allowed to
543 * execute concurrently
544 * Variables :
545 * Result : If the function succeeds, the return value is the handle to the
546 * I/O completion port that is associated with the specified file.
547 * This return value is not NULL.
548 * If the function fails, the return value is NULL.
549 * Remark : The Win32 I/O system can be instructed to send I/O completion
550 * notification packets to input/output completion ports, where they
551 * are queued up. The CreateIoCompletionPort function provides a
552 * mechanism for this.
553 * When you perform an input/output operation with a file handle
554 * that has an associated input/output completion port, the
555 * I/O system sends a completion notification packet to the
556 * completion port when the I/O operation completes.
557 * The I/O completion port places the completion packet in a
558 * first-in-first-out queue.
559 * Use the GetQueuedCompletionStatus function to retrieve these
560 * queued I/O completion packets.
561 * Threads in the same process can use the PostQueuedCompletionStatus
562 * function to place I/O completion notification packets in a
563 * completion port's queue. This allows you to use the port to
564 * receive communications from other threads of the process,
565 * in addition to receiving I/O completion notification packets
566 * from the Win32 I/O system.
567 * Status : UNTESTED STUB
568 *
569 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
570 *****************************************************************************/
571
572HANDLE WIN32API CreateIoCompletionPort( HANDLE FileHandle,
573 HANDLE ExistingCompletionPort,
574 DWORD CompletionKey,
575 DWORD NumberOfConcurrentThreads)
576{
577
578 dprintf(("KERNEL32: CreateIoCompletionPort(%08x,%08x,%08x,%08x) not implemented\n",
579 FileHandle, ExistingCompletionPort, CompletionKey,
580 NumberOfConcurrentThreads
581 ));
582
583 return (NULL);
584}
585
586/*****************************************************************************
587 * Name : HANDLE WIN32API CreateRemoteThread
588 * Purpose : The CreateRemoteThread function creates a thread that runs in
589 * the address space of another process.
590 * Parameters: HANDLE hProcess handle to process to create thread in
591 * LPSECURITY_ATTRIBUTES lpThreadAttributes pointer to thread
592 * security attributes
593 * DWORD dwStackSize initial thread stack size, in bytes
594 * LPTHREAD_START_ROUTINE lpStartAddress pointer to thread function
595 * LPVOID lpParameter pointer to argument for new thread
596 * DWORD dwCreationFlags creation flags
597 * LPDWORD lpThreadId pointer to returned thread identifier
598 * Variables :
599 * Result : If the function succeeds, the return value is a handle to
600 * the new thread.
601 * If the function fails, the return value is NULL.
602 * Remark :
603 * Status : UNTESTED STUB
604 *
605 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
606 *****************************************************************************/
607
608HANDLE WIN32API CreateRemoteThread( HANDLE hProcess,
609 LPSECURITY_ATTRIBUTES lpThreadAttributes,
610 DWORD dwStackSize,
611 LPTHREAD_START_ROUTINE lpStartAddress,
612 LPVOID lpParameter,DWORD dwCreationFlags,
613 LPDWORD lpThreadId )
614{
615
616 dprintf(("KERNEL32: CreateRemoteThread(%08x,%08x,%08x,%08x,%08x,%08x,%08x) not implemented\n",
617 hProcess, lpThreadAttributes, dwStackSize, lpStartAddress,
618 lpParameter, dwCreationFlags, lpThreadId
619 ));
620
621 return (NULL);
622}
623/*****************************************************************************
624 * Name : DWORD WIN32API CreateTapePartition
625 * Purpose : The CreateTapePartition function reformats a tape.
626 * Parameters: HANDLE hDevice handle to open device
627 * DWORD dwPartitionMethode type of new partition
628 * DWORD dwCount number of new partitions to create
629 * DWORD dwSize size of new partition, in megabytes
630 * Variables :
631 * Result : If the function succeeds, the return value is NO_ERROR.
632 * If the function fails, it may return one of the following
633 * error codes:
634 * Error Description
635 * ERROR_BEGINNING_OF_MEDIA An attempt to access data before
636 * the beginning-of-medium marker failed.
637 * ERROR_BUS_RESET A reset condition was detected on the bus.
638 * ERROR_END_OF_MEDIA The end-of-tape marker was reached
639 * during an operation.
640 * ERROR_FILEMARK_DETECTED A filemark was reached during an operation.
641 * ERROR_SETMARK_DETECTED A setmark was reached during an operation.
642 * ERROR_NO_DATA_DETECTED The end-of-data marker was reached
643 * during an operation.
644 * ERROR_PARTITION_FAILURE The tape could not be partitioned.
645 * ERROR_INVALID_BLOCK_LENGTH The block size is incorrect on a
646 * new tape in a multivolume partition.
647 * ERROR_DEVICE_NOT_PARTITIONED The partition information could not
648 * be found when a tape was being loaded.
649 * ERROR_MEDIA_CHANGED The tape that was in the drive has
650 * been replaced or removed.
651 * ERROR_NO_MEDIA_IN_DRIVE There is no media in the drive.
652 * ERROR_NOT_SUPPORTED The tape driver does not support a
653 * requested function.
654 * ERROR_UNABLE_TO_LOCK_MEDIA An attempt to lock the ejection
655 * mechanism failed.
656 * ERROR_UNABLE_TO_UNLOAD_MEDIA An attempt to unload the tape failed.
657 * ERROR_WRITE_PROTECT The media is write protected.
658 * Remark : Creating partitions reformats the tape. All previous information
659 * recorded on the tape is destroyed.
660 * Errorcodes are defined in winerror.h
661 * Status : UNTESTED STUB
662 *
663 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
664 *****************************************************************************/
665
666DWORD WIN32API CreateTapePartition( HANDLE hDevice, DWORD dwPartitionMethod,
667 DWORD dwCount, DWORD dwSize)
668{
669
670 dprintf(("KERNEL32: CreateTapePartition(%08x,%08x,%08x,%08x) not implemented - ERROR_NOT_SUPPORTED\n",
671 hDevice, dwPartitionMethod, dwCount, dwSize
672 ));
673
674 return (ERROR_NOT_SUPPORTED);
675}
676/*****************************************************************************
677 * Name : HANDLE WIN23API CreateWaitableTimerA
678 * Purpose : The CreateWaitableTimerA function creates a "waitable" timer object.
679 * Parameters: LPSECURITY_ATTRIBUTES lpTimerAttributes pointer to security attributes
680 * BOOL bManualReset flag for manual reset state
681 * LPCTSTR lpTimerName pointer to timer object name
682 * Variables :
683 * Result : If the function succeeds, the return value is a handle to the
684 * timer object. If the named timer object exists before the
685 * function call, GetLastError returns ERROR_ALREADY_EXISTS.
686 * Otherwise, GetLastError returns zero.
687 * If the function fails, the return value is NULL
688 * Remark :
689 * Status : UNTESTED STUB
690 *
691 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
692 *****************************************************************************/
693
694HANDLE WIN32API CreateWaitableTimerA( LPSECURITY_ATTRIBUTES lpTimerAttributes,
695 BOOL bManualReset, LPCSTR lpTimerName)
696{
697
698 dprintf(("KERNEL32: CreateWaitableTimer(%08x,%08x,%08x) not implemented\n",
699 lpTimerAttributes, bManualReset, lpTimerName
700 ));
701
702 return (NULL);
703}
704
705/*****************************************************************************
706 * Name : HANDLE WIN23API CreateWaitableTimerW
707 * Purpose : The CreateWaitableTimerW function creates a "waitable" timer object.
708 * Parameters: LPSECURITY_ATTRIBUTES lpTimerAttributes pointer to security attributes
709 * BOOL bManualReset flag for manual reset state
710 * LPCTSTR lpTimerName pointer to timer object name
711 * Variables :
712 * Result : If the function succeeds, the return value is a handle to the
713 * timer object. If the named timer object exists before the
714 * function call, GetLastError returns ERROR_ALREADY_EXISTS.
715 * Otherwise, GetLastError returns zero.
716 * If the function fails, the return value is NULL
717 * Remark :
718 * Status : UNTESTED STUB
719 *
720 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
721 *****************************************************************************/
722
723HANDLE WIN32API CreateWaitableTimerW( LPSECURITY_ATTRIBUTES lpTimerAttributes,
724 BOOL bManualReset, LPCWSTR lpTimerName)
725{
726
727 dprintf(("KERNEL32: CreateWaitableTimer(%08x,%08x,%08x) not implemented\n",
728 lpTimerAttributes, bManualReset, lpTimerName
729 ));
730
731 return (NULL);
732}
733
734/*****************************************************************************
735 * Name : BOOL WIN32API DebugActiveProcess
736 * Purpose : The DebugActiveProcess function allows a debugger to attach to
737 * an active process and then debug it.
738 * Parameters: DWORD dwProcessId process to be debugged
739 * Variables :
740 * Result : If the function succeeds, the return value is nonzero.
741 * If the function fails, the return value is zero
742 * Remark :
743 * Status : UNTESTED STUB
744 *
745 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
746 *****************************************************************************/
747
748BOOL WIN32API DebugActiveProcess(DWORD dwProcessId)
749{
750
751 dprintf(("KERNEL32:DebugActiveProcess(%08x) not implemented\n",
752 dwProcessId
753 ));
754
755 return (FALSE);
756}
757
758/*****************************************************************************
759 * Name : BOOL WIN32API DefineDosDeviceA
760 * Purpose : The DefineDosDeviceA function lets an application define,
761 * redefine, or delete MS-DOS device names.
762 * MS-DOS device names are stored as symbolic links in the object
763 * name space in 32-bit versions of Windows. The code that converts
764 * an MS-DOS path into a corresponding path in 32-bit versions of
765 * Windows uses these symbolic links to map MS-DOS devices and drive
766 * letters. The DefineDosDevice function provides a mechanism
767 * whereby a Win32-based application can modify the symbolic links
768 * used to implement the MS-DOS device name space.
769 * Parameters: DWORD dwFlags flags specifying aspects of device definition
770 * LPCSTR lpDeviceName pointer to MS-DOS device name string
771 * LPCSTR lpTargetPath pointer to MS-DOS or path string for
772 * 32-bit Windows
773 * Variables :
774 * Result : If the function succeeds, the return value is nonzero.
775 * If the function fails, the return value is zero
776 * Remark :
777 * Status : UNTESTED STUB
778 *
779 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
780 *****************************************************************************/
781
782BOOL WIN32API DefineDosDeviceA( DWORD dwFlags, LPCSTR lpDeviceName,
783 LPCSTR lpTargetPath )
784{
785
786 dprintf(("KERNEL32: DefineDosDeviceA(%08x,%08x,%08x) not implemented\n",
787 dwFlags, lpDeviceName, lpTargetPath
788 ));
789
790 return (FALSE);
791}
792
793/*****************************************************************************
794 * Name : BOOL WIN32API DefineDosDeviceW
795 * Purpose : UNICODE version of DefineDosDeviceA
796 * Parameters: DWORD dwFlags flags specifying aspects of device definition
797 * LPCSTR lpDeviceName pointer to MS-DOS device name string
798 * LPCSTR lpTargetPath pointer to MS-DOS or path string for
799 * 32-bit Windows
800 * Variables :
801 * Result : If the function succeeds, the return value is nonzero.
802 * If the function fails, the return value is zero
803 * Remark :
804 * Status : UNTESTED STUB
805 *
806 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
807 *****************************************************************************/
808
809BOOL WIN32API DefineDosDeviceW( DWORD dwFlags, LPCWSTR lpDeviceName,
810 LPCWSTR lpTargetPath )
811{
812
813 dprintf(("KERNEL32: DefineDosDeviceW(%08x,%08x,%08x) not implemented\n",
814 dwFlags, lpDeviceName, lpTargetPath
815 ));
816
817 return (FALSE);
818}
819
820/*****************************************************************************
821 * Name : VOID WIN32API DeleteFiber
822 * Purpose : The DeleteFiber function deletes an existing fiber
823 * Parameters: LPVOID lpFiber pointer to the fiber to delete
824 * Variables :
825 * Result : No returnvalue
826 * Remark : The DeleteFiber function deletes all data associated with the
827 * fiber. This data includes the stack, a subset of the registers,
828 * and the fiber data. If the currently running fiber calls
829 * DeleteFiber, the ExitThread function is called and the thread
830 * terminates. If the currently running fiber is deleted by another
831 * thread, the thread associated with the fiber is likely to
832 * terminate abnormally because the fiber stack has been freed.
833 * Status : UNTESTED STUB
834 *
835 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
836 *****************************************************************************/
837
838VOID WIN32API DeleteFiber(LPVOID lpFiber)
839{
840
841 dprintf(("KERNEL32: DeleteFiber(%08x) not implemented\n",
842 lpFiber
843 ));
844}
845/*****************************************************************************
846 * Name : BOOL WIN3API EndUpdateResourceA
847 * Purpose : The EndUpdateResourceA function ends a resource update
848 * in an executable file.
849 * Parameters: HANDLE hUpdate update-file handle
850 * BOOL fDiscard write flag
851 * Variables :
852 * Result : If the function succeeds and the accumulated resource
853 * modifications specified by calls to the UpdateResource function
854 * are written to the specified executable file,
855 * the return value is nonzero.
856 * If the function fails, the return value is zero
857 * Remark :
858 * Status : UNTESTED STUB
859 *
860 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
861 *****************************************************************************/
862
863BOOL WIN32API EndUpdateResourceA(HANDLE hUpdate,BOOL fDiscard)
864{
865
866 dprintf(("KERNEL32:EndUpdateResourceA(%08x,%08x)not implemented\n",
867 hUpdate, fDiscard
868 ));
869
870 return (FALSE);
871}
872
873/*****************************************************************************
874 * Name : BOOL WIN3API EndUpdateResourceW
875 * Purpose : The EndUpdateResourceW function ends a resource update
876 * in an executable file.
877 * Parameters: HANDLE hUpdate update-file handle
878 * BOOL fDiscard write flag
879 * Variables :
880 * Result : If the function succeeds and the accumulated resource
881 * modifications specified by calls to the UpdateResource function
882 * are written to the specified executable file,
883 * the return value is nonzero.
884 * If the function fails, the return value is zero
885 * Remark :
886 * Status : UNTESTED STUB
887 *
888 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
889 *****************************************************************************/
890
891BOOL WIN32API EndUpdateResourceW(HANDLE hUpdate,BOOL fDiscard)
892{
893
894 dprintf(("KERNEL32:EndUpdateResourceW(%08x,%08x) not implemented\n",
895 hUpdate, fDiscard
896 ));
897
898 return (FALSE);
899}
900
901
902/*****************************************************************************
903 * Name : DWORD WIN32API EraseTape
904 * Purpose : The EraseTape function erases all or part of a tape.
905 * Parameters: HANDLE hDevice handle to open device
906 * DWORD dwEraseType type of erasure to perform
907 * BOOL bImmediate return after erase operation begins
908 * Variables :
909 * Result : If the function succeeds, the return value is NO_ERROR.
910 * If the function fails, the return value is like in
911 * CreateTapePartition
912 * Remark : Some tape devices do not support certain tape operations. To de
913 * termine your tape device's capabilities, see your tape device
914 * documentation and use the GetTapeParameters function
915 * Status : UNTESTED STUB
916 *
917 * Author : Markus Montkowski [Tha, 1998/05/21 20:57]
918 *****************************************************************************/
919
920DWORD WIN32API EraseTape( HANDLE hDevice, DWORD dwEraseType, BOOL bImmediate)
921{
922
923 dprintf(("KERNEL32: EraseTape(%08x,%08x,%08x) not implemented - ERROR_NOT_SUPPORTED\n",
924 hDevice, dwEraseType, bImmediate
925 ));
926
927 return (ERROR_NOT_SUPPORTED);
928}
929
930
931/*****************************************************************************
932 * Name : HANDLE WIN32API FindFirstFileExA
933 * Purpose : The FindFirstFileExA function searches a directory for a file
934 * whose name and attributes match those specified in the
935 * function call.
936 * Parameters: LPCSTR lpFileName pointer to the name of the file
937 * to search for
938 * FINDEX_INFO_LEVELS fInfoLevelId information level of the returned data
939 * LPVOID lpFindFileData pointer to the returned information
940 * FINDEX_SEARCH_OPS fSearchOp type of filtering to perform
941 * LPVOID lpSearchFilter pointer to search criteria
942 * DWORD dwAdditionalFlags additional search control flags
943 * Variables :
944 * Result : If the function succeeds, the return value is a search handle
945 * that can be used in a subsequent call to the FindNextFile or
946 * FindClose functions.
947 * If the function fails, the return value is INVALID_HANDLE_VALUE
948 * Remark :
949 * Status : UNTESTED STUB
950 *
951 * Author : Markus Montkowski [Tha, 1998/05/21 20:57]
952 *****************************************************************************/
953
954HANDLE WIN32API FindFirstFileExA( LPCSTR lpFileName,
955 FINDEX_INFO_LEVELS fInfoLevelId,
956 LPVOID lpFindFileData,
957 FINDEX_SEARCH_OPS fSearchOp,
958 LPVOID lpSearchFilter,
959 DWORD dwAdditionalFlags)
960{
961
962 dprintf(("KERNEL32: FindFirstFileExA(%08x,%08x,%08x,%08x,%08x,%08x)not implemented - INVALID_HANDLE_VALUE\n",
963 lpFileName,
964 fInfoLevelId,
965 lpFindFileData,
966 fSearchOp,
967 lpSearchFilter,
968 dwAdditionalFlags
969 ));
970
971 return (INVALID_HANDLE_VALUE);
972}
973
974/*****************************************************************************
975 * Name : HANDLE WIN32API FindFirstFileExW
976 * Purpose : The FindFirstFileExW function searches a directory for a file
977 * whose name and attributes match those specified in the
978 * function call.
979 * Parameters: LPCWSTR lpFileName pointer to the name of the file
980 * to search for
981 * FINDEX_INFO_LEVELS fInfoLevelId information level of the returned data
982 * LPVOID lpFindFileData pointer to the returned information
983 * FINDEX_SEARCH_OPS fSearchOp type of filtering to perform
984 * LPVOID lpSearchFilter pointer to search criteria
985 * DWORD dwAdditionalFlags additional search control flags
986 * Variables :
987 * Result : If the function succeeds, the return value is a search handle
988 * that can be used in a subsequent call to the FindNextFile or
989 * FindClose functions.
990 * If the function fails, the return value is INVALID_HANDLE_VALUE
991 * Remark :
992 * Status : UNTESTED STUB
993 *
994 * Author : Markus Montkowski [Tha, 1998/05/21 20:57]
995 *****************************************************************************/
996
997HANDLE WIN32API FindFirstFileExW( LPCWSTR lpFileName,
998 FINDEX_INFO_LEVELS fInfoLevelId,
999 LPVOID lpFindFileData,
1000 FINDEX_SEARCH_OPS fSearchOp,
1001 LPVOID lpSearchFilter,
1002 DWORD dwAdditionalFlags)
1003{
1004
1005 dprintf(("KERNEL32: FindFirstFileExW(%08x,%08x,%08x,%08x,%08x,%08x)not implemented - INVALID_HANDLE_VALUE\n",
1006 lpFileName,
1007 fInfoLevelId,
1008 lpFindFileData,
1009 fSearchOp,
1010 lpSearchFilter,
1011 dwAdditionalFlags
1012 ));
1013
1014 return (INVALID_HANDLE_VALUE);
1015}
1016
1017/*****************************************************************************
1018 * Name : int WIN32API FoldStringA
1019 * Purpose : The FoldStringW function maps one string to another, performing
1020 * a specified transformation option.
1021 * Parameters: DWORD dwMapFlags, // mapping transformation options
1022 * LPCSTR lpSrcStr, // pointer to source string
1023 * int cchSrc, // size of source string, in bytes or characters
1024 * LPSTR lpDestStr, // pointer to destination buffer
1025 * int cchDest // size of destination buffer, in bytes or characters
1026 * Variables :
1027 * Result : If the function succeeds, the return value is the number of bytes
1028 * (ANSI version) or characters (Unicode version) written to the
1029 * destination buffer, or if the cchDest parameter is zero,
1030 * the number of bytes or characters required to hold the mapped
1031 * string.
1032 * If the function fails, the return value is zero
1033 * Remark :
1034 * Status : UNTESTED STUB
1035 *
1036 * Author : Markus Montkowski [Tha, 1998/05/21 20:57]
1037 *****************************************************************************/
1038
1039int WIN32API FoldStringA( DWORD dwMapFlags, LPCSTR lpSrcStr,
1040 int cchSrc, LPSTR lpDestStr, int cchDest)
1041{
1042
1043 dprintf(("KERNEL32: FoldStringA(%08x,%08x,%08x,%08x,%08x) not implemented\n",
1044 dwMapFlags, lpSrcStr, cchSrc, lpDestStr, cchDest
1045 ));
1046
1047 return (0);
1048}
1049
1050/*****************************************************************************
1051 * Name : int WIN32API FoldStringW
1052 * Purpose : The FoldStringW function maps one string to another, performing
1053 * a specified transformation option.
1054 * Parameters: DWORD dwMapFlags, // mapping transformation options
1055 * LPCSTR lpSrcStr, // pointer to source string
1056 * int cchSrc, // size of source string, in bytes or characters
1057 * LPSTR lpDestStr, // pointer to destination buffer
1058 * int cchDest // size of destination buffer, in bytes or characters
1059 * Variables :
1060 * Result : If the function succeeds, the return value is the number of bytes
1061 * (ANSI version) or characters (Unicode version) written to the
1062 * destination buffer, or if the cchDest parameter is zero,
1063 * the number of bytes or characters required to hold the mapped
1064 * string.
1065 * If the function fails, the return value is zero
1066 * Remark :
1067 * Status : UNTESTED STUB
1068 *
1069 * Author : Markus Montkowski [Tha, 1998/05/21 20:57]
1070 *****************************************************************************/
1071
1072int WIN32API FoldStringW( DWORD dwMapFlags, LPCWSTR lpSrcStr,
1073 int cchSrc, LPWSTR lpDestStr, int cchDest)
1074{
1075
1076 dprintf(("KERNEL32: FoldStringA(%08x,%08x,%08x,%08x,%08x) not implemented\n",
1077 dwMapFlags, lpSrcStr, cchSrc, lpDestStr, cchDest
1078 ));
1079
1080 return (0);
1081}
1082
1083
1084/*****************************************************************************
1085 * Name : DWORD GetHandleInformation
1086 * Purpose : The GetHandleInformation function obtains information about certain
1087 * properties of an object handle. The information is obtained as a set of bit flags.
1088 * Parameters: HANDLE hObject
1089 * LPDWORD lpdwFlags
1090 * Variables :
1091 * Result : TRUE / FALSE
1092 * Remark :
1093 * Status : UNTESTED STUB
1094 *
1095 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1096 *****************************************************************************/
1097
1098BOOL WIN32API GetHandleInformation(HANDLE hObject,
1099 LPDWORD lpdwFlags)
1100{
1101 dprintf(("KERNEL32: GetHandleInformation (%08xh, %08xh) not implemented\n",
1102 hObject,
1103 lpdwFlags));
1104
1105 return (FALSE);
1106}
1107
1108
1109
1110
1111/*****************************************************************************
1112 * Name : BOOL GetQueuedCompletionStatus
1113 * Purpose : The GetQueuedCompletionStatus function attempts to dequeue an
1114 * I/O completion packet from a specified input/output completion
1115 * port. If there is no completion packet queued, the function waits
1116 * for a pending input/output operation associated with the completion
1117 * port to complete. The function returns when it can dequeue a
1118 * completion packet, or optionally when the function times out. If
1119 * the function returns because of an I/O operation completion, it
1120 * sets several variables that provide information about the operation.
1121 * Parameters: HANDLE CompletionPort the I/O completion port of interest
1122 * LPDWORD lpNumberOfBytesTransferred to receive number of bytes transferred during I/O
1123 * LPDWORD lpCompletionKey to receive file's completion key
1124 * LPOVERLAPPED * lpOverlapped to receive pointer to OVERLAPPED structure
1125 * DWORD dwMilliseconds optional timeout value
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 GetQueuedCompletionStatus(HANDLE CompletionPort,
1135 LPDWORD lpNumberOfBytesTransferred,
1136 LPDWORD lpCompletionKey,
1137 LPOVERLAPPED *lpOverlapped,
1138 DWORD dwMilliseconds)
1139{
1140 dprintf(("Kernel32: GetQueuedCompletionStatus(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.",
1141 CompletionPort,
1142 lpNumberOfBytesTransferred,
1143 lpCompletionKey,
1144 lpOverlapped,
1145 dwMilliseconds));
1146
1147 return (FALSE);
1148}
1149
1150
1151
1152/*****************************************************************************
1153 * Name : BOOL GetSystemTimeAdjustment
1154 * Purpose : The GetSystemTimeAdjustment function determines whether the system
1155 * is applying periodic time adjustments to its time-of-day clock
1156 * at each clock interrupt, along with the value and period of any
1157 * such adjustments. Note that the period of such adjustments is
1158 * equivalent to the time period between clock interrupts.
1159 * Parameters: PDWORD lpTimeAdjustment
1160 * size, in 100-nanosecond units, of a periodic time adjustment
1161 * PDWORD lpTimeIncrement
1162 * time, in 100-nanosecond units, between periodic time adjustments
1163 * PBOOL lpTimeAdjustmentDisabled
1164 * whether periodic time adjustment is disabled or enabled
1165 * Variables :
1166 * Result : TRUE / FALSE
1167 * Remark :
1168 * Status : UNTESTED STUB
1169 *
1170 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1171 *****************************************************************************/
1172
1173BOOL WIN32API GetSystemTimeAdjustment(PDWORD lpTimeAdjustment,
1174 PDWORD lpTimeIncrement,
1175 PBOOL lpTimeAdjustmentDisabled)
1176{
1177 dprintf(("KERNEL32: GetSystemTimeAdjustment(%08xh,%08xh,%08xh) not implemented.\n",
1178 lpTimeAdjustment,
1179 lpTimeIncrement,
1180 lpTimeAdjustmentDisabled));
1181
1182 return (FALSE);
1183}
1184
1185
1186/*****************************************************************************
1187 * Name : BOOL GetTapeParameters
1188 * Purpose : The GetTapeParameters function retrieves information that
1189 * describes the tape or the tape drive.
1190 * Parameters: HANDLE hDevice handle of open device
1191 * DWORD dwOperation type of information requested
1192 * LPDWORD lpdwSize address of returned information
1193 * LPVOID lpTapeInformation tape media or drive information
1194 * Variables :
1195 * Result : API returncode
1196 * Remark :
1197 * Status : UNTESTED STUB
1198 *
1199 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1200 *****************************************************************************/
1201
1202DWORD WIN32API GetTapeParameters(HANDLE hDevice,
1203 DWORD dwOperation,
1204 LPDWORD lpdwSize,
1205 LPVOID lpTapeInformation)
1206{
1207 dprintf(("KERNEL32: GetTapeParameters(%08xh,%08xh,%08xh,%08xh) not implemented - ERROR_NOT_SUPPORTED.\n",
1208 hDevice,
1209 dwOperation,
1210 lpdwSize,
1211 lpTapeInformation));
1212
1213 return (ERROR_NOT_SUPPORTED);
1214}
1215
1216
1217/*****************************************************************************
1218 * Name : BOOL GetTapePosition
1219 * Purpose : The GetTapePosition function retrieves the current address of
1220 * the tape, in logical or absolute blocks.
1221 * Parameters: HANDLE hDevice handle of open device
1222 * DWORD dwPositionType type of address to obtain
1223 * LPDWORD lpdwPartition address of current tape partition
1224 * LPDWORD lpdwOffsetLow address of low-order 32 bits of tape position
1225 * LPDWORD lpdwOffsetHigh address of high-order 32 bits of tape position
1226 * Variables :
1227 * Result : TRUE / FALSE
1228 * Remark :
1229 * Status : UNTESTED STUB
1230 *
1231 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1232 *****************************************************************************/
1233
1234DWORD WIN32API GetTapePosition(HANDLE hDevice,
1235 DWORD dwPositionType,
1236 LPDWORD lpdwPartition,
1237 LPDWORD lpdwOffsetLow,
1238 LPDWORD lpdwOffsetHigh)
1239{
1240 dprintf(("KERNEL32: OS2GetTapePosition(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented - ERROR_NOT_SUPPORTED.\n",
1241 hDevice,
1242 dwPositionType,
1243 lpdwPartition,
1244 lpdwOffsetLow,
1245 lpdwOffsetHigh));
1246
1247 return (ERROR_NOT_SUPPORTED);
1248}
1249
1250
1251/*****************************************************************************
1252 * Name : BOOL GetTapeStatus
1253 * Purpose : The GetTapeStatus function indicates whether the tape device is
1254 * ready to process tape commands.
1255 * Parameters: HANDLE hDevice handle of open device
1256 * Variables :
1257 * Result : API returncode
1258 * Remark :
1259 * Status : UNTESTED STUB
1260 *
1261 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1262 *****************************************************************************/
1263
1264DWORD WIN32API GetTapeStatus(HANDLE hDevice)
1265{
1266 dprintf(("KERNEL32: OS2GetTapeStatus(%08xh) not implemented - ERROR_NOT_SUPPORTED.\n",
1267 hDevice));
1268
1269 return (ERROR_NOT_SUPPORTED);
1270}
1271
1272
1273/*****************************************************************************
1274 * Name : BOOL GetThreadSelectorEntry
1275 * Purpose : The GetThreadSelectorEntry function retrieves a descriptor table
1276 * entry for the specified selector and thread.
1277 * Parameters: HANDLE hThread handle of thread that contains selector
1278 * DWORD dwSelector number of selector value to look up
1279 * LPLDT_ENTRY lpSelectorEntry address of selector entry structure
1280 * Variables :
1281 * Result : TRUE / FALSE
1282 * Remark :
1283 * Status : UNTESTED STUB
1284 *
1285 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1286 *****************************************************************************/
1287
1288BOOL WIN32API GetThreadSelectorEntry(HANDLE hThread,
1289 DWORD dwSelector,
1290 LPLDT_ENTRY lpSelectorEntry)
1291{
1292 dprintf(("KERNEL32: GetThreadSelectorEntry(%08xh,%08xh,%08xh) not implemented.\n",
1293 hThread,
1294 dwSelector,
1295 lpSelectorEntry));
1296
1297 return (FALSE);
1298}
1299
1300
1301/*****************************************************************************
1302 * Name : BOOL GetThreadTimes
1303 * Purpose : The GetThreadTimes function obtains timing information about a specified thread.
1304 * Parameters: HANDLE hThread specifies the thread of interest
1305 * LPFILETIME lpCreationTime when the thread was created
1306 * LPFILETIME lpExitTime when the thread exited
1307 * LPFILETIME lpKernelTime time the thread has spent in kernel mode
1308 * LPFILETIME lpUserTime time the thread has spent in user mode
1309 * Variables :
1310 * Result : TRUE / FALSE
1311 * Remark :
1312 * Status : UNTESTED STUB
1313 *
1314 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1315 *****************************************************************************/
1316
1317BOOL WIN32API GetThreadTimes(HANDLE hThread,
1318 LPFILETIME lpCreationTime,
1319 LPFILETIME lpExitTime,
1320 LPFILETIME lpKernelTime,
1321 LPFILETIME lpUserTime)
1322{
1323 dprintf(("Kernel32: GetThreadTimes(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1324 hThread,
1325 lpCreationTime,
1326 lpExitTime,
1327 lpKernelTime,
1328 lpUserTime));
1329
1330 return (FALSE);
1331}
1332
1333
1334
1335/*****************************************************************************
1336 * Name : BOOL PostQueuedCompletionStatus
1337 * Purpose : The PostQueuedCompletionStatus function lets you post an I/O
1338 * completion packet to an I/O completion port. The I/O completion
1339 * packet will satisfy an outstanding call to the GetQueuedCompletionStatus
1340 * function. The GetQueuedCompletionStatus function returns with the three
1341 * values passed as the second, third, and fourth parameters of the call
1342 * to PostQueuedCompletionStatus.
1343 * Parameters: HANDLE CompletionPort handle to an I/O completion port
1344 * DWORD dwNumberOfBytesTransferred
1345 * DWORD dwCompletionKey
1346 * LPOVERLAPPED lpOverlapped
1347 * Variables :
1348 * Result : TRUE / FALSE
1349 * Remark :
1350 * Status : UNTESTED STUB
1351 *
1352 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1353 *****************************************************************************/
1354
1355BOOL WIN32API PostQueuedCompletionStatus(HANDLE CompletionPort,
1356 DWORD dwNumberOfBytesTransferred,
1357 DWORD dwCompletionKey,
1358 LPOVERLAPPED lpOverlapped)
1359{
1360 dprintf(("Kernel32: PostQueuedCompletionStatus(%08xh,%08xh,%08xh,%08xh) not implemented.",
1361 CompletionPort,
1362 dwNumberOfBytesTransferred,
1363 dwCompletionKey,
1364 lpOverlapped));
1365
1366 return (FALSE);
1367}
1368
1369
1370/*****************************************************************************
1371 * Name : DWORD PrepareTape
1372 * Purpose : The PrepareTape function prepares the tape to be accessed or removed.
1373 * Parameters: HANDLE hDevice handle of open device
1374 * DWORD dwOperation preparation method
1375 * BOOL bImmediate return after operation begins
1376 * Variables :
1377 * Result : API returncode
1378 * Remark :
1379 * Status : UNTESTED STUB
1380 *
1381 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1382 *****************************************************************************/
1383
1384DWORD WIN32API PrepareTape(HANDLE hDevice,
1385 DWORD dwOperation,
1386 BOOL bImmediate)
1387{
1388 dprintf(("Kernel32: PrepareTape(%08xh,%08xh,%08xh) not implemented - ERROR_NOT_SUPPORTED.\n",
1389 hDevice,
1390 dwOperation,
1391 bImmediate));
1392
1393 return (ERROR_NOT_SUPPORTED);
1394}
1395
1396
1397/*****************************************************************************
1398 * Name : DWORD QueryDosDeviceA
1399 * Purpose : The QueryDosDevice function lets an application obtain information
1400 * about MS-DOS device names. The function can obtain the current
1401 * mapping for a particular MS-DOS device name. The function can also
1402 * obtain a list of all existing MS-DOS device names.
1403 * MS-DOS device names are stored as symbolic links in the Windows NT
1404 * object name space. The code that converts an MS-DOS path into a
1405 * corresponding Windows NT path uses these symbolic links to map
1406 * MS-DOS devices and drive letters. The QueryDosDevice function
1407 * provides a mechanism whereby a Win32-based application can query
1408 * the names of the symbolic links used to implement the MS-DOS device
1409 * namespace as well as the value of each specific symbolic link.
1410 * Parameters: LPCTSTR lpDeviceName address of MS-DOS device name string
1411 * LPTSTR lpTargetPath ddress of buffer for storing query results
1412 * DWORD ucchMax maximum storage capacity of buffer
1413 * Variables :
1414 * Result : pointer to lpTargetPath
1415 * Remark :
1416 * Status : UNTESTED STUB
1417 *
1418 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1419 *****************************************************************************/
1420
1421DWORD WIN32API QueryDosDeviceA(LPCTSTR lpDeviceName,
1422 LPTSTR lpTargetPath,
1423 DWORD ucchMax)
1424{
1425 dprintf(("Kernel32: QueryDosDeviceA(%s,%08xh,%08xh) not implemented.\n",
1426 lpDeviceName,
1427 lpTargetPath,
1428 ucchMax));
1429
1430 return (0);
1431}
1432
1433
1434/*****************************************************************************
1435 * Name : DWORD QueryDosDeviceW
1436 * Purpose : The QueryDosDevice function lets an application obtain information
1437 * about MS-DOS device names. The function can obtain the current
1438 * mapping for a particular MS-DOS device name. The function can also
1439 * obtain a list of all existing MS-DOS device names.
1440 * MS-DOS device names are stored as symbolic links in the Windows NT
1441 * object name space. The code that converts an MS-DOS path into a
1442 * corresponding Windows NT path uses these symbolic links to map
1443 * MS-DOS devices and drive letters. The QueryDosDevice function
1444 * provides a mechanism whereby a Win32-based application can query
1445 * the names of the symbolic links used to implement the MS-DOS device
1446 * namespace as well as the value of each specific symbolic link.
1447 * Parameters: LPCTSTR lpDeviceName address of MS-DOS device name string
1448 * LPTSTR lpTargetPath ddress of buffer for storing query results
1449 * DWORD ucchMax maximum storage capacity of buffer
1450 * Variables :
1451 * Result : pointer to lpTargetPath
1452 * Remark :
1453 * Status : UNTESTED STUB
1454 *
1455 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1456 *****************************************************************************/
1457
1458DWORD WIN32API QueryDosDeviceW(LPCWSTR lpDeviceName,
1459 LPWSTR lpTargetPath,
1460 DWORD ucchMax)
1461{
1462 dprintf(("Kernel32: QueryDosDeviceW(%s,%08xh,%08xh) not implemented.\n",
1463 lpDeviceName,
1464 lpTargetPath,
1465 ucchMax));
1466
1467 return (0);
1468}
1469
1470
1471/*****************************************************************************
1472 * Name : DWORD ReadProcessMemory
1473 * Purpose : The ReadProcessMemory function reads memory in a specified process.
1474 * The entire area to be read must be accessible, or the operation fails.
1475 * Parameters: HANDLE hProcess handle of the process whose memory is read
1476 * LPCVOID lpBaseAddress address to start reading
1477 * LPVOID lpBuffer address of buffer to place read data
1478 * DWORD cbRead number of bytes to read
1479 * LPDWORD lpNumberOfBytesRead address of number of bytes read
1480 * Variables :
1481 * Result : TRUE / FALSE
1482 * Remark :
1483 * Status : UNTESTED STUB
1484 *
1485 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1486 *****************************************************************************/
1487
1488DWORD WIN32API ReadProcessMemory(HANDLE hProcess,
1489 LPCVOID lpBaseAddress,
1490 LPVOID lpBuffer,
1491 DWORD cbRead,
1492 LPDWORD lpNumberOfBytesRead)
1493{
1494 dprintf(("Kernel32: ReadProcessMemory(%08xh,%08xh,%08xh,%08xh,%08xh) not completely implemented",
1495 hProcess,
1496 lpBaseAddress,
1497 lpBuffer,
1498 cbRead,
1499 lpNumberOfBytesRead));
1500
1501 // do some (faked) access check
1502 if(hProcess != GetCurrentProcess())
1503 {
1504 dprintf(("WARNING: ReadProcessMemory: can't read memory from other processes!"));
1505 SetLastError(ERROR_ACCESS_DENIED);
1506 return FALSE;
1507 }
1508
1509 if(IsBadReadPtr(lpBaseAddress, cbRead)) {
1510 dprintf(("ERROR: ReadProcessMemory bad source pointer!"));
1511 if(lpNumberOfBytesRead)
1512 *lpNumberOfBytesRead = 0;
1513 SetLastError(ERROR_ACCESS_DENIED);
1514 return FALSE;
1515 }
1516 // FIXME: check this, if we ever run win32 binaries in different addressspaces
1517 // ... and add a sizecheck
1518 memcpy(lpBuffer,lpBaseAddress,cbRead);
1519 if(lpNumberOfBytesRead)
1520 *lpNumberOfBytesRead = cbRead;
1521
1522 SetLastError(ERROR_SUCCESS);
1523 return TRUE;
1524}
1525
1526/*****************************************************************************
1527 * Name : DWORD WriteProcessMemory
1528 * Purpose : The WriteProcessMemory function writes memory in a specified
1529 * process. The entire area to be written to must be accessible,
1530 * or the operation fails.
1531 * Parameters: HANDLE hProcess handle of process whose memory is written to
1532 * LPVOID lpBaseAddress address to start writing to
1533 * LPVOID lpBuffer address of buffer to write data to
1534 * DWORD cbWrite number of bytes to write
1535 * LPDWORD lpNumberOfBytesWritten actual number of bytes written
1536 * Variables :
1537 * Result : TRUE / FALSE
1538 * Remark :
1539 * Status : UNTESTED STUB
1540 *
1541 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1542 *****************************************************************************/
1543
1544BOOL WIN32API WriteProcessMemory(HANDLE hProcess,
1545 LPCVOID lpBaseAddress,
1546 LPVOID lpBuffer,
1547 DWORD cbWrite,
1548 LPDWORD lpNumberOfBytesWritten)
1549{
1550 // do some (faked) access check
1551 if(hProcess != GetCurrentProcess())
1552 {
1553 dprintf(("Kernel32: WriteProcessMemory(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented (different process!!)",
1554 hProcess, lpBaseAddress, lpBuffer, cbWrite, lpNumberOfBytesWritten));
1555 SetLastError(ERROR_ACCESS_DENIED);
1556 return FALSE;
1557 }
1558 dprintf(("Kernel32: WriteProcessMemory(%08xh,%08xh,%08xh,%08xh,%08xh))",
1559 hProcess,lpBaseAddress, lpBuffer, cbWrite, lpNumberOfBytesWritten));
1560
1561 if(IsBadWritePtr((LPVOID)lpBaseAddress, cbWrite))
1562 {
1563 dprintf(("ERROR: WriteProcessMemory bad destination pointer!"));
1564 if(lpNumberOfBytesWritten)
1565 *lpNumberOfBytesWritten = 0;
1566 SetLastError(ERROR_ACCESS_DENIED);
1567 return FALSE;
1568 }
1569
1570 // FIXME: check this, if we ever run win32 binaries in different addressspaces
1571 // ... and add a sizecheck
1572 memcpy((void*)lpBaseAddress,lpBuffer,cbWrite);
1573 if(lpNumberOfBytesWritten)
1574 *lpNumberOfBytesWritten = cbWrite;
1575
1576 SetLastError(ERROR_SUCCESS);
1577 return TRUE;
1578}
1579
1580
1581/*****************************************************************************
1582 * Name : BOOL SetComputerNameA
1583 * Purpose : The SetComputerNameA function sets the computer name to be used
1584 * the next time the system is restarted.
1585 * Parameters: LPCTSTR lpszName address of new computer name
1586 * Variables :
1587 * Result : TRUE / FALSE
1588 * Remark :
1589 * Status : UNTESTED STUB
1590 *
1591 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1592 *****************************************************************************/
1593
1594BOOL WIN32API SetComputerNameA(LPCTSTR lpszName)
1595{
1596 dprintf(("Kernel32: SetComputerNameA(%s) not implemented.\n",
1597 lpszName));
1598
1599 return (FALSE);
1600}
1601
1602
1603/*****************************************************************************
1604 * Name : BOOL SetComputerNameW
1605 * Purpose : The SetComputerNameW function sets the computer name to be used
1606 * the next time the system is restarted.
1607 * Parameters: LPCTSTR lpszName address of new computer name
1608 * Variables :
1609 * Result : TRUE / FALSE
1610 * Remark :
1611 * Status : UNTESTED STUB
1612 *
1613 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1614 *****************************************************************************/
1615
1616BOOL WIN32API SetComputerNameW(LPCWSTR lpszName)
1617{
1618 dprintf(("Kernel32: SetComputerNameW(%s) not implemented.\n",
1619 lpszName));
1620
1621 return (FALSE);
1622}
1623
1624
1625/*****************************************************************************
1626 * Name : VOID SetFileApisToOEM
1627 * Purpose : The SetFileApisToOEM function causes a set of Win32 file functions
1628 * to use the OEM character set code page. This function is useful
1629 * for 8-bit console input and output operations.
1630 * Parameters: VOID
1631 * Variables :
1632 * Result :
1633 * Remark :
1634 * Status : UNTESTED STUB
1635 *
1636 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1637 *****************************************************************************/
1638
1639VOID WIN32API SetFileApisToOEM(VOID)
1640{
1641 dprintf(("Kernel32: SetFileApisToOEM() not implemented.\n"));
1642}
1643
1644
1645/*****************************************************************************
1646 * Name : BOOL SetHandleInformation
1647 * Purpose : The SetHandleInformation function sets certain properties of an
1648 * object handle. The information is specified as a set of bit flags.
1649 * Parameters: HANDLE hObject handle to an object
1650 * DWORD dwMask specifies flags to change
1651 * DWORD dwFlags specifies new values for flags
1652 * Variables :
1653 * Result : TRUE / FALSE
1654 * Remark :
1655 * Status : UNTESTED STUB
1656 *
1657 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1658 *****************************************************************************/
1659
1660BOOL WIN32API SetHandleInformation(HANDLE hObject,
1661 DWORD dwMask,
1662 DWORD dwFlags)
1663{
1664 dprintf(("KERNEL32: SetHandleInformation(%08xh,%08xh,%08xh) not implemented.\n",
1665 hObject,
1666 dwMask,
1667 dwFlags));
1668
1669 return (FALSE);
1670}
1671
1672/*****************************************************************************
1673 * Name : BOOL SetSystemPowerState
1674 * Purpose : The SetSystemPowerState function suspends the system by shutting
1675 * power down. Depending on the ForceFlag parameter, the function
1676 * either suspends operation immediately or requests permission from
1677 * all applications and device drivers before doing so.
1678 * Parameters: BOOL fSuspend
1679 * BOOL fForce
1680 * Variables :
1681 * Result : TRUE / FALSE
1682 * Remark :
1683 * Status : UNTESTED STUB
1684 *
1685 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1686 *****************************************************************************/
1687
1688BOOL WIN32API SetSystemPowerState(BOOL fSuspend,
1689 BOOL fForce)
1690{
1691 dprintf(("KERNEL32: SetSystemPowerState(%08xh,%08xh) not implemented.\n",
1692 fSuspend,
1693 fForce));
1694
1695 return (FALSE);
1696}
1697
1698
1699/*****************************************************************************
1700 * Name : BOOL SetSystemTimeAdjustment
1701 * Purpose : The SetSystemTimeAdjustment function tells the system to enable
1702 * or disable periodic time adjustments to its time of day clock.
1703 * Such time adjustments are used to synchronize the time of day
1704 * with some other source of time information. When periodic time
1705 * adjustments are enabled, they are applied at each clock interrupt.
1706 * Parameters: DWORD dwTimeAdjustment
1707 * BOOL bTimeAdjustmentDisabled
1708 * Variables :
1709 * Result : TRUE / FALSE
1710 * Remark :
1711 * Status : UNTESTED STUB
1712 *
1713 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1714 *****************************************************************************/
1715
1716BOOL WIN32API SetSystemTimeAdjustment(DWORD dwTimeAdjustment,
1717 BOOL bTimeAdjustmentDisabled)
1718{
1719 dprintf(("KERNEL32: SetSystemTimeAdjustment(%08xh,%08xh) not implemented.\n",
1720 dwTimeAdjustment,
1721 bTimeAdjustmentDisabled));
1722
1723 return (FALSE);
1724}
1725
1726
1727/*****************************************************************************
1728 * Name : DWORD SetTapeParameters
1729 * Purpose : The SetTapeParameters function either specifies the block size
1730 * of a tape or configures the tape device.
1731 * Parameters: HANDLE hDevice handle of open device
1732 * DWORD dwOperation type of information to set
1733 * LPVOID lpTapeInformation address of buffer with information to set
1734 * Variables :
1735 * Result : API returncode
1736 * Remark :
1737 * Status : UNTESTED STUB
1738 *
1739 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1740 *****************************************************************************/
1741
1742BOOL WIN32API SetTapeParameters(HANDLE hDevice,
1743 DWORD dwOperation,
1744 LPVOID lpTapeInformation)
1745{
1746 dprintf(("KERNEL32: SetTapeParameters(%08xh,%08xh,%08xh) not implemented - ERROR_NOT_SUPPORTED.\n",
1747 hDevice,
1748 dwOperation,
1749 lpTapeInformation));
1750
1751 return (ERROR_NOT_SUPPORTED);
1752}
1753
1754
1755/*****************************************************************************
1756 * Name : DWORD SetTapePosition
1757 * Purpose : The SetTapePosition sets the tape position on the specified device.
1758 * Parameters: HANDLE hDevice handle of open device
1759 * DWORD dwPositionMethod type of positioning to perform
1760 * DWORD dwPartition new tape partition
1761 * DWORD dwOffsetLow low-order 32 bits of tape position
1762 * DWORD dwOffsetHigh high-order 32 bits of tape position
1763 * BOOL bImmediate return after operation begins
1764 * Variables :
1765 * Result : API returncode
1766 * Remark :
1767 * Status : UNTESTED STUB
1768 *
1769 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1770 *****************************************************************************/
1771
1772BOOL WIN32API SetTapePosition(HANDLE hDevice,
1773 DWORD dwPositionMethod,
1774 DWORD dwPartition,
1775 DWORD dwOffsetLow,
1776 DWORD dwOffsetHigh,
1777 BOOL bImmediate)
1778{
1779 dprintf(("KERNEL32: SetTapePosition(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented - ERROR_NOT_SUPPORTED.\n",
1780 hDevice,
1781 dwPositionMethod,
1782 dwPartition,
1783 dwOffsetLow,
1784 dwOffsetHigh,
1785 bImmediate));
1786
1787 return (ERROR_NOT_SUPPORTED);
1788}
1789
1790
1791/*****************************************************************************
1792 * Name : DWORD SetThreadAffinityMask
1793 * Purpose : The SetThreadAffinityMask function sets a processor affinity
1794 * mask for a specified thread.
1795 * A thread affinity mask is a bit vector in which each bit
1796 * represents the processors that a thread is allowed to run on.
1797 * A thread affinity mask must be a proper subset of the process
1798 * affinity mask for the containing process of a thread. A thread
1799 * is only allowed to run on the processors its process is allowed to run on.
1800 * Parameters: HANDLE hThread handle to the thread of interest
1801 * DWORD dwThreadAffinityMask a thread affinity mask
1802 * Variables :
1803 * Result : TRUE / FALSE
1804 * Remark :
1805 * Status : UNTESTED STUB
1806 *
1807 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1808 *****************************************************************************/
1809
1810DWORD WIN32API SetThreadAffinityMask(HANDLE hThread,
1811 DWORD dwThreadAffinityMask)
1812{
1813 dprintf(("KERNEL32: SetThreadAffinityMask(%08xh,%08xh) not implemented.\n",
1814 hThread,
1815 dwThreadAffinityMask));
1816
1817 return (0);
1818}
1819
1820
1821
1822/*****************************************************************************
1823 * Name : BOOL UpdateResourceA
1824 * Purpose : The UpdateResourceA function adds, deletes, or replaces a resource
1825 * in an executable file.
1826 * Parameters: HANDLE hUpdateFile update-file handle
1827 * LPCTSTR lpszType address of resource type to update
1828 * LPCTSTR lpszName address of resource name to update
1829 * WORD IDLanguage language identifier of resource
1830 * LPVOID lpvData address of resource data
1831 * DWORD cbData length of resource data, in bytes
1832 * Variables :
1833 * Result : TRUE / FALSE
1834 * Remark :
1835 * Status : UNTESTED STUB
1836 *
1837 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1838 *****************************************************************************/
1839
1840BOOL WIN32API UpdateResourceA(HANDLE hUpdateFile,
1841 LPCTSTR lpszType,
1842 LPCTSTR lpszName,
1843 WORD IDLanguage,
1844 LPVOID lpvData,
1845 DWORD cbData)
1846{
1847 dprintf(("KERNEL32: UpdateResourceA(%08xh,%s,%s,%08xh,%08xh,%08xh) not implemented.\n",
1848 hUpdateFile,
1849 lpszType,
1850 lpszName,
1851 IDLanguage,
1852 lpvData,
1853 cbData));
1854
1855 return (FALSE);
1856}
1857
1858
1859/*****************************************************************************
1860 * Name : BOOL UpdateResourceW
1861 * Purpose : The UpdateResourceW function adds, deletes, or replaces a resource
1862 * in an executable file.
1863 * Parameters: HANDLE hUpdateFile update-file handle
1864 * LPCTSTR lpszType address of resource type to update
1865 * LPCTSTR lpszName address of resource name to update
1866 * WORD IDLanguage language identifier of resource
1867 * LPVOID lpvData address of resource data
1868 * DWORD cbData length of resource data, in bytes
1869 * Variables :
1870 * Result : TRUE / FALSE
1871 * Remark :
1872 * Status : UNTESTED STUB
1873 *
1874 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1875 *****************************************************************************/
1876
1877BOOL WIN32API UpdateResourceW(HANDLE hUpdateFile,
1878 LPCWSTR lpszType,
1879 LPCWSTR lpszName,
1880 WORD IDLanguage,
1881 LPVOID lpvData,
1882 DWORD cbData)
1883{
1884 dprintf(("KERNEL32: UpdateResourceW(%08xh,%s,%s,%08xh,%08xh,%08xh) not implemented.\n",
1885 hUpdateFile,
1886 lpszType,
1887 lpszName,
1888 IDLanguage,
1889 lpvData,
1890 cbData));
1891
1892 return (FALSE);
1893}
1894
1895/*****************************************************************************
1896 * Name : BOOL WriteTapemark
1897 * Purpose : The WriteTapemark function writes a specified number of filemarks,
1898 * setmarks, short filemarks, or long filemarks to a tape device.
1899 * These tapemarks divide a tape partition into smaller areas.
1900 * Parameters: HANDLE hDevice handle of open device
1901 * DWORD dwTapemarkType type of tapemarks to write
1902 * DWORD dwTapemarkCount number of tapemarks to write
1903 * BOOL bImmediate return after write begins
1904 * Variables :
1905 * Result : API returncode
1906 * Remark :
1907 * Status : UNTESTED STUB
1908 *
1909 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1910 *****************************************************************************/
1911
1912DWORD WIN32API WriteTapemark(HANDLE hDevice,
1913 DWORD dwTapemarkType,
1914 DWORD dwTapemarkCount,
1915 BOOL bImmediate)
1916{
1917 dprintf(("KERNEL32: WriteTapemark(%08xh,%08xh,%08xh,%08xh) not implemented - ERROR_NOT_SUPPORTED.\n",
1918 hDevice,
1919 dwTapemarkType,
1920 dwTapemarkCount,
1921 bImmediate));
1922
1923 return (ERROR_NOT_SUPPORTED);
1924}
1925
1926
1927/*****************************************************************************
1928 * Name : DWORD CmdBatNotification
1929 * Purpose : Unknown, used by /winnt/cmd.exe
1930 * Parameters: Unknown (wrong)
1931 * Variables :
1932 * Result : Unknown
1933 * Remark :
1934 * Status : UNTESTED STUB
1935 *
1936 * Author : Patrick Haller [Tue, 1999/06/08 21:44]
1937 *****************************************************************************/
1938
1939DWORD WIN32API CmdBatNotification(DWORD x1)
1940{
1941 dprintf(("KERNEL32: CmdBatNotification(%08xh) not implemented\n",
1942 x1));
1943
1944 return (0);
1945}
1946
1947
1948/*****************************************************************************
1949 * Name : DWORD GetVDMCurrentDirectories
1950 * Purpose : Unknown, used by /winnt/cmd.exe
1951 * Parameters: Unknown (wrong)
1952 * Variables :
1953 * Result : Unknown
1954 * Remark :
1955 * Status : UNTESTED STUB
1956 *
1957 * Author : Patrick Haller [Tue, 1999/06/08 21:44]
1958 *****************************************************************************/
1959
1960DWORD WIN32API GetVDMCurrentDirectories(DWORD x1)
1961{
1962 dprintf(("KERNEL32: GetVDMCurrentDirectories(%08xh) not implemented\n",
1963 x1));
1964
1965 return (0);
1966}
1967
1968
1969/*****************************************************************************
1970 * Name : DWORD SetThreadPriorityBoost
1971 * Purpose : Unknown
1972 * Parameters: Unknown (wrong)
1973 * Variables :
1974 * Result : Unknown
1975 * Remark :
1976 * Status : UNTESTED STUB
1977 *
1978 * Author : Patrick Haller [Tue, 1999/06/08 21:44]
1979 *****************************************************************************/
1980
1981DWORD WIN32API SetThreadPriorityBoost(DWORD x1,
1982 DWORD x2)
1983{
1984 dprintf(("KERNEL32: SetThreadPriorityBoost(%08xh, %08xh) not implemented\n",
1985 x1,
1986 x2));
1987
1988 return (0);
1989}
Note: See TracBrowser for help on using the repository browser.