source: trunk/src/advapi32/eventlog.cpp

Last change on this file was 3503, checked in by sandervl, 25 years ago

extra logging
File size: 16.0 KB
Line 
1/* $Id: eventlog.cpp,v 1.2 2000-05-09 18:59:10 sandervl Exp $ */
2
3/*
4 * Win32 advanced API functions for OS/2
5 *
6 * 1998/06/12
7 *
8 * Copyright 1998 Sander van Leeuwen
9 * Copyright 1998 Patrick Haller
10 *
11 *
12 * NOTE: Uses registry key for service as handle
13 *
14 * Project Odin Software License can be found in LICENSE.TXT
15 *
16 */
17
18#include <os2win.h>
19#include <stdlib.h>
20#include <stdarg.h>
21#include <string.h>
22#include <odinwrap.h>
23#include "misc.h"
24#include "advapi32.h"
25#include "unicode.h"
26#include "winreg.h"
27#include <heapstring.h>
28
29ODINDEBUGCHANNEL(ADVAPI32-EVENTLOG)
30
31
32BOOL WIN32API ReportEventA( /*PLF Sat 98-03-07 00:36:43*/
33 HANDLE hEventLog,
34 WORD wType,
35 WORD wCategory,
36 DWORD dwEventID,
37 PSID lpUserSid,
38 WORD wNumStrings,
39 DWORD dwDataSize,
40 LPCSTR *lpStrings,
41 LPVOID lpRawData
42 )
43{
44 dprintf(("ReportEventA(): NIY\n"));
45 return TRUE;
46}
47
48
49BOOL WIN32API ReportEventW( /*PLF Sat 98-03-07 00:36:43*/
50 HANDLE hEventLog,
51 WORD wType,
52 WORD wCategory,
53 DWORD dwEventID,
54 PSID lpUserSid,
55 WORD wNumStrings,
56 DWORD dwDataSize,
57 LPCWSTR *lpStrings,
58 LPVOID lpRawData
59 )
60{
61 dprintf(("ReportEventW %x %x %x %x %x %x %x %x %x: not implemented\n",hEventLog, wType,
62 wCategory, dwEventID, lpUserSid, wNumStrings, dwDataSize, lpStrings, lpRawData));
63 return TRUE;
64}
65
66
67/*PLF Sat 98-03-07 02:59:20*/
68HANDLE WIN32API RegisterEventSourceA(LPCSTR lpUNCServerName, LPCSTR lpSourceName)
69{
70 dprintf(("ADVAPI32: RegisterEventSourceA() %s %s", lpUNCServerName, lpSourceName));
71
72 return 0xCAFECAFE;
73}
74
75/*PLF Sat 98-03-07 02:59:20*/
76HANDLE WIN32API RegisterEventSourceW(LPCWSTR lpUNCServerName, LPCWSTR lpSourceName)
77{
78 LPSTR lpUNCServerNameA = NULL, lpSourceNameA = NULL;
79 HANDLE hEvent;
80
81 dprintf(("ADVAPI32: RegisterEventSourceW()"));
82 if(lpUNCServerName)
83 lpUNCServerNameA = HEAP_strdupWtoA(GetProcessHeap(), 0, lpUNCServerName);
84 if(lpSourceName)
85 lpSourceNameA = HEAP_strdupWtoA(GetProcessHeap(), 0, lpSourceName);
86
87 hEvent = RegisterEventSourceA(lpUNCServerNameA, lpSourceNameA);
88
89 if(lpUNCServerNameA)
90 HeapFree(GetProcessHeap(), 0, lpUNCServerNameA);
91 if(lpSourceNameA)
92 HeapFree(GetProcessHeap(), 0, lpSourceNameA);
93
94 return hEvent;
95}
96
97
98/*PLF Sat 98-03-07 02:59:20*/
99BOOL WIN32API DeregisterEventSource(HANDLE hEventLog)
100{
101 dprintf(("DeregisterEventSource() NIY\n"));
102 return FALSE;
103}
104
105/*****************************************************************************
106 * Name : BackupEventLogA
107 * Purpose : The BackupEventLog function saves the specified event log to a
108 * backup file. The function does not clear the event log.
109 * Parameters: HANDLE hEventLog handle to event log
110 * LPCSTR lpBackupFileName name of backup file
111 * Variables :
112 * Result :
113 * Remark :
114 * Status : UNTESTED STUB
115 *
116 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
117 *****************************************************************************/
118
119BOOL WIN32API BackupEventLogA(HANDLE hEventLog,
120 LPCSTR lpBackupFileName)
121{
122 dprintf(("ADVAPI32: BackupEventLogA(%08xh,%s) not implemented.\n",
123 hEventLog,
124 lpBackupFileName));
125
126 return (FALSE); /* signal failure */
127}
128
129
130/*****************************************************************************
131 * Name : BackupEventLogW
132 * Purpose : The BackupEventLog function saves the specified event log to a
133 * backup file. The function does not clear the event log.
134 * Parameters: HANDLE hEventLog handle to event log
135 * LPCWSTR lpBackupFileName name of backup file
136 * Variables :
137 * Result :
138 * Remark :
139 * Status : UNTESTED STUB
140 *
141 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
142 *****************************************************************************/
143
144BOOL WIN32API BackupEventLogW(HANDLE hEventLog,
145 LPCWSTR lpBackupFileName)
146{
147 dprintf(("ADVAPI32: BackupEventLogW() not implemented.\n",
148 hEventLog,
149 lpBackupFileName));
150
151 return (FALSE); /* signal failure */
152}
153
154
155/*****************************************************************************
156 * Name : ClearEventLogA
157 * Purpose : The ClearEventLog function clears the specified event log, and
158 * optionally saves the current copy of the logfile to a backup file.
159 * Parameters: HANDLE hEventLog handle to event log
160 * LPCSTR lpBackupFileName name of backup file
161 * Variables :
162 * Result :
163 * Remark :
164 * Status : UNTESTED STUB
165 *
166 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
167 *****************************************************************************/
168
169BOOL WIN32API ClearEventLogA(HANDLE hEventLog,
170 LPCSTR lpBackupFileName)
171{
172 dprintf(("ADVAPI32: ClearEventLogA(%08xh,%s) not implemented.\n",
173 hEventLog,
174 lpBackupFileName));
175
176 return (FALSE); /* signal failure */
177}
178
179
180/*****************************************************************************
181 * Name : ClearEventLogW
182 * Purpose : The ClearEventLog function clears the specified event log, and
183 * optionally saves the current copy of the logfile to a backup file.
184 * Parameters: HANDLE hEventLog handle to event log
185 * LPCSTR lpBackupFileName name of backup file
186 * Variables :
187 * Result :
188 * Remark :
189 * Status : UNTESTED STUB
190 *
191 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
192 *****************************************************************************/
193
194BOOL WIN32API ClearEventLogW(HANDLE hEventLog,
195 LPCWSTR lpBackupFileName)
196{
197 dprintf(("ADVAPI32: ClearEventLogW(%08xh,%s) not implemented.\n",
198 hEventLog,
199 lpBackupFileName));
200
201 return (FALSE); /* signal failure */
202}
203
204
205/*****************************************************************************
206 * Name : CloseEventLog
207 * Purpose : The CloseEventLog function closes the specified event log.
208 * Parameters: HANDLE hEventLog handle to event log
209 * Variables :
210 * Result :
211 * Remark :
212 * Status : UNTESTED STUB
213 *
214 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
215 *****************************************************************************/
216
217BOOL WIN32API CloseEventLog(HANDLE hEventLog)
218{
219 dprintf(("ADVAPI32: CloseEventLog(%08xh) not implemented.\n",
220 hEventLog));
221
222 return (FALSE); /* signal failure */
223}
224
225/*****************************************************************************
226 * Name : GetNumberOfEventLogRecords
227 * Purpose : The GetNumberOfEventLogRecords function retrieves the number of
228 * records in the specified event log.
229 * Parameters: HANDLE hEventLog handle to event log
230 * LPDWORD NumberOfRecords buffer for number of records
231 * Variables :
232 * Result :
233 * Remark :
234 * Status : UNTESTED STUB
235 *
236 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
237 *****************************************************************************/
238
239BOOL WIN32API GetNumberOfEventLogRecords(HANDLE hEventLog,
240 LPDWORD NumberOfRecords)
241{
242 dprintf(("ADVAPI32: GetNumberOfEventLogRecords(%08xh,%08xh) not implemented.\n",
243 hEventLog,
244 NumberOfRecords));
245
246 return (FALSE); /* signal failure */
247}
248
249
250/*****************************************************************************
251 * Name : GetOldestEventLogRecord
252 * Purpose : The GetOldestEventLogRecord function retrieves the absolute
253 * record number of the oldest record in the specified event log.
254 * Parameters: HANDLE hEventLog handle to event log
255 * LPDWORD OldestRecord buffer for number of oldest record
256 * Variables :
257 * Result :
258 * Remark :
259 * Status : UNTESTED STUB
260 *
261 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
262 *****************************************************************************/
263
264BOOL WIN32API GetOldestEventLogRecord(HANDLE hEventLog,
265 LPDWORD OldestRecord)
266{
267 dprintf(("ADVAPI32: GetOldestEventLogRecord(%08xh,%08xh) not implemented.\n",
268 hEventLog,
269 OldestRecord));
270
271 return (FALSE); /* signal failure */
272}
273
274/*****************************************************************************
275 * Name : NotifyChangeEventLog
276 * Purpose : The NotifyChangeEventLog function lets an application receive
277 * notification when an event is written to the event log file
278 * specified by hEventLog. When the event is written to the event
279 * log file, the function causes the event object specified by
280 * hEvent to become signaled.
281 * Parameters: HANDLE hEventLog special default locale value to be converted
282 * HANDLE hEvent special default locale value to be converted
283 * Variables :
284 * Result :
285 * Remark :
286 * Status : UNTESTED STUB
287 *
288 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
289 *****************************************************************************/
290
291BOOL WIN32API NotifyChangeEventLog(HANDLE hEventLog,
292 HANDLE hEvent)
293{
294 dprintf(("ADVAPI32: NotifyChangeEventLog(%08xh,%08xh) not implemented.\n",
295 hEventLog,
296 hEvent));
297
298 return (FALSE); /* signal failure */
299}
300
301/*****************************************************************************
302 * Name : OpenBackupEventLogA
303 * Purpose : The OpenBackupEventLog function opens a handle of a backup event
304 * log. This handle can be used with the BackupEventLog function.
305 * Parameters: LPCSTR lpszUNCServerName backup file server name
306 * LPCSTR lpszFileName backup filename
307 * Variables :
308 * Result :
309 * Remark :
310 * Status : UNTESTED STUB
311 *
312 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
313 *****************************************************************************/
314
315HANDLE WIN32API OpenBackupEventLogA(LPCSTR lpszUNCServerName,
316 LPCSTR lpszFileName)
317{
318 dprintf(("ADVAPI32: OpenBackupEventLogA(%s,%s) not implemented.\n",
319 lpszUNCServerName,
320 lpszFileName));
321
322 return (NULL); /* signal failure */
323}
324
325
326/*****************************************************************************
327 * Name : OpenBackupEventLogW
328 * Purpose : The OpenBackupEventLog function opens a handle of a backup event
329 * log. This handle can be used with the BackupEventLog function.
330 * Parameters: LPCWSTR lpszUNCServerName backup file server name
331 * LPCWSTR lpszFileName backup filename
332 * Variables :
333 * Result :
334 * Remark :
335 * Status : UNTESTED STUB
336 *
337 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
338 *****************************************************************************/
339
340HANDLE WIN32API OpenBackupEventLogW(LPCWSTR lpszUNCServerName,
341 LPCWSTR lpszFileName)
342{
343 dprintf(("ADVAPI32: OpenBackupEventLogW(%s,%s) not implemented.\n",
344 lpszUNCServerName,
345 lpszFileName));
346
347 return (NULL); /* signal failure */
348}
349
350
351/*****************************************************************************
352 * Name : OpenEventLogA
353 * Purpose : The OpenEventLog function opens a handle of an event log.
354 * Parameters: LPCSTR lpszUNCServerName
355 * LPCSTR lpszSourceName
356 * Variables :
357 * Result :
358 * Remark :
359 * Status : UNTESTED STUB
360 *
361 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
362 *****************************************************************************/
363
364HANDLE WIN32API OpenEventLogA(LPCSTR lpszUNCServerName,
365 LPCSTR lpszSourceName)
366{
367 dprintf(("ADVAPI32: OpenEventLogA(%s,%s) not implemented.\n",
368 lpszUNCServerName,
369 lpszSourceName));
370
371 return (NULL); /* signal failure */
372}
373
374
375/*****************************************************************************
376 * Name : OpenEventLogW
377 * Purpose : The OpenEventLog function opens a handle of an event log.
378 * Parameters: LPCWSTR lpszUNCServerName
379 * LPCWSTR lpszSourceName
380 * Variables :
381 * Result :
382 * Remark :
383 * Status : UNTESTED STUB
384 *
385 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
386 *****************************************************************************/
387
388HANDLE WIN32API OpenEventLogW(LPCWSTR lpszUNCServerName,
389 LPCWSTR lpszSourceName)
390{
391 dprintf(("ADVAPI32: OpenEventLogW(%s,%s) not implemented.\n",
392 lpszUNCServerName,
393 lpszSourceName));
394
395 return (NULL); /* signal failure */
396}
397
398/*****************************************************************************
399 * Name : ReadEventLogW
400 * Purpose : The ReadEventLog function reads a whole number of entries from
401 * the specified event log. The function can be used to read log
402 * entries in forward or reverse chronological order.
403 * Parameters: HANDLE hEventLog handle of event log
404 * DWORD dwReadFlags specifies how to read log
405 * DWORD dwRecordOffset number of first record
406 * LPVOID lpBuffer address of buffer for read data
407 * DWORD nNumberOfBytesToRead number of bytes to read
408 * DWORD *pnBytesRea number of bytes read
409 * DWORD *pnMinNumberOfBytesNeeded number of bytes required for next record
410 * Variables :
411 * Result :
412 * Remark :
413 * Status : UNTESTED STUB
414 *
415 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
416 *****************************************************************************/
417
418BOOL WIN32API ReadEventLogW(HANDLE hEventLog,
419 DWORD dwReadFlags,
420 DWORD dwRecordOffset,
421 LPVOID lpBuffer,
422 DWORD nNumberOfBytesToRead,
423 DWORD *pnBytesRead,
424 DWORD *pnMinNumberOfBytesNeeded)
425{
426 dprintf(("ADVAPI32: ReadEventLogW(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
427 hEventLog,
428 dwReadFlags,
429 dwRecordOffset,
430 lpBuffer,
431 nNumberOfBytesToRead,
432 pnBytesRead,
433 pnMinNumberOfBytesNeeded));
434
435 return (FALSE); /* signal failure */
436}
437
438
439/*****************************************************************************
440 * Name : ReadEventLogA
441 * Purpose : The ReadEventLog function reads a whole number of entries from
442 * the specified event log. The function can be used to read log
443 * entries in forward or reverse chronological order.
444 * Parameters: HANDLE hEventLog handle of event log
445 * DWORD dwReadFlags specifies how to read log
446 * DWORD dwRecordOffset number of first record
447 * LPVOID lpBuffer address of buffer for read data
448 * DWORD nNumberOfBytesToRead number of bytes to read
449 * DWORD *pnBytesRea number of bytes read
450 * DWORD *pnMinNumberOfBytesNeeded number of bytes required for next record
451 * Variables :
452 * Result :
453 * Remark :
454 * Status : UNTESTED STUB
455 *
456 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
457 *****************************************************************************/
458
459BOOL WIN32API ReadEventLogA(HANDLE hEventLog,
460 DWORD dwReadFlags,
461 DWORD dwRecordOffset,
462 LPVOID lpBuffer,
463 DWORD nNumberOfBytesToRead,
464 DWORD *pnBytesRead,
465 DWORD *pnMinNumberOfBytesNeeded)
466{
467 dprintf(("ADVAPI32: ReadEventLogA(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
468 hEventLog,
469 dwReadFlags,
470 dwRecordOffset,
471 lpBuffer,
472 nNumberOfBytesToRead,
473 pnBytesRead,
474 pnMinNumberOfBytesNeeded));
475
476 return (FALSE); /* signal failure */
477}
478
Note: See TracBrowser for help on using the repository browser.