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