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

Last change on this file since 21324 was 21324, checked in by ydario, 16 years ago

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