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