reactos/lib/advapi32/service/eventlog.c

   1 /*
   2  * Win32 advapi functions
   3  *
   4  * Copyright 1995 Sven Verdoolaege
   5  * Copyright 1998 Juergen Schmied
   6  * Copyright 2003 Mike Hearn
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include <advapi32.h>
  24 #define NDEBUG
  25 #include <debug.h>
  26
  27
  28 /******************************************************************************
  29  * BackupEventLogA [ADVAPI32.@]
  30  */
  31 BOOL WINAPI
  32 BackupEventLogA (HANDLE hEventLog,
  33                  LPCSTR lpBackupFileName)
  34 {
  35   DPRINT1("stub\n");
  36   return TRUE;
  37 }
  38
  39 /******************************************************************************
  40  * BackupEventLogW [ADVAPI32.@]
  41  *
  42  * PARAMS
  43  *   hEventLog        []
  44  *   lpBackupFileName []
  45  */
  46 BOOL WINAPI
  47 BackupEventLogW (HANDLE hEventLog,
  48                  LPCWSTR lpBackupFileName)
  49 {
  50   DPRINT1("stub\n");
  51   return TRUE;
  52 }
  53
  54
  55 /******************************************************************************
  56  * ClearEventLogA [ADVAPI32.@]
  57  */
  58 BOOL WINAPI
  59 ClearEventLogA (HANDLE hEventLog,
  60                 LPCSTR lpBackupFileName)
  61 {
  62   DPRINT1("stub\n");
  63   return TRUE;
  64 }
  65
  66
  67 /******************************************************************************
  68  * ClearEventLogW [ADVAPI32.@]
  69  */
  70 BOOL WINAPI
  71 ClearEventLogW (HANDLE hEventLog,
  72                 LPCWSTR lpBackupFileName)
  73 {
  74   DPRINT1("stub\n");
  75   return TRUE;
  76 }
  77
  78
  79 /******************************************************************************
  80  * CloseEventLog [ADVAPI32.@]
  81  */
  82 BOOL WINAPI
  83 CloseEventLog (HANDLE hEventLog)
  84 {
  85   DPRINT1("stub\n");
  86   return TRUE;
  87 }
  88
  89
  90 /******************************************************************************
  91  * DeregisterEventSource [ADVAPI32.@]
  92  * Closes a handle to the specified event log
  93  *
  94  * PARAMS
  95  *    hEventLog [I] Handle to event log
  96  *
  97  * RETURNS STD
  98  */
  99 BOOL WINAPI
 100 DeregisterEventSource (HANDLE hEventLog)
 101 {
 102   DPRINT1("(%p): stub\n",hEventLog);
 103   return TRUE;
 104 }
 105
 106
 107 /******************************************************************************
 108  * GetNumberOfEventLogRecords [ADVAPI32.@]
 109  *
 110  * PARAMS
 111  *   hEventLog       []
 112  *   NumberOfRecords []
 113  */
 114 BOOL WINAPI
 115 GetNumberOfEventLogRecords (HANDLE hEventLog,
 116                             PDWORD NumberOfRecords)
 117 {
 118   DPRINT1("stub\n");
 119   return TRUE;
 120 }
 121
 122
 123 /******************************************************************************
 124  * GetOldestEventLogRecord [ADVAPI32.@]
 125  *
 126  * PARAMS
 127  *   hEventLog    []
 128  *   OldestRecord []
 129  */
 130 BOOL WINAPI
 131 GetOldestEventLogRecord (HANDLE hEventLog,
 132                          PDWORD OldestRecord)
 133 {
 134   DPRINT1("stub\n");
 135   return TRUE;
 136 }
 137
 138
 139 /******************************************************************************
 140  * NotifyChangeEventLog [ADVAPI32.@]
 141  *
 142  * PARAMS
 143  *   hEventLog []
 144  *   hEvent    []
 145  */
 146 BOOL WINAPI
 147 NotifyChangeEventLog (HANDLE hEventLog,
 148                       HANDLE hEvent)
 149 {
 150   DPRINT1("stub\n");
 151   return TRUE;
 152 }
 153
 154
 155 /******************************************************************************
 156  * OpenBackupEventLogA [ADVAPI32.@]
 157  */
 158 HANDLE WINAPI
 159 OpenBackupEventLogA (LPCSTR lpUNCServerName,
 160                      LPCSTR lpFileName)
 161 {
 162   DPRINT1("stub\n");
 163   return (HANDLE)1;
 164 }
 165
 166
 167 /******************************************************************************
 168  * OpenBackupEventLogW [ADVAPI32.@]
 169  *
 170  * PARAMS
 171  *   lpUNCServerName []
 172  *   lpFileName      []
 173  */
 174 HANDLE WINAPI
 175 OpenBackupEventLogW (LPCWSTR lpUNCServerName,
 176                      LPCWSTR lpFileName)
 177 {
 178   DPRINT1("stub\n");
 179   return (HANDLE)1;
 180 }
 181
 182
 183 /******************************************************************************
 184  * OpenEventLogA [ADVAPI32.@]
 185  */
 186 HANDLE WINAPI
 187 OpenEventLogA (LPCSTR lpUNCServerName,
 188                LPCSTR lpSourceName)
 189 {
 190   DPRINT1("(%s,%s),stub!\n",
 191           lpUNCServerName, lpSourceName);
 192   return (HANDLE)0xcafe4242;
 193 }
 194
 195
 196 /******************************************************************************
 197  * OpenEventLogW [ADVAPI32.@]
 198  *
 199  * PARAMS
 200  *   uncname []
 201  *   source  []
 202  */
 203 HANDLE WINAPI
 204 OpenEventLogW (LPCWSTR lpUNCServerName,
 205                LPCWSTR lpSourceName)
 206 {
 207   DPRINT1("stub\n");
 208   return (HANDLE)1;
 209 }
 210
 211
 212 /******************************************************************************
 213  * ReadEventLogA [ADVAPI32.@]
 214  */
 215 BOOL WINAPI
 216 ReadEventLogA (HANDLE hEventLog,
 217                DWORD dwReadFlags,
 218                DWORD dwRecordOffset,
 219                LPVOID lpBuffer,
 220                DWORD nNumberOfBytesToRead,
 221                DWORD *pnBytesRead,
 222                DWORD *pnMinNumberOfBytesNeeded)
 223 {
 224   DPRINT1("stub\n");
 225   return TRUE;
 226 }
 227
 228
 229 /******************************************************************************
 230  * ReadEventLogW [ADVAPI32.@]
 231  *
 232  * PARAMS
 233  *   hEventLog                []
 234  *   dwReadFlags              []
 235  *   dwRecordOffset           []
 236  *   lpBuffer                 []
 237  *   nNumberOfBytesToRead     []
 238  *   pnBytesRead              []
 239  *   pnMinNumberOfBytesNeeded []
 240  */
 241 BOOL WINAPI
 242 ReadEventLogW (HANDLE hEventLog,
 243                DWORD dwReadFlags,
 244                DWORD dwRecordOffset,
 245                LPVOID lpBuffer,
 246                DWORD nNumberOfBytesToRead,
 247                DWORD *pnBytesRead,
 248                DWORD *pnMinNumberOfBytesNeeded)
 249 {
 250   DPRINT1("stub\n");
 251   return TRUE;
 252 }
 253
 254
 255 /******************************************************************************
 256  * RegisterEventSourceA [ADVAPI32.@]
 257  */
 258 HANDLE WINAPI
 259 RegisterEventSourceA (LPCSTR lpUNCServerName,
 260                       LPCSTR lpSourceName)
 261 {
 262   UNICODE_STRING UNCServerName;
 263   UNICODE_STRING SourceName;
 264   HANDLE ret;
 265
 266   RtlCreateUnicodeStringFromAsciiz (&UNCServerName,
 267                                     (PSTR)lpUNCServerName);
 268   RtlCreateUnicodeStringFromAsciiz (&SourceName,
 269                                     (PSTR)lpSourceName);
 270
 271   ret = RegisterEventSourceW (UNCServerName.Buffer,
 272                               SourceName.Buffer);
 273
 274   RtlFreeUnicodeString (&UNCServerName);
 275   RtlFreeUnicodeString (&SourceName);
 276
 277   return ret;
 278 }
 279
 280
 281 /******************************************************************************
 282  * RegisterEventSourceW [ADVAPI32.@]
 283  * Returns a registered handle to an event log
 284  *
 285  * PARAMS
 286  *   lpUNCServerName [I] Server name for source
 287  *   lpSourceName    [I] Source name for registered handle
 288  *
 289  * RETURNS
 290  *    Success: Handle
 291  *    Failure: NULL
 292  */
 293 HANDLE WINAPI
 294 RegisterEventSourceW (LPCWSTR lpUNCServerName,
 295                       LPCWSTR lpSourceName)
 296 {
 297   DPRINT1("(%S, %S): stub\n",
 298           lpUNCServerName, lpSourceName);
 299   return (HANDLE)1;
 300 }
 301
 302
 303 /******************************************************************************
 304  * ReportEventA [ADVAPI32.@]
 305  */
 306 BOOL WINAPI
 307 ReportEventA (HANDLE hEventLog,
 308               WORD wType,
 309               WORD wCategory,
 310               DWORD dwEventID,
 311               PSID lpUserSid,
 312               WORD wNumStrings,
 313               DWORD dwDataSize,
 314               LPCSTR *lpStrings,
 315               LPVOID lpRawData)
 316 {
 317   LPCWSTR *wideStrArray;
 318   UNICODE_STRING str;
 319   int i;
 320   BOOL ret;
 321
 322   if (wNumStrings == 0)
 323      return TRUE;
 324
 325   if (lpStrings == NULL)
 326      return TRUE;
 327
 328   wideStrArray = HeapAlloc (GetProcessHeap (),
 329                             0,
 330                             sizeof(LPCWSTR) * wNumStrings);
 331
 332   for (i = 0; i < wNumStrings; i++)
 333     {
 334         RtlCreateUnicodeStringFromAsciiz (&str,
 335                                           (PSTR)lpStrings[i]);
 336         wideStrArray[i] = str.Buffer;
 337     }
 338
 339   ret = ReportEventW (hEventLog,
 340                       wType,
 341                       wCategory,
 342                       dwEventID,
 343                       lpUserSid,
 344                       wNumStrings,
 345                       dwDataSize,
 346                       wideStrArray,
 347                       lpRawData);
 348
 349   for (i = 0; i < wNumStrings; i++)
 350     {
 351       if (wideStrArray[i])
 352         {
 353           HeapFree (GetProcessHeap (),
 354                     0,
 355                     (LPSTR)wideStrArray[i]);
 356         }
 357     }
 358
 359   HeapFree (GetProcessHeap(),
 360             0,
 361             wideStrArray);
 362
 363   return ret;
 364 }
 365
 366
 367 /******************************************************************************
 368  * ReportEventW [ADVAPI32.@]
 369  *
 370  * PARAMS
 371  *   hEventLog   []
 372  *   wType       []
 373  *   wCategory   []
 374  *   dwEventID   []
 375  *   lpUserSid   []
 376  *   wNumStrings []
 377  *   dwDataSize  []
 378  *   lpStrings   []
 379  *   lpRawData   []
 380  */
 381 BOOL WINAPI
 382 ReportEventW (HANDLE hEventLog,
 383               WORD wType,
 384               WORD wCategory,
 385               DWORD dwEventID,
 386               PSID lpUserSid,
 387               WORD wNumStrings,
 388               DWORD dwDataSize,
 389               LPCWSTR *lpStrings,
 390               LPVOID lpRawData)
 391 {
 392   int i;
 393
 394     /* partial stub */
 395
 396   if (wNumStrings == 0)
 397     return TRUE;
 398
 399   if (lpStrings == NULL)
 400     return TRUE;
 401
 402   for (i = 0; i < wNumStrings; i++)
 403     {
 404       switch (wType)
 405         {
 406         case EVENTLOG_SUCCESS:
 407             DPRINT1("Success: %S\n", lpStrings[i]);
 408             break;
 409
 410         case EVENTLOG_ERROR_TYPE:
 411             DPRINT1("Error: %S\n", lpStrings[i]);
 412             break;
 413
 414         case EVENTLOG_WARNING_TYPE:
 415             DPRINT1("Warning: %S\n", lpStrings[i]);
 416             break;
 417
 418         default:
 419             DPRINT1("Type %hu: %S\n", wType, lpStrings[i]);
 420             break;
 421         }
 422     }
 423
 424   return TRUE;
 425 }