dlls/advapi32/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 <stdarg.h>
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winerror.h"
  28 #include "winreg.h"
  29 #include "winternl.h"
  30
  31 #include "wine/debug.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(advapi);
  34 WINE_DECLARE_DEBUG_CHANNEL(eventlog);
  35
  36 /******************************************************************************
  37  * BackupEventLogA [ADVAPI32.@]
  38  */
  39 BOOL WINAPI BackupEventLogA( HANDLE hEventLog, LPCSTR lpBackupFileName )
  40 {
  41         FIXME("stub\n");
  42         return TRUE;
  43 }
  44
  45 /******************************************************************************
  46  * BackupEventLogW [ADVAPI32.@]
  47  *
  48  * PARAMS
  49  *   hEventLog        []
  50  *   lpBackupFileName []
  51  */
  52 BOOL WINAPI
  53 BackupEventLogW( HANDLE hEventLog, LPCWSTR lpBackupFileName )
  54 {
  55         FIXME("stub\n");
  56         return TRUE;
  57 }
  58
  59 /******************************************************************************
  60  * ClearEventLogA [ADVAPI32.@]
  61  */
  62 BOOL WINAPI ClearEventLogA ( HANDLE hEventLog, LPCSTR lpBackupFileName )
  63 {
  64         FIXME("stub\n");
  65         return TRUE;
  66 }
  67
  68 /******************************************************************************
  69  * ClearEventLogW [ADVAPI32.@]
  70  */
  71 BOOL WINAPI ClearEventLogW ( HANDLE hEventLog, LPCWSTR lpBackupFileName )
  72 {
  73         FIXME("stub\n");
  74         return TRUE;
  75 }
  76
  77 /******************************************************************************
  78  * CloseEventLog [ADVAPI32.@]
  79  */
  80 BOOL WINAPI CloseEventLog ( HANDLE hEventLog )
  81 {
  82         FIXME("stub\n");
  83         return TRUE;
  84 }
  85
  86 /******************************************************************************
  87  * DeregisterEventSource [ADVAPI32.@]
  88  * Closes a handle to the specified event log
  89  *
  90  * PARAMS
  91  *    hEventLog [I] Handle to event log
  92  *
  93  * RETURNS STD
  94  */
  95 BOOL WINAPI DeregisterEventSource( HANDLE hEventLog )
  96 {
  97     FIXME("(%p): stub\n",hEventLog);
  98     return TRUE;
  99 }
 100
 101 /******************************************************************************
 102  * GetNumberOfEventLogRecords [ADVAPI32.@]
 103  *
 104  * PARAMS
 105  *   hEventLog       []
 106  *   NumberOfRecords []
 107  */
 108 BOOL WINAPI
 109 GetNumberOfEventLogRecords( HANDLE hEventLog, PDWORD NumberOfRecords )
 110 {
 111         FIXME("stub\n");
 112         return TRUE;
 113 }
 114
 115 /******************************************************************************
 116  * GetOldestEventLogRecord [ADVAPI32.@]
 117  *
 118  * PARAMS
 119  *   hEventLog    []
 120  *   OldestRecord []
 121  */
 122 BOOL WINAPI
 123 GetOldestEventLogRecord( HANDLE hEventLog, PDWORD OldestRecord )
 124 {
 125         FIXME(":stub\n");
 126         return TRUE;
 127 }
 128
 129 /******************************************************************************
 130  * NotifyChangeEventLog [ADVAPI32.@]
 131  *
 132  * PARAMS
 133  *   hEventLog []
 134  *   hEvent    []
 135  */
 136 BOOL WINAPI NotifyChangeEventLog( HANDLE hEventLog, HANDLE hEvent )
 137 {
 138         FIXME("stub\n");
 139         return TRUE;
 140 }
 141
 142 /******************************************************************************
 143  * OpenBackupEventLogA [ADVAPI32.@]
 144  */
 145 HANDLE WINAPI
 146 OpenBackupEventLogA( LPCSTR lpUNCServerName, LPCSTR lpFileName )
 147 {
 148         FIXME("stub\n");
 149         return (HANDLE)1;
 150 }
 151
 152 /******************************************************************************
 153  * OpenBackupEventLogW [ADVAPI32.@]
 154  *
 155  * PARAMS
 156  *   lpUNCServerName []
 157  *   lpFileName      []
 158  */
 159 HANDLE WINAPI
 160 OpenBackupEventLogW( LPCWSTR lpUNCServerName, LPCWSTR lpFileName )
 161 {
 162         FIXME("stub\n");
 163         return (HANDLE)1;
 164 }
 165
 166 /******************************************************************************
 167  * OpenEventLogA [ADVAPI32.@]
 168  */
 169 HANDLE WINAPI OpenEventLogA(LPCSTR uncname,LPCSTR source)
 170 {
 171         FIXME("(%s,%s),stub!\n",uncname,source);
 172         return (HANDLE)0xcafe4242;
 173 }
 174
 175 /******************************************************************************
 176  * OpenEventLogW [ADVAPI32.@]
 177  *
 178  * PARAMS
 179  *   uncname []
 180  *   source  []
 181  */
 182 HANDLE WINAPI
 183 OpenEventLogW( LPCWSTR uncname, LPCWSTR source )
 184 {
 185         FIXME("stub\n");
 186         return (HANDLE)1;
 187 }
 188
 189 /******************************************************************************
 190  * ReadEventLogA [ADVAPI32.@]
 191  */
 192 BOOL WINAPI ReadEventLogA( HANDLE hEventLog, DWORD dwReadFlags, DWORD dwRecordOffset,
 193     LPVOID lpBuffer, DWORD nNumberOfBytesToRead, DWORD *pnBytesRead, DWORD *pnMinNumberOfBytesNeeded )
 194 {
 195         FIXME("stub\n");
 196         return TRUE;
 197 }
 198
 199 /******************************************************************************
 200  * ReadEventLogW [ADVAPI32.@]
 201  *
 202  * PARAMS
 203  *   hEventLog                []
 204  *   dwReadFlags              []
 205  *   dwRecordOffset           []
 206  *   lpBuffer                 []
 207  *   nNumberOfBytesToRead     []
 208  *   pnBytesRead              []
 209  *   pnMinNumberOfBytesNeeded []
 210  */
 211 BOOL WINAPI
 212 ReadEventLogW( HANDLE hEventLog, DWORD dwReadFlags, DWORD dwRecordOffset,
 213                  LPVOID lpBuffer, DWORD nNumberOfBytesToRead,
 214                  DWORD *pnBytesRead, DWORD *pnMinNumberOfBytesNeeded )
 215 {
 216         FIXME("stub\n");
 217         return TRUE;
 218 }
 219
 220 /******************************************************************************
 221  * RegisterEventSourceA [ADVAPI32.@]
 222  */
 223 HANDLE WINAPI RegisterEventSourceA( LPCSTR lpUNCServerName, LPCSTR lpSourceName )
 224 {
 225
 226     UNICODE_STRING lpUNCServerNameW;
 227     UNICODE_STRING lpSourceNameW;
 228     HANDLE ret;
 229     RtlCreateUnicodeStringFromAsciiz(&lpUNCServerNameW, lpUNCServerName);
 230     RtlCreateUnicodeStringFromAsciiz(&lpSourceNameW, lpSourceName);
 231     ret = RegisterEventSourceW(lpUNCServerNameW.Buffer,lpSourceNameW.Buffer);
 232     RtlFreeUnicodeString (&lpUNCServerNameW);
 233     RtlFreeUnicodeString (&lpSourceNameW);
 234     return ret;
 235 }
 236
 237 /******************************************************************************
 238  * RegisterEventSourceW [ADVAPI32.@]
 239  * Returns a registered handle to an event log
 240  *
 241  * PARAMS
 242  *   lpUNCServerName [I] Server name for source
 243  *   lpSourceName    [I] Source name for registered handle
 244  *
 245  * RETURNS
 246  *    Success: Handle
 247  *    Failure: NULL
 248  */
 249 HANDLE WINAPI
 250 RegisterEventSourceW( LPCWSTR lpUNCServerName, LPCWSTR lpSourceName )
 251 {
 252     FIXME("(%s,%s): stub\n", debugstr_w(lpUNCServerName),
 253           debugstr_w(lpSourceName));
 254     return (HANDLE)1;
 255 }
 256
 257 /******************************************************************************
 258  * ReportEventA [ADVAPI32.@]
 259  */
 260 BOOL WINAPI ReportEventA ( HANDLE hEventLog, WORD wType, WORD wCategory, DWORD dwEventID,
 261     PSID lpUserSid, WORD wNumStrings, DWORD dwDataSize, LPCSTR *lpStrings, LPVOID lpRawData)
 262 {
 263     LPCWSTR *wideStrArray;
 264     UNICODE_STRING str;
 265     int i;
 266     BOOL ret;
 267
 268     if (wNumStrings == 0) return TRUE;
 269     if (!lpStrings) return TRUE;
 270
 271     wideStrArray = HeapAlloc(GetProcessHeap(), 0, sizeof(LPCWSTR) * wNumStrings);
 272     for (i = 0; i < wNumStrings; i++)
 273     {
 274         RtlCreateUnicodeStringFromAsciiz(&str, lpStrings[i]);
 275         wideStrArray[i] = str.Buffer;
 276     }
 277     ret = ReportEventW(hEventLog, wType, wCategory, dwEventID, lpUserSid,
 278                        wNumStrings, dwDataSize, wideStrArray, lpRawData);
 279     for (i = 0; i < wNumStrings; i++)
 280     {
 281         if (wideStrArray[i]) HeapFree( GetProcessHeap(), 0, (LPSTR)wideStrArray[i] );
 282     }
 283     HeapFree(GetProcessHeap(), 0, wideStrArray);
 284     return ret;
 285 }
 286
 287 /******************************************************************************
 288  * ReportEventW [ADVAPI32.@]
 289  *
 290  * PARAMS
 291  *   hEventLog   []
 292  *   wType       []
 293  *   wCategory   []
 294  *   dwEventID   []
 295  *   lpUserSid   []
 296  *   wNumStrings []
 297  *   dwDataSize  []
 298  *   lpStrings   []
 299  *   lpRawData   []
 300  */
 301 BOOL WINAPI
 302 ReportEventW( HANDLE hEventLog, WORD wType, WORD wCategory,
 303                 DWORD dwEventID, PSID lpUserSid, WORD wNumStrings,
 304                 DWORD dwDataSize, LPCWSTR *lpStrings, LPVOID lpRawData )
 305 {
 306     int i;
 307
 308     /* partial stub */
 309
 310     if (wNumStrings == 0) return TRUE;
 311     if (!lpStrings) return TRUE;
 312
 313     for (i = 0; i < wNumStrings; i++)
 314     {
 315         switch (wType)
 316         {
 317         case EVENTLOG_SUCCESS:
 318             TRACE_(eventlog)("%s\n", debugstr_w(lpStrings[i]));
 319             break;
 320         case EVENTLOG_ERROR_TYPE:
 321             ERR_(eventlog)("%s\n", debugstr_w(lpStrings[i]));
 322             break;
 323         case EVENTLOG_WARNING_TYPE:
 324             WARN_(eventlog)("%s\n", debugstr_w(lpStrings[i]));
 325             break;
 326         default:
 327             TRACE_(eventlog)("%s\n", debugstr_w(lpStrings[i]));
 328             break;
 329         }
 330     }
 331     return TRUE;
 332
 333 }