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