source/librpc/gen_ndr/ndr_eventlog.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "librpc/gen_ndr/ndr_eventlog.h"
   5
   6 #include "librpc/gen_ndr/ndr_lsa.h"
   7 #include "librpc/gen_ndr/ndr_security.h"
   8 NTSTATUS ndr_push_eventlog_OpenUnknown0(struct ndr_push *ndr, int ndr_flags, const struct eventlog_OpenUnknown0 *r)
   9 {
  10         if (ndr_flags & NDR_SCALARS) {
  11                 NDR_CHECK(ndr_push_align(ndr, 2));
  12                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown0));
  13                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown1));
  14         }
  15         if (ndr_flags & NDR_BUFFERS) {
  16         }
  17         return NT_STATUS_OK;
  18 }
  19
  20 NTSTATUS ndr_pull_eventlog_OpenUnknown0(struct ndr_pull *ndr, int ndr_flags, struct eventlog_OpenUnknown0 *r)
  21 {
  22         if (ndr_flags & NDR_SCALARS) {
  23                 NDR_CHECK(ndr_pull_align(ndr, 2));
  24                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown0));
  25                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown1));
  26         }
  27         if (ndr_flags & NDR_BUFFERS) {
  28         }
  29         return NT_STATUS_OK;
  30 }
  31
  32 _PUBLIC_ void ndr_print_eventlog_OpenUnknown0(struct ndr_print *ndr, const char *name, const struct eventlog_OpenUnknown0 *r)
  33 {
  34         ndr_print_struct(ndr, name, "eventlog_OpenUnknown0");
  35         ndr->depth++;
  36         ndr_print_uint16(ndr, "unknown0", r->unknown0);
  37         ndr_print_uint16(ndr, "unknown1", r->unknown1);
  38         ndr->depth--;
  39 }
  40
  41 _PUBLIC_ NTSTATUS ndr_push_eventlog_Record(struct ndr_push *ndr, int ndr_flags, const struct eventlog_Record *r)
  42 {
  43         uint32_t cntr_strings_0;
  44         if (ndr_flags & NDR_SCALARS) {
  45                 NDR_CHECK(ndr_push_align(ndr, 4));
  46                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
  47                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
  48                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->record_number));
  49                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time_generated));
  50                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time_written));
  51                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->event_id));
  52                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->event_type));
  53                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_of_strings));
  54                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->event_category));
  55                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->reserved_flags));
  56                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->closing_record_number));
  57                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->stringoffset));
  58                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sid_length));
  59                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sid_offset));
  60                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->data_length));
  61                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->data_offset));
  62                 {
  63                         uint32_t _flags_save_string = ndr->flags;
  64                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
  65                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->source_name));
  66                         ndr->flags = _flags_save_string;
  67                 }
  68                 {
  69                         uint32_t _flags_save_string = ndr->flags;
  70                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
  71                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->computer_name));
  72                         ndr->flags = _flags_save_string;
  73                 }
  74                 {
  75                         uint32_t _flags_save_string = ndr->flags;
  76                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
  77                         for (cntr_strings_0 = 0; cntr_strings_0 < r->num_of_strings; cntr_strings_0++) {
  78                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->strings[cntr_strings_0]));
  79                         }
  80                         ndr->flags = _flags_save_string;
  81                 }
  82                 {
  83                         uint32_t _flags_save_string = ndr->flags;
  84                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
  85                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->raw_data));
  86                         ndr->flags = _flags_save_string;
  87                 }
  88         }
  89         if (ndr_flags & NDR_BUFFERS) {
  90         }
  91         return NT_STATUS_OK;
  92 }
  93
  94 _PUBLIC_ NTSTATUS ndr_pull_eventlog_Record(struct ndr_pull *ndr, int ndr_flags, struct eventlog_Record *r)
  95 {
  96         uint32_t cntr_strings_0;
  97         TALLOC_CTX *_mem_save_strings_0;
  98         if (ndr_flags & NDR_SCALARS) {
  99                 NDR_CHECK(ndr_pull_align(ndr, 4));
 100                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
 101                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
 102                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->record_number));
 103                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time_generated));
 104                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time_written));
 105                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->event_id));
 106                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->event_type));
 107                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_of_strings));
 108                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->event_category));
 109                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reserved_flags));
 110                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->closing_record_number));
 111                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->stringoffset));
 112                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_length));
 113                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_offset));
 114                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->data_length));
 115                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->data_offset));
 116                 {
 117                         uint32_t _flags_save_string = ndr->flags;
 118                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 119                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->source_name));
 120                         ndr->flags = _flags_save_string;
 121                 }
 122                 {
 123                         uint32_t _flags_save_string = ndr->flags;
 124                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 125                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->computer_name));
 126                         ndr->flags = _flags_save_string;
 127                 }
 128                 {
 129                         uint32_t _flags_save_string = ndr->flags;
 130                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 131                         NDR_PULL_ALLOC_N(ndr, r->strings, r->num_of_strings);
 132                         _mem_save_strings_0 = NDR_PULL_GET_MEM_CTX(ndr);
 133                         NDR_PULL_SET_MEM_CTX(ndr, *r->strings, 0);
 134                         for (cntr_strings_0 = 0; cntr_strings_0 < r->num_of_strings; cntr_strings_0++) {
 135                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->strings[cntr_strings_0]));
 136                         }
 137                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_strings_0, 0);
 138                         ndr->flags = _flags_save_string;
 139                 }
 140                 {
 141                         uint32_t _flags_save_string = ndr->flags;
 142                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 143                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->raw_data));
 144                         ndr->flags = _flags_save_string;
 145                 }
 146         }
 147         if (ndr_flags & NDR_BUFFERS) {
 148         }
 149         return NT_STATUS_OK;
 150 }
 151
 152 _PUBLIC_ void ndr_print_eventlog_Record(struct ndr_print *ndr, const char *name, const struct eventlog_Record *r)
 153 {
 154         uint32_t cntr_strings_0;
 155         ndr_print_struct(ndr, name, "eventlog_Record");
 156         ndr->depth++;
 157         ndr_print_uint32(ndr, "size", r->size);
 158         ndr_print_uint32(ndr, "reserved", r->reserved);
 159         ndr_print_uint32(ndr, "record_number", r->record_number);
 160         ndr_print_uint32(ndr, "time_generated", r->time_generated);
 161         ndr_print_uint32(ndr, "time_written", r->time_written);
 162         ndr_print_uint32(ndr, "event_id", r->event_id);
 163         ndr_print_uint16(ndr, "event_type", r->event_type);
 164         ndr_print_uint16(ndr, "num_of_strings", r->num_of_strings);
 165         ndr_print_uint16(ndr, "event_category", r->event_category);
 166         ndr_print_uint16(ndr, "reserved_flags", r->reserved_flags);
 167         ndr_print_uint32(ndr, "closing_record_number", r->closing_record_number);
 168         ndr_print_uint32(ndr, "stringoffset", r->stringoffset);
 169         ndr_print_uint32(ndr, "sid_length", r->sid_length);
 170         ndr_print_uint32(ndr, "sid_offset", r->sid_offset);
 171         ndr_print_uint32(ndr, "data_length", r->data_length);
 172         ndr_print_uint32(ndr, "data_offset", r->data_offset);
 173         ndr_print_string(ndr, "source_name", r->source_name);
 174         ndr_print_string(ndr, "computer_name", r->computer_name);
 175         ndr->print(ndr, "%s: ARRAY(%d)", "strings", r->num_of_strings);
 176         ndr->depth++;
 177         for (cntr_strings_0=0;cntr_strings_0<r->num_of_strings;cntr_strings_0++) {
 178                 char *idx_0=NULL;
 179                 asprintf(&idx_0, "[%d]", cntr_strings_0);
 180                 if (idx_0) {
 181                         ndr_print_string(ndr, "strings", r->strings[cntr_strings_0]);
 182                         free(idx_0);
 183                 }
 184         }
 185         ndr->depth--;
 186         ndr_print_string(ndr, "raw_data", r->raw_data);
 187         ndr->depth--;
 188 }
 189
 190 NTSTATUS ndr_push_eventlog_ClearEventLogW(struct ndr_push *ndr, int flags, const struct eventlog_ClearEventLogW *r)
 191 {
 192         if (flags & NDR_IN) {
 193                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
 194                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 195                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown));
 196                 if (r->in.unknown) {
 197                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.unknown));
 198                 }
 199         }
 200         if (flags & NDR_OUT) {
 201                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 202         }
 203         return NT_STATUS_OK;
 204 }
 205
 206 NTSTATUS ndr_pull_eventlog_ClearEventLogW(struct ndr_pull *ndr, int flags, struct eventlog_ClearEventLogW *r)
 207 {
 208         uint32_t _ptr_unknown;
 209         TALLOC_CTX *_mem_save_handle_0;
 210         TALLOC_CTX *_mem_save_unknown_0;
 211         if (flags & NDR_IN) {
 212                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 213                         NDR_PULL_ALLOC(ndr, r->in.handle);
 214                 }
 215                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 216                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
 217                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 218                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 219                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown));
 220                 if (_ptr_unknown) {
 221                         NDR_PULL_ALLOC(ndr, r->in.unknown);
 222                 } else {
 223                         r->in.unknown = NULL;
 224                 }
 225                 if (r->in.unknown) {
 226                         _mem_save_unknown_0 = NDR_PULL_GET_MEM_CTX(ndr);
 227                         NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown, 0);
 228                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.unknown));
 229                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown_0, 0);
 230                 }
 231         }
 232         if (flags & NDR_OUT) {
 233                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 234         }
 235         return NT_STATUS_OK;
 236 }
 237
 238 _PUBLIC_ void ndr_print_eventlog_ClearEventLogW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ClearEventLogW *r)
 239 {
 240         ndr_print_struct(ndr, name, "eventlog_ClearEventLogW");
 241         ndr->depth++;
 242         if (flags & NDR_SET_VALUES) {
 243                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 244         }
 245         if (flags & NDR_IN) {
 246                 ndr_print_struct(ndr, "in", "eventlog_ClearEventLogW");
 247                 ndr->depth++;
 248                 ndr_print_ptr(ndr, "handle", r->in.handle);
 249                 ndr->depth++;
 250                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
 251                 ndr->depth--;
 252                 ndr_print_ptr(ndr, "unknown", r->in.unknown);
 253                 ndr->depth++;
 254                 if (r->in.unknown) {
 255                         ndr_print_lsa_String(ndr, "unknown", r->in.unknown);
 256                 }
 257                 ndr->depth--;
 258                 ndr->depth--;
 259         }
 260         if (flags & NDR_OUT) {
 261                 ndr_print_struct(ndr, "out", "eventlog_ClearEventLogW");
 262                 ndr->depth++;
 263                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
 264                 ndr->depth--;
 265         }
 266         ndr->depth--;
 267 }
 268
 269 NTSTATUS ndr_push_eventlog_BackupEventLogW(struct ndr_push *ndr, int flags, const struct eventlog_BackupEventLogW *r)
 270 {
 271         if (flags & NDR_IN) {
 272         }
 273         if (flags & NDR_OUT) {
 274                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 275         }
 276         return NT_STATUS_OK;
 277 }
 278
 279 NTSTATUS ndr_pull_eventlog_BackupEventLogW(struct ndr_pull *ndr, int flags, struct eventlog_BackupEventLogW *r)
 280 {
 281         if (flags & NDR_IN) {
 282         }
 283         if (flags & NDR_OUT) {
 284                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 285         }
 286         return NT_STATUS_OK;
 287 }
 288
 289 _PUBLIC_ void ndr_print_eventlog_BackupEventLogW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_BackupEventLogW *r)
 290 {
 291         ndr_print_struct(ndr, name, "eventlog_BackupEventLogW");
 292         ndr->depth++;
 293         if (flags & NDR_SET_VALUES) {
 294                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 295         }
 296         if (flags & NDR_IN) {
 297                 ndr_print_struct(ndr, "in", "eventlog_BackupEventLogW");
 298                 ndr->depth++;
 299                 ndr->depth--;
 300         }
 301         if (flags & NDR_OUT) {
 302                 ndr_print_struct(ndr, "out", "eventlog_BackupEventLogW");
 303                 ndr->depth++;
 304                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
 305                 ndr->depth--;
 306         }
 307         ndr->depth--;
 308 }
 309
 310 NTSTATUS ndr_push_eventlog_CloseEventLog(struct ndr_push *ndr, int flags, const struct eventlog_CloseEventLog *r)
 311 {
 312         if (flags & NDR_IN) {
 313                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
 314                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 315         }
 316         if (flags & NDR_OUT) {
 317                 if (r->out.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
 318                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
 319                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 320         }
 321         return NT_STATUS_OK;
 322 }
 323
 324 NTSTATUS ndr_pull_eventlog_CloseEventLog(struct ndr_pull *ndr, int flags, struct eventlog_CloseEventLog *r)
 325 {
 326         TALLOC_CTX *_mem_save_handle_0;
 327         if (flags & NDR_IN) {
 328                 ZERO_STRUCT(r->out);
 329
 330                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 331                         NDR_PULL_ALLOC(ndr, r->in.handle);
 332                 }
 333                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 334                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
 335                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 336                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 337                 NDR_PULL_ALLOC(ndr, r->out.handle);
 338                 *r->out.handle = *r->in.handle;
 339         }
 340         if (flags & NDR_OUT) {
 341                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 342                         NDR_PULL_ALLOC(ndr, r->out.handle);
 343                 }
 344                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 345                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
 346                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
 347                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 348                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 349         }
 350         return NT_STATUS_OK;
 351 }
 352
 353 _PUBLIC_ void ndr_print_eventlog_CloseEventLog(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_CloseEventLog *r)
 354 {
 355         ndr_print_struct(ndr, name, "eventlog_CloseEventLog");
 356         ndr->depth++;
 357         if (flags & NDR_SET_VALUES) {
 358                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 359         }
 360         if (flags & NDR_IN) {
 361                 ndr_print_struct(ndr, "in", "eventlog_CloseEventLog");
 362                 ndr->depth++;
 363                 ndr_print_ptr(ndr, "handle", r->in.handle);
 364                 ndr->depth++;
 365                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
 366                 ndr->depth--;
 367                 ndr->depth--;
 368         }
 369         if (flags & NDR_OUT) {
 370                 ndr_print_struct(ndr, "out", "eventlog_CloseEventLog");
 371                 ndr->depth++;
 372                 ndr_print_ptr(ndr, "handle", r->out.handle);
 373                 ndr->depth++;
 374                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
 375                 ndr->depth--;
 376                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
 377                 ndr->depth--;
 378         }
 379         ndr->depth--;
 380 }
 381
 382 NTSTATUS ndr_push_eventlog_DeregisterEventSource(struct ndr_push *ndr, int flags, const struct eventlog_DeregisterEventSource *r)
 383 {
 384         if (flags & NDR_IN) {
 385         }
 386         if (flags & NDR_OUT) {
 387                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 388         }
 389         return NT_STATUS_OK;
 390 }
 391
 392 NTSTATUS ndr_pull_eventlog_DeregisterEventSource(struct ndr_pull *ndr, int flags, struct eventlog_DeregisterEventSource *r)
 393 {
 394         if (flags & NDR_IN) {
 395         }
 396         if (flags & NDR_OUT) {
 397                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 398         }
 399         return NT_STATUS_OK;
 400 }
 401
 402 _PUBLIC_ void ndr_print_eventlog_DeregisterEventSource(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_DeregisterEventSource *r)
 403 {
 404         ndr_print_struct(ndr, name, "eventlog_DeregisterEventSource");
 405         ndr->depth++;
 406         if (flags & NDR_SET_VALUES) {
 407                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 408         }
 409         if (flags & NDR_IN) {
 410                 ndr_print_struct(ndr, "in", "eventlog_DeregisterEventSource");
 411                 ndr->depth++;
 412                 ndr->depth--;
 413         }
 414         if (flags & NDR_OUT) {
 415                 ndr_print_struct(ndr, "out", "eventlog_DeregisterEventSource");
 416                 ndr->depth++;
 417                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
 418                 ndr->depth--;
 419         }
 420         ndr->depth--;
 421 }
 422
 423 NTSTATUS ndr_push_eventlog_GetNumRecords(struct ndr_push *ndr, int flags, const struct eventlog_GetNumRecords *r)
 424 {
 425         if (flags & NDR_IN) {
 426                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
 427                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 428         }
 429         if (flags & NDR_OUT) {
 430                 if (r->out.number == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
 431                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.number));
 432                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 433         }
 434         return NT_STATUS_OK;
 435 }
 436
 437 NTSTATUS ndr_pull_eventlog_GetNumRecords(struct ndr_pull *ndr, int flags, struct eventlog_GetNumRecords *r)
 438 {
 439         TALLOC_CTX *_mem_save_handle_0;
 440         TALLOC_CTX *_mem_save_number_0;
 441         if (flags & NDR_IN) {
 442                 ZERO_STRUCT(r->out);
 443
 444                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 445                         NDR_PULL_ALLOC(ndr, r->in.handle);
 446                 }
 447                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 448                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
 449                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 450                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 451                 NDR_PULL_ALLOC(ndr, r->out.number);
 452                 ZERO_STRUCTP(r->out.number);
 453         }
 454         if (flags & NDR_OUT) {
 455                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 456                         NDR_PULL_ALLOC(ndr, r->out.number);
 457                 }
 458                 _mem_save_number_0 = NDR_PULL_GET_MEM_CTX(ndr);
 459                 NDR_PULL_SET_MEM_CTX(ndr, r->out.number, LIBNDR_FLAG_REF_ALLOC);
 460                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.number));
 461                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_number_0, LIBNDR_FLAG_REF_ALLOC);
 462                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 463         }
 464         return NT_STATUS_OK;
 465 }
 466
 467 _PUBLIC_ void ndr_print_eventlog_GetNumRecords(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_GetNumRecords *r)
 468 {
 469         ndr_print_struct(ndr, name, "eventlog_GetNumRecords");
 470         ndr->depth++;
 471         if (flags & NDR_SET_VALUES) {
 472                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 473         }
 474         if (flags & NDR_IN) {
 475                 ndr_print_struct(ndr, "in", "eventlog_GetNumRecords");
 476                 ndr->depth++;
 477                 ndr_print_ptr(ndr, "handle", r->in.handle);
 478                 ndr->depth++;
 479                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
 480                 ndr->depth--;
 481                 ndr->depth--;
 482         }
 483         if (flags & NDR_OUT) {
 484                 ndr_print_struct(ndr, "out", "eventlog_GetNumRecords");
 485                 ndr->depth++;
 486                 ndr_print_ptr(ndr, "number", r->out.number);
 487                 ndr->depth++;
 488                 ndr_print_uint32(ndr, "number", *r->out.number);
 489                 ndr->depth--;
 490                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
 491                 ndr->depth--;
 492         }
 493         ndr->depth--;
 494 }
 495
 496 NTSTATUS ndr_push_eventlog_GetOldestRecord(struct ndr_push *ndr, int flags, const struct eventlog_GetOldestRecord *r)
 497 {
 498         if (flags & NDR_IN) {
 499         }
 500         if (flags & NDR_OUT) {
 501                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 502         }
 503         return NT_STATUS_OK;
 504 }
 505
 506 NTSTATUS ndr_pull_eventlog_GetOldestRecord(struct ndr_pull *ndr, int flags, struct eventlog_GetOldestRecord *r)
 507 {
 508         if (flags & NDR_IN) {
 509         }
 510         if (flags & NDR_OUT) {
 511                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 512         }
 513         return NT_STATUS_OK;
 514 }
 515
 516 _PUBLIC_ void ndr_print_eventlog_GetOldestRecord(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_GetOldestRecord *r)
 517 {
 518         ndr_print_struct(ndr, name, "eventlog_GetOldestRecord");
 519         ndr->depth++;
 520         if (flags & NDR_SET_VALUES) {
 521                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 522         }
 523         if (flags & NDR_IN) {
 524                 ndr_print_struct(ndr, "in", "eventlog_GetOldestRecord");
 525                 ndr->depth++;
 526                 ndr->depth--;
 527         }
 528         if (flags & NDR_OUT) {
 529                 ndr_print_struct(ndr, "out", "eventlog_GetOldestRecord");
 530                 ndr->depth++;
 531                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
 532                 ndr->depth--;
 533         }
 534         ndr->depth--;
 535 }
 536
 537 NTSTATUS ndr_push_eventlog_ChangeNotify(struct ndr_push *ndr, int flags, const struct eventlog_ChangeNotify *r)
 538 {
 539         if (flags & NDR_IN) {
 540         }
 541         if (flags & NDR_OUT) {
 542                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 543         }
 544         return NT_STATUS_OK;
 545 }
 546
 547 NTSTATUS ndr_pull_eventlog_ChangeNotify(struct ndr_pull *ndr, int flags, struct eventlog_ChangeNotify *r)
 548 {
 549         if (flags & NDR_IN) {
 550         }
 551         if (flags & NDR_OUT) {
 552                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 553         }
 554         return NT_STATUS_OK;
 555 }
 556
 557 _PUBLIC_ void ndr_print_eventlog_ChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ChangeNotify *r)
 558 {
 559         ndr_print_struct(ndr, name, "eventlog_ChangeNotify");
 560         ndr->depth++;
 561         if (flags & NDR_SET_VALUES) {
 562                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 563         }
 564         if (flags & NDR_IN) {
 565                 ndr_print_struct(ndr, "in", "eventlog_ChangeNotify");
 566                 ndr->depth++;
 567                 ndr->depth--;
 568         }
 569         if (flags & NDR_OUT) {
 570                 ndr_print_struct(ndr, "out", "eventlog_ChangeNotify");
 571                 ndr->depth++;
 572                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
 573                 ndr->depth--;
 574         }
 575         ndr->depth--;
 576 }
 577
 578 NTSTATUS ndr_push_eventlog_OpenEventLogW(struct ndr_push *ndr, int flags, const struct eventlog_OpenEventLogW *r)
 579 {
 580         if (flags & NDR_IN) {
 581                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown0));
 582                 if (r->in.unknown0) {
 583                         NDR_CHECK(ndr_push_eventlog_OpenUnknown0(ndr, NDR_SCALARS, r->in.unknown0));
 584                 }
 585                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.logname));
 586                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.servername));
 587                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
 588                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown3));
 589         }
 590         if (flags & NDR_OUT) {
 591                 if (r->out.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
 592                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
 593                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 594         }
 595         return NT_STATUS_OK;
 596 }
 597
 598 NTSTATUS ndr_pull_eventlog_OpenEventLogW(struct ndr_pull *ndr, int flags, struct eventlog_OpenEventLogW *r)
 599 {
 600         uint32_t _ptr_unknown0;
 601         TALLOC_CTX *_mem_save_unknown0_0;
 602         TALLOC_CTX *_mem_save_handle_0;
 603         if (flags & NDR_IN) {
 604                 ZERO_STRUCT(r->out);
 605
 606                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown0));
 607                 if (_ptr_unknown0) {
 608                         NDR_PULL_ALLOC(ndr, r->in.unknown0);
 609                 } else {
 610                         r->in.unknown0 = NULL;
 611                 }
 612                 if (r->in.unknown0) {
 613                         _mem_save_unknown0_0 = NDR_PULL_GET_MEM_CTX(ndr);
 614                         NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown0, 0);
 615                         NDR_CHECK(ndr_pull_eventlog_OpenUnknown0(ndr, NDR_SCALARS, r->in.unknown0));
 616                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown0_0, 0);
 617                 }
 618                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.logname));
 619                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.servername));
 620                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
 621                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown3));
 622                 NDR_PULL_ALLOC(ndr, r->out.handle);
 623                 ZERO_STRUCTP(r->out.handle);
 624         }
 625         if (flags & NDR_OUT) {
 626                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 627                         NDR_PULL_ALLOC(ndr, r->out.handle);
 628                 }
 629                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 630                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
 631                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
 632                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 633                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 634         }
 635         return NT_STATUS_OK;
 636 }
 637
 638 _PUBLIC_ void ndr_print_eventlog_OpenEventLogW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_OpenEventLogW *r)
 639 {
 640         ndr_print_struct(ndr, name, "eventlog_OpenEventLogW");
 641         ndr->depth++;
 642         if (flags & NDR_SET_VALUES) {
 643                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 644         }
 645         if (flags & NDR_IN) {
 646                 ndr_print_struct(ndr, "in", "eventlog_OpenEventLogW");
 647                 ndr->depth++;
 648                 ndr_print_ptr(ndr, "unknown0", r->in.unknown0);
 649                 ndr->depth++;
 650                 if (r->in.unknown0) {
 651                         ndr_print_eventlog_OpenUnknown0(ndr, "unknown0", r->in.unknown0);
 652                 }
 653                 ndr->depth--;
 654                 ndr_print_lsa_String(ndr, "logname", &r->in.logname);
 655                 ndr_print_lsa_String(ndr, "servername", &r->in.servername);
 656                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
 657                 ndr_print_uint32(ndr, "unknown3", r->in.unknown3);
 658                 ndr->depth--;
 659         }
 660         if (flags & NDR_OUT) {
 661                 ndr_print_struct(ndr, "out", "eventlog_OpenEventLogW");
 662                 ndr->depth++;
 663                 ndr_print_ptr(ndr, "handle", r->out.handle);
 664                 ndr->depth++;
 665                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
 666                 ndr->depth--;
 667                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
 668                 ndr->depth--;
 669         }
 670         ndr->depth--;
 671 }
 672
 673 NTSTATUS ndr_push_eventlog_RegisterEventSourceW(struct ndr_push *ndr, int flags, const struct eventlog_RegisterEventSourceW *r)
 674 {
 675         if (flags & NDR_IN) {
 676         }
 677         if (flags & NDR_OUT) {
 678                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 679         }
 680         return NT_STATUS_OK;
 681 }
 682
 683 NTSTATUS ndr_pull_eventlog_RegisterEventSourceW(struct ndr_pull *ndr, int flags, struct eventlog_RegisterEventSourceW *r)
 684 {
 685         if (flags & NDR_IN) {
 686         }
 687         if (flags & NDR_OUT) {
 688                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 689         }
 690         return NT_STATUS_OK;
 691 }
 692
 693 _PUBLIC_ void ndr_print_eventlog_RegisterEventSourceW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_RegisterEventSourceW *r)
 694 {
 695         ndr_print_struct(ndr, name, "eventlog_RegisterEventSourceW");
 696         ndr->depth++;
 697         if (flags & NDR_SET_VALUES) {
 698                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 699         }
 700         if (flags & NDR_IN) {
 701                 ndr_print_struct(ndr, "in", "eventlog_RegisterEventSourceW");
 702                 ndr->depth++;
 703                 ndr->depth--;
 704         }
 705         if (flags & NDR_OUT) {
 706                 ndr_print_struct(ndr, "out", "eventlog_RegisterEventSourceW");
 707                 ndr->depth++;
 708                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
 709                 ndr->depth--;
 710         }
 711         ndr->depth--;
 712 }
 713
 714 NTSTATUS ndr_push_eventlog_OpenBackupEventLogW(struct ndr_push *ndr, int flags, const struct eventlog_OpenBackupEventLogW *r)
 715 {
 716         if (flags & NDR_IN) {
 717         }
 718         if (flags & NDR_OUT) {
 719                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 720         }
 721         return NT_STATUS_OK;
 722 }
 723
 724 NTSTATUS ndr_pull_eventlog_OpenBackupEventLogW(struct ndr_pull *ndr, int flags, struct eventlog_OpenBackupEventLogW *r)
 725 {
 726         if (flags & NDR_IN) {
 727         }
 728         if (flags & NDR_OUT) {
 729                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 730         }
 731         return NT_STATUS_OK;
 732 }
 733
 734 _PUBLIC_ void ndr_print_eventlog_OpenBackupEventLogW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_OpenBackupEventLogW *r)
 735 {
 736         ndr_print_struct(ndr, name, "eventlog_OpenBackupEventLogW");
 737         ndr->depth++;
 738         if (flags & NDR_SET_VALUES) {
 739                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 740         }
 741         if (flags & NDR_IN) {
 742                 ndr_print_struct(ndr, "in", "eventlog_OpenBackupEventLogW");
 743                 ndr->depth++;
 744                 ndr->depth--;
 745         }
 746         if (flags & NDR_OUT) {
 747                 ndr_print_struct(ndr, "out", "eventlog_OpenBackupEventLogW");
 748                 ndr->depth++;
 749                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
 750                 ndr->depth--;
 751         }
 752         ndr->depth--;
 753 }
 754
 755 NTSTATUS ndr_push_eventlog_ReadEventLogW(struct ndr_push *ndr, int flags, const struct eventlog_ReadEventLogW *r)
 756 {
 757         if (flags & NDR_IN) {
 758                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
 759                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 760                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
 761                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offset));
 762                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.number_of_bytes));
 763         }
 764         if (flags & NDR_OUT) {
 765                 if (r->out.data == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
 766                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.number_of_bytes));
 767                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.number_of_bytes));
 768                 if (r->out.sent_size == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
 769                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.sent_size));
 770                 if (r->out.real_size == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
 771                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.real_size));
 772                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 773         }
 774         return NT_STATUS_OK;
 775 }
 776
 777 NTSTATUS ndr_pull_eventlog_ReadEventLogW(struct ndr_pull *ndr, int flags, struct eventlog_ReadEventLogW *r)
 778 {
 779         TALLOC_CTX *_mem_save_handle_0;
 780         TALLOC_CTX *_mem_save_sent_size_0;
 781         TALLOC_CTX *_mem_save_real_size_0;
 782         if (flags & NDR_IN) {
 783                 ZERO_STRUCT(r->out);
 784
 785                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 786                         NDR_PULL_ALLOC(ndr, r->in.handle);
 787                 }
 788                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 789                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
 790                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 791                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 792                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
 793                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offset));
 794                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.number_of_bytes));
 795                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.number_of_bytes);
 796                 memset(r->out.data, 0, r->in.number_of_bytes * sizeof(*r->out.data));
 797                 NDR_PULL_ALLOC(ndr, r->out.sent_size);
 798                 ZERO_STRUCTP(r->out.sent_size);
 799                 NDR_PULL_ALLOC(ndr, r->out.real_size);
 800                 ZERO_STRUCTP(r->out.real_size);
 801         }
 802         if (flags & NDR_OUT) {
 803                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
 804                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 805                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
 806                 }
 807                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
 808                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 809                         NDR_PULL_ALLOC(ndr, r->out.sent_size);
 810                 }
 811                 _mem_save_sent_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
 812                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sent_size, LIBNDR_FLAG_REF_ALLOC);
 813                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.sent_size));
 814                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sent_size_0, LIBNDR_FLAG_REF_ALLOC);
 815                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 816                         NDR_PULL_ALLOC(ndr, r->out.real_size);
 817                 }
 818                 _mem_save_real_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
 819                 NDR_PULL_SET_MEM_CTX(ndr, r->out.real_size, LIBNDR_FLAG_REF_ALLOC);
 820                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.real_size));
 821                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_real_size_0, LIBNDR_FLAG_REF_ALLOC);
 822                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 823                 if (r->out.data) {
 824                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.number_of_bytes));
 825                 }
 826         }
 827         return NT_STATUS_OK;
 828 }
 829
 830 _PUBLIC_ void ndr_print_eventlog_ReadEventLogW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ReadEventLogW *r)
 831 {
 832         ndr_print_struct(ndr, name, "eventlog_ReadEventLogW");
 833         ndr->depth++;
 834         if (flags & NDR_SET_VALUES) {
 835                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 836         }
 837         if (flags & NDR_IN) {
 838                 ndr_print_struct(ndr, "in", "eventlog_ReadEventLogW");
 839                 ndr->depth++;
 840                 ndr_print_ptr(ndr, "handle", r->in.handle);
 841                 ndr->depth++;
 842                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
 843                 ndr->depth--;
 844                 ndr_print_uint32(ndr, "flags", r->in.flags);
 845                 ndr_print_uint32(ndr, "offset", r->in.offset);
 846                 ndr_print_uint32(ndr, "number_of_bytes", r->in.number_of_bytes);
 847                 ndr->depth--;
 848         }
 849         if (flags & NDR_OUT) {
 850                 ndr_print_struct(ndr, "out", "eventlog_ReadEventLogW");
 851                 ndr->depth++;
 852                 ndr_print_ptr(ndr, "data", r->out.data);
 853                 ndr->depth++;
 854                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.number_of_bytes);
 855                 ndr->depth--;
 856                 ndr_print_ptr(ndr, "sent_size", r->out.sent_size);
 857                 ndr->depth++;
 858                 ndr_print_uint32(ndr, "sent_size", *r->out.sent_size);
 859                 ndr->depth--;
 860                 ndr_print_ptr(ndr, "real_size", r->out.real_size);
 861                 ndr->depth++;
 862                 ndr_print_uint32(ndr, "real_size", *r->out.real_size);
 863                 ndr->depth--;
 864                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
 865                 ndr->depth--;
 866         }
 867         ndr->depth--;
 868 }
 869
 870 NTSTATUS ndr_push_eventlog_ReportEventW(struct ndr_push *ndr, int flags, const struct eventlog_ReportEventW *r)
 871 {
 872         if (flags & NDR_IN) {
 873         }
 874         if (flags & NDR_OUT) {
 875                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 876         }
 877         return NT_STATUS_OK;
 878 }
 879
 880 NTSTATUS ndr_pull_eventlog_ReportEventW(struct ndr_pull *ndr, int flags, struct eventlog_ReportEventW *r)
 881 {
 882         if (flags & NDR_IN) {
 883         }
 884         if (flags & NDR_OUT) {
 885                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 886         }
 887         return NT_STATUS_OK;
 888 }
 889
 890 _PUBLIC_ void ndr_print_eventlog_ReportEventW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ReportEventW *r)
 891 {
 892         ndr_print_struct(ndr, name, "eventlog_ReportEventW");
 893         ndr->depth++;
 894         if (flags & NDR_SET_VALUES) {
 895                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 896         }
 897         if (flags & NDR_IN) {
 898                 ndr_print_struct(ndr, "in", "eventlog_ReportEventW");
 899                 ndr->depth++;
 900                 ndr->depth--;
 901         }
 902         if (flags & NDR_OUT) {
 903                 ndr_print_struct(ndr, "out", "eventlog_ReportEventW");
 904                 ndr->depth++;
 905                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
 906                 ndr->depth--;
 907         }
 908         ndr->depth--;
 909 }
 910
 911 NTSTATUS ndr_push_eventlog_ClearEventLogA(struct ndr_push *ndr, int flags, const struct eventlog_ClearEventLogA *r)
 912 {
 913         if (flags & NDR_IN) {
 914         }
 915         if (flags & NDR_OUT) {
 916                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 917         }
 918         return NT_STATUS_OK;
 919 }
 920
 921 NTSTATUS ndr_pull_eventlog_ClearEventLogA(struct ndr_pull *ndr, int flags, struct eventlog_ClearEventLogA *r)
 922 {
 923         if (flags & NDR_IN) {
 924         }
 925         if (flags & NDR_OUT) {
 926                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 927         }
 928         return NT_STATUS_OK;
 929 }
 930
 931 _PUBLIC_ void ndr_print_eventlog_ClearEventLogA(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ClearEventLogA *r)
 932 {
 933         ndr_print_struct(ndr, name, "eventlog_ClearEventLogA");
 934         ndr->depth++;
 935         if (flags & NDR_SET_VALUES) {
 936                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 937         }
 938         if (flags & NDR_IN) {
 939                 ndr_print_struct(ndr, "in", "eventlog_ClearEventLogA");
 940                 ndr->depth++;
 941                 ndr->depth--;
 942         }
 943         if (flags & NDR_OUT) {
 944                 ndr_print_struct(ndr, "out", "eventlog_ClearEventLogA");
 945                 ndr->depth++;
 946                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
 947                 ndr->depth--;
 948         }
 949         ndr->depth--;
 950 }
 951
 952 NTSTATUS ndr_push_eventlog_BackupEventLogA(struct ndr_push *ndr, int flags, const struct eventlog_BackupEventLogA *r)
 953 {
 954         if (flags & NDR_IN) {
 955         }
 956         if (flags & NDR_OUT) {
 957                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 958         }
 959         return NT_STATUS_OK;
 960 }
 961
 962 NTSTATUS ndr_pull_eventlog_BackupEventLogA(struct ndr_pull *ndr, int flags, struct eventlog_BackupEventLogA *r)
 963 {
 964         if (flags & NDR_IN) {
 965         }
 966         if (flags & NDR_OUT) {
 967                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 968         }
 969         return NT_STATUS_OK;
 970 }
 971
 972 _PUBLIC_ void ndr_print_eventlog_BackupEventLogA(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_BackupEventLogA *r)
 973 {
 974         ndr_print_struct(ndr, name, "eventlog_BackupEventLogA");
 975         ndr->depth++;
 976         if (flags & NDR_SET_VALUES) {
 977                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 978         }
 979         if (flags & NDR_IN) {
 980                 ndr_print_struct(ndr, "in", "eventlog_BackupEventLogA");
 981                 ndr->depth++;
 982                 ndr->depth--;
 983         }
 984         if (flags & NDR_OUT) {
 985                 ndr_print_struct(ndr, "out", "eventlog_BackupEventLogA");
 986                 ndr->depth++;
 987                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
 988                 ndr->depth--;
 989         }
 990         ndr->depth--;
 991 }
 992
 993 NTSTATUS ndr_push_eventlog_OpenEventLogA(struct ndr_push *ndr, int flags, const struct eventlog_OpenEventLogA *r)
 994 {
 995         if (flags & NDR_IN) {
 996         }
 997         if (flags & NDR_OUT) {
 998                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 999         }
1000         return NT_STATUS_OK;
1001 }
1002
1003 NTSTATUS ndr_pull_eventlog_OpenEventLogA(struct ndr_pull *ndr, int flags, struct eventlog_OpenEventLogA *r)
1004 {
1005         if (flags & NDR_IN) {
1006         }
1007         if (flags & NDR_OUT) {
1008                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1009         }
1010         return NT_STATUS_OK;
1011 }
1012
1013 _PUBLIC_ void ndr_print_eventlog_OpenEventLogA(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_OpenEventLogA *r)
1014 {
1015         ndr_print_struct(ndr, name, "eventlog_OpenEventLogA");
1016         ndr->depth++;
1017         if (flags & NDR_SET_VALUES) {
1018                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1019         }
1020         if (flags & NDR_IN) {
1021                 ndr_print_struct(ndr, "in", "eventlog_OpenEventLogA");
1022                 ndr->depth++;
1023                 ndr->depth--;
1024         }
1025         if (flags & NDR_OUT) {
1026                 ndr_print_struct(ndr, "out", "eventlog_OpenEventLogA");
1027                 ndr->depth++;
1028                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1029                 ndr->depth--;
1030         }
1031         ndr->depth--;
1032 }
1033
1034 NTSTATUS ndr_push_eventlog_RegisterEventSourceA(struct ndr_push *ndr, int flags, const struct eventlog_RegisterEventSourceA *r)
1035 {
1036         if (flags & NDR_IN) {
1037         }
1038         if (flags & NDR_OUT) {
1039                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1040         }
1041         return NT_STATUS_OK;
1042 }
1043
1044 NTSTATUS ndr_pull_eventlog_RegisterEventSourceA(struct ndr_pull *ndr, int flags, struct eventlog_RegisterEventSourceA *r)
1045 {
1046         if (flags & NDR_IN) {
1047         }
1048         if (flags & NDR_OUT) {
1049                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1050         }
1051         return NT_STATUS_OK;
1052 }
1053
1054 _PUBLIC_ void ndr_print_eventlog_RegisterEventSourceA(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_RegisterEventSourceA *r)
1055 {
1056         ndr_print_struct(ndr, name, "eventlog_RegisterEventSourceA");
1057         ndr->depth++;
1058         if (flags & NDR_SET_VALUES) {
1059                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1060         }
1061         if (flags & NDR_IN) {
1062                 ndr_print_struct(ndr, "in", "eventlog_RegisterEventSourceA");
1063                 ndr->depth++;
1064                 ndr->depth--;
1065         }
1066         if (flags & NDR_OUT) {
1067                 ndr_print_struct(ndr, "out", "eventlog_RegisterEventSourceA");
1068                 ndr->depth++;
1069                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1070                 ndr->depth--;
1071         }
1072         ndr->depth--;
1073 }
1074
1075 NTSTATUS ndr_push_eventlog_OpenBackupEventLogA(struct ndr_push *ndr, int flags, const struct eventlog_OpenBackupEventLogA *r)
1076 {
1077         if (flags & NDR_IN) {
1078         }
1079         if (flags & NDR_OUT) {
1080                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1081         }
1082         return NT_STATUS_OK;
1083 }
1084
1085 NTSTATUS ndr_pull_eventlog_OpenBackupEventLogA(struct ndr_pull *ndr, int flags, struct eventlog_OpenBackupEventLogA *r)
1086 {
1087         if (flags & NDR_IN) {
1088         }
1089         if (flags & NDR_OUT) {
1090                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1091         }
1092         return NT_STATUS_OK;
1093 }
1094
1095 _PUBLIC_ void ndr_print_eventlog_OpenBackupEventLogA(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_OpenBackupEventLogA *r)
1096 {
1097         ndr_print_struct(ndr, name, "eventlog_OpenBackupEventLogA");
1098         ndr->depth++;
1099         if (flags & NDR_SET_VALUES) {
1100                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1101         }
1102         if (flags & NDR_IN) {
1103                 ndr_print_struct(ndr, "in", "eventlog_OpenBackupEventLogA");
1104                 ndr->depth++;
1105                 ndr->depth--;
1106         }
1107         if (flags & NDR_OUT) {
1108                 ndr_print_struct(ndr, "out", "eventlog_OpenBackupEventLogA");
1109                 ndr->depth++;
1110                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1111                 ndr->depth--;
1112         }
1113         ndr->depth--;
1114 }
1115
1116 NTSTATUS ndr_push_eventlog_ReadEventLogA(struct ndr_push *ndr, int flags, const struct eventlog_ReadEventLogA *r)
1117 {
1118         if (flags & NDR_IN) {
1119         }
1120         if (flags & NDR_OUT) {
1121                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1122         }
1123         return NT_STATUS_OK;
1124 }
1125
1126 NTSTATUS ndr_pull_eventlog_ReadEventLogA(struct ndr_pull *ndr, int flags, struct eventlog_ReadEventLogA *r)
1127 {
1128         if (flags & NDR_IN) {
1129         }
1130         if (flags & NDR_OUT) {
1131                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1132         }
1133         return NT_STATUS_OK;
1134 }
1135
1136 _PUBLIC_ void ndr_print_eventlog_ReadEventLogA(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ReadEventLogA *r)
1137 {
1138         ndr_print_struct(ndr, name, "eventlog_ReadEventLogA");
1139         ndr->depth++;
1140         if (flags & NDR_SET_VALUES) {
1141                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1142         }
1143         if (flags & NDR_IN) {
1144                 ndr_print_struct(ndr, "in", "eventlog_ReadEventLogA");
1145                 ndr->depth++;
1146                 ndr->depth--;
1147         }
1148         if (flags & NDR_OUT) {
1149                 ndr_print_struct(ndr, "out", "eventlog_ReadEventLogA");
1150                 ndr->depth++;
1151                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1152                 ndr->depth--;
1153         }
1154         ndr->depth--;
1155 }
1156
1157 NTSTATUS ndr_push_eventlog_ReportEventA(struct ndr_push *ndr, int flags, const struct eventlog_ReportEventA *r)
1158 {
1159         if (flags & NDR_IN) {
1160         }
1161         if (flags & NDR_OUT) {
1162                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1163         }
1164         return NT_STATUS_OK;
1165 }
1166
1167 NTSTATUS ndr_pull_eventlog_ReportEventA(struct ndr_pull *ndr, int flags, struct eventlog_ReportEventA *r)
1168 {
1169         if (flags & NDR_IN) {
1170         }
1171         if (flags & NDR_OUT) {
1172                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1173         }
1174         return NT_STATUS_OK;
1175 }
1176
1177 _PUBLIC_ void ndr_print_eventlog_ReportEventA(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ReportEventA *r)
1178 {
1179         ndr_print_struct(ndr, name, "eventlog_ReportEventA");
1180         ndr->depth++;
1181         if (flags & NDR_SET_VALUES) {
1182                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1183         }
1184         if (flags & NDR_IN) {
1185                 ndr_print_struct(ndr, "in", "eventlog_ReportEventA");
1186                 ndr->depth++;
1187                 ndr->depth--;
1188         }
1189         if (flags & NDR_OUT) {
1190                 ndr_print_struct(ndr, "out", "eventlog_ReportEventA");
1191                 ndr->depth++;
1192                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1193                 ndr->depth--;
1194         }
1195         ndr->depth--;
1196 }
1197
1198 NTSTATUS ndr_push_eventlog_RegisterClusterSvc(struct ndr_push *ndr, int flags, const struct eventlog_RegisterClusterSvc *r)
1199 {
1200         if (flags & NDR_IN) {
1201         }
1202         if (flags & NDR_OUT) {
1203                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1204         }
1205         return NT_STATUS_OK;
1206 }
1207
1208 NTSTATUS ndr_pull_eventlog_RegisterClusterSvc(struct ndr_pull *ndr, int flags, struct eventlog_RegisterClusterSvc *r)
1209 {
1210         if (flags & NDR_IN) {
1211         }
1212         if (flags & NDR_OUT) {
1213                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1214         }
1215         return NT_STATUS_OK;
1216 }
1217
1218 _PUBLIC_ void ndr_print_eventlog_RegisterClusterSvc(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_RegisterClusterSvc *r)
1219 {
1220         ndr_print_struct(ndr, name, "eventlog_RegisterClusterSvc");
1221         ndr->depth++;
1222         if (flags & NDR_SET_VALUES) {
1223                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1224         }
1225         if (flags & NDR_IN) {
1226                 ndr_print_struct(ndr, "in", "eventlog_RegisterClusterSvc");
1227                 ndr->depth++;
1228                 ndr->depth--;
1229         }
1230         if (flags & NDR_OUT) {
1231                 ndr_print_struct(ndr, "out", "eventlog_RegisterClusterSvc");
1232                 ndr->depth++;
1233                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1234                 ndr->depth--;
1235         }
1236         ndr->depth--;
1237 }
1238
1239 NTSTATUS ndr_push_eventlog_DeregisterClusterSvc(struct ndr_push *ndr, int flags, const struct eventlog_DeregisterClusterSvc *r)
1240 {
1241         if (flags & NDR_IN) {
1242         }
1243         if (flags & NDR_OUT) {
1244                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1245         }
1246         return NT_STATUS_OK;
1247 }
1248
1249 NTSTATUS ndr_pull_eventlog_DeregisterClusterSvc(struct ndr_pull *ndr, int flags, struct eventlog_DeregisterClusterSvc *r)
1250 {
1251         if (flags & NDR_IN) {
1252         }
1253         if (flags & NDR_OUT) {
1254                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1255         }
1256         return NT_STATUS_OK;
1257 }
1258
1259 _PUBLIC_ void ndr_print_eventlog_DeregisterClusterSvc(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_DeregisterClusterSvc *r)
1260 {
1261         ndr_print_struct(ndr, name, "eventlog_DeregisterClusterSvc");
1262         ndr->depth++;
1263         if (flags & NDR_SET_VALUES) {
1264                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1265         }
1266         if (flags & NDR_IN) {
1267                 ndr_print_struct(ndr, "in", "eventlog_DeregisterClusterSvc");
1268                 ndr->depth++;
1269                 ndr->depth--;
1270         }
1271         if (flags & NDR_OUT) {
1272                 ndr_print_struct(ndr, "out", "eventlog_DeregisterClusterSvc");
1273                 ndr->depth++;
1274                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1275                 ndr->depth--;
1276         }
1277         ndr->depth--;
1278 }
1279
1280 NTSTATUS ndr_push_eventlog_WriteClusterEvents(struct ndr_push *ndr, int flags, const struct eventlog_WriteClusterEvents *r)
1281 {
1282         if (flags & NDR_IN) {
1283         }
1284         if (flags & NDR_OUT) {
1285                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1286         }
1287         return NT_STATUS_OK;
1288 }
1289
1290 NTSTATUS ndr_pull_eventlog_WriteClusterEvents(struct ndr_pull *ndr, int flags, struct eventlog_WriteClusterEvents *r)
1291 {
1292         if (flags & NDR_IN) {
1293         }
1294         if (flags & NDR_OUT) {
1295                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1296         }
1297         return NT_STATUS_OK;
1298 }
1299
1300 _PUBLIC_ void ndr_print_eventlog_WriteClusterEvents(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_WriteClusterEvents *r)
1301 {
1302         ndr_print_struct(ndr, name, "eventlog_WriteClusterEvents");
1303         ndr->depth++;
1304         if (flags & NDR_SET_VALUES) {
1305                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1306         }
1307         if (flags & NDR_IN) {
1308                 ndr_print_struct(ndr, "in", "eventlog_WriteClusterEvents");
1309                 ndr->depth++;
1310                 ndr->depth--;
1311         }
1312         if (flags & NDR_OUT) {
1313                 ndr_print_struct(ndr, "out", "eventlog_WriteClusterEvents");
1314                 ndr->depth++;
1315                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1316                 ndr->depth--;
1317         }
1318         ndr->depth--;
1319 }
1320
1321 NTSTATUS ndr_push_eventlog_GetLogIntormation(struct ndr_push *ndr, int flags, const struct eventlog_GetLogIntormation *r)
1322 {
1323         if (flags & NDR_IN) {
1324         }
1325         if (flags & NDR_OUT) {
1326                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1327         }
1328         return NT_STATUS_OK;
1329 }
1330
1331 NTSTATUS ndr_pull_eventlog_GetLogIntormation(struct ndr_pull *ndr, int flags, struct eventlog_GetLogIntormation *r)
1332 {
1333         if (flags & NDR_IN) {
1334         }
1335         if (flags & NDR_OUT) {
1336                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1337         }
1338         return NT_STATUS_OK;
1339 }
1340
1341 _PUBLIC_ void ndr_print_eventlog_GetLogIntormation(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_GetLogIntormation *r)
1342 {
1343         ndr_print_struct(ndr, name, "eventlog_GetLogIntormation");
1344         ndr->depth++;
1345         if (flags & NDR_SET_VALUES) {
1346                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1347         }
1348         if (flags & NDR_IN) {
1349                 ndr_print_struct(ndr, "in", "eventlog_GetLogIntormation");
1350                 ndr->depth++;
1351                 ndr->depth--;
1352         }
1353         if (flags & NDR_OUT) {
1354                 ndr_print_struct(ndr, "out", "eventlog_GetLogIntormation");
1355                 ndr->depth++;
1356                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1357                 ndr->depth--;
1358         }
1359         ndr->depth--;
1360 }
1361
1362 NTSTATUS ndr_push_eventlog_FlushEventLog(struct ndr_push *ndr, int flags, const struct eventlog_FlushEventLog *r)
1363 {
1364         if (flags & NDR_IN) {
1365                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1366                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
1367         }
1368         if (flags & NDR_OUT) {
1369                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1370         }
1371         return NT_STATUS_OK;
1372 }
1373
1374 NTSTATUS ndr_pull_eventlog_FlushEventLog(struct ndr_pull *ndr, int flags, struct eventlog_FlushEventLog *r)
1375 {
1376         TALLOC_CTX *_mem_save_handle_0;
1377         if (flags & NDR_IN) {
1378                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1379                         NDR_PULL_ALLOC(ndr, r->in.handle);
1380                 }
1381                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1382                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1383                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
1384                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1385         }
1386         if (flags & NDR_OUT) {
1387                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1388         }
1389         return NT_STATUS_OK;
1390 }
1391
1392 _PUBLIC_ void ndr_print_eventlog_FlushEventLog(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_FlushEventLog *r)
1393 {
1394         ndr_print_struct(ndr, name, "eventlog_FlushEventLog");
1395         ndr->depth++;
1396         if (flags & NDR_SET_VALUES) {
1397                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1398         }
1399         if (flags & NDR_IN) {
1400                 ndr_print_struct(ndr, "in", "eventlog_FlushEventLog");
1401                 ndr->depth++;
1402                 ndr_print_ptr(ndr, "handle", r->in.handle);
1403                 ndr->depth++;
1404                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
1405                 ndr->depth--;
1406                 ndr->depth--;
1407         }
1408         if (flags & NDR_OUT) {
1409                 ndr_print_struct(ndr, "out", "eventlog_FlushEventLog");
1410                 ndr->depth++;
1411                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1412                 ndr->depth--;
1413         }
1414         ndr->depth--;
1415 }
1416
1417 const struct dcerpc_interface_call eventlog_calls[] = {
1418         {
1419                 "eventlog_ClearEventLogW",
1420                 sizeof(struct eventlog_ClearEventLogW),
1421                 (ndr_push_flags_fn_t) ndr_push_eventlog_ClearEventLogW,
1422                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_ClearEventLogW,
1423                 (ndr_print_function_t) ndr_print_eventlog_ClearEventLogW,
1424                 False,
1425         },
1426         {
1427                 "eventlog_BackupEventLogW",
1428                 sizeof(struct eventlog_BackupEventLogW),
1429                 (ndr_push_flags_fn_t) ndr_push_eventlog_BackupEventLogW,
1430                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_BackupEventLogW,
1431                 (ndr_print_function_t) ndr_print_eventlog_BackupEventLogW,
1432                 False,
1433         },
1434         {
1435                 "eventlog_CloseEventLog",
1436                 sizeof(struct eventlog_CloseEventLog),
1437                 (ndr_push_flags_fn_t) ndr_push_eventlog_CloseEventLog,
1438                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_CloseEventLog,
1439                 (ndr_print_function_t) ndr_print_eventlog_CloseEventLog,
1440                 False,
1441         },
1442         {
1443                 "eventlog_DeregisterEventSource",
1444                 sizeof(struct eventlog_DeregisterEventSource),
1445                 (ndr_push_flags_fn_t) ndr_push_eventlog_DeregisterEventSource,
1446                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_DeregisterEventSource,
1447                 (ndr_print_function_t) ndr_print_eventlog_DeregisterEventSource,
1448                 False,
1449         },
1450         {
1451                 "eventlog_GetNumRecords",
1452                 sizeof(struct eventlog_GetNumRecords),
1453                 (ndr_push_flags_fn_t) ndr_push_eventlog_GetNumRecords,
1454                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_GetNumRecords,
1455                 (ndr_print_function_t) ndr_print_eventlog_GetNumRecords,
1456                 False,
1457         },
1458         {
1459                 "eventlog_GetOldestRecord",
1460                 sizeof(struct eventlog_GetOldestRecord),
1461                 (ndr_push_flags_fn_t) ndr_push_eventlog_GetOldestRecord,
1462                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_GetOldestRecord,
1463                 (ndr_print_function_t) ndr_print_eventlog_GetOldestRecord,
1464                 False,
1465         },
1466         {
1467                 "eventlog_ChangeNotify",
1468                 sizeof(struct eventlog_ChangeNotify),
1469                 (ndr_push_flags_fn_t) ndr_push_eventlog_ChangeNotify,
1470                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_ChangeNotify,
1471                 (ndr_print_function_t) ndr_print_eventlog_ChangeNotify,
1472                 False,
1473         },
1474         {
1475                 "eventlog_OpenEventLogW",
1476                 sizeof(struct eventlog_OpenEventLogW),
1477                 (ndr_push_flags_fn_t) ndr_push_eventlog_OpenEventLogW,
1478                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_OpenEventLogW,
1479                 (ndr_print_function_t) ndr_print_eventlog_OpenEventLogW,
1480                 False,
1481         },
1482         {
1483                 "eventlog_RegisterEventSourceW",
1484                 sizeof(struct eventlog_RegisterEventSourceW),
1485                 (ndr_push_flags_fn_t) ndr_push_eventlog_RegisterEventSourceW,
1486                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_RegisterEventSourceW,
1487                 (ndr_print_function_t) ndr_print_eventlog_RegisterEventSourceW,
1488                 False,
1489         },
1490         {
1491                 "eventlog_OpenBackupEventLogW",
1492                 sizeof(struct eventlog_OpenBackupEventLogW),
1493                 (ndr_push_flags_fn_t) ndr_push_eventlog_OpenBackupEventLogW,
1494                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_OpenBackupEventLogW,
1495                 (ndr_print_function_t) ndr_print_eventlog_OpenBackupEventLogW,
1496                 False,
1497         },
1498         {
1499                 "eventlog_ReadEventLogW",
1500                 sizeof(struct eventlog_ReadEventLogW),
1501                 (ndr_push_flags_fn_t) ndr_push_eventlog_ReadEventLogW,
1502                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_ReadEventLogW,
1503                 (ndr_print_function_t) ndr_print_eventlog_ReadEventLogW,
1504                 False,
1505         },
1506         {
1507                 "eventlog_ReportEventW",
1508                 sizeof(struct eventlog_ReportEventW),
1509                 (ndr_push_flags_fn_t) ndr_push_eventlog_ReportEventW,
1510                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_ReportEventW,
1511                 (ndr_print_function_t) ndr_print_eventlog_ReportEventW,
1512                 False,
1513         },
1514         {
1515                 "eventlog_ClearEventLogA",
1516                 sizeof(struct eventlog_ClearEventLogA),
1517                 (ndr_push_flags_fn_t) ndr_push_eventlog_ClearEventLogA,
1518                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_ClearEventLogA,
1519                 (ndr_print_function_t) ndr_print_eventlog_ClearEventLogA,
1520                 False,
1521         },
1522         {
1523                 "eventlog_BackupEventLogA",
1524                 sizeof(struct eventlog_BackupEventLogA),
1525                 (ndr_push_flags_fn_t) ndr_push_eventlog_BackupEventLogA,
1526                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_BackupEventLogA,
1527                 (ndr_print_function_t) ndr_print_eventlog_BackupEventLogA,
1528                 False,
1529         },
1530         {
1531                 "eventlog_OpenEventLogA",
1532                 sizeof(struct eventlog_OpenEventLogA),
1533                 (ndr_push_flags_fn_t) ndr_push_eventlog_OpenEventLogA,
1534                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_OpenEventLogA,
1535                 (ndr_print_function_t) ndr_print_eventlog_OpenEventLogA,
1536                 False,
1537         },
1538         {
1539                 "eventlog_RegisterEventSourceA",
1540                 sizeof(struct eventlog_RegisterEventSourceA),
1541                 (ndr_push_flags_fn_t) ndr_push_eventlog_RegisterEventSourceA,
1542                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_RegisterEventSourceA,
1543                 (ndr_print_function_t) ndr_print_eventlog_RegisterEventSourceA,
1544                 False,
1545         },
1546         {
1547                 "eventlog_OpenBackupEventLogA",
1548                 sizeof(struct eventlog_OpenBackupEventLogA),
1549                 (ndr_push_flags_fn_t) ndr_push_eventlog_OpenBackupEventLogA,
1550                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_OpenBackupEventLogA,
1551                 (ndr_print_function_t) ndr_print_eventlog_OpenBackupEventLogA,
1552                 False,
1553         },
1554         {
1555                 "eventlog_ReadEventLogA",
1556                 sizeof(struct eventlog_ReadEventLogA),
1557                 (ndr_push_flags_fn_t) ndr_push_eventlog_ReadEventLogA,
1558                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_ReadEventLogA,
1559                 (ndr_print_function_t) ndr_print_eventlog_ReadEventLogA,
1560                 False,
1561         },
1562         {
1563                 "eventlog_ReportEventA",
1564                 sizeof(struct eventlog_ReportEventA),
1565                 (ndr_push_flags_fn_t) ndr_push_eventlog_ReportEventA,
1566                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_ReportEventA,
1567                 (ndr_print_function_t) ndr_print_eventlog_ReportEventA,
1568                 False,
1569         },
1570         {
1571                 "eventlog_RegisterClusterSvc",
1572                 sizeof(struct eventlog_RegisterClusterSvc),
1573                 (ndr_push_flags_fn_t) ndr_push_eventlog_RegisterClusterSvc,
1574                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_RegisterClusterSvc,
1575                 (ndr_print_function_t) ndr_print_eventlog_RegisterClusterSvc,
1576                 False,
1577         },
1578         {
1579                 "eventlog_DeregisterClusterSvc",
1580                 sizeof(struct eventlog_DeregisterClusterSvc),
1581                 (ndr_push_flags_fn_t) ndr_push_eventlog_DeregisterClusterSvc,
1582                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_DeregisterClusterSvc,
1583                 (ndr_print_function_t) ndr_print_eventlog_DeregisterClusterSvc,
1584                 False,
1585         },
1586         {
1587                 "eventlog_WriteClusterEvents",
1588                 sizeof(struct eventlog_WriteClusterEvents),
1589                 (ndr_push_flags_fn_t) ndr_push_eventlog_WriteClusterEvents,
1590                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_WriteClusterEvents,
1591                 (ndr_print_function_t) ndr_print_eventlog_WriteClusterEvents,
1592                 False,
1593         },
1594         {
1595                 "eventlog_GetLogIntormation",
1596                 sizeof(struct eventlog_GetLogIntormation),
1597                 (ndr_push_flags_fn_t) ndr_push_eventlog_GetLogIntormation,
1598                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_GetLogIntormation,
1599                 (ndr_print_function_t) ndr_print_eventlog_GetLogIntormation,
1600                 False,
1601         },
1602         {
1603                 "eventlog_FlushEventLog",
1604                 sizeof(struct eventlog_FlushEventLog),
1605                 (ndr_push_flags_fn_t) ndr_push_eventlog_FlushEventLog,
1606                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_FlushEventLog,
1607                 (ndr_print_function_t) ndr_print_eventlog_FlushEventLog,
1608                 False,
1609         },
1610         { NULL, 0, NULL, NULL, NULL, False }
1611 };
1612
1613 const char * const eventlog_endpoint_strings[] = {
1614         "ncacn_np:[\\pipe\\eventlog]",
1615 };
1616
1617 const struct dcerpc_endpoint_list eventlog_endpoints = {
1618         .count  = 1,
1619         .names  = eventlog_endpoint_strings
1620 };
1621
1622 const char * const eventlog_authservice_strings[] = {
1623         "host",
1624 };
1625
1626 const struct dcerpc_authservice_list eventlog_authservices = {
1627         .count  = 1,
1628         .names  = eventlog_authservice_strings
1629 };
1630
1631
1632 const struct dcerpc_interface_table dcerpc_table_eventlog = {
1633         .name           = "eventlog",
1634         .syntax_id      = {
1635                 {0x82273fdc,0xe32a,0x18c3,{0x3f,0x78},{0x82,0x79,0x29,0xdc,0x23,0xea}},
1636                 DCERPC_EVENTLOG_VERSION
1637         },
1638         .helpstring     = DCERPC_EVENTLOG_HELPSTRING,
1639         .num_calls      = 24,
1640         .calls          = eventlog_calls,
1641         .endpoints      = &eventlog_endpoints,
1642         .authservices   = &eventlog_authservices
1643 };
1644