librpc/gen_ndr/eventlog.h

   1 /* header auto-generated by pidl */
   2
   3 #include <stdint.h>
   4
   5 #include "librpc/gen_ndr/lsa.h"
   6 #include "librpc/gen_ndr/security.h"
   7 #ifndef _HEADER_eventlog
   8 #define _HEADER_eventlog
   9
  10 /* bitmap eventlogReadFlags */
  11 #define EVENTLOG_SEQUENTIAL_READ ( 0x0001 )
  12 #define EVENTLOG_SEEK_READ ( 0x0002 )
  13 #define EVENTLOG_FORWARDS_READ ( 0x0004 )
  14 #define EVENTLOG_BACKWARDS_READ ( 0x0008 )
  15
  16 enum eventlogEventTypes
  17 #ifndef USE_UINT_ENUMS
  18  {
  19         EVENTLOG_SUCCESS=0x0000,
  20         EVENTLOG_ERROR_TYPE=0x0001,
  21         EVENTLOG_WARNING_TYPE=0x0002,
  22         EVENTLOG_INFORMATION_TYPE=0x0004,
  23         EVENTLOG_AUDIT_SUCCESS=0x0008,
  24         EVENTLOG_AUDIT_FAILURE=0x0010
  25 }
  26 #else
  27  { __donnot_use_enum_eventlogEventTypes=0x7FFFFFFF}
  28 #define EVENTLOG_SUCCESS ( 0x0000 )
  29 #define EVENTLOG_ERROR_TYPE ( 0x0001 )
  30 #define EVENTLOG_WARNING_TYPE ( 0x0002 )
  31 #define EVENTLOG_INFORMATION_TYPE ( 0x0004 )
  32 #define EVENTLOG_AUDIT_SUCCESS ( 0x0008 )
  33 #define EVENTLOG_AUDIT_FAILURE ( 0x0010 )
  34 #endif
  35 ;
  36
  37 struct eventlog_OpenUnknown0 {
  38         uint16_t unknown0;
  39         uint16_t unknown1;
  40 };
  41
  42 struct eventlog_Record {
  43         uint32_t size;
  44         const char *reserved;/* [value("eLfL"),charset(DOS)] */
  45         uint32_t record_number;
  46         time_t time_generated;
  47         time_t time_written;
  48         uint32_t event_id;
  49         enum eventlogEventTypes event_type;
  50         uint16_t num_of_strings;/* [range(0,256)] */
  51         uint16_t event_category;
  52         uint16_t reserved_flags;
  53         uint32_t closing_record_number;
  54         uint32_t stringoffset;
  55         uint32_t sid_size;/* [value(ndr_size_dom_sid0(&sid,ndr->flags))] */
  56         uint32_t sid_offset;
  57         uint32_t data_length;
  58         uint32_t data_offset;
  59         const char * source_name;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
  60         const char * computer_name;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
  61         struct dom_sid0 sid;/* [subcontext_size(sid_size),subcontext(0)] */
  62         const char * *strings;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
  63         const char * raw_data;/* [flag(LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM)] */
  64         DATA_BLOB _padding;/* [flag(LIBNDR_FLAG_ALIGN4)] */
  65         uint32_t size2;/* [value(size)] */
  66 }/* [public,flag(LIBNDR_FLAG_NOALIGN)] */;
  67
  68 struct eventlog_Record_tdb {
  69         uint32_t size;
  70         const char *reserved;/* [value("eLfL"),charset(DOS)] */
  71         uint32_t record_number;
  72         time_t time_generated;
  73         time_t time_written;
  74         uint32_t event_id;
  75         enum eventlogEventTypes event_type;
  76         uint16_t num_of_strings;/* [range(0,256)] */
  77         uint16_t event_category;
  78         uint16_t reserved_flags;
  79         uint32_t closing_record_number;
  80         uint32_t stringoffset;
  81         uint32_t sid_length;/* [value(sid.length)] */
  82         uint32_t sid_offset;
  83         uint32_t data_length;/* [value(data.length)] */
  84         uint32_t data_offset;
  85         uint32_t source_name_len;/* [value(2*strlen_m_term(source_name))] */
  86         const char * source_name;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
  87         uint32_t computer_name_len;/* [value(2*strlen_m_term(computer_name))] */
  88         const char * computer_name;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
  89         uint32_t sid_padding;
  90         DATA_BLOB sid;
  91         uint32_t strings_len;/* [value(2*ndr_size_string_array(strings,num_of_strings,LIBNDR_FLAG_STR_NULLTERM))] */
  92         const char * *strings;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
  93         DATA_BLOB data;
  94         uint32_t padding;
  95 }/* [public,flag(LIBNDR_FLAG_NOALIGN|LIBNDR_PRINT_ARRAY_HEX)] */;
  96
  97 enum EVENTLOG_HEADER_FLAGS
  98 #ifndef USE_UINT_ENUMS
  99  {
 100         ELF_LOGFILE_HEADER_DIRTY=0x0001,
 101         ELF_LOGFILE_HEADER_WRAP=0x0002,
 102         ELF_LOGFILE_LOGFULL_WRITTEN=0x0004,
 103         ELF_LOGFILE_ARCHIVE_SET=0x0008
 104 }
 105 #else
 106  { __donnot_use_enum_EVENTLOG_HEADER_FLAGS=0x7FFFFFFF}
 107 #define ELF_LOGFILE_HEADER_DIRTY ( 0x0001 )
 108 #define ELF_LOGFILE_HEADER_WRAP ( 0x0002 )
 109 #define ELF_LOGFILE_LOGFULL_WRITTEN ( 0x0004 )
 110 #define ELF_LOGFILE_ARCHIVE_SET ( 0x0008 )
 111 #endif
 112 ;
 113
 114 struct EVENTLOGHEADER {
 115         uint32_t HeaderSize;/* [value(0x30)] */
 116         const char *Signature;/* [value("LfLe"),charset(DOS)] */
 117         uint32_t MajorVersion;/* [value] */
 118         uint32_t MinorVersion;/* [value] */
 119         uint32_t StartOffset;
 120         uint32_t EndOffset;
 121         uint32_t CurrentRecordNumber;
 122         uint32_t OldestRecordNumber;
 123         uint32_t MaxSize;
 124         enum EVENTLOG_HEADER_FLAGS Flags;
 125         uint32_t Retention;
 126         uint32_t EndHeaderSize;/* [value(0x30)] */
 127 }/* [public] */;
 128
 129 struct EVENTLOGRECORD {
 130         uint32_t Length;
 131         const char *Reserved;/* [value("LfLe"),charset(DOS)] */
 132         uint32_t RecordNumber;
 133         time_t TimeGenerated;
 134         time_t TimeWritten;
 135         uint32_t EventID;
 136         enum eventlogEventTypes EventType;
 137         uint16_t NumStrings;
 138         uint16_t EventCategory;
 139         uint16_t ReservedFlags;
 140         uint32_t ClosingRecordNumber;
 141         uint32_t StringOffset;/* [value(56+2*(strlen_m_term(SourceName)+strlen_m_term(Computername))+UserSidLength)] */
 142         uint32_t UserSidLength;/* [value(ndr_size_dom_sid0(&UserSid,ndr->flags))] */
 143         uint32_t UserSidOffset;/* [value(56+2*(strlen_m_term(SourceName)+strlen_m_term(Computername)))] */
 144         uint32_t DataLength;
 145         uint32_t DataOffset;/* [value(56+2*(strlen_m_term(SourceName)+strlen_m_term(Computername))+UserSidLength+(2*ndr_size_string_array(Strings,NumStrings,LIBNDR_FLAG_STR_NULLTERM)))] */
 146         const char * SourceName;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
 147         const char * Computername;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
 148         struct dom_sid0 UserSid;/* [subcontext_size(UserSidLength),subcontext(0),flag(LIBNDR_FLAG_ALIGN4)] */
 149         const char * *Strings;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
 150         uint8_t *Data;/* [flag(LIBNDR_PRINT_ARRAY_HEX)] */
 151         const char * Pad;/* [flag(LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM)] */
 152         uint32_t Length2;/* [value(Length)] */
 153 }/* [gensize,public] */;
 154
 155 struct EVENTLOGEOF {
 156         uint32_t RecordSizeBeginning;/* [value(0x28)] */
 157         uint32_t One;/* [value(0x11111111)] */
 158         uint32_t Two;/* [value(0x22222222)] */
 159         uint32_t Three;/* [value(0x33333333)] */
 160         uint32_t Four;/* [value(0x44444444)] */
 161         uint32_t BeginRecord;
 162         uint32_t EndRecord;
 163         uint32_t CurrentRecordNumber;
 164         uint32_t OldestRecordNumber;
 165         uint32_t RecordSizeEnd;/* [value(0x28)] */
 166 }/* [public] */;
 167
 168 struct EVENTLOG_EVT_FILE {
 169         struct EVENTLOGHEADER hdr;
 170         struct EVENTLOGRECORD *records;
 171         struct EVENTLOGEOF eof;
 172 }/* [public] */;
 173
 174 struct EVENTLOG_FULL_INFORMATION {
 175         uint32_t full;
 176 };
 177
 178
 179 struct eventlog_ClearEventLogW {
 180         struct {
 181                 struct policy_handle *handle;/* [ref] */
 182                 struct lsa_String *backupfile;/* [unique] */
 183         } in;
 184
 185         struct {
 186                 NTSTATUS result;
 187         } out;
 188
 189 };
 190
 191
 192 struct eventlog_BackupEventLogW {
 193         struct {
 194                 struct policy_handle *handle;/* [ref] */
 195                 struct lsa_String *backup_filename;/* [ref] */
 196         } in;
 197
 198         struct {
 199                 NTSTATUS result;
 200         } out;
 201
 202 };
 203
 204
 205 struct eventlog_CloseEventLog {
 206         struct {
 207                 struct policy_handle *handle;/* [ref] */
 208         } in;
 209
 210         struct {
 211                 struct policy_handle *handle;/* [ref] */
 212                 NTSTATUS result;
 213         } out;
 214
 215 };
 216
 217
 218 struct eventlog_DeregisterEventSource {
 219         struct {
 220                 struct policy_handle *handle;/* [ref] */
 221         } in;
 222
 223         struct {
 224                 struct policy_handle *handle;/* [ref] */
 225                 NTSTATUS result;
 226         } out;
 227
 228 };
 229
 230
 231 struct eventlog_GetNumRecords {
 232         struct {
 233                 struct policy_handle *handle;/* [ref] */
 234         } in;
 235
 236         struct {
 237                 uint32_t *number;/* [ref] */
 238                 NTSTATUS result;
 239         } out;
 240
 241 };
 242
 243
 244 struct eventlog_GetOldestRecord {
 245         struct {
 246                 struct policy_handle *handle;/* [ref] */
 247         } in;
 248
 249         struct {
 250                 uint32_t *oldest_entry;/* [ref] */
 251                 NTSTATUS result;
 252         } out;
 253
 254 };
 255
 256
 257 struct eventlog_ChangeNotify {
 258         struct {
 259                 NTSTATUS result;
 260         } out;
 261
 262 };
 263
 264
 265 struct eventlog_OpenEventLogW {
 266         struct {
 267                 struct eventlog_OpenUnknown0 *unknown0;/* [unique] */
 268                 struct lsa_String *logname;/* [ref] */
 269                 struct lsa_String *servername;/* [ref] */
 270                 uint32_t major_version;
 271                 uint32_t minor_version;
 272         } in;
 273
 274         struct {
 275                 struct policy_handle *handle;/* [ref] */
 276                 NTSTATUS result;
 277         } out;
 278
 279 };
 280
 281
 282 struct eventlog_RegisterEventSourceW {
 283         struct {
 284                 struct eventlog_OpenUnknown0 *unknown0;/* [unique] */
 285                 struct lsa_String *module_name;/* [ref] */
 286                 struct lsa_String *reg_module_name;/* [ref] */
 287                 uint32_t major_version;
 288                 uint32_t minor_version;
 289         } in;
 290
 291         struct {
 292                 struct policy_handle *log_handle;/* [ref] */
 293                 NTSTATUS result;
 294         } out;
 295
 296 };
 297
 298
 299 struct eventlog_OpenBackupEventLogW {
 300         struct {
 301                 struct eventlog_OpenUnknown0 *unknown0;/* [unique] */
 302                 struct lsa_String *backup_logname;/* [ref] */
 303                 uint32_t major_version;
 304                 uint32_t minor_version;
 305         } in;
 306
 307         struct {
 308                 struct policy_handle *handle;/* [ref] */
 309                 NTSTATUS result;
 310         } out;
 311
 312 };
 313
 314
 315 struct eventlog_ReadEventLogW {
 316         struct {
 317                 struct policy_handle *handle;/* [ref] */
 318                 uint32_t flags;
 319                 uint32_t offset;
 320                 uint32_t number_of_bytes;/* [range(0,0x7FFFF)] */
 321         } in;
 322
 323         struct {
 324                 uint8_t *data;/* [ref,size_is(number_of_bytes)] */
 325                 uint32_t *sent_size;/* [ref] */
 326                 uint32_t *real_size;/* [ref] */
 327                 NTSTATUS result;
 328         } out;
 329
 330 };
 331
 332
 333 struct eventlog_ReportEventW {
 334         struct {
 335                 struct policy_handle *handle;/* [ref] */
 336                 time_t timestamp;
 337                 enum eventlogEventTypes event_type;
 338                 uint16_t event_category;
 339                 uint32_t event_id;
 340                 uint16_t num_of_strings;/* [range(0,256)] */
 341                 uint32_t data_size;/* [range(0,0x3FFFF)] */
 342                 struct lsa_String *servername;/* [ref] */
 343                 struct dom_sid *user_sid;/* [unique] */
 344                 struct lsa_String **strings;/* [unique,size_is(num_of_strings)] */
 345                 uint8_t *data;/* [unique,size_is(data_size)] */
 346                 uint16_t flags;
 347                 uint32_t *record_number;/* [unique] */
 348                 time_t *time_written;/* [unique] */
 349         } in;
 350
 351         struct {
 352                 uint32_t *record_number;/* [unique] */
 353                 time_t *time_written;/* [unique] */
 354                 NTSTATUS result;
 355         } out;
 356
 357 };
 358
 359
 360 struct eventlog_ClearEventLogA {
 361         struct {
 362                 NTSTATUS result;
 363         } out;
 364
 365 };
 366
 367
 368 struct eventlog_BackupEventLogA {
 369         struct {
 370                 NTSTATUS result;
 371         } out;
 372
 373 };
 374
 375
 376 struct eventlog_OpenEventLogA {
 377         struct {
 378                 NTSTATUS result;
 379         } out;
 380
 381 };
 382
 383
 384 struct eventlog_RegisterEventSourceA {
 385         struct {
 386                 NTSTATUS result;
 387         } out;
 388
 389 };
 390
 391
 392 struct eventlog_OpenBackupEventLogA {
 393         struct {
 394                 NTSTATUS result;
 395         } out;
 396
 397 };
 398
 399
 400 struct eventlog_ReadEventLogA {
 401         struct {
 402                 NTSTATUS result;
 403         } out;
 404
 405 };
 406
 407
 408 struct eventlog_ReportEventA {
 409         struct {
 410                 NTSTATUS result;
 411         } out;
 412
 413 };
 414
 415
 416 struct eventlog_RegisterClusterSvc {
 417         struct {
 418                 NTSTATUS result;
 419         } out;
 420
 421 };
 422
 423
 424 struct eventlog_DeregisterClusterSvc {
 425         struct {
 426                 NTSTATUS result;
 427         } out;
 428
 429 };
 430
 431
 432 struct eventlog_WriteClusterEvents {
 433         struct {
 434                 NTSTATUS result;
 435         } out;
 436
 437 };
 438
 439
 440 struct eventlog_GetLogIntormation {
 441         struct {
 442                 struct policy_handle *handle;/* [ref] */
 443                 uint32_t level;
 444                 uint32_t buf_size;/* [range(0,1024)] */
 445         } in;
 446
 447         struct {
 448                 uint8_t *buffer;/* [ref,size_is(buf_size)] */
 449                 uint32_t *bytes_needed;/* [ref] */
 450                 NTSTATUS result;
 451         } out;
 452
 453 };
 454
 455
 456 struct eventlog_FlushEventLog {
 457         struct {
 458                 struct policy_handle *handle;/* [ref] */
 459         } in;
 460
 461         struct {
 462                 NTSTATUS result;
 463         } out;
 464
 465 };
 466
 467
 468 struct eventlog_ReportEventAndSourceW {
 469         struct {
 470                 struct policy_handle *handle;/* [ref] */
 471                 time_t timestamp;
 472                 enum eventlogEventTypes event_type;
 473                 uint16_t event_category;
 474                 uint32_t event_id;
 475                 struct lsa_String *sourcename;/* [ref] */
 476                 uint16_t num_of_strings;/* [range(0,256)] */
 477                 uint32_t data_size;/* [range(0,0x3FFFF)] */
 478                 struct lsa_String *servername;/* [ref] */
 479                 struct dom_sid *user_sid;/* [unique] */
 480                 struct lsa_String **strings;/* [unique,size_is(num_of_strings)] */
 481                 uint8_t *data;/* [unique,size_is(data_size)] */
 482                 uint16_t flags;
 483                 uint32_t *record_number;/* [unique] */
 484                 time_t *time_written;/* [unique] */
 485         } in;
 486
 487         struct {
 488                 uint32_t *record_number;/* [unique] */
 489                 time_t *time_written;/* [unique] */
 490                 NTSTATUS result;
 491         } out;
 492
 493 };
 494
 495 #endif /* _HEADER_eventlog */