reactos/base/services/eventlog/rpc.c

   1 /*
   2  * PROJECT:          ReactOS kernel
   3  * LICENSE:          GPL - See COPYING in the top level directory
   4  * FILE:             services/eventlog/rpc.c
   5  * PURPOSE:          Event logging service
   6  * COPYRIGHT:        Copyright 2005 Saveliy Tretiakov
   7  */
   8
   9 /* INCLUDES *****************************************************************/
  10
  11 #include "eventlog.h"
  12
  13 /* FUNCTIONS ****************************************************************/
  14
  15 DWORD STDCALL RpcThreadRoutine(LPVOID lpParameter)
  16 {
  17     RPC_STATUS Status;
  18
  19     Status = RpcServerUseProtseqEpW(L"ncacn_np", 20, L"\\pipe\\EventLog", NULL);
  20     if (Status != RPC_S_OK)
  21     {
  22         DPRINT("RpcServerUseProtseqEpW() failed (Status %lx)\n", Status);
  23         return 0;
  24     }
  25
  26     Status = RpcServerRegisterIf(eventlog_v0_0_s_ifspec, NULL, NULL);
  27
  28     if (Status != RPC_S_OK)
  29     {
  30         DPRINT("RpcServerRegisterIf() failed (Status %lx)\n", Status);
  31         return 0;
  32     }
  33
  34     Status = RpcServerListen(1, RPC_C_LISTEN_MAX_CALLS_DEFAULT, FALSE);
  35
  36     if (Status != RPC_S_OK)
  37     {
  38         DPRINT("RpcServerListen() failed (Status %lx)\n", Status);
  39     }
  40
  41     return 0;
  42 }
  43
  44
  45 /* Function 0 */
  46 NTSTATUS ElfrClearELFW(
  47     handle_t BindingHandle,
  48     IELF_HANDLE LogHandle,
  49     PRPC_UNICODE_STRING BackupFileName)
  50 {
  51     UNIMPLEMENTED;
  52     return STATUS_NOT_IMPLEMENTED;
  53 }
  54
  55
  56 /* Function 1 */
  57 NTSTATUS ElfrBackupELFW(
  58     handle_t BindingHandle,
  59     IELF_HANDLE LogHandle,
  60     PRPC_UNICODE_STRING BackupFileName)
  61 {
  62     UNIMPLEMENTED;
  63     return STATUS_NOT_IMPLEMENTED;
  64 }
  65
  66
  67 /* Function 2 */
  68 NTSTATUS ElfrCloseEL(
  69     handle_t BindingHandle,
  70     IELF_HANDLE *LogHandle)
  71 {
  72     UNIMPLEMENTED;
  73     return STATUS_NOT_IMPLEMENTED;
  74 }
  75
  76
  77 /* Function 3 */
  78 NTSTATUS ElfrDeregisterEventSource(
  79     handle_t BindingHandle,
  80     IELF_HANDLE *LogHandle)
  81 {
  82     UNIMPLEMENTED;
  83     return STATUS_SUCCESS;
  84 }
  85
  86
  87 /* Function 4 */
  88 NTSTATUS ElfrNumberOfRecords(
  89     handle_t BindingHandle,
  90     IELF_HANDLE LogHandle,
  91     DWORD *NumberOfRecords)
  92 {
  93     UNIMPLEMENTED;
  94     return STATUS_NOT_IMPLEMENTED;
  95 }
  96
  97
  98 /* Function 5 */
  99 NTSTATUS ElfrOldestRecord(
 100     handle_t BindingHandle,
 101     IELF_HANDLE LogHandle,
 102     DWORD *OldestRecordNumber)
 103 {
 104     UNIMPLEMENTED;
 105     return STATUS_NOT_IMPLEMENTED;
 106 }
 107
 108
 109 /* Function 6 */
 110 NTSTATUS ElfrChangeNotify(
 111     handle_t BindingHandle,
 112     IELF_HANDLE *LogHandle,
 113     RPC_CLIENT_ID ClientId,
 114     DWORD Event)
 115 {
 116     UNIMPLEMENTED;
 117     return STATUS_NOT_IMPLEMENTED;
 118 }
 119
 120
 121 /* Function 7 */
 122 NTSTATUS ElfrOpenELW(
 123     handle_t BindingHandle,
 124     EVENTLOG_HANDLE_W UNCServerName,
 125     PRPC_UNICODE_STRING ModuleName,
 126     PRPC_UNICODE_STRING RegModuleName,
 127     DWORD MajorVersion,
 128     DWORD MinorVersion,
 129     IELF_HANDLE *LogHandle)
 130 {
 131     UNIMPLEMENTED;
 132     *LogHandle = 1;
 133     return STATUS_SUCCESS;
 134 }
 135
 136
 137 /* Function 8 */
 138 NTSTATUS ElfrRegisterEventSourceW(
 139     handle_t BindingHandle,
 140     EVENTLOG_HANDLE_W UNCServerName,
 141     PRPC_UNICODE_STRING ModuleName,
 142     PRPC_UNICODE_STRING RegModuleName,
 143     DWORD MajorVersion,
 144     DWORD MinorVersion,
 145     IELF_HANDLE *LogHandle)
 146 {
 147     UNIMPLEMENTED;
 148     *LogHandle = 1;
 149     return STATUS_SUCCESS;
 150 }
 151
 152
 153 /* Function 9 */
 154 NTSTATUS ElfrOpenBELW(
 155     handle_t BindingHandle,
 156     EVENTLOG_HANDLE_W UNCServerName,
 157     PRPC_UNICODE_STRING BackupFileName,
 158     DWORD MajorVersion,
 159     DWORD MinorVersion,
 160     IELF_HANDLE *LogHandle)
 161 {
 162     UNIMPLEMENTED;
 163     return STATUS_NOT_IMPLEMENTED;
 164 }
 165
 166
 167 /* Function 10 */
 168 NTSTATUS ElfrReadELW(
 169     handle_t BindingHandle,
 170     IELF_HANDLE LogHandle,
 171     DWORD ReadFlags,
 172     DWORD RecordOffset,
 173     RULONG NumberOfBytesToRead,
 174     BYTE *Buffer,
 175     DWORD *NumberOfBytesRead,
 176     DWORD *MinNumberOfBytesNeeded)
 177 {
 178     UNIMPLEMENTED;
 179     return STATUS_NOT_IMPLEMENTED;
 180 }
 181
 182
 183 /* Function 11 */
 184 NTSTATUS ElfrReportEventW(
 185     handle_t BindingHandle,
 186     IELF_HANDLE LogHandle,
 187     DWORD Time,
 188     USHORT EventType,
 189     USHORT EventCategory,
 190     DWORD EventID,
 191     USHORT NumStrings,
 192     DWORD DataSize,
 193     PRPC_UNICODE_STRING ComputerName,
 194     PRPC_SID UserSID,
 195     PRPC_UNICODE_STRING Strings[],
 196     BYTE *Data,
 197     USHORT Flags,
 198     DWORD *RecordNumber,
 199     DWORD *TimeWritten)
 200 {
 201     USHORT i;
 202
 203     /* partial stub */
 204     for (i = 0; i < NumStrings; i++)
 205     {
 206         switch (EventType)
 207         {
 208             case EVENTLOG_SUCCESS:
 209                 DPRINT1("Success: %S\n", Strings[i]);
 210                 break;
 211
 212             case EVENTLOG_ERROR_TYPE:
 213                 DPRINT1("Error: %S\n", Strings[i]);
 214                 break;
 215
 216             case EVENTLOG_WARNING_TYPE:
 217                 DPRINT1("Warning: %S\n", Strings[i]);
 218                 break;
 219
 220             case EVENTLOG_INFORMATION_TYPE:
 221                 DPRINT1("Info: %S\n", Strings[i]);
 222                 break;
 223
 224             default:
 225                 DPRINT1("Type %hu: %S\n", EventType, Strings[i]);
 226                 break;
 227         }
 228     }
 229
 230     return STATUS_SUCCESS;
 231 }
 232
 233
 234 /* Function 12 */
 235 NTSTATUS ElfrClearELFA(
 236     handle_t BindingHandle,
 237     IELF_HANDLE LogHandle,
 238     PRPC_STRING BackupFileName)
 239 {
 240     UNIMPLEMENTED;
 241     return STATUS_NOT_IMPLEMENTED;
 242 }
 243
 244
 245 /* Function 13 */
 246 NTSTATUS ElfrBackupELFA(
 247     handle_t BindingHandle,
 248     IELF_HANDLE LogHandle,
 249     PRPC_STRING BackupFileName)
 250 {
 251     UNIMPLEMENTED;
 252     return STATUS_NOT_IMPLEMENTED;
 253 }
 254
 255
 256 /* Function 14 */
 257 NTSTATUS ElfrOpenELA(
 258     handle_t BindingHandle,
 259     EVENTLOG_HANDLE_A UNCServerName,
 260     PRPC_STRING ModuleName,
 261     PRPC_STRING RegModuleName,
 262     DWORD MajorVersion,
 263     DWORD MinorVersion,
 264     IELF_HANDLE *LogHandle)
 265 {
 266     UNICODE_STRING UNCServerNameW = { 0, };
 267     UNICODE_STRING ModuleNameW = { 0, };
 268     UNICODE_STRING RegModuleNameW = { 0, };
 269     NTSTATUS Status;
 270
 271     if (UNCServerName &&
 272         !RtlCreateUnicodeStringFromAsciiz(&UNCServerNameW, UNCServerName))
 273     {
 274         return STATUS_NO_MEMORY;
 275     }
 276
 277     if (ModuleName &&
 278         !RtlAnsiStringToUnicodeString(&ModuleNameW, (PANSI_STRING)ModuleName, TRUE))
 279     {
 280         RtlFreeUnicodeString(&UNCServerNameW);
 281         return STATUS_NO_MEMORY;
 282     }
 283
 284     if (RegModuleName &&
 285         !RtlAnsiStringToUnicodeString(&RegModuleNameW, (PANSI_STRING)RegModuleName, TRUE))
 286     {
 287         RtlFreeUnicodeString(&UNCServerNameW);
 288         RtlFreeUnicodeString(&ModuleNameW);
 289         return STATUS_NO_MEMORY;
 290     }
 291
 292     Status = ElfrOpenELW(
 293         BindingHandle,
 294         UNCServerName ? UNCServerNameW.Buffer : NULL,
 295         ModuleName ? (PRPC_UNICODE_STRING)&ModuleNameW : NULL,
 296         RegModuleName ? (PRPC_UNICODE_STRING)&RegModuleNameW : NULL,
 297         MajorVersion,
 298         MinorVersion,
 299         LogHandle);
 300
 301     RtlFreeUnicodeString(&UNCServerNameW);
 302     RtlFreeUnicodeString(&ModuleNameW);
 303     RtlFreeUnicodeString(&RegModuleNameW);
 304
 305     return Status;
 306 }
 307
 308
 309 /* Function 15 */
 310 NTSTATUS ElfrRegisterEventSourceA(
 311     handle_t BindingHandle,
 312     EVENTLOG_HANDLE_A UNCServerName,
 313     PRPC_STRING ModuleName,
 314     PRPC_STRING RegModuleName,
 315     DWORD MajorVersion,
 316     DWORD MinorVersion,
 317     IELF_HANDLE *LogHandle)
 318 {
 319     UNIMPLEMENTED;
 320     return STATUS_NOT_IMPLEMENTED;
 321 }
 322
 323
 324 /* Function 16 */
 325 NTSTATUS ElfrOpenBELA(
 326     handle_t BindingHandle,
 327     EVENTLOG_HANDLE_A UNCServerName,
 328     PRPC_STRING BackupFileName,
 329     DWORD MajorVersion,
 330     DWORD MinorVersion,
 331     IELF_HANDLE *LogHandle)
 332 {
 333     UNIMPLEMENTED;
 334     return STATUS_NOT_IMPLEMENTED;
 335 }
 336
 337
 338 /* Function 17 */
 339 NTSTATUS ElfrReadELA(
 340     handle_t BindingHandle,
 341     IELF_HANDLE LogHandle,
 342     DWORD ReadFlags,
 343     DWORD RecordOffset,
 344     RULONG NumberOfBytesToRead,
 345     BYTE *Buffer,
 346     DWORD *NumberOfBytesRead,
 347     DWORD *MinNumberOfBytesNeeded)
 348 {
 349     UNIMPLEMENTED;
 350     return STATUS_NOT_IMPLEMENTED;
 351 }
 352
 353
 354 /* Function 18 */
 355 NTSTATUS ElfrReportEventA(
 356     handle_t BindingHandle,
 357     IELF_HANDLE LogHandle,
 358     DWORD Time,
 359     USHORT EventType,
 360     USHORT EventCategory,
 361     DWORD EventID,
 362     USHORT NumStrings,
 363     DWORD DataSize,
 364     PRPC_STRING ComputerName,
 365     PRPC_SID UserSID,
 366     PRPC_STRING Strings[],
 367     BYTE *Data,
 368     USHORT Flags,
 369     DWORD *RecordNumber,
 370     DWORD *TimeWritten)
 371 {
 372     UNIMPLEMENTED;
 373     return STATUS_NOT_IMPLEMENTED;
 374 }
 375
 376
 377 /* Function 19 */
 378 NTSTATUS ElfrRegisterClusterSvc(
 379     handle_t BindingHandle)
 380 {
 381     UNIMPLEMENTED;
 382     return STATUS_NOT_IMPLEMENTED;
 383 }
 384
 385
 386 /* Function 20 */
 387 NTSTATUS ElfrDeregisterClusterSvc(
 388     handle_t BindingHandle)
 389 {
 390     UNIMPLEMENTED;
 391     return STATUS_NOT_IMPLEMENTED;
 392 }
 393
 394
 395 /* Function 21 */
 396 NTSTATUS ElfrWriteClusterEvents(
 397     handle_t BindingHandle)
 398 {
 399     UNIMPLEMENTED;
 400     return STATUS_NOT_IMPLEMENTED;
 401 }
 402
 403
 404 /* Function 22 */
 405 NTSTATUS ElfrGetLogInformation(
 406     handle_t BindingHandle,
 407     IELF_HANDLE LogHandle,
 408     DWORD InfoLevel,
 409     BYTE *Buffer,
 410     DWORD cbBufSize,
 411     DWORD *pcbBytesNeeded)
 412 {
 413     UNIMPLEMENTED;
 414     return STATUS_NOT_IMPLEMENTED;
 415 }
 416
 417
 418 /* Function 23 */
 419 NTSTATUS ElfrFlushEL(
 420     handle_t BindingHandle,
 421     IELF_HANDLE LogHandle)
 422 {
 423     UNIMPLEMENTED;
 424     return STATUS_NOT_IMPLEMENTED;
 425 }
 426
 427
 428 /* Function 24 */
 429 NTSTATUS ElfrReportEventAndSourceW(
 430     handle_t BindingHandle,
 431     IELF_HANDLE LogHandle,
 432     DWORD Time,
 433     USHORT EventType,
 434     USHORT EventCategory,
 435     ULONG EventID,
 436     PRPC_UNICODE_STRING SourceName,
 437     USHORT NumStrings,
 438     DWORD DataSize,
 439     PRPC_UNICODE_STRING ComputerName,
 440     PRPC_SID UserSID,
 441     PRPC_UNICODE_STRING Strings[],
 442     BYTE *Data,
 443     USHORT Flags,
 444     DWORD *RecordNumber,
 445     DWORD *TimeWritten)
 446 {
 447     UNIMPLEMENTED;
 448     return STATUS_NOT_IMPLEMENTED;
 449 }
 450
 451
 452 void __RPC_FAR *__RPC_USER midl_user_allocate(size_t len)
 453 {
 454     return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len);
 455 }
 456
 457
 458 void __RPC_USER midl_user_free(void __RPC_FAR * ptr)
 459 {
 460     HeapFree(GetProcessHeap(), 0, ptr);
 461 }
 462
 463
 464 void __RPC_USER IELF_HANDLE_rundown(IELF_HANDLE LogHandle)
 465 {
 466 }