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_tdb(struct ndr_push *ndr, int ndr_flags, const struct eventlog_Record_tdb *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|LIBNDR_PRINT_ARRAY_HEX);
 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, r->sid.length));
 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                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m_term(r->source_name)));
 120                         {
 121                                 uint32_t _flags_save_string = ndr->flags;
 122                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 123                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->source_name));
 124                                 ndr->flags = _flags_save_string;
 125                         }
 126                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m_term(r->computer_name)));
 127                         {
 128                                 uint32_t _flags_save_string = ndr->flags;
 129                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 130                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->computer_name));
 131                                 ndr->flags = _flags_save_string;
 132                         }
 133                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sid_padding));
 134                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->sid));
 135                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * ndr_size_string_array(r->strings, r->num_of_strings, LIBNDR_FLAG_STR_NULLTERM)));
 136                         {
 137                                 uint32_t _flags_save_string = ndr->flags;
 138                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 139                                 for (cntr_strings_0 = 0; cntr_strings_0 < r->num_of_strings; cntr_strings_0++) {
 140                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->strings[cntr_strings_0]));
 141                                 }
 142                                 ndr->flags = _flags_save_string;
 143                         }
 144                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
 145                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->padding));
 146                 }
 147                 if (ndr_flags & NDR_BUFFERS) {
 148                 }
 149                 ndr->flags = _flags_save_STRUCT;
 150         }
 151         return NDR_ERR_SUCCESS;
 152 }
 153
 154 _PUBLIC_ enum ndr_err_code ndr_pull_eventlog_Record_tdb(struct ndr_pull *ndr, int ndr_flags, struct eventlog_Record_tdb *r)
 155 {
 156         uint32_t cntr_strings_0;
 157         TALLOC_CTX *_mem_save_strings_0;
 158         {
 159                 uint32_t _flags_save_STRUCT = ndr->flags;
 160                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN|LIBNDR_PRINT_ARRAY_HEX);
 161                 if (ndr_flags & NDR_SCALARS) {
 162                         NDR_CHECK(ndr_pull_align(ndr, 4));
 163                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
 164                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->reserved, 4, sizeof(uint8_t), CH_DOS));
 165                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->record_number));
 166                         NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, &r->time_generated));
 167                         NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, &r->time_written));
 168                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->event_id));
 169                         NDR_CHECK(ndr_pull_eventlogEventTypes(ndr, NDR_SCALARS, &r->event_type));
 170                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_of_strings));
 171                         if (r->num_of_strings > 256) {
 172                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 173                         }
 174                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->event_category));
 175                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reserved_flags));
 176                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->closing_record_number));
 177                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->stringoffset));
 178                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_length));
 179                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_offset));
 180                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->data_length));
 181                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->data_offset));
 182                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->source_name_len));
 183                         {
 184                                 uint32_t _flags_save_string = ndr->flags;
 185                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 186                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->source_name));
 187                                 ndr->flags = _flags_save_string;
 188                         }
 189                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->computer_name_len));
 190                         {
 191                                 uint32_t _flags_save_string = ndr->flags;
 192                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 193                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->computer_name));
 194                                 ndr->flags = _flags_save_string;
 195                         }
 196                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_padding));
 197                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->sid));
 198                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->strings_len));
 199                         {
 200                                 uint32_t _flags_save_string = ndr->flags;
 201                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 202                                 NDR_PULL_ALLOC_N(ndr, r->strings, r->num_of_strings);
 203                                 _mem_save_strings_0 = NDR_PULL_GET_MEM_CTX(ndr);
 204                                 NDR_PULL_SET_MEM_CTX(ndr, r->strings, 0);
 205                                 for (cntr_strings_0 = 0; cntr_strings_0 < r->num_of_strings; cntr_strings_0++) {
 206                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->strings[cntr_strings_0]));
 207                                 }
 208                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_strings_0, 0);
 209                                 ndr->flags = _flags_save_string;
 210                         }
 211                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
 212                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->padding));
 213                 }
 214                 if (ndr_flags & NDR_BUFFERS) {
 215                 }
 216                 ndr->flags = _flags_save_STRUCT;
 217         }
 218         return NDR_ERR_SUCCESS;
 219 }
 220
 221 _PUBLIC_ void ndr_print_eventlog_Record_tdb(struct ndr_print *ndr, const char *name, const struct eventlog_Record_tdb *r)
 222 {
 223         uint32_t cntr_strings_0;
 224         ndr_print_struct(ndr, name, "eventlog_Record_tdb");
 225         {
 226                 uint32_t _flags_save_STRUCT = ndr->flags;
 227                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN|LIBNDR_PRINT_ARRAY_HEX);
 228                 ndr->depth++;
 229                 ndr_print_uint32(ndr, "size", r->size);
 230                 ndr_print_string(ndr, "reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?"eLfL":r->reserved);
 231                 ndr_print_uint32(ndr, "record_number", r->record_number);
 232                 ndr_print_time_t(ndr, "time_generated", r->time_generated);
 233                 ndr_print_time_t(ndr, "time_written", r->time_written);
 234                 ndr_print_uint32(ndr, "event_id", r->event_id);
 235                 ndr_print_eventlogEventTypes(ndr, "event_type", r->event_type);
 236                 ndr_print_uint16(ndr, "num_of_strings", r->num_of_strings);
 237                 ndr_print_uint16(ndr, "event_category", r->event_category);
 238                 ndr_print_uint16(ndr, "reserved_flags", r->reserved_flags);
 239                 ndr_print_uint32(ndr, "closing_record_number", r->closing_record_number);
 240                 ndr_print_uint32(ndr, "stringoffset", r->stringoffset);
 241                 ndr_print_uint32(ndr, "sid_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->sid.length:r->sid_length);
 242                 ndr_print_uint32(ndr, "sid_offset", r->sid_offset);
 243                 ndr_print_uint32(ndr, "data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->data.length:r->data_length);
 244                 ndr_print_uint32(ndr, "data_offset", r->data_offset);
 245                 ndr_print_uint32(ndr, "source_name_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m_term(r->source_name):r->source_name_len);
 246                 ndr_print_string(ndr, "source_name", r->source_name);
 247                 ndr_print_uint32(ndr, "computer_name_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m_term(r->computer_name):r->computer_name_len);
 248                 ndr_print_string(ndr, "computer_name", r->computer_name);
 249                 ndr_print_uint32(ndr, "sid_padding", r->sid_padding);
 250                 ndr_print_DATA_BLOB(ndr, "sid", r->sid);
 251                 ndr_print_uint32(ndr, "strings_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * ndr_size_string_array(r->strings, r->num_of_strings, LIBNDR_FLAG_STR_NULLTERM):r->strings_len);
 252                 ndr->print(ndr, "%s: ARRAY(%d)", "strings", (int)r->num_of_strings);
 253                 ndr->depth++;
 254                 for (cntr_strings_0=0;cntr_strings_0<r->num_of_strings;cntr_strings_0++) {
 255                         char *idx_0=NULL;
 256                         if (asprintf(&idx_0, "[%d]", cntr_strings_0) != -1) {
 257                                 ndr_print_string(ndr, "strings", r->strings[cntr_strings_0]);
 258                                 free(idx_0);
 259                         }
 260                 }
 261                 ndr->depth--;
 262                 ndr_print_DATA_BLOB(ndr, "data", r->data);
 263                 ndr_print_uint32(ndr, "padding", r->padding);
 264                 ndr->depth--;
 265                 ndr->flags = _flags_save_STRUCT;
 266         }
 267 }
 268
 269 static enum ndr_err_code ndr_push_EVENTLOG_HEADER_FLAGS(struct ndr_push *ndr, int ndr_flags, enum EVENTLOG_HEADER_FLAGS r)
 270 {
 271         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 272         return NDR_ERR_SUCCESS;
 273 }
 274
 275 static enum ndr_err_code ndr_pull_EVENTLOG_HEADER_FLAGS(struct ndr_pull *ndr, int ndr_flags, enum EVENTLOG_HEADER_FLAGS *r)
 276 {
 277         uint32_t v;
 278         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 279         *r = v;
 280         return NDR_ERR_SUCCESS;
 281 }
 282
 283 _PUBLIC_ void ndr_print_EVENTLOG_HEADER_FLAGS(struct ndr_print *ndr, const char *name, enum EVENTLOG_HEADER_FLAGS r)
 284 {
 285         const char *val = NULL;
 286
 287         switch (r) {
 288                 case ELF_LOGFILE_HEADER_DIRTY: val = "ELF_LOGFILE_HEADER_DIRTY"; break;
 289                 case ELF_LOGFILE_HEADER_WRAP: val = "ELF_LOGFILE_HEADER_WRAP"; break;
 290                 case ELF_LOGFILE_LOGFULL_WRITTEN: val = "ELF_LOGFILE_LOGFULL_WRITTEN"; break;
 291                 case ELF_LOGFILE_ARCHIVE_SET: val = "ELF_LOGFILE_ARCHIVE_SET"; break;
 292         }
 293         ndr_print_enum(ndr, name, "ENUM", val, r);
 294 }
 295
 296 _PUBLIC_ enum ndr_err_code ndr_push_EVENTLOGHEADER(struct ndr_push *ndr, int ndr_flags, const struct EVENTLOGHEADER *r)
 297 {
 298         if (ndr_flags & NDR_SCALARS) {
 299                 NDR_CHECK(ndr_push_align(ndr, 4));
 300                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x30));
 301                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, "LfLe", 4, sizeof(uint8_t), CH_DOS));
 302                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
 303                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
 304                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->StartOffset));
 305                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->EndOffset));
 306                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->CurrentRecordNumber));
 307                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->OldestRecordNumber));
 308                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->MaxSize));
 309                 NDR_CHECK(ndr_push_EVENTLOG_HEADER_FLAGS(ndr, NDR_SCALARS, r->Flags));
 310                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Retention));
 311                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x30));
 312         }
 313         if (ndr_flags & NDR_BUFFERS) {
 314         }
 315         return NDR_ERR_SUCCESS;
 316 }
 317
 318 _PUBLIC_ enum ndr_err_code ndr_pull_EVENTLOGHEADER(struct ndr_pull *ndr, int ndr_flags, struct EVENTLOGHEADER *r)
 319 {
 320         if (ndr_flags & NDR_SCALARS) {
 321                 NDR_CHECK(ndr_pull_align(ndr, 4));
 322                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->HeaderSize));
 323                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->Signature, 4, sizeof(uint8_t), CH_DOS));
 324                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->MajorVersion));
 325                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->MinorVersion));
 326                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->StartOffset));
 327                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->EndOffset));
 328                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->CurrentRecordNumber));
 329                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->OldestRecordNumber));
 330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->MaxSize));
 331                 NDR_CHECK(ndr_pull_EVENTLOG_HEADER_FLAGS(ndr, NDR_SCALARS, &r->Flags));
 332                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Retention));
 333                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->EndHeaderSize));
 334         }
 335         if (ndr_flags & NDR_BUFFERS) {
 336         }
 337         return NDR_ERR_SUCCESS;
 338 }
 339
 340 _PUBLIC_ void ndr_print_EVENTLOGHEADER(struct ndr_print *ndr, const char *name, const struct EVENTLOGHEADER *r)
 341 {
 342         ndr_print_struct(ndr, name, "EVENTLOGHEADER");
 343         ndr->depth++;
 344         ndr_print_uint32(ndr, "HeaderSize", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x30:r->HeaderSize);
 345         ndr_print_string(ndr, "Signature", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?"LfLe":r->Signature);
 346         ndr_print_uint32(ndr, "MajorVersion", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->MajorVersion);
 347         ndr_print_uint32(ndr, "MinorVersion", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->MinorVersion);
 348         ndr_print_uint32(ndr, "StartOffset", r->StartOffset);
 349         ndr_print_uint32(ndr, "EndOffset", r->EndOffset);
 350         ndr_print_uint32(ndr, "CurrentRecordNumber", r->CurrentRecordNumber);
 351         ndr_print_uint32(ndr, "OldestRecordNumber", r->OldestRecordNumber);
 352         ndr_print_uint32(ndr, "MaxSize", r->MaxSize);
 353         ndr_print_EVENTLOG_HEADER_FLAGS(ndr, "Flags", r->Flags);
 354         ndr_print_uint32(ndr, "Retention", r->Retention);
 355         ndr_print_uint32(ndr, "EndHeaderSize", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x30:r->EndHeaderSize);
 356         ndr->depth--;
 357 }
 358
 359 _PUBLIC_ enum ndr_err_code ndr_push_EVENTLOGRECORD(struct ndr_push *ndr, int ndr_flags, const struct EVENTLOGRECORD *r)
 360 {
 361         uint32_t cntr_Strings_0;
 362         if (ndr_flags & NDR_SCALARS) {
 363                 NDR_CHECK(ndr_push_align(ndr, 4));
 364                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Length));
 365                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, "LfLe", 4, sizeof(uint8_t), CH_DOS));
 366                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->RecordNumber));
 367                 NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, r->TimeGenerated));
 368                 NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, r->TimeWritten));
 369                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->EventID));
 370                 NDR_CHECK(ndr_push_eventlogEventTypes(ndr, NDR_SCALARS, r->EventType));
 371                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->NumStrings));
 372                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->EventCategory));
 373                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ReservedFlags));
 374                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ClosingRecordNumber));
 375                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 56 + 2 * (strlen_m_term(r->SourceName) + strlen_m_term(r->Computername)) + ndr_size_dom_sid0(&r->UserSid, ndr->flags)));
 376                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid0(&r->UserSid, ndr->flags)));
 377                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 56 + 2 * (strlen_m_term(r->SourceName) + strlen_m_term(r->Computername))));
 378                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->DataLength));
 379                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 56 + 2 * (strlen_m_term(r->SourceName) + strlen_m_term(r->Computername)) + ndr_size_dom_sid0(&r->UserSid, ndr->flags) + (2 * ndr_size_string_array(r->Strings, r->NumStrings, LIBNDR_FLAG_STR_NULLTERM))));
 380                 {
 381                         uint32_t _flags_save_string = ndr->flags;
 382                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 383                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->SourceName));
 384                         ndr->flags = _flags_save_string;
 385                 }
 386                 {
 387                         uint32_t _flags_save_string = ndr->flags;
 388                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 389                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->Computername));
 390                         ndr->flags = _flags_save_string;
 391                 }
 392                 {
 393                         uint32_t _flags_save_dom_sid0 = ndr->flags;
 394                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
 395                         {
 396                                 struct ndr_push *_ndr_UserSid;
 397                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_UserSid, 0, ndr_size_dom_sid0(&r->UserSid, ndr->flags)));
 398                                 NDR_CHECK(ndr_push_dom_sid0(_ndr_UserSid, NDR_SCALARS|NDR_BUFFERS, &r->UserSid));
 399                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_UserSid, 0, ndr_size_dom_sid0(&r->UserSid, ndr->flags)));
 400                         }
 401                         ndr->flags = _flags_save_dom_sid0;
 402                 }
 403                 {
 404                         uint32_t _flags_save_string = ndr->flags;
 405                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 406                         for (cntr_Strings_0 = 0; cntr_Strings_0 < r->NumStrings; cntr_Strings_0++) {
 407                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->Strings[cntr_Strings_0]));
 408                         }
 409                         ndr->flags = _flags_save_string;
 410                 }
 411                 {
 412                         uint32_t _flags_save_uint8 = ndr->flags;
 413                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 414                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Data, r->DataLength));
 415                         ndr->flags = _flags_save_uint8;
 416                 }
 417                 {
 418                         uint32_t _flags_save_string = ndr->flags;
 419                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 420                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->Pad));
 421                         ndr->flags = _flags_save_string;
 422                 }
 423                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Length));
 424         }
 425         if (ndr_flags & NDR_BUFFERS) {
 426                 {
 427                         uint32_t _flags_save_dom_sid0 = ndr->flags;
 428                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
 429                         ndr->flags = _flags_save_dom_sid0;
 430                 }
 431         }
 432         return NDR_ERR_SUCCESS;
 433 }
 434
 435 _PUBLIC_ enum ndr_err_code ndr_pull_EVENTLOGRECORD(struct ndr_pull *ndr, int ndr_flags, struct EVENTLOGRECORD *r)
 436 {
 437         uint32_t cntr_Strings_0;
 438         TALLOC_CTX *_mem_save_Strings_0;
 439         if (ndr_flags & NDR_SCALARS) {
 440                 NDR_CHECK(ndr_pull_align(ndr, 4));
 441                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Length));
 442                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->Reserved, 4, sizeof(uint8_t), CH_DOS));
 443                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->RecordNumber));
 444                 NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, &r->TimeGenerated));
 445                 NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, &r->TimeWritten));
 446                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->EventID));
 447                 NDR_CHECK(ndr_pull_eventlogEventTypes(ndr, NDR_SCALARS, &r->EventType));
 448                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->NumStrings));
 449                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->EventCategory));
 450                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ReservedFlags));
 451                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ClosingRecordNumber));
 452                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->StringOffset));
 453                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->UserSidLength));
 454                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->UserSidOffset));
 455                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->DataLength));
 456                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->DataOffset));
 457                 {
 458                         uint32_t _flags_save_string = ndr->flags;
 459                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 460                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->SourceName));
 461                         ndr->flags = _flags_save_string;
 462                 }
 463                 {
 464                         uint32_t _flags_save_string = ndr->flags;
 465                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 466                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->Computername));
 467                         ndr->flags = _flags_save_string;
 468                 }
 469                 {
 470                         uint32_t _flags_save_dom_sid0 = ndr->flags;
 471                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
 472                         {
 473                                 struct ndr_pull *_ndr_UserSid;
 474                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_UserSid, 0, r->UserSidLength));
 475                                 NDR_CHECK(ndr_pull_dom_sid0(_ndr_UserSid, NDR_SCALARS|NDR_BUFFERS, &r->UserSid));
 476                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_UserSid, 0, r->UserSidLength));
 477                         }
 478                         ndr->flags = _flags_save_dom_sid0;
 479                 }
 480                 {
 481                         uint32_t _flags_save_string = ndr->flags;
 482                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 483                         NDR_PULL_ALLOC_N(ndr, r->Strings, r->NumStrings);
 484                         _mem_save_Strings_0 = NDR_PULL_GET_MEM_CTX(ndr);
 485                         NDR_PULL_SET_MEM_CTX(ndr, r->Strings, 0);
 486                         for (cntr_Strings_0 = 0; cntr_Strings_0 < r->NumStrings; cntr_Strings_0++) {
 487                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->Strings[cntr_Strings_0]));
 488                         }
 489                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Strings_0, 0);
 490                         ndr->flags = _flags_save_string;
 491                 }
 492                 {
 493                         uint32_t _flags_save_uint8 = ndr->flags;
 494                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 495                         NDR_PULL_ALLOC_N(ndr, r->Data, r->DataLength);
 496                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Data, r->DataLength));
 497                         ndr->flags = _flags_save_uint8;
 498                 }
 499                 {
 500                         uint32_t _flags_save_string = ndr->flags;
 501                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 502                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->Pad));
 503                         ndr->flags = _flags_save_string;
 504                 }
 505                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Length2));
 506         }
 507         if (ndr_flags & NDR_BUFFERS) {
 508                 {
 509                         uint32_t _flags_save_dom_sid0 = ndr->flags;
 510                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
 511                         ndr->flags = _flags_save_dom_sid0;
 512                 }
 513         }
 514         return NDR_ERR_SUCCESS;
 515 }
 516
 517 _PUBLIC_ void ndr_print_EVENTLOGRECORD(struct ndr_print *ndr, const char *name, const struct EVENTLOGRECORD *r)
 518 {
 519         uint32_t cntr_Strings_0;
 520         ndr_print_struct(ndr, name, "EVENTLOGRECORD");
 521         ndr->depth++;
 522         ndr_print_uint32(ndr, "Length", r->Length);
 523         ndr_print_string(ndr, "Reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?"LfLe":r->Reserved);
 524         ndr_print_uint32(ndr, "RecordNumber", r->RecordNumber);
 525         ndr_print_time_t(ndr, "TimeGenerated", r->TimeGenerated);
 526         ndr_print_time_t(ndr, "TimeWritten", r->TimeWritten);
 527         ndr_print_uint32(ndr, "EventID", r->EventID);
 528         ndr_print_eventlogEventTypes(ndr, "EventType", r->EventType);
 529         ndr_print_uint16(ndr, "NumStrings", r->NumStrings);
 530         ndr_print_uint16(ndr, "EventCategory", r->EventCategory);
 531         ndr_print_uint16(ndr, "ReservedFlags", r->ReservedFlags);
 532         ndr_print_uint32(ndr, "ClosingRecordNumber", r->ClosingRecordNumber);
 533         ndr_print_uint32(ndr, "StringOffset", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?56 + 2 * (strlen_m_term(r->SourceName) + strlen_m_term(r->Computername)) + r->UserSidLength:r->StringOffset);
 534         ndr_print_uint32(ndr, "UserSidLength", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_dom_sid0(&r->UserSid, ndr->flags):r->UserSidLength);
 535         ndr_print_uint32(ndr, "UserSidOffset", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?56 + 2 * (strlen_m_term(r->SourceName) + strlen_m_term(r->Computername)):r->UserSidOffset);
 536         ndr_print_uint32(ndr, "DataLength", r->DataLength);
 537         ndr_print_uint32(ndr, "DataOffset", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?56 + 2 * (strlen_m_term(r->SourceName) + strlen_m_term(r->Computername)) + r->UserSidLength + (2 * ndr_size_string_array(r->Strings, r->NumStrings, LIBNDR_FLAG_STR_NULLTERM)):r->DataOffset);
 538         ndr_print_string(ndr, "SourceName", r->SourceName);
 539         ndr_print_string(ndr, "Computername", r->Computername);
 540         ndr_print_dom_sid0(ndr, "UserSid", &r->UserSid);
 541         ndr->print(ndr, "%s: ARRAY(%d)", "Strings", (int)r->NumStrings);
 542         ndr->depth++;
 543         for (cntr_Strings_0=0;cntr_Strings_0<r->NumStrings;cntr_Strings_0++) {
 544                 char *idx_0=NULL;
 545                 if (asprintf(&idx_0, "[%d]", cntr_Strings_0) != -1) {
 546                         ndr_print_string(ndr, "Strings", r->Strings[cntr_Strings_0]);
 547                         free(idx_0);
 548                 }
 549         }
 550         ndr->depth--;
 551         ndr_print_array_uint8(ndr, "Data", r->Data, r->DataLength);
 552         ndr_print_string(ndr, "Pad", r->Pad);
 553         ndr_print_uint32(ndr, "Length2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->Length:r->Length2);
 554         ndr->depth--;
 555 }
 556
 557 _PUBLIC_ size_t ndr_size_EVENTLOGRECORD(const struct EVENTLOGRECORD *r, struct smb_iconv_convenience *ic, int flags)
 558 {
 559         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_EVENTLOGRECORD, ic);
 560 }
 561
 562 _PUBLIC_ enum ndr_err_code ndr_push_EVENTLOGEOF(struct ndr_push *ndr, int ndr_flags, const struct EVENTLOGEOF *r)
 563 {
 564         if (ndr_flags & NDR_SCALARS) {
 565                 NDR_CHECK(ndr_push_align(ndr, 4));
 566                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x28));
 567                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x11111111));
 568                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x22222222));
 569                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x33333333));
 570                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x44444444));
 571                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->BeginRecord));
 572                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->EndRecord));
 573                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->CurrentRecordNumber));
 574                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->OldestRecordNumber));
 575                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x28));
 576         }
 577         if (ndr_flags & NDR_BUFFERS) {
 578         }
 579         return NDR_ERR_SUCCESS;
 580 }
 581
 582 _PUBLIC_ enum ndr_err_code ndr_pull_EVENTLOGEOF(struct ndr_pull *ndr, int ndr_flags, struct EVENTLOGEOF *r)
 583 {
 584         if (ndr_flags & NDR_SCALARS) {
 585                 NDR_CHECK(ndr_pull_align(ndr, 4));
 586                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->RecordSizeBeginning));
 587                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->One));
 588                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Two));
 589                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Three));
 590                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Four));
 591                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->BeginRecord));
 592                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->EndRecord));
 593                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->CurrentRecordNumber));
 594                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->OldestRecordNumber));
 595                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->RecordSizeEnd));
 596         }
 597         if (ndr_flags & NDR_BUFFERS) {
 598         }
 599         return NDR_ERR_SUCCESS;
 600 }
 601
 602 _PUBLIC_ void ndr_print_EVENTLOGEOF(struct ndr_print *ndr, const char *name, const struct EVENTLOGEOF *r)
 603 {
 604         ndr_print_struct(ndr, name, "EVENTLOGEOF");
 605         ndr->depth++;
 606         ndr_print_uint32(ndr, "RecordSizeBeginning", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x28:r->RecordSizeBeginning);
 607         ndr_print_uint32(ndr, "One", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x11111111:r->One);
 608         ndr_print_uint32(ndr, "Two", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x22222222:r->Two);
 609         ndr_print_uint32(ndr, "Three", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x33333333:r->Three);
 610         ndr_print_uint32(ndr, "Four", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x44444444:r->Four);
 611         ndr_print_uint32(ndr, "BeginRecord", r->BeginRecord);
 612         ndr_print_uint32(ndr, "EndRecord", r->EndRecord);
 613         ndr_print_uint32(ndr, "CurrentRecordNumber", r->CurrentRecordNumber);
 614         ndr_print_uint32(ndr, "OldestRecordNumber", r->OldestRecordNumber);
 615         ndr_print_uint32(ndr, "RecordSizeEnd", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x28:r->RecordSizeEnd);
 616         ndr->depth--;
 617 }
 618
 619 _PUBLIC_ enum ndr_err_code ndr_push_EVENTLOG_EVT_FILE(struct ndr_push *ndr, int ndr_flags, const struct EVENTLOG_EVT_FILE *r)
 620 {
 621         uint32_t cntr_records_0;
 622         if (ndr_flags & NDR_SCALARS) {
 623                 NDR_CHECK(ndr_push_align(ndr, 4));
 624                 NDR_CHECK(ndr_push_EVENTLOGHEADER(ndr, NDR_SCALARS, &r->hdr));
 625                 for (cntr_records_0 = 0; cntr_records_0 < r->hdr.CurrentRecordNumber - r->hdr.OldestRecordNumber; cntr_records_0++) {
 626                         NDR_CHECK(ndr_push_EVENTLOGRECORD(ndr, NDR_SCALARS, &r->records[cntr_records_0]));
 627                 }
 628                 NDR_CHECK(ndr_push_EVENTLOGEOF(ndr, NDR_SCALARS, &r->eof));
 629         }
 630         if (ndr_flags & NDR_BUFFERS) {
 631                 for (cntr_records_0 = 0; cntr_records_0 < r->hdr.CurrentRecordNumber - r->hdr.OldestRecordNumber; cntr_records_0++) {
 632                         NDR_CHECK(ndr_push_EVENTLOGRECORD(ndr, NDR_BUFFERS, &r->records[cntr_records_0]));
 633                 }
 634         }
 635         return NDR_ERR_SUCCESS;
 636 }
 637
 638 _PUBLIC_ enum ndr_err_code ndr_pull_EVENTLOG_EVT_FILE(struct ndr_pull *ndr, int ndr_flags, struct EVENTLOG_EVT_FILE *r)
 639 {
 640         uint32_t cntr_records_0;
 641         TALLOC_CTX *_mem_save_records_0;
 642         if (ndr_flags & NDR_SCALARS) {
 643                 NDR_CHECK(ndr_pull_align(ndr, 4));
 644                 NDR_CHECK(ndr_pull_EVENTLOGHEADER(ndr, NDR_SCALARS, &r->hdr));
 645                 NDR_PULL_ALLOC_N(ndr, r->records, r->hdr.CurrentRecordNumber - r->hdr.OldestRecordNumber);
 646                 _mem_save_records_0 = NDR_PULL_GET_MEM_CTX(ndr);
 647                 NDR_PULL_SET_MEM_CTX(ndr, r->records, 0);
 648                 for (cntr_records_0 = 0; cntr_records_0 < r->hdr.CurrentRecordNumber - r->hdr.OldestRecordNumber; cntr_records_0++) {
 649                         NDR_CHECK(ndr_pull_EVENTLOGRECORD(ndr, NDR_SCALARS, &r->records[cntr_records_0]));
 650                 }
 651                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_records_0, 0);
 652                 NDR_CHECK(ndr_pull_EVENTLOGEOF(ndr, NDR_SCALARS, &r->eof));
 653         }
 654         if (ndr_flags & NDR_BUFFERS) {
 655                 _mem_save_records_0 = NDR_PULL_GET_MEM_CTX(ndr);
 656                 NDR_PULL_SET_MEM_CTX(ndr, r->records, 0);
 657                 for (cntr_records_0 = 0; cntr_records_0 < r->hdr.CurrentRecordNumber - r->hdr.OldestRecordNumber; cntr_records_0++) {
 658                         NDR_CHECK(ndr_pull_EVENTLOGRECORD(ndr, NDR_BUFFERS, &r->records[cntr_records_0]));
 659                 }
 660                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_records_0, 0);
 661         }
 662         return NDR_ERR_SUCCESS;
 663 }
 664
 665 _PUBLIC_ void ndr_print_EVENTLOG_EVT_FILE(struct ndr_print *ndr, const char *name, const struct EVENTLOG_EVT_FILE *r)
 666 {
 667         uint32_t cntr_records_0;
 668         ndr_print_struct(ndr, name, "EVENTLOG_EVT_FILE");
 669         ndr->depth++;
 670         ndr_print_EVENTLOGHEADER(ndr, "hdr", &r->hdr);
 671         ndr->print(ndr, "%s: ARRAY(%d)", "records", (int)r->hdr.CurrentRecordNumber - r->hdr.OldestRecordNumber);
 672         ndr->depth++;
 673         for (cntr_records_0=0;cntr_records_0<r->hdr.CurrentRecordNumber - r->hdr.OldestRecordNumber;cntr_records_0++) {
 674                 char *idx_0=NULL;
 675                 if (asprintf(&idx_0, "[%d]", cntr_records_0) != -1) {
 676                         ndr_print_EVENTLOGRECORD(ndr, "records", &r->records[cntr_records_0]);
 677                         free(idx_0);
 678                 }
 679         }
 680         ndr->depth--;
 681         ndr_print_EVENTLOGEOF(ndr, "eof", &r->eof);
 682         ndr->depth--;
 683 }
 684
 685 _PUBLIC_ enum ndr_err_code ndr_push_EVENTLOG_FULL_INFORMATION(struct ndr_push *ndr, int ndr_flags, const struct EVENTLOG_FULL_INFORMATION *r)
 686 {
 687         if (ndr_flags & NDR_SCALARS) {
 688                 NDR_CHECK(ndr_push_align(ndr, 4));
 689                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->full));
 690         }
 691         if (ndr_flags & NDR_BUFFERS) {
 692         }
 693         return NDR_ERR_SUCCESS;
 694 }
 695
 696 _PUBLIC_ enum ndr_err_code ndr_pull_EVENTLOG_FULL_INFORMATION(struct ndr_pull *ndr, int ndr_flags, struct EVENTLOG_FULL_INFORMATION *r)
 697 {
 698         if (ndr_flags & NDR_SCALARS) {
 699                 NDR_CHECK(ndr_pull_align(ndr, 4));
 700                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->full));
 701         }
 702         if (ndr_flags & NDR_BUFFERS) {
 703         }
 704         return NDR_ERR_SUCCESS;
 705 }
 706
 707 _PUBLIC_ void ndr_print_EVENTLOG_FULL_INFORMATION(struct ndr_print *ndr, const char *name, const struct EVENTLOG_FULL_INFORMATION *r)
 708 {
 709         ndr_print_struct(ndr, name, "EVENTLOG_FULL_INFORMATION");
 710         ndr->depth++;
 711         ndr_print_uint32(ndr, "full", r->full);
 712         ndr->depth--;
 713 }
 714
 715 static enum ndr_err_code ndr_push_eventlog_ClearEventLogW(struct ndr_push *ndr, int flags, const struct eventlog_ClearEventLogW *r)
 716 {
 717         if (flags & NDR_IN) {
 718                 if (r->in.handle == NULL) {
 719                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 720                 }
 721                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
 722                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.backupfile));
 723                 if (r->in.backupfile) {
 724                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.backupfile));
 725                 }
 726         }
 727         if (flags & NDR_OUT) {
 728                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 729         }
 730         return NDR_ERR_SUCCESS;
 731 }
 732
 733 static enum ndr_err_code ndr_pull_eventlog_ClearEventLogW(struct ndr_pull *ndr, int flags, struct eventlog_ClearEventLogW *r)
 734 {
 735         uint32_t _ptr_backupfile;
 736         TALLOC_CTX *_mem_save_handle_0;
 737         TALLOC_CTX *_mem_save_backupfile_0;
 738         if (flags & NDR_IN) {
 739                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 740                         NDR_PULL_ALLOC(ndr, r->in.handle);
 741                 }
 742                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 743                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
 744                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
 745                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 746                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_backupfile));
 747                 if (_ptr_backupfile) {
 748                         NDR_PULL_ALLOC(ndr, r->in.backupfile);
 749                 } else {
 750                         r->in.backupfile = NULL;
 751                 }
 752                 if (r->in.backupfile) {
 753                         _mem_save_backupfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
 754                         NDR_PULL_SET_MEM_CTX(ndr, r->in.backupfile, 0);
 755                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.backupfile));
 756                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_backupfile_0, 0);
 757                 }
 758         }
 759         if (flags & NDR_OUT) {
 760                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 761         }
 762         return NDR_ERR_SUCCESS;
 763 }
 764
 765 _PUBLIC_ void ndr_print_eventlog_ClearEventLogW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ClearEventLogW *r)
 766 {
 767         ndr_print_struct(ndr, name, "eventlog_ClearEventLogW");
 768         ndr->depth++;
 769         if (flags & NDR_SET_VALUES) {
 770                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 771         }
 772         if (flags & NDR_IN) {
 773                 ndr_print_struct(ndr, "in", "eventlog_ClearEventLogW");
 774                 ndr->depth++;
 775                 ndr_print_ptr(ndr, "handle", r->in.handle);
 776                 ndr->depth++;
 777                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
 778                 ndr->depth--;
 779                 ndr_print_ptr(ndr, "backupfile", r->in.backupfile);
 780                 ndr->depth++;
 781                 if (r->in.backupfile) {
 782                         ndr_print_lsa_String(ndr, "backupfile", r->in.backupfile);
 783                 }
 784                 ndr->depth--;
 785                 ndr->depth--;
 786         }
 787         if (flags & NDR_OUT) {
 788                 ndr_print_struct(ndr, "out", "eventlog_ClearEventLogW");
 789                 ndr->depth++;
 790                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
 791                 ndr->depth--;
 792         }
 793         ndr->depth--;
 794 }
 795
 796 static enum ndr_err_code ndr_push_eventlog_BackupEventLogW(struct ndr_push *ndr, int flags, const struct eventlog_BackupEventLogW *r)
 797 {
 798         if (flags & NDR_IN) {
 799                 if (r->in.handle == NULL) {
 800                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 801                 }
 802                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
 803                 if (r->in.backup_filename == NULL) {
 804                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 805                 }
 806                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.backup_filename));
 807         }
 808         if (flags & NDR_OUT) {
 809                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 810         }
 811         return NDR_ERR_SUCCESS;
 812 }
 813
 814 static enum ndr_err_code ndr_pull_eventlog_BackupEventLogW(struct ndr_pull *ndr, int flags, struct eventlog_BackupEventLogW *r)
 815 {
 816         TALLOC_CTX *_mem_save_handle_0;
 817         TALLOC_CTX *_mem_save_backup_filename_0;
 818         if (flags & NDR_IN) {
 819                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 820                         NDR_PULL_ALLOC(ndr, r->in.handle);
 821                 }
 822                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 823                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
 824                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
 825                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 826                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 827                         NDR_PULL_ALLOC(ndr, r->in.backup_filename);
 828                 }
 829                 _mem_save_backup_filename_0 = NDR_PULL_GET_MEM_CTX(ndr);
 830                 NDR_PULL_SET_MEM_CTX(ndr, r->in.backup_filename, LIBNDR_FLAG_REF_ALLOC);
 831                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.backup_filename));
 832                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_backup_filename_0, LIBNDR_FLAG_REF_ALLOC);
 833         }
 834         if (flags & NDR_OUT) {
 835                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 836         }
 837         return NDR_ERR_SUCCESS;
 838 }
 839
 840 _PUBLIC_ void ndr_print_eventlog_BackupEventLogW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_BackupEventLogW *r)
 841 {
 842         ndr_print_struct(ndr, name, "eventlog_BackupEventLogW");
 843         ndr->depth++;
 844         if (flags & NDR_SET_VALUES) {
 845                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 846         }
 847         if (flags & NDR_IN) {
 848                 ndr_print_struct(ndr, "in", "eventlog_BackupEventLogW");
 849                 ndr->depth++;
 850                 ndr_print_ptr(ndr, "handle", r->in.handle);
 851                 ndr->depth++;
 852                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
 853                 ndr->depth--;
 854                 ndr_print_ptr(ndr, "backup_filename", r->in.backup_filename);
 855                 ndr->depth++;
 856                 ndr_print_lsa_String(ndr, "backup_filename", r->in.backup_filename);
 857                 ndr->depth--;
 858                 ndr->depth--;
 859         }
 860         if (flags & NDR_OUT) {
 861                 ndr_print_struct(ndr, "out", "eventlog_BackupEventLogW");
 862                 ndr->depth++;
 863                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
 864                 ndr->depth--;
 865         }
 866         ndr->depth--;
 867 }
 868
 869 static enum ndr_err_code ndr_push_eventlog_CloseEventLog(struct ndr_push *ndr, int flags, const struct eventlog_CloseEventLog *r)
 870 {
 871         if (flags & NDR_IN) {
 872                 if (r->in.handle == NULL) {
 873                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 874                 }
 875                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
 876         }
 877         if (flags & NDR_OUT) {
 878                 if (r->out.handle == NULL) {
 879                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 880                 }
 881                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
 882                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 883         }
 884         return NDR_ERR_SUCCESS;
 885 }
 886
 887 static enum ndr_err_code ndr_pull_eventlog_CloseEventLog(struct ndr_pull *ndr, int flags, struct eventlog_CloseEventLog *r)
 888 {
 889         TALLOC_CTX *_mem_save_handle_0;
 890         if (flags & NDR_IN) {
 891                 ZERO_STRUCT(r->out);
 892
 893                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 894                         NDR_PULL_ALLOC(ndr, r->in.handle);
 895                 }
 896                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 897                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
 898                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
 899                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 900                 NDR_PULL_ALLOC(ndr, r->out.handle);
 901                 *r->out.handle = *r->in.handle;
 902         }
 903         if (flags & NDR_OUT) {
 904                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 905                         NDR_PULL_ALLOC(ndr, r->out.handle);
 906                 }
 907                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 908                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
 909                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
 910                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 911                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 912         }
 913         return NDR_ERR_SUCCESS;
 914 }
 915
 916 _PUBLIC_ void ndr_print_eventlog_CloseEventLog(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_CloseEventLog *r)
 917 {
 918         ndr_print_struct(ndr, name, "eventlog_CloseEventLog");
 919         ndr->depth++;
 920         if (flags & NDR_SET_VALUES) {
 921                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 922         }
 923         if (flags & NDR_IN) {
 924                 ndr_print_struct(ndr, "in", "eventlog_CloseEventLog");
 925                 ndr->depth++;
 926                 ndr_print_ptr(ndr, "handle", r->in.handle);
 927                 ndr->depth++;
 928                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
 929                 ndr->depth--;
 930                 ndr->depth--;
 931         }
 932         if (flags & NDR_OUT) {
 933                 ndr_print_struct(ndr, "out", "eventlog_CloseEventLog");
 934                 ndr->depth++;
 935                 ndr_print_ptr(ndr, "handle", r->out.handle);
 936                 ndr->depth++;
 937                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
 938                 ndr->depth--;
 939                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
 940                 ndr->depth--;
 941         }
 942         ndr->depth--;
 943 }
 944
 945 static enum ndr_err_code ndr_push_eventlog_DeregisterEventSource(struct ndr_push *ndr, int flags, const struct eventlog_DeregisterEventSource *r)
 946 {
 947         if (flags & NDR_IN) {
 948                 if (r->in.handle == NULL) {
 949                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 950                 }
 951                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
 952         }
 953         if (flags & NDR_OUT) {
 954                 if (r->out.handle == NULL) {
 955                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 956                 }
 957                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
 958                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 959         }
 960         return NDR_ERR_SUCCESS;
 961 }
 962
 963 static enum ndr_err_code ndr_pull_eventlog_DeregisterEventSource(struct ndr_pull *ndr, int flags, struct eventlog_DeregisterEventSource *r)
 964 {
 965         TALLOC_CTX *_mem_save_handle_0;
 966         if (flags & NDR_IN) {
 967                 ZERO_STRUCT(r->out);
 968
 969                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 970                         NDR_PULL_ALLOC(ndr, r->in.handle);
 971                 }
 972                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 973                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
 974                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
 975                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 976                 NDR_PULL_ALLOC(ndr, r->out.handle);
 977                 *r->out.handle = *r->in.handle;
 978         }
 979         if (flags & NDR_OUT) {
 980                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 981                         NDR_PULL_ALLOC(ndr, r->out.handle);
 982                 }
 983                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 984                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
 985                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
 986                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 987                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 988         }
 989         return NDR_ERR_SUCCESS;
 990 }
 991
 992 _PUBLIC_ void ndr_print_eventlog_DeregisterEventSource(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_DeregisterEventSource *r)
 993 {
 994         ndr_print_struct(ndr, name, "eventlog_DeregisterEventSource");
 995         ndr->depth++;
 996         if (flags & NDR_SET_VALUES) {
 997                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 998         }
 999         if (flags & NDR_IN) {
1000                 ndr_print_struct(ndr, "in", "eventlog_DeregisterEventSource");
1001                 ndr->depth++;
1002                 ndr_print_ptr(ndr, "handle", r->in.handle);
1003                 ndr->depth++;
1004                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
1005                 ndr->depth--;
1006                 ndr->depth--;
1007         }
1008         if (flags & NDR_OUT) {
1009                 ndr_print_struct(ndr, "out", "eventlog_DeregisterEventSource");
1010                 ndr->depth++;
1011                 ndr_print_ptr(ndr, "handle", r->out.handle);
1012                 ndr->depth++;
1013                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
1014                 ndr->depth--;
1015                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1016                 ndr->depth--;
1017         }
1018         ndr->depth--;
1019 }
1020
1021 static enum ndr_err_code ndr_push_eventlog_GetNumRecords(struct ndr_push *ndr, int flags, const struct eventlog_GetNumRecords *r)
1022 {
1023         if (flags & NDR_IN) {
1024                 if (r->in.handle == NULL) {
1025                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1026                 }
1027                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1028         }
1029         if (flags & NDR_OUT) {
1030                 if (r->out.number == NULL) {
1031                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1032                 }
1033                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.number));
1034                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1035         }
1036         return NDR_ERR_SUCCESS;
1037 }
1038
1039 static enum ndr_err_code ndr_pull_eventlog_GetNumRecords(struct ndr_pull *ndr, int flags, struct eventlog_GetNumRecords *r)
1040 {
1041         TALLOC_CTX *_mem_save_handle_0;
1042         TALLOC_CTX *_mem_save_number_0;
1043         if (flags & NDR_IN) {
1044                 ZERO_STRUCT(r->out);
1045
1046                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1047                         NDR_PULL_ALLOC(ndr, r->in.handle);
1048                 }
1049                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1050                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1051                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1052                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1053                 NDR_PULL_ALLOC(ndr, r->out.number);
1054                 ZERO_STRUCTP(r->out.number);
1055         }
1056         if (flags & NDR_OUT) {
1057                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1058                         NDR_PULL_ALLOC(ndr, r->out.number);
1059                 }
1060                 _mem_save_number_0 = NDR_PULL_GET_MEM_CTX(ndr);
1061                 NDR_PULL_SET_MEM_CTX(ndr, r->out.number, LIBNDR_FLAG_REF_ALLOC);
1062                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.number));
1063                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_number_0, LIBNDR_FLAG_REF_ALLOC);
1064                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1065         }
1066         return NDR_ERR_SUCCESS;
1067 }
1068
1069 _PUBLIC_ void ndr_print_eventlog_GetNumRecords(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_GetNumRecords *r)
1070 {
1071         ndr_print_struct(ndr, name, "eventlog_GetNumRecords");
1072         ndr->depth++;
1073         if (flags & NDR_SET_VALUES) {
1074                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1075         }
1076         if (flags & NDR_IN) {
1077                 ndr_print_struct(ndr, "in", "eventlog_GetNumRecords");
1078                 ndr->depth++;
1079                 ndr_print_ptr(ndr, "handle", r->in.handle);
1080                 ndr->depth++;
1081                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
1082                 ndr->depth--;
1083                 ndr->depth--;
1084         }
1085         if (flags & NDR_OUT) {
1086                 ndr_print_struct(ndr, "out", "eventlog_GetNumRecords");
1087                 ndr->depth++;
1088                 ndr_print_ptr(ndr, "number", r->out.number);
1089                 ndr->depth++;
1090                 ndr_print_uint32(ndr, "number", *r->out.number);
1091                 ndr->depth--;
1092                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1093                 ndr->depth--;
1094         }
1095         ndr->depth--;
1096 }
1097
1098 static enum ndr_err_code ndr_push_eventlog_GetOldestRecord(struct ndr_push *ndr, int flags, const struct eventlog_GetOldestRecord *r)
1099 {
1100         if (flags & NDR_IN) {
1101                 if (r->in.handle == NULL) {
1102                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1103                 }
1104                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1105         }
1106         if (flags & NDR_OUT) {
1107                 if (r->out.oldest_entry == NULL) {
1108                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1109                 }
1110                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.oldest_entry));
1111                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1112         }
1113         return NDR_ERR_SUCCESS;
1114 }
1115
1116 static enum ndr_err_code ndr_pull_eventlog_GetOldestRecord(struct ndr_pull *ndr, int flags, struct eventlog_GetOldestRecord *r)
1117 {
1118         TALLOC_CTX *_mem_save_handle_0;
1119         TALLOC_CTX *_mem_save_oldest_entry_0;
1120         if (flags & NDR_IN) {
1121                 ZERO_STRUCT(r->out);
1122
1123                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1124                         NDR_PULL_ALLOC(ndr, r->in.handle);
1125                 }
1126                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1127                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1128                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1129                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1130                 NDR_PULL_ALLOC(ndr, r->out.oldest_entry);
1131                 ZERO_STRUCTP(r->out.oldest_entry);
1132         }
1133         if (flags & NDR_OUT) {
1134                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1135                         NDR_PULL_ALLOC(ndr, r->out.oldest_entry);
1136                 }
1137                 _mem_save_oldest_entry_0 = NDR_PULL_GET_MEM_CTX(ndr);
1138                 NDR_PULL_SET_MEM_CTX(ndr, r->out.oldest_entry, LIBNDR_FLAG_REF_ALLOC);
1139                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.oldest_entry));
1140                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_oldest_entry_0, LIBNDR_FLAG_REF_ALLOC);
1141                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1142         }
1143         return NDR_ERR_SUCCESS;
1144 }
1145
1146 _PUBLIC_ void ndr_print_eventlog_GetOldestRecord(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_GetOldestRecord *r)
1147 {
1148         ndr_print_struct(ndr, name, "eventlog_GetOldestRecord");
1149         ndr->depth++;
1150         if (flags & NDR_SET_VALUES) {
1151                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1152         }
1153         if (flags & NDR_IN) {
1154                 ndr_print_struct(ndr, "in", "eventlog_GetOldestRecord");
1155                 ndr->depth++;
1156                 ndr_print_ptr(ndr, "handle", r->in.handle);
1157                 ndr->depth++;
1158                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
1159                 ndr->depth--;
1160                 ndr->depth--;
1161         }
1162         if (flags & NDR_OUT) {
1163                 ndr_print_struct(ndr, "out", "eventlog_GetOldestRecord");
1164                 ndr->depth++;
1165                 ndr_print_ptr(ndr, "oldest_entry", r->out.oldest_entry);
1166                 ndr->depth++;
1167                 ndr_print_uint32(ndr, "oldest_entry", *r->out.oldest_entry);
1168                 ndr->depth--;
1169                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1170                 ndr->depth--;
1171         }
1172         ndr->depth--;
1173 }
1174
1175 static enum ndr_err_code ndr_push_eventlog_ChangeNotify(struct ndr_push *ndr, int flags, const struct eventlog_ChangeNotify *r)
1176 {
1177         if (flags & NDR_IN) {
1178         }
1179         if (flags & NDR_OUT) {
1180                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1181         }
1182         return NDR_ERR_SUCCESS;
1183 }
1184
1185 static enum ndr_err_code ndr_pull_eventlog_ChangeNotify(struct ndr_pull *ndr, int flags, struct eventlog_ChangeNotify *r)
1186 {
1187         if (flags & NDR_IN) {
1188         }
1189         if (flags & NDR_OUT) {
1190                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1191         }
1192         return NDR_ERR_SUCCESS;
1193 }
1194
1195 _PUBLIC_ void ndr_print_eventlog_ChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ChangeNotify *r)
1196 {
1197         ndr_print_struct(ndr, name, "eventlog_ChangeNotify");
1198         ndr->depth++;
1199         if (flags & NDR_SET_VALUES) {
1200                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1201         }
1202         if (flags & NDR_IN) {
1203                 ndr_print_struct(ndr, "in", "eventlog_ChangeNotify");
1204                 ndr->depth++;
1205                 ndr->depth--;
1206         }
1207         if (flags & NDR_OUT) {
1208                 ndr_print_struct(ndr, "out", "eventlog_ChangeNotify");
1209                 ndr->depth++;
1210                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1211                 ndr->depth--;
1212         }
1213         ndr->depth--;
1214 }
1215
1216 static enum ndr_err_code ndr_push_eventlog_OpenEventLogW(struct ndr_push *ndr, int flags, const struct eventlog_OpenEventLogW *r)
1217 {
1218         if (flags & NDR_IN) {
1219                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown0));
1220                 if (r->in.unknown0) {
1221                         NDR_CHECK(ndr_push_eventlog_OpenUnknown0(ndr, NDR_SCALARS, r->in.unknown0));
1222                 }
1223                 if (r->in.logname == NULL) {
1224                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1225                 }
1226                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.logname));
1227                 if (r->in.servername == NULL) {
1228                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1229                 }
1230                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.servername));
1231                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.major_version));
1232                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.minor_version));
1233         }
1234         if (flags & NDR_OUT) {
1235                 if (r->out.handle == NULL) {
1236                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1237                 }
1238                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
1239                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1240         }
1241         return NDR_ERR_SUCCESS;
1242 }
1243
1244 static enum ndr_err_code ndr_pull_eventlog_OpenEventLogW(struct ndr_pull *ndr, int flags, struct eventlog_OpenEventLogW *r)
1245 {
1246         uint32_t _ptr_unknown0;
1247         TALLOC_CTX *_mem_save_unknown0_0;
1248         TALLOC_CTX *_mem_save_logname_0;
1249         TALLOC_CTX *_mem_save_servername_0;
1250         TALLOC_CTX *_mem_save_handle_0;
1251         if (flags & NDR_IN) {
1252                 ZERO_STRUCT(r->out);
1253
1254                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown0));
1255                 if (_ptr_unknown0) {
1256                         NDR_PULL_ALLOC(ndr, r->in.unknown0);
1257                 } else {
1258                         r->in.unknown0 = NULL;
1259                 }
1260                 if (r->in.unknown0) {
1261                         _mem_save_unknown0_0 = NDR_PULL_GET_MEM_CTX(ndr);
1262                         NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown0, 0);
1263                         NDR_CHECK(ndr_pull_eventlog_OpenUnknown0(ndr, NDR_SCALARS, r->in.unknown0));
1264                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown0_0, 0);
1265                 }
1266                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1267                         NDR_PULL_ALLOC(ndr, r->in.logname);
1268                 }
1269                 _mem_save_logname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1270                 NDR_PULL_SET_MEM_CTX(ndr, r->in.logname, LIBNDR_FLAG_REF_ALLOC);
1271                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.logname));
1272                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_logname_0, LIBNDR_FLAG_REF_ALLOC);
1273                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1274                         NDR_PULL_ALLOC(ndr, r->in.servername);
1275                 }
1276                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1277                 NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, LIBNDR_FLAG_REF_ALLOC);
1278                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.servername));
1279                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, LIBNDR_FLAG_REF_ALLOC);
1280                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.major_version));
1281                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.minor_version));
1282                 NDR_PULL_ALLOC(ndr, r->out.handle);
1283                 ZERO_STRUCTP(r->out.handle);
1284         }
1285         if (flags & NDR_OUT) {
1286                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1287                         NDR_PULL_ALLOC(ndr, r->out.handle);
1288                 }
1289                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1290                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
1291                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
1292                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1293                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1294         }
1295         return NDR_ERR_SUCCESS;
1296 }
1297
1298 _PUBLIC_ void ndr_print_eventlog_OpenEventLogW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_OpenEventLogW *r)
1299 {
1300         ndr_print_struct(ndr, name, "eventlog_OpenEventLogW");
1301         ndr->depth++;
1302         if (flags & NDR_SET_VALUES) {
1303                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1304         }
1305         if (flags & NDR_IN) {
1306                 ndr_print_struct(ndr, "in", "eventlog_OpenEventLogW");
1307                 ndr->depth++;
1308                 ndr_print_ptr(ndr, "unknown0", r->in.unknown0);
1309                 ndr->depth++;
1310                 if (r->in.unknown0) {
1311                         ndr_print_eventlog_OpenUnknown0(ndr, "unknown0", r->in.unknown0);
1312                 }
1313                 ndr->depth--;
1314                 ndr_print_ptr(ndr, "logname", r->in.logname);
1315                 ndr->depth++;
1316                 ndr_print_lsa_String(ndr, "logname", r->in.logname);
1317                 ndr->depth--;
1318                 ndr_print_ptr(ndr, "servername", r->in.servername);
1319                 ndr->depth++;
1320                 ndr_print_lsa_String(ndr, "servername", r->in.servername);
1321                 ndr->depth--;
1322                 ndr_print_uint32(ndr, "major_version", r->in.major_version);
1323                 ndr_print_uint32(ndr, "minor_version", r->in.minor_version);
1324                 ndr->depth--;
1325         }
1326         if (flags & NDR_OUT) {
1327                 ndr_print_struct(ndr, "out", "eventlog_OpenEventLogW");
1328                 ndr->depth++;
1329                 ndr_print_ptr(ndr, "handle", r->out.handle);
1330                 ndr->depth++;
1331                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
1332                 ndr->depth--;
1333                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1334                 ndr->depth--;
1335         }
1336         ndr->depth--;
1337 }
1338
1339 static enum ndr_err_code ndr_push_eventlog_RegisterEventSourceW(struct ndr_push *ndr, int flags, const struct eventlog_RegisterEventSourceW *r)
1340 {
1341         if (flags & NDR_IN) {
1342                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown0));
1343                 if (r->in.unknown0) {
1344                         NDR_CHECK(ndr_push_eventlog_OpenUnknown0(ndr, NDR_SCALARS, r->in.unknown0));
1345                 }
1346                 if (r->in.module_name == NULL) {
1347                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1348                 }
1349                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.module_name));
1350                 if (r->in.reg_module_name == NULL) {
1351                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1352                 }
1353                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.reg_module_name));
1354                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.major_version));
1355                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.minor_version));
1356         }
1357         if (flags & NDR_OUT) {
1358                 if (r->out.log_handle == NULL) {
1359                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1360                 }
1361                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.log_handle));
1362                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1363         }
1364         return NDR_ERR_SUCCESS;
1365 }
1366
1367 static enum ndr_err_code ndr_pull_eventlog_RegisterEventSourceW(struct ndr_pull *ndr, int flags, struct eventlog_RegisterEventSourceW *r)
1368 {
1369         uint32_t _ptr_unknown0;
1370         TALLOC_CTX *_mem_save_unknown0_0;
1371         TALLOC_CTX *_mem_save_module_name_0;
1372         TALLOC_CTX *_mem_save_reg_module_name_0;
1373         TALLOC_CTX *_mem_save_log_handle_0;
1374         if (flags & NDR_IN) {
1375                 ZERO_STRUCT(r->out);
1376
1377                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown0));
1378                 if (_ptr_unknown0) {
1379                         NDR_PULL_ALLOC(ndr, r->in.unknown0);
1380                 } else {
1381                         r->in.unknown0 = NULL;
1382                 }
1383                 if (r->in.unknown0) {
1384                         _mem_save_unknown0_0 = NDR_PULL_GET_MEM_CTX(ndr);
1385                         NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown0, 0);
1386                         NDR_CHECK(ndr_pull_eventlog_OpenUnknown0(ndr, NDR_SCALARS, r->in.unknown0));
1387                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown0_0, 0);
1388                 }
1389                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1390                         NDR_PULL_ALLOC(ndr, r->in.module_name);
1391                 }
1392                 _mem_save_module_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1393                 NDR_PULL_SET_MEM_CTX(ndr, r->in.module_name, LIBNDR_FLAG_REF_ALLOC);
1394                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.module_name));
1395                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_module_name_0, LIBNDR_FLAG_REF_ALLOC);
1396                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1397                         NDR_PULL_ALLOC(ndr, r->in.reg_module_name);
1398                 }
1399                 _mem_save_reg_module_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1400                 NDR_PULL_SET_MEM_CTX(ndr, r->in.reg_module_name, LIBNDR_FLAG_REF_ALLOC);
1401                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.reg_module_name));
1402                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reg_module_name_0, LIBNDR_FLAG_REF_ALLOC);
1403                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.major_version));
1404                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.minor_version));
1405                 NDR_PULL_ALLOC(ndr, r->out.log_handle);
1406                 ZERO_STRUCTP(r->out.log_handle);
1407         }
1408         if (flags & NDR_OUT) {
1409                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1410                         NDR_PULL_ALLOC(ndr, r->out.log_handle);
1411                 }
1412                 _mem_save_log_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1413                 NDR_PULL_SET_MEM_CTX(ndr, r->out.log_handle, LIBNDR_FLAG_REF_ALLOC);
1414                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.log_handle));
1415                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_log_handle_0, LIBNDR_FLAG_REF_ALLOC);
1416                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1417         }
1418         return NDR_ERR_SUCCESS;
1419 }
1420
1421 _PUBLIC_ void ndr_print_eventlog_RegisterEventSourceW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_RegisterEventSourceW *r)
1422 {
1423         ndr_print_struct(ndr, name, "eventlog_RegisterEventSourceW");
1424         ndr->depth++;
1425         if (flags & NDR_SET_VALUES) {
1426                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1427         }
1428         if (flags & NDR_IN) {
1429                 ndr_print_struct(ndr, "in", "eventlog_RegisterEventSourceW");
1430                 ndr->depth++;
1431                 ndr_print_ptr(ndr, "unknown0", r->in.unknown0);
1432                 ndr->depth++;
1433                 if (r->in.unknown0) {
1434                         ndr_print_eventlog_OpenUnknown0(ndr, "unknown0", r->in.unknown0);
1435                 }
1436                 ndr->depth--;
1437                 ndr_print_ptr(ndr, "module_name", r->in.module_name);
1438                 ndr->depth++;
1439                 ndr_print_lsa_String(ndr, "module_name", r->in.module_name);
1440                 ndr->depth--;
1441                 ndr_print_ptr(ndr, "reg_module_name", r->in.reg_module_name);
1442                 ndr->depth++;
1443                 ndr_print_lsa_String(ndr, "reg_module_name", r->in.reg_module_name);
1444                 ndr->depth--;
1445                 ndr_print_uint32(ndr, "major_version", r->in.major_version);
1446                 ndr_print_uint32(ndr, "minor_version", r->in.minor_version);
1447                 ndr->depth--;
1448         }
1449         if (flags & NDR_OUT) {
1450                 ndr_print_struct(ndr, "out", "eventlog_RegisterEventSourceW");
1451                 ndr->depth++;
1452                 ndr_print_ptr(ndr, "log_handle", r->out.log_handle);
1453                 ndr->depth++;
1454                 ndr_print_policy_handle(ndr, "log_handle", r->out.log_handle);
1455                 ndr->depth--;
1456                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1457                 ndr->depth--;
1458         }
1459         ndr->depth--;
1460 }
1461
1462 static enum ndr_err_code ndr_push_eventlog_OpenBackupEventLogW(struct ndr_push *ndr, int flags, const struct eventlog_OpenBackupEventLogW *r)
1463 {
1464         if (flags & NDR_IN) {
1465                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown0));
1466                 if (r->in.unknown0) {
1467                         NDR_CHECK(ndr_push_eventlog_OpenUnknown0(ndr, NDR_SCALARS, r->in.unknown0));
1468                 }
1469                 if (r->in.backup_logname == NULL) {
1470                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1471                 }
1472                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.backup_logname));
1473                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.major_version));
1474                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.minor_version));
1475         }
1476         if (flags & NDR_OUT) {
1477                 if (r->out.handle == NULL) {
1478                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1479                 }
1480                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
1481                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1482         }
1483         return NDR_ERR_SUCCESS;
1484 }
1485
1486 static enum ndr_err_code ndr_pull_eventlog_OpenBackupEventLogW(struct ndr_pull *ndr, int flags, struct eventlog_OpenBackupEventLogW *r)
1487 {
1488         uint32_t _ptr_unknown0;
1489         TALLOC_CTX *_mem_save_unknown0_0;
1490         TALLOC_CTX *_mem_save_backup_logname_0;
1491         TALLOC_CTX *_mem_save_handle_0;
1492         if (flags & NDR_IN) {
1493                 ZERO_STRUCT(r->out);
1494
1495                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown0));
1496                 if (_ptr_unknown0) {
1497                         NDR_PULL_ALLOC(ndr, r->in.unknown0);
1498                 } else {
1499                         r->in.unknown0 = NULL;
1500                 }
1501                 if (r->in.unknown0) {
1502                         _mem_save_unknown0_0 = NDR_PULL_GET_MEM_CTX(ndr);
1503                         NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown0, 0);
1504                         NDR_CHECK(ndr_pull_eventlog_OpenUnknown0(ndr, NDR_SCALARS, r->in.unknown0));
1505                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown0_0, 0);
1506                 }
1507                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1508                         NDR_PULL_ALLOC(ndr, r->in.backup_logname);
1509                 }
1510                 _mem_save_backup_logname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1511                 NDR_PULL_SET_MEM_CTX(ndr, r->in.backup_logname, LIBNDR_FLAG_REF_ALLOC);
1512                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.backup_logname));
1513                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_backup_logname_0, LIBNDR_FLAG_REF_ALLOC);
1514                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.major_version));
1515                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.minor_version));
1516                 NDR_PULL_ALLOC(ndr, r->out.handle);
1517                 ZERO_STRUCTP(r->out.handle);
1518         }
1519         if (flags & NDR_OUT) {
1520                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1521                         NDR_PULL_ALLOC(ndr, r->out.handle);
1522                 }
1523                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1524                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
1525                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
1526                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1527                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1528         }
1529         return NDR_ERR_SUCCESS;
1530 }
1531
1532 _PUBLIC_ void ndr_print_eventlog_OpenBackupEventLogW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_OpenBackupEventLogW *r)
1533 {
1534         ndr_print_struct(ndr, name, "eventlog_OpenBackupEventLogW");
1535         ndr->depth++;
1536         if (flags & NDR_SET_VALUES) {
1537                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1538         }
1539         if (flags & NDR_IN) {
1540                 ndr_print_struct(ndr, "in", "eventlog_OpenBackupEventLogW");
1541                 ndr->depth++;
1542                 ndr_print_ptr(ndr, "unknown0", r->in.unknown0);
1543                 ndr->depth++;
1544                 if (r->in.unknown0) {
1545                         ndr_print_eventlog_OpenUnknown0(ndr, "unknown0", r->in.unknown0);
1546                 }
1547                 ndr->depth--;
1548                 ndr_print_ptr(ndr, "backup_logname", r->in.backup_logname);
1549                 ndr->depth++;
1550                 ndr_print_lsa_String(ndr, "backup_logname", r->in.backup_logname);
1551                 ndr->depth--;
1552                 ndr_print_uint32(ndr, "major_version", r->in.major_version);
1553                 ndr_print_uint32(ndr, "minor_version", r->in.minor_version);
1554                 ndr->depth--;
1555         }
1556         if (flags & NDR_OUT) {
1557                 ndr_print_struct(ndr, "out", "eventlog_OpenBackupEventLogW");
1558                 ndr->depth++;
1559                 ndr_print_ptr(ndr, "handle", r->out.handle);
1560                 ndr->depth++;
1561                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
1562                 ndr->depth--;
1563                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1564                 ndr->depth--;
1565         }
1566         ndr->depth--;
1567 }
1568
1569 static enum ndr_err_code ndr_push_eventlog_ReadEventLogW(struct ndr_push *ndr, int flags, const struct eventlog_ReadEventLogW *r)
1570 {
1571         if (flags & NDR_IN) {
1572                 if (r->in.handle == NULL) {
1573                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1574                 }
1575                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1576                 NDR_CHECK(ndr_push_eventlogReadFlags(ndr, NDR_SCALARS, r->in.flags));
1577                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offset));
1578                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.number_of_bytes));
1579         }
1580         if (flags & NDR_OUT) {
1581                 if (r->out.data == NULL) {
1582                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1583                 }
1584                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.number_of_bytes));
1585                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.number_of_bytes));
1586                 if (r->out.sent_size == NULL) {
1587                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1588                 }
1589                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.sent_size));
1590                 if (r->out.real_size == NULL) {
1591                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1592                 }
1593                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.real_size));
1594                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1595         }
1596         return NDR_ERR_SUCCESS;
1597 }
1598
1599 static enum ndr_err_code ndr_pull_eventlog_ReadEventLogW(struct ndr_pull *ndr, int flags, struct eventlog_ReadEventLogW *r)
1600 {
1601         TALLOC_CTX *_mem_save_handle_0;
1602         TALLOC_CTX *_mem_save_sent_size_0;
1603         TALLOC_CTX *_mem_save_real_size_0;
1604         if (flags & NDR_IN) {
1605                 ZERO_STRUCT(r->out);
1606
1607                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1608                         NDR_PULL_ALLOC(ndr, r->in.handle);
1609                 }
1610                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1611                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1612                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1613                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1614                 NDR_CHECK(ndr_pull_eventlogReadFlags(ndr, NDR_SCALARS, &r->in.flags));
1615                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offset));
1616                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.number_of_bytes));
1617                 if (r->in.number_of_bytes > 0x7FFFF) {
1618                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1619                 }
1620                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.number_of_bytes);
1621                 memset(r->out.data, 0, (r->in.number_of_bytes) * sizeof(*r->out.data));
1622                 NDR_PULL_ALLOC(ndr, r->out.sent_size);
1623                 ZERO_STRUCTP(r->out.sent_size);
1624                 NDR_PULL_ALLOC(ndr, r->out.real_size);
1625                 ZERO_STRUCTP(r->out.real_size);
1626         }
1627         if (flags & NDR_OUT) {
1628                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
1629                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1630                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
1631                 }
1632                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
1633                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1634                         NDR_PULL_ALLOC(ndr, r->out.sent_size);
1635                 }
1636                 _mem_save_sent_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
1637                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sent_size, LIBNDR_FLAG_REF_ALLOC);
1638                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.sent_size));
1639                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sent_size_0, LIBNDR_FLAG_REF_ALLOC);
1640                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1641                         NDR_PULL_ALLOC(ndr, r->out.real_size);
1642                 }
1643                 _mem_save_real_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
1644                 NDR_PULL_SET_MEM_CTX(ndr, r->out.real_size, LIBNDR_FLAG_REF_ALLOC);
1645                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.real_size));
1646                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_real_size_0, LIBNDR_FLAG_REF_ALLOC);
1647                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1648                 if (r->out.data) {
1649                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.number_of_bytes));
1650                 }
1651         }
1652         return NDR_ERR_SUCCESS;
1653 }
1654
1655 _PUBLIC_ void ndr_print_eventlog_ReadEventLogW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ReadEventLogW *r)
1656 {
1657         ndr_print_struct(ndr, name, "eventlog_ReadEventLogW");
1658         ndr->depth++;
1659         if (flags & NDR_SET_VALUES) {
1660                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1661         }
1662         if (flags & NDR_IN) {
1663                 ndr_print_struct(ndr, "in", "eventlog_ReadEventLogW");
1664                 ndr->depth++;
1665                 ndr_print_ptr(ndr, "handle", r->in.handle);
1666                 ndr->depth++;
1667                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
1668                 ndr->depth--;
1669                 ndr_print_eventlogReadFlags(ndr, "flags", r->in.flags);
1670                 ndr_print_uint32(ndr, "offset", r->in.offset);
1671                 ndr_print_uint32(ndr, "number_of_bytes", r->in.number_of_bytes);
1672                 ndr->depth--;
1673         }
1674         if (flags & NDR_OUT) {
1675                 ndr_print_struct(ndr, "out", "eventlog_ReadEventLogW");
1676                 ndr->depth++;
1677                 ndr_print_ptr(ndr, "data", r->out.data);
1678                 ndr->depth++;
1679                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.number_of_bytes);
1680                 ndr->depth--;
1681                 ndr_print_ptr(ndr, "sent_size", r->out.sent_size);
1682                 ndr->depth++;
1683                 ndr_print_uint32(ndr, "sent_size", *r->out.sent_size);
1684                 ndr->depth--;
1685                 ndr_print_ptr(ndr, "real_size", r->out.real_size);
1686                 ndr->depth++;
1687                 ndr_print_uint32(ndr, "real_size", *r->out.real_size);
1688                 ndr->depth--;
1689                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1690                 ndr->depth--;
1691         }
1692         ndr->depth--;
1693 }
1694
1695 static enum ndr_err_code ndr_push_eventlog_ReportEventW(struct ndr_push *ndr, int flags, const struct eventlog_ReportEventW *r)
1696 {
1697         uint32_t cntr_strings_1;
1698         if (flags & NDR_IN) {
1699                 if (r->in.handle == NULL) {
1700                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1701                 }
1702                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1703                 NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, r->in.timestamp));
1704                 NDR_CHECK(ndr_push_eventlogEventTypes(ndr, NDR_SCALARS, r->in.event_type));
1705                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.event_category));
1706                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.event_id));
1707                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.num_of_strings));
1708                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
1709                 if (r->in.servername == NULL) {
1710                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1711                 }
1712                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.servername));
1713                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.user_sid));
1714                 if (r->in.user_sid) {
1715                         NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->in.user_sid));
1716                 }
1717                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.strings));
1718                 if (r->in.strings) {
1719                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.num_of_strings));
1720                         for (cntr_strings_1 = 0; cntr_strings_1 < r->in.num_of_strings; cntr_strings_1++) {
1721                         }
1722                         for (cntr_strings_1 = 0; cntr_strings_1 < r->in.num_of_strings; cntr_strings_1++) {
1723                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.strings[cntr_strings_1]));
1724                                 if (r->in.strings[cntr_strings_1]) {
1725                                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.strings[cntr_strings_1]));
1726                                 }
1727                         }
1728                 }
1729                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data));
1730                 if (r->in.data) {
1731                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_size));
1732                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.data, r->in.data_size));
1733                 }
1734                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.flags));
1735                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.record_number));
1736                 if (r->in.record_number) {
1737                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.record_number));
1738                 }
1739                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.time_written));
1740                 if (r->in.time_written) {
1741                         NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, *r->in.time_written));
1742                 }
1743         }
1744         if (flags & NDR_OUT) {
1745                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.record_number));
1746                 if (r->out.record_number) {
1747                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.record_number));
1748                 }
1749                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.time_written));
1750                 if (r->out.time_written) {
1751                         NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, *r->out.time_written));
1752                 }
1753                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1754         }
1755         return NDR_ERR_SUCCESS;
1756 }
1757
1758 static enum ndr_err_code ndr_pull_eventlog_ReportEventW(struct ndr_pull *ndr, int flags, struct eventlog_ReportEventW *r)
1759 {
1760         uint32_t _ptr_user_sid;
1761         uint32_t _ptr_strings;
1762         uint32_t cntr_strings_1;
1763         uint32_t _ptr_data;
1764         uint32_t _ptr_record_number;
1765         uint32_t _ptr_time_written;
1766         TALLOC_CTX *_mem_save_handle_0;
1767         TALLOC_CTX *_mem_save_servername_0;
1768         TALLOC_CTX *_mem_save_user_sid_0;
1769         TALLOC_CTX *_mem_save_strings_0;
1770         TALLOC_CTX *_mem_save_strings_1;
1771         TALLOC_CTX *_mem_save_strings_2;
1772         TALLOC_CTX *_mem_save_data_0;
1773         TALLOC_CTX *_mem_save_record_number_0;
1774         TALLOC_CTX *_mem_save_time_written_0;
1775         if (flags & NDR_IN) {
1776                 ZERO_STRUCT(r->out);
1777
1778                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1779                         NDR_PULL_ALLOC(ndr, r->in.handle);
1780                 }
1781                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1782                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1783                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1784                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1785                 NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, &r->in.timestamp));
1786                 NDR_CHECK(ndr_pull_eventlogEventTypes(ndr, NDR_SCALARS, &r->in.event_type));
1787                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.event_category));
1788                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.event_id));
1789                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.num_of_strings));
1790                 if (r->in.num_of_strings > 256) {
1791                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1792                 }
1793                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
1794                 if (r->in.data_size > 0x3FFFF) {
1795                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1796                 }
1797                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1798                         NDR_PULL_ALLOC(ndr, r->in.servername);
1799                 }
1800                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1801                 NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, LIBNDR_FLAG_REF_ALLOC);
1802                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.servername));
1803                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, LIBNDR_FLAG_REF_ALLOC);
1804                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_sid));
1805                 if (_ptr_user_sid) {
1806                         NDR_PULL_ALLOC(ndr, r->in.user_sid);
1807                 } else {
1808                         r->in.user_sid = NULL;
1809                 }
1810                 if (r->in.user_sid) {
1811                         _mem_save_user_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1812                         NDR_PULL_SET_MEM_CTX(ndr, r->in.user_sid, 0);
1813                         NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->in.user_sid));
1814                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_sid_0, 0);
1815                 }
1816                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_strings));
1817                 if (_ptr_strings) {
1818                         NDR_PULL_ALLOC(ndr, r->in.strings);
1819                 } else {
1820                         r->in.strings = NULL;
1821                 }
1822                 if (r->in.strings) {
1823                         _mem_save_strings_0 = NDR_PULL_GET_MEM_CTX(ndr);
1824                         NDR_PULL_SET_MEM_CTX(ndr, r->in.strings, 0);
1825                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.strings));
1826                         NDR_PULL_ALLOC_N(ndr, r->in.strings, ndr_get_array_size(ndr, &r->in.strings));
1827                         _mem_save_strings_1 = NDR_PULL_GET_MEM_CTX(ndr);
1828                         NDR_PULL_SET_MEM_CTX(ndr, r->in.strings, 0);
1829                         for (cntr_strings_1 = 0; cntr_strings_1 < r->in.num_of_strings; cntr_strings_1++) {
1830                         }
1831                         for (cntr_strings_1 = 0; cntr_strings_1 < r->in.num_of_strings; cntr_strings_1++) {
1832                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_strings));
1833                                 if (_ptr_strings) {
1834                                         NDR_PULL_ALLOC(ndr, r->in.strings[cntr_strings_1]);
1835                                 } else {
1836                                         r->in.strings[cntr_strings_1] = NULL;
1837                                 }
1838                                 if (r->in.strings[cntr_strings_1]) {
1839                                         _mem_save_strings_2 = NDR_PULL_GET_MEM_CTX(ndr);
1840                                         NDR_PULL_SET_MEM_CTX(ndr, r->in.strings[cntr_strings_1], 0);
1841                                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.strings[cntr_strings_1]));
1842                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_strings_2, 0);
1843                                 }
1844                         }
1845                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_strings_1, 0);
1846                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_strings_0, 0);
1847                 }
1848                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
1849                 if (_ptr_data) {
1850                         NDR_PULL_ALLOC(ndr, r->in.data);
1851                 } else {
1852                         r->in.data = NULL;
1853                 }
1854                 if (r->in.data) {
1855                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
1856                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data, 0);
1857                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data));
1858                         NDR_PULL_ALLOC_N(ndr, r->in.data, ndr_get_array_size(ndr, &r->in.data));
1859                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.data, ndr_get_array_size(ndr, &r->in.data)));
1860                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
1861                 }
1862                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.flags));
1863                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_record_number));
1864                 if (_ptr_record_number) {
1865                         NDR_PULL_ALLOC(ndr, r->in.record_number);
1866                 } else {
1867                         r->in.record_number = NULL;
1868                 }
1869                 if (r->in.record_number) {
1870                         _mem_save_record_number_0 = NDR_PULL_GET_MEM_CTX(ndr);
1871                         NDR_PULL_SET_MEM_CTX(ndr, r->in.record_number, 0);
1872                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.record_number));
1873                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_record_number_0, 0);
1874                 }
1875                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time_written));
1876                 if (_ptr_time_written) {
1877                         NDR_PULL_ALLOC(ndr, r->in.time_written);
1878                 } else {
1879                         r->in.time_written = NULL;
1880                 }
1881                 if (r->in.time_written) {
1882                         _mem_save_time_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
1883                         NDR_PULL_SET_MEM_CTX(ndr, r->in.time_written, 0);
1884                         NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, r->in.time_written));
1885                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_written_0, 0);
1886                 }
1887                 if (r->in.strings) {
1888                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.strings, r->in.num_of_strings));
1889                 }
1890                 if (r->in.data) {
1891                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.data, r->in.data_size));
1892                 }
1893         }
1894         if (flags & NDR_OUT) {
1895                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_record_number));
1896                 if (_ptr_record_number) {
1897                         NDR_PULL_ALLOC(ndr, r->out.record_number);
1898                 } else {
1899                         r->out.record_number = NULL;
1900                 }
1901                 if (r->out.record_number) {
1902                         _mem_save_record_number_0 = NDR_PULL_GET_MEM_CTX(ndr);
1903                         NDR_PULL_SET_MEM_CTX(ndr, r->out.record_number, 0);
1904                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.record_number));
1905                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_record_number_0, 0);
1906                 }
1907                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time_written));
1908                 if (_ptr_time_written) {
1909                         NDR_PULL_ALLOC(ndr, r->out.time_written);
1910                 } else {
1911                         r->out.time_written = NULL;
1912                 }
1913                 if (r->out.time_written) {
1914                         _mem_save_time_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
1915                         NDR_PULL_SET_MEM_CTX(ndr, r->out.time_written, 0);
1916                         NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, r->out.time_written));
1917                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_written_0, 0);
1918                 }
1919                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1920         }
1921         return NDR_ERR_SUCCESS;
1922 }
1923
1924 _PUBLIC_ void ndr_print_eventlog_ReportEventW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ReportEventW *r)
1925 {
1926         uint32_t cntr_strings_1;
1927         ndr_print_struct(ndr, name, "eventlog_ReportEventW");
1928         ndr->depth++;
1929         if (flags & NDR_SET_VALUES) {
1930                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1931         }
1932         if (flags & NDR_IN) {
1933                 ndr_print_struct(ndr, "in", "eventlog_ReportEventW");
1934                 ndr->depth++;
1935                 ndr_print_ptr(ndr, "handle", r->in.handle);
1936                 ndr->depth++;
1937                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
1938                 ndr->depth--;
1939                 ndr_print_time_t(ndr, "timestamp", r->in.timestamp);
1940                 ndr_print_eventlogEventTypes(ndr, "event_type", r->in.event_type);
1941                 ndr_print_uint16(ndr, "event_category", r->in.event_category);
1942                 ndr_print_uint32(ndr, "event_id", r->in.event_id);
1943                 ndr_print_uint16(ndr, "num_of_strings", r->in.num_of_strings);
1944                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
1945                 ndr_print_ptr(ndr, "servername", r->in.servername);
1946                 ndr->depth++;
1947                 ndr_print_lsa_String(ndr, "servername", r->in.servername);
1948                 ndr->depth--;
1949                 ndr_print_ptr(ndr, "user_sid", r->in.user_sid);
1950                 ndr->depth++;
1951                 if (r->in.user_sid) {
1952                         ndr_print_dom_sid(ndr, "user_sid", r->in.user_sid);
1953                 }
1954                 ndr->depth--;
1955                 ndr_print_ptr(ndr, "strings", r->in.strings);
1956                 ndr->depth++;
1957                 if (r->in.strings) {
1958                         ndr->print(ndr, "%s: ARRAY(%d)", "strings", (int)r->in.num_of_strings);
1959                         ndr->depth++;
1960                         for (cntr_strings_1=0;cntr_strings_1<r->in.num_of_strings;cntr_strings_1++) {
1961                                 char *idx_1=NULL;
1962                                 if (asprintf(&idx_1, "[%d]", cntr_strings_1) != -1) {
1963                                         ndr_print_ptr(ndr, "strings", r->in.strings[cntr_strings_1]);
1964                                         ndr->depth++;
1965                                         if (r->in.strings[cntr_strings_1]) {
1966                                                 ndr_print_lsa_String(ndr, "strings", r->in.strings[cntr_strings_1]);
1967                                         }
1968                                         ndr->depth--;
1969                                         free(idx_1);
1970                                 }
1971                         }
1972                         ndr->depth--;
1973                 }
1974                 ndr->depth--;
1975                 ndr_print_ptr(ndr, "data", r->in.data);
1976                 ndr->depth++;
1977                 if (r->in.data) {
1978                         ndr_print_array_uint8(ndr, "data", r->in.data, r->in.data_size);
1979                 }
1980                 ndr->depth--;
1981                 ndr_print_uint16(ndr, "flags", r->in.flags);
1982                 ndr_print_ptr(ndr, "record_number", r->in.record_number);
1983                 ndr->depth++;
1984                 if (r->in.record_number) {
1985                         ndr_print_uint32(ndr, "record_number", *r->in.record_number);
1986                 }
1987                 ndr->depth--;
1988                 ndr_print_ptr(ndr, "time_written", r->in.time_written);
1989                 ndr->depth++;
1990                 if (r->in.time_written) {
1991                         ndr_print_time_t(ndr, "time_written", *r->in.time_written);
1992                 }
1993                 ndr->depth--;
1994                 ndr->depth--;
1995         }
1996         if (flags & NDR_OUT) {
1997                 ndr_print_struct(ndr, "out", "eventlog_ReportEventW");
1998                 ndr->depth++;
1999                 ndr_print_ptr(ndr, "record_number", r->out.record_number);
2000                 ndr->depth++;
2001                 if (r->out.record_number) {
2002                         ndr_print_uint32(ndr, "record_number", *r->out.record_number);
2003                 }
2004                 ndr->depth--;
2005                 ndr_print_ptr(ndr, "time_written", r->out.time_written);
2006                 ndr->depth++;
2007                 if (r->out.time_written) {
2008                         ndr_print_time_t(ndr, "time_written", *r->out.time_written);
2009                 }
2010                 ndr->depth--;
2011                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
2012                 ndr->depth--;
2013         }
2014         ndr->depth--;
2015 }
2016
2017 static enum ndr_err_code ndr_push_eventlog_ClearEventLogA(struct ndr_push *ndr, int flags, const struct eventlog_ClearEventLogA *r)
2018 {
2019         if (flags & NDR_IN) {
2020         }
2021         if (flags & NDR_OUT) {
2022                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2023         }
2024         return NDR_ERR_SUCCESS;
2025 }
2026
2027 static enum ndr_err_code ndr_pull_eventlog_ClearEventLogA(struct ndr_pull *ndr, int flags, struct eventlog_ClearEventLogA *r)
2028 {
2029         if (flags & NDR_IN) {
2030         }
2031         if (flags & NDR_OUT) {
2032                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2033         }
2034         return NDR_ERR_SUCCESS;
2035 }
2036
2037 _PUBLIC_ void ndr_print_eventlog_ClearEventLogA(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ClearEventLogA *r)
2038 {
2039         ndr_print_struct(ndr, name, "eventlog_ClearEventLogA");
2040         ndr->depth++;
2041         if (flags & NDR_SET_VALUES) {
2042                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2043         }
2044         if (flags & NDR_IN) {
2045                 ndr_print_struct(ndr, "in", "eventlog_ClearEventLogA");
2046                 ndr->depth++;
2047                 ndr->depth--;
2048         }
2049         if (flags & NDR_OUT) {
2050                 ndr_print_struct(ndr, "out", "eventlog_ClearEventLogA");
2051                 ndr->depth++;
2052                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
2053                 ndr->depth--;
2054         }
2055         ndr->depth--;
2056 }
2057
2058 static enum ndr_err_code ndr_push_eventlog_BackupEventLogA(struct ndr_push *ndr, int flags, const struct eventlog_BackupEventLogA *r)
2059 {
2060         if (flags & NDR_IN) {
2061         }
2062         if (flags & NDR_OUT) {
2063                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2064         }
2065         return NDR_ERR_SUCCESS;
2066 }
2067
2068 static enum ndr_err_code ndr_pull_eventlog_BackupEventLogA(struct ndr_pull *ndr, int flags, struct eventlog_BackupEventLogA *r)
2069 {
2070         if (flags & NDR_IN) {
2071         }
2072         if (flags & NDR_OUT) {
2073                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2074         }
2075         return NDR_ERR_SUCCESS;
2076 }
2077
2078 _PUBLIC_ void ndr_print_eventlog_BackupEventLogA(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_BackupEventLogA *r)
2079 {
2080         ndr_print_struct(ndr, name, "eventlog_BackupEventLogA");
2081         ndr->depth++;
2082         if (flags & NDR_SET_VALUES) {
2083                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2084         }
2085         if (flags & NDR_IN) {
2086                 ndr_print_struct(ndr, "in", "eventlog_BackupEventLogA");
2087                 ndr->depth++;
2088                 ndr->depth--;
2089         }
2090         if (flags & NDR_OUT) {
2091                 ndr_print_struct(ndr, "out", "eventlog_BackupEventLogA");
2092                 ndr->depth++;
2093                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
2094                 ndr->depth--;
2095         }
2096         ndr->depth--;
2097 }
2098
2099 static enum ndr_err_code ndr_push_eventlog_OpenEventLogA(struct ndr_push *ndr, int flags, const struct eventlog_OpenEventLogA *r)
2100 {
2101         if (flags & NDR_IN) {
2102         }
2103         if (flags & NDR_OUT) {
2104                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2105         }
2106         return NDR_ERR_SUCCESS;
2107 }
2108
2109 static enum ndr_err_code ndr_pull_eventlog_OpenEventLogA(struct ndr_pull *ndr, int flags, struct eventlog_OpenEventLogA *r)
2110 {
2111         if (flags & NDR_IN) {
2112         }
2113         if (flags & NDR_OUT) {
2114                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2115         }
2116         return NDR_ERR_SUCCESS;
2117 }
2118
2119 _PUBLIC_ void ndr_print_eventlog_OpenEventLogA(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_OpenEventLogA *r)
2120 {
2121         ndr_print_struct(ndr, name, "eventlog_OpenEventLogA");
2122         ndr->depth++;
2123         if (flags & NDR_SET_VALUES) {
2124                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2125         }
2126         if (flags & NDR_IN) {
2127                 ndr_print_struct(ndr, "in", "eventlog_OpenEventLogA");
2128                 ndr->depth++;
2129                 ndr->depth--;
2130         }
2131         if (flags & NDR_OUT) {
2132                 ndr_print_struct(ndr, "out", "eventlog_OpenEventLogA");
2133                 ndr->depth++;
2134                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
2135                 ndr->depth--;
2136         }
2137         ndr->depth--;
2138 }
2139
2140 static enum ndr_err_code ndr_push_eventlog_RegisterEventSourceA(struct ndr_push *ndr, int flags, const struct eventlog_RegisterEventSourceA *r)
2141 {
2142         if (flags & NDR_IN) {
2143         }
2144         if (flags & NDR_OUT) {
2145                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2146         }
2147         return NDR_ERR_SUCCESS;
2148 }
2149
2150 static enum ndr_err_code ndr_pull_eventlog_RegisterEventSourceA(struct ndr_pull *ndr, int flags, struct eventlog_RegisterEventSourceA *r)
2151 {
2152         if (flags & NDR_IN) {
2153         }
2154         if (flags & NDR_OUT) {
2155                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2156         }
2157         return NDR_ERR_SUCCESS;
2158 }
2159
2160 _PUBLIC_ void ndr_print_eventlog_RegisterEventSourceA(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_RegisterEventSourceA *r)
2161 {
2162         ndr_print_struct(ndr, name, "eventlog_RegisterEventSourceA");
2163         ndr->depth++;
2164         if (flags & NDR_SET_VALUES) {
2165                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2166         }
2167         if (flags & NDR_IN) {
2168                 ndr_print_struct(ndr, "in", "eventlog_RegisterEventSourceA");
2169                 ndr->depth++;
2170                 ndr->depth--;
2171         }
2172         if (flags & NDR_OUT) {
2173                 ndr_print_struct(ndr, "out", "eventlog_RegisterEventSourceA");
2174                 ndr->depth++;
2175                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
2176                 ndr->depth--;
2177         }
2178         ndr->depth--;
2179 }
2180
2181 static enum ndr_err_code ndr_push_eventlog_OpenBackupEventLogA(struct ndr_push *ndr, int flags, const struct eventlog_OpenBackupEventLogA *r)
2182 {
2183         if (flags & NDR_IN) {
2184         }
2185         if (flags & NDR_OUT) {
2186                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2187         }
2188         return NDR_ERR_SUCCESS;
2189 }
2190
2191 static enum ndr_err_code ndr_pull_eventlog_OpenBackupEventLogA(struct ndr_pull *ndr, int flags, struct eventlog_OpenBackupEventLogA *r)
2192 {
2193         if (flags & NDR_IN) {
2194         }
2195         if (flags & NDR_OUT) {
2196                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2197         }
2198         return NDR_ERR_SUCCESS;
2199 }
2200
2201 _PUBLIC_ void ndr_print_eventlog_OpenBackupEventLogA(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_OpenBackupEventLogA *r)
2202 {
2203         ndr_print_struct(ndr, name, "eventlog_OpenBackupEventLogA");
2204         ndr->depth++;
2205         if (flags & NDR_SET_VALUES) {
2206                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2207         }
2208         if (flags & NDR_IN) {
2209                 ndr_print_struct(ndr, "in", "eventlog_OpenBackupEventLogA");
2210                 ndr->depth++;
2211                 ndr->depth--;
2212         }
2213         if (flags & NDR_OUT) {
2214                 ndr_print_struct(ndr, "out", "eventlog_OpenBackupEventLogA");
2215                 ndr->depth++;
2216                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
2217                 ndr->depth--;
2218         }
2219         ndr->depth--;
2220 }
2221
2222 static enum ndr_err_code ndr_push_eventlog_ReadEventLogA(struct ndr_push *ndr, int flags, const struct eventlog_ReadEventLogA *r)
2223 {
2224         if (flags & NDR_IN) {
2225         }
2226         if (flags & NDR_OUT) {
2227                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2228         }
2229         return NDR_ERR_SUCCESS;
2230 }
2231
2232 static enum ndr_err_code ndr_pull_eventlog_ReadEventLogA(struct ndr_pull *ndr, int flags, struct eventlog_ReadEventLogA *r)
2233 {
2234         if (flags & NDR_IN) {
2235         }
2236         if (flags & NDR_OUT) {
2237                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2238         }
2239         return NDR_ERR_SUCCESS;
2240 }
2241
2242 _PUBLIC_ void ndr_print_eventlog_ReadEventLogA(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ReadEventLogA *r)
2243 {
2244         ndr_print_struct(ndr, name, "eventlog_ReadEventLogA");
2245         ndr->depth++;
2246         if (flags & NDR_SET_VALUES) {
2247                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2248         }
2249         if (flags & NDR_IN) {
2250                 ndr_print_struct(ndr, "in", "eventlog_ReadEventLogA");
2251                 ndr->depth++;
2252                 ndr->depth--;
2253         }
2254         if (flags & NDR_OUT) {
2255                 ndr_print_struct(ndr, "out", "eventlog_ReadEventLogA");
2256                 ndr->depth++;
2257                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
2258                 ndr->depth--;
2259         }
2260         ndr->depth--;
2261 }
2262
2263 static enum ndr_err_code ndr_push_eventlog_ReportEventA(struct ndr_push *ndr, int flags, const struct eventlog_ReportEventA *r)
2264 {
2265         if (flags & NDR_IN) {
2266         }
2267         if (flags & NDR_OUT) {
2268                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2269         }
2270         return NDR_ERR_SUCCESS;
2271 }
2272
2273 static enum ndr_err_code ndr_pull_eventlog_ReportEventA(struct ndr_pull *ndr, int flags, struct eventlog_ReportEventA *r)
2274 {
2275         if (flags & NDR_IN) {
2276         }
2277         if (flags & NDR_OUT) {
2278                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2279         }
2280         return NDR_ERR_SUCCESS;
2281 }
2282
2283 _PUBLIC_ void ndr_print_eventlog_ReportEventA(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ReportEventA *r)
2284 {
2285         ndr_print_struct(ndr, name, "eventlog_ReportEventA");
2286         ndr->depth++;
2287         if (flags & NDR_SET_VALUES) {
2288                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2289         }
2290         if (flags & NDR_IN) {
2291                 ndr_print_struct(ndr, "in", "eventlog_ReportEventA");
2292                 ndr->depth++;
2293                 ndr->depth--;
2294         }
2295         if (flags & NDR_OUT) {
2296                 ndr_print_struct(ndr, "out", "eventlog_ReportEventA");
2297                 ndr->depth++;
2298                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
2299                 ndr->depth--;
2300         }
2301         ndr->depth--;
2302 }
2303
2304 static enum ndr_err_code ndr_push_eventlog_RegisterClusterSvc(struct ndr_push *ndr, int flags, const struct eventlog_RegisterClusterSvc *r)
2305 {
2306         if (flags & NDR_IN) {
2307         }
2308         if (flags & NDR_OUT) {
2309                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2310         }
2311         return NDR_ERR_SUCCESS;
2312 }
2313
2314 static enum ndr_err_code ndr_pull_eventlog_RegisterClusterSvc(struct ndr_pull *ndr, int flags, struct eventlog_RegisterClusterSvc *r)
2315 {
2316         if (flags & NDR_IN) {
2317         }
2318         if (flags & NDR_OUT) {
2319                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2320         }
2321         return NDR_ERR_SUCCESS;
2322 }
2323
2324 _PUBLIC_ void ndr_print_eventlog_RegisterClusterSvc(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_RegisterClusterSvc *r)
2325 {
2326         ndr_print_struct(ndr, name, "eventlog_RegisterClusterSvc");
2327         ndr->depth++;
2328         if (flags & NDR_SET_VALUES) {
2329                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2330         }
2331         if (flags & NDR_IN) {
2332                 ndr_print_struct(ndr, "in", "eventlog_RegisterClusterSvc");
2333                 ndr->depth++;
2334                 ndr->depth--;
2335         }
2336         if (flags & NDR_OUT) {
2337                 ndr_print_struct(ndr, "out", "eventlog_RegisterClusterSvc");
2338                 ndr->depth++;
2339                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
2340                 ndr->depth--;
2341         }
2342         ndr->depth--;
2343 }
2344
2345 static enum ndr_err_code ndr_push_eventlog_DeregisterClusterSvc(struct ndr_push *ndr, int flags, const struct eventlog_DeregisterClusterSvc *r)
2346 {
2347         if (flags & NDR_IN) {
2348         }
2349         if (flags & NDR_OUT) {
2350                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2351         }
2352         return NDR_ERR_SUCCESS;
2353 }
2354
2355 static enum ndr_err_code ndr_pull_eventlog_DeregisterClusterSvc(struct ndr_pull *ndr, int flags, struct eventlog_DeregisterClusterSvc *r)
2356 {
2357         if (flags & NDR_IN) {
2358         }
2359         if (flags & NDR_OUT) {
2360                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2361         }
2362         return NDR_ERR_SUCCESS;
2363 }
2364
2365 _PUBLIC_ void ndr_print_eventlog_DeregisterClusterSvc(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_DeregisterClusterSvc *r)
2366 {
2367         ndr_print_struct(ndr, name, "eventlog_DeregisterClusterSvc");
2368         ndr->depth++;
2369         if (flags & NDR_SET_VALUES) {
2370                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2371         }
2372         if (flags & NDR_IN) {
2373                 ndr_print_struct(ndr, "in", "eventlog_DeregisterClusterSvc");
2374                 ndr->depth++;
2375                 ndr->depth--;
2376         }
2377         if (flags & NDR_OUT) {
2378                 ndr_print_struct(ndr, "out", "eventlog_DeregisterClusterSvc");
2379                 ndr->depth++;
2380                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
2381                 ndr->depth--;
2382         }
2383         ndr->depth--;
2384 }
2385
2386 static enum ndr_err_code ndr_push_eventlog_WriteClusterEvents(struct ndr_push *ndr, int flags, const struct eventlog_WriteClusterEvents *r)
2387 {
2388         if (flags & NDR_IN) {
2389         }
2390         if (flags & NDR_OUT) {
2391                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2392         }
2393         return NDR_ERR_SUCCESS;
2394 }
2395
2396 static enum ndr_err_code ndr_pull_eventlog_WriteClusterEvents(struct ndr_pull *ndr, int flags, struct eventlog_WriteClusterEvents *r)
2397 {
2398         if (flags & NDR_IN) {
2399         }
2400         if (flags & NDR_OUT) {
2401                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2402         }
2403         return NDR_ERR_SUCCESS;
2404 }
2405
2406 _PUBLIC_ void ndr_print_eventlog_WriteClusterEvents(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_WriteClusterEvents *r)
2407 {
2408         ndr_print_struct(ndr, name, "eventlog_WriteClusterEvents");
2409         ndr->depth++;
2410         if (flags & NDR_SET_VALUES) {
2411                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2412         }
2413         if (flags & NDR_IN) {
2414                 ndr_print_struct(ndr, "in", "eventlog_WriteClusterEvents");
2415                 ndr->depth++;
2416                 ndr->depth--;
2417         }
2418         if (flags & NDR_OUT) {
2419                 ndr_print_struct(ndr, "out", "eventlog_WriteClusterEvents");
2420                 ndr->depth++;
2421                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
2422                 ndr->depth--;
2423         }
2424         ndr->depth--;
2425 }
2426
2427 static enum ndr_err_code ndr_push_eventlog_GetLogInformation(struct ndr_push *ndr, int flags, const struct eventlog_GetLogInformation *r)
2428 {
2429         if (flags & NDR_IN) {
2430                 if (r->in.handle == NULL) {
2431                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2432                 }
2433                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2434                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
2435                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
2436         }
2437         if (flags & NDR_OUT) {
2438                 if (r->out.buffer == NULL) {
2439                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2440                 }
2441                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.buf_size));
2442                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.buf_size));
2443                 if (r->out.bytes_needed == NULL) {
2444                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2445                 }
2446                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.bytes_needed));
2447                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2448         }
2449         return NDR_ERR_SUCCESS;
2450 }
2451
2452 static enum ndr_err_code ndr_pull_eventlog_GetLogInformation(struct ndr_pull *ndr, int flags, struct eventlog_GetLogInformation *r)
2453 {
2454         TALLOC_CTX *_mem_save_handle_0;
2455         TALLOC_CTX *_mem_save_bytes_needed_0;
2456         if (flags & NDR_IN) {
2457                 ZERO_STRUCT(r->out);
2458
2459                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2460                         NDR_PULL_ALLOC(ndr, r->in.handle);
2461                 }
2462                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2463                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2464                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2465                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2466                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
2467                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
2468                 if (r->in.buf_size > 1024) {
2469                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2470                 }
2471                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.buf_size);
2472                 memset(r->out.buffer, 0, (r->in.buf_size) * sizeof(*r->out.buffer));
2473                 NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
2474                 ZERO_STRUCTP(r->out.bytes_needed);
2475         }
2476         if (flags & NDR_OUT) {
2477                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
2478                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2479                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
2480                 }
2481                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
2482                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2483                         NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
2484                 }
2485                 _mem_save_bytes_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
2486                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bytes_needed, LIBNDR_FLAG_REF_ALLOC);
2487                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.bytes_needed));
2488                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bytes_needed_0, LIBNDR_FLAG_REF_ALLOC);
2489                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2490                 if (r->out.buffer) {
2491                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.buf_size));
2492                 }
2493         }
2494         return NDR_ERR_SUCCESS;
2495 }
2496
2497 _PUBLIC_ void ndr_print_eventlog_GetLogInformation(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_GetLogInformation *r)
2498 {
2499         ndr_print_struct(ndr, name, "eventlog_GetLogInformation");
2500         ndr->depth++;
2501         if (flags & NDR_SET_VALUES) {
2502                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2503         }
2504         if (flags & NDR_IN) {
2505                 ndr_print_struct(ndr, "in", "eventlog_GetLogInformation");
2506                 ndr->depth++;
2507                 ndr_print_ptr(ndr, "handle", r->in.handle);
2508                 ndr->depth++;
2509                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
2510                 ndr->depth--;
2511                 ndr_print_uint32(ndr, "level", r->in.level);
2512                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
2513                 ndr->depth--;
2514         }
2515         if (flags & NDR_OUT) {
2516                 ndr_print_struct(ndr, "out", "eventlog_GetLogInformation");
2517                 ndr->depth++;
2518                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
2519                 ndr->depth++;
2520                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.buf_size);
2521                 ndr->depth--;
2522                 ndr_print_ptr(ndr, "bytes_needed", r->out.bytes_needed);
2523                 ndr->depth++;
2524                 ndr_print_uint32(ndr, "bytes_needed", *r->out.bytes_needed);
2525                 ndr->depth--;
2526                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
2527                 ndr->depth--;
2528         }
2529         ndr->depth--;
2530 }
2531
2532 static enum ndr_err_code ndr_push_eventlog_FlushEventLog(struct ndr_push *ndr, int flags, const struct eventlog_FlushEventLog *r)
2533 {
2534         if (flags & NDR_IN) {
2535                 if (r->in.handle == NULL) {
2536                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2537                 }
2538                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2539         }
2540         if (flags & NDR_OUT) {
2541                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2542         }
2543         return NDR_ERR_SUCCESS;
2544 }
2545
2546 static enum ndr_err_code ndr_pull_eventlog_FlushEventLog(struct ndr_pull *ndr, int flags, struct eventlog_FlushEventLog *r)
2547 {
2548         TALLOC_CTX *_mem_save_handle_0;
2549         if (flags & NDR_IN) {
2550                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2551                         NDR_PULL_ALLOC(ndr, r->in.handle);
2552                 }
2553                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2554                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2555                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2556                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2557         }
2558         if (flags & NDR_OUT) {
2559                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2560         }
2561         return NDR_ERR_SUCCESS;
2562 }
2563
2564 _PUBLIC_ void ndr_print_eventlog_FlushEventLog(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_FlushEventLog *r)
2565 {
2566         ndr_print_struct(ndr, name, "eventlog_FlushEventLog");
2567         ndr->depth++;
2568         if (flags & NDR_SET_VALUES) {
2569                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2570         }
2571         if (flags & NDR_IN) {
2572                 ndr_print_struct(ndr, "in", "eventlog_FlushEventLog");
2573                 ndr->depth++;
2574                 ndr_print_ptr(ndr, "handle", r->in.handle);
2575                 ndr->depth++;
2576                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
2577                 ndr->depth--;
2578                 ndr->depth--;
2579         }
2580         if (flags & NDR_OUT) {
2581                 ndr_print_struct(ndr, "out", "eventlog_FlushEventLog");
2582                 ndr->depth++;
2583                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
2584                 ndr->depth--;
2585         }
2586         ndr->depth--;
2587 }
2588
2589 static enum ndr_err_code ndr_push_eventlog_ReportEventAndSourceW(struct ndr_push *ndr, int flags, const struct eventlog_ReportEventAndSourceW *r)
2590 {
2591         uint32_t cntr_strings_1;
2592         if (flags & NDR_IN) {
2593                 if (r->in.handle == NULL) {
2594                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2595                 }
2596                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2597                 NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, r->in.timestamp));
2598                 NDR_CHECK(ndr_push_eventlogEventTypes(ndr, NDR_SCALARS, r->in.event_type));
2599                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.event_category));
2600                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.event_id));
2601                 if (r->in.sourcename == NULL) {
2602                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2603                 }
2604                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sourcename));
2605                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.num_of_strings));
2606                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
2607                 if (r->in.servername == NULL) {
2608                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2609                 }
2610                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.servername));
2611                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.user_sid));
2612                 if (r->in.user_sid) {
2613                         NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->in.user_sid));
2614                 }
2615                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.strings));
2616                 if (r->in.strings) {
2617                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.num_of_strings));
2618                         for (cntr_strings_1 = 0; cntr_strings_1 < r->in.num_of_strings; cntr_strings_1++) {
2619                         }
2620                         for (cntr_strings_1 = 0; cntr_strings_1 < r->in.num_of_strings; cntr_strings_1++) {
2621                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.strings[cntr_strings_1]));
2622                                 if (r->in.strings[cntr_strings_1]) {
2623                                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.strings[cntr_strings_1]));
2624                                 }
2625                         }
2626                 }
2627                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data));
2628                 if (r->in.data) {
2629                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_size));
2630                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.data, r->in.data_size));
2631                 }
2632                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.flags));
2633                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.record_number));
2634                 if (r->in.record_number) {
2635                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.record_number));
2636                 }
2637                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.time_written));
2638                 if (r->in.time_written) {
2639                         NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, *r->in.time_written));
2640                 }
2641         }
2642         if (flags & NDR_OUT) {
2643                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.record_number));
2644                 if (r->out.record_number) {
2645                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.record_number));
2646                 }
2647                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.time_written));
2648                 if (r->out.time_written) {
2649                         NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, *r->out.time_written));
2650                 }
2651                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2652         }
2653         return NDR_ERR_SUCCESS;
2654 }
2655
2656 static enum ndr_err_code ndr_pull_eventlog_ReportEventAndSourceW(struct ndr_pull *ndr, int flags, struct eventlog_ReportEventAndSourceW *r)
2657 {
2658         uint32_t _ptr_user_sid;
2659         uint32_t _ptr_strings;
2660         uint32_t cntr_strings_1;
2661         uint32_t _ptr_data;
2662         uint32_t _ptr_record_number;
2663         uint32_t _ptr_time_written;
2664         TALLOC_CTX *_mem_save_handle_0;
2665         TALLOC_CTX *_mem_save_sourcename_0;
2666         TALLOC_CTX *_mem_save_servername_0;
2667         TALLOC_CTX *_mem_save_user_sid_0;
2668         TALLOC_CTX *_mem_save_strings_0;
2669         TALLOC_CTX *_mem_save_strings_1;
2670         TALLOC_CTX *_mem_save_strings_2;
2671         TALLOC_CTX *_mem_save_data_0;
2672         TALLOC_CTX *_mem_save_record_number_0;
2673         TALLOC_CTX *_mem_save_time_written_0;
2674         if (flags & NDR_IN) {
2675                 ZERO_STRUCT(r->out);
2676
2677                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2678                         NDR_PULL_ALLOC(ndr, r->in.handle);
2679                 }
2680                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2681                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2682                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2683                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2684                 NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, &r->in.timestamp));
2685                 NDR_CHECK(ndr_pull_eventlogEventTypes(ndr, NDR_SCALARS, &r->in.event_type));
2686                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.event_category));
2687                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.event_id));
2688                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2689                         NDR_PULL_ALLOC(ndr, r->in.sourcename);
2690                 }
2691                 _mem_save_sourcename_0 = NDR_PULL_GET_MEM_CTX(ndr);
2692                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sourcename, LIBNDR_FLAG_REF_ALLOC);
2693                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sourcename));
2694                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sourcename_0, LIBNDR_FLAG_REF_ALLOC);
2695                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.num_of_strings));
2696                 if (r->in.num_of_strings > 256) {
2697                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2698                 }
2699                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
2700                 if (r->in.data_size > 0x3FFFF) {
2701                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2702                 }
2703                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2704                         NDR_PULL_ALLOC(ndr, r->in.servername);
2705                 }
2706                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2707                 NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, LIBNDR_FLAG_REF_ALLOC);
2708                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.servername));
2709                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, LIBNDR_FLAG_REF_ALLOC);
2710                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_sid));
2711                 if (_ptr_user_sid) {
2712                         NDR_PULL_ALLOC(ndr, r->in.user_sid);
2713                 } else {
2714                         r->in.user_sid = NULL;
2715                 }
2716                 if (r->in.user_sid) {
2717                         _mem_save_user_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2718                         NDR_PULL_SET_MEM_CTX(ndr, r->in.user_sid, 0);
2719                         NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->in.user_sid));
2720                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_sid_0, 0);
2721                 }
2722                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_strings));
2723                 if (_ptr_strings) {
2724                         NDR_PULL_ALLOC(ndr, r->in.strings);
2725                 } else {
2726                         r->in.strings = NULL;
2727                 }
2728                 if (r->in.strings) {
2729                         _mem_save_strings_0 = NDR_PULL_GET_MEM_CTX(ndr);
2730                         NDR_PULL_SET_MEM_CTX(ndr, r->in.strings, 0);
2731                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.strings));
2732                         NDR_PULL_ALLOC_N(ndr, r->in.strings, ndr_get_array_size(ndr, &r->in.strings));
2733                         _mem_save_strings_1 = NDR_PULL_GET_MEM_CTX(ndr);
2734                         NDR_PULL_SET_MEM_CTX(ndr, r->in.strings, 0);
2735                         for (cntr_strings_1 = 0; cntr_strings_1 < r->in.num_of_strings; cntr_strings_1++) {
2736                         }
2737                         for (cntr_strings_1 = 0; cntr_strings_1 < r->in.num_of_strings; cntr_strings_1++) {
2738                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_strings));
2739                                 if (_ptr_strings) {
2740                                         NDR_PULL_ALLOC(ndr, r->in.strings[cntr_strings_1]);
2741                                 } else {
2742                                         r->in.strings[cntr_strings_1] = NULL;
2743                                 }
2744                                 if (r->in.strings[cntr_strings_1]) {
2745                                         _mem_save_strings_2 = NDR_PULL_GET_MEM_CTX(ndr);
2746                                         NDR_PULL_SET_MEM_CTX(ndr, r->in.strings[cntr_strings_1], 0);
2747                                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.strings[cntr_strings_1]));
2748                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_strings_2, 0);
2749                                 }
2750                         }
2751                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_strings_1, 0);
2752                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_strings_0, 0);
2753                 }
2754                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
2755                 if (_ptr_data) {
2756                         NDR_PULL_ALLOC(ndr, r->in.data);
2757                 } else {
2758                         r->in.data = NULL;
2759                 }
2760                 if (r->in.data) {
2761                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
2762                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data, 0);
2763                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data));
2764                         NDR_PULL_ALLOC_N(ndr, r->in.data, ndr_get_array_size(ndr, &r->in.data));
2765                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.data, ndr_get_array_size(ndr, &r->in.data)));
2766                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
2767                 }
2768                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.flags));
2769                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_record_number));
2770                 if (_ptr_record_number) {
2771                         NDR_PULL_ALLOC(ndr, r->in.record_number);
2772                 } else {
2773                         r->in.record_number = NULL;
2774                 }
2775                 if (r->in.record_number) {
2776                         _mem_save_record_number_0 = NDR_PULL_GET_MEM_CTX(ndr);
2777                         NDR_PULL_SET_MEM_CTX(ndr, r->in.record_number, 0);
2778                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.record_number));
2779                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_record_number_0, 0);
2780                 }
2781                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time_written));
2782                 if (_ptr_time_written) {
2783                         NDR_PULL_ALLOC(ndr, r->in.time_written);
2784                 } else {
2785                         r->in.time_written = NULL;
2786                 }
2787                 if (r->in.time_written) {
2788                         _mem_save_time_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
2789                         NDR_PULL_SET_MEM_CTX(ndr, r->in.time_written, 0);
2790                         NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, r->in.time_written));
2791                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_written_0, 0);
2792                 }
2793                 if (r->in.strings) {
2794                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.strings, r->in.num_of_strings));
2795                 }
2796                 if (r->in.data) {
2797                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.data, r->in.data_size));
2798                 }
2799         }
2800         if (flags & NDR_OUT) {
2801                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_record_number));
2802                 if (_ptr_record_number) {
2803                         NDR_PULL_ALLOC(ndr, r->out.record_number);
2804                 } else {
2805                         r->out.record_number = NULL;
2806                 }
2807                 if (r->out.record_number) {
2808                         _mem_save_record_number_0 = NDR_PULL_GET_MEM_CTX(ndr);
2809                         NDR_PULL_SET_MEM_CTX(ndr, r->out.record_number, 0);
2810                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.record_number));
2811                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_record_number_0, 0);
2812                 }
2813                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time_written));
2814                 if (_ptr_time_written) {
2815                         NDR_PULL_ALLOC(ndr, r->out.time_written);
2816                 } else {
2817                         r->out.time_written = NULL;
2818                 }
2819                 if (r->out.time_written) {
2820                         _mem_save_time_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
2821                         NDR_PULL_SET_MEM_CTX(ndr, r->out.time_written, 0);
2822                         NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, r->out.time_written));
2823                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_written_0, 0);
2824                 }
2825                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2826         }
2827         return NDR_ERR_SUCCESS;
2828 }
2829
2830 _PUBLIC_ void ndr_print_eventlog_ReportEventAndSourceW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ReportEventAndSourceW *r)
2831 {
2832         uint32_t cntr_strings_1;
2833         ndr_print_struct(ndr, name, "eventlog_ReportEventAndSourceW");
2834         ndr->depth++;
2835         if (flags & NDR_SET_VALUES) {
2836                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2837         }
2838         if (flags & NDR_IN) {
2839                 ndr_print_struct(ndr, "in", "eventlog_ReportEventAndSourceW");
2840                 ndr->depth++;
2841                 ndr_print_ptr(ndr, "handle", r->in.handle);
2842                 ndr->depth++;
2843                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
2844                 ndr->depth--;
2845                 ndr_print_time_t(ndr, "timestamp", r->in.timestamp);
2846                 ndr_print_eventlogEventTypes(ndr, "event_type", r->in.event_type);
2847                 ndr_print_uint16(ndr, "event_category", r->in.event_category);
2848                 ndr_print_uint32(ndr, "event_id", r->in.event_id);
2849                 ndr_print_ptr(ndr, "sourcename", r->in.sourcename);
2850                 ndr->depth++;
2851                 ndr_print_lsa_String(ndr, "sourcename", r->in.sourcename);
2852                 ndr->depth--;
2853                 ndr_print_uint16(ndr, "num_of_strings", r->in.num_of_strings);
2854                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
2855                 ndr_print_ptr(ndr, "servername", r->in.servername);
2856                 ndr->depth++;
2857                 ndr_print_lsa_String(ndr, "servername", r->in.servername);
2858                 ndr->depth--;
2859                 ndr_print_ptr(ndr, "user_sid", r->in.user_sid);
2860                 ndr->depth++;
2861                 if (r->in.user_sid) {
2862                         ndr_print_dom_sid(ndr, "user_sid", r->in.user_sid);
2863                 }
2864                 ndr->depth--;
2865                 ndr_print_ptr(ndr, "strings", r->in.strings);
2866                 ndr->depth++;
2867                 if (r->in.strings) {
2868                         ndr->print(ndr, "%s: ARRAY(%d)", "strings", (int)r->in.num_of_strings);
2869                         ndr->depth++;
2870                         for (cntr_strings_1=0;cntr_strings_1<r->in.num_of_strings;cntr_strings_1++) {
2871                                 char *idx_1=NULL;
2872                                 if (asprintf(&idx_1, "[%d]", cntr_strings_1) != -1) {
2873                                         ndr_print_ptr(ndr, "strings", r->in.strings[cntr_strings_1]);
2874                                         ndr->depth++;
2875                                         if (r->in.strings[cntr_strings_1]) {
2876                                                 ndr_print_lsa_String(ndr, "strings", r->in.strings[cntr_strings_1]);
2877                                         }
2878                                         ndr->depth--;
2879                                         free(idx_1);
2880                                 }
2881                         }
2882                         ndr->depth--;
2883                 }
2884                 ndr->depth--;
2885                 ndr_print_ptr(ndr, "data", r->in.data);
2886                 ndr->depth++;
2887                 if (r->in.data) {
2888                         ndr_print_array_uint8(ndr, "data", r->in.data, r->in.data_size);
2889                 }
2890                 ndr->depth--;
2891                 ndr_print_uint16(ndr, "flags", r->in.flags);
2892                 ndr_print_ptr(ndr, "record_number", r->in.record_number);
2893                 ndr->depth++;
2894                 if (r->in.record_number) {
2895                         ndr_print_uint32(ndr, "record_number", *r->in.record_number);
2896                 }
2897                 ndr->depth--;
2898                 ndr_print_ptr(ndr, "time_written", r->in.time_written);
2899                 ndr->depth++;
2900                 if (r->in.time_written) {
2901                         ndr_print_time_t(ndr, "time_written", *r->in.time_written);
2902                 }
2903                 ndr->depth--;
2904                 ndr->depth--;
2905         }
2906         if (flags & NDR_OUT) {
2907                 ndr_print_struct(ndr, "out", "eventlog_ReportEventAndSourceW");
2908                 ndr->depth++;
2909                 ndr_print_ptr(ndr, "record_number", r->out.record_number);
2910                 ndr->depth++;
2911                 if (r->out.record_number) {
2912                         ndr_print_uint32(ndr, "record_number", *r->out.record_number);
2913                 }
2914                 ndr->depth--;
2915                 ndr_print_ptr(ndr, "time_written", r->out.time_written);
2916                 ndr->depth++;
2917                 if (r->out.time_written) {
2918                         ndr_print_time_t(ndr, "time_written", *r->out.time_written);
2919                 }
2920                 ndr->depth--;
2921                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
2922                 ndr->depth--;
2923         }
2924         ndr->depth--;
2925 }
2926
2927 static const struct ndr_interface_call eventlog_calls[] = {
2928         {
2929                 "eventlog_ClearEventLogW",
2930                 sizeof(struct eventlog_ClearEventLogW),
2931                 (ndr_push_flags_fn_t) ndr_push_eventlog_ClearEventLogW,
2932                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_ClearEventLogW,
2933                 (ndr_print_function_t) ndr_print_eventlog_ClearEventLogW,
2934                 false,
2935         },
2936         {
2937                 "eventlog_BackupEventLogW",
2938                 sizeof(struct eventlog_BackupEventLogW),
2939                 (ndr_push_flags_fn_t) ndr_push_eventlog_BackupEventLogW,
2940                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_BackupEventLogW,
2941                 (ndr_print_function_t) ndr_print_eventlog_BackupEventLogW,
2942                 false,
2943         },
2944         {
2945                 "eventlog_CloseEventLog",
2946                 sizeof(struct eventlog_CloseEventLog),
2947                 (ndr_push_flags_fn_t) ndr_push_eventlog_CloseEventLog,
2948                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_CloseEventLog,
2949                 (ndr_print_function_t) ndr_print_eventlog_CloseEventLog,
2950                 false,
2951         },
2952         {
2953                 "eventlog_DeregisterEventSource",
2954                 sizeof(struct eventlog_DeregisterEventSource),
2955                 (ndr_push_flags_fn_t) ndr_push_eventlog_DeregisterEventSource,
2956                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_DeregisterEventSource,
2957                 (ndr_print_function_t) ndr_print_eventlog_DeregisterEventSource,
2958                 false,
2959         },
2960         {
2961                 "eventlog_GetNumRecords",
2962                 sizeof(struct eventlog_GetNumRecords),
2963                 (ndr_push_flags_fn_t) ndr_push_eventlog_GetNumRecords,
2964                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_GetNumRecords,
2965                 (ndr_print_function_t) ndr_print_eventlog_GetNumRecords,
2966                 false,
2967         },
2968         {
2969                 "eventlog_GetOldestRecord",
2970                 sizeof(struct eventlog_GetOldestRecord),
2971                 (ndr_push_flags_fn_t) ndr_push_eventlog_GetOldestRecord,
2972                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_GetOldestRecord,
2973                 (ndr_print_function_t) ndr_print_eventlog_GetOldestRecord,
2974                 false,
2975         },
2976         {
2977                 "eventlog_ChangeNotify",
2978                 sizeof(struct eventlog_ChangeNotify),
2979                 (ndr_push_flags_fn_t) ndr_push_eventlog_ChangeNotify,
2980                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_ChangeNotify,
2981                 (ndr_print_function_t) ndr_print_eventlog_ChangeNotify,
2982                 false,
2983         },
2984         {
2985                 "eventlog_OpenEventLogW",
2986                 sizeof(struct eventlog_OpenEventLogW),
2987                 (ndr_push_flags_fn_t) ndr_push_eventlog_OpenEventLogW,
2988                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_OpenEventLogW,
2989                 (ndr_print_function_t) ndr_print_eventlog_OpenEventLogW,
2990                 false,
2991         },
2992         {
2993                 "eventlog_RegisterEventSourceW",
2994                 sizeof(struct eventlog_RegisterEventSourceW),
2995                 (ndr_push_flags_fn_t) ndr_push_eventlog_RegisterEventSourceW,
2996                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_RegisterEventSourceW,
2997                 (ndr_print_function_t) ndr_print_eventlog_RegisterEventSourceW,
2998                 false,
2999         },
3000         {
3001                 "eventlog_OpenBackupEventLogW",
3002                 sizeof(struct eventlog_OpenBackupEventLogW),
3003                 (ndr_push_flags_fn_t) ndr_push_eventlog_OpenBackupEventLogW,
3004                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_OpenBackupEventLogW,
3005                 (ndr_print_function_t) ndr_print_eventlog_OpenBackupEventLogW,
3006                 false,
3007         },
3008         {
3009                 "eventlog_ReadEventLogW",
3010                 sizeof(struct eventlog_ReadEventLogW),
3011                 (ndr_push_flags_fn_t) ndr_push_eventlog_ReadEventLogW,
3012                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_ReadEventLogW,
3013                 (ndr_print_function_t) ndr_print_eventlog_ReadEventLogW,
3014                 false,
3015         },
3016         {
3017                 "eventlog_ReportEventW",
3018                 sizeof(struct eventlog_ReportEventW),
3019                 (ndr_push_flags_fn_t) ndr_push_eventlog_ReportEventW,
3020                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_ReportEventW,
3021                 (ndr_print_function_t) ndr_print_eventlog_ReportEventW,
3022                 false,
3023         },
3024         {
3025                 "eventlog_ClearEventLogA",
3026                 sizeof(struct eventlog_ClearEventLogA),
3027                 (ndr_push_flags_fn_t) ndr_push_eventlog_ClearEventLogA,
3028                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_ClearEventLogA,
3029                 (ndr_print_function_t) ndr_print_eventlog_ClearEventLogA,
3030                 false,
3031         },
3032         {
3033                 "eventlog_BackupEventLogA",
3034                 sizeof(struct eventlog_BackupEventLogA),
3035                 (ndr_push_flags_fn_t) ndr_push_eventlog_BackupEventLogA,
3036                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_BackupEventLogA,
3037                 (ndr_print_function_t) ndr_print_eventlog_BackupEventLogA,
3038                 false,
3039         },
3040         {
3041                 "eventlog_OpenEventLogA",
3042                 sizeof(struct eventlog_OpenEventLogA),
3043                 (ndr_push_flags_fn_t) ndr_push_eventlog_OpenEventLogA,
3044                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_OpenEventLogA,
3045                 (ndr_print_function_t) ndr_print_eventlog_OpenEventLogA,
3046                 false,
3047         },
3048         {
3049                 "eventlog_RegisterEventSourceA",
3050                 sizeof(struct eventlog_RegisterEventSourceA),
3051                 (ndr_push_flags_fn_t) ndr_push_eventlog_RegisterEventSourceA,
3052                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_RegisterEventSourceA,
3053                 (ndr_print_function_t) ndr_print_eventlog_RegisterEventSourceA,
3054                 false,
3055         },
3056         {
3057                 "eventlog_OpenBackupEventLogA",
3058                 sizeof(struct eventlog_OpenBackupEventLogA),
3059                 (ndr_push_flags_fn_t) ndr_push_eventlog_OpenBackupEventLogA,
3060                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_OpenBackupEventLogA,
3061                 (ndr_print_function_t) ndr_print_eventlog_OpenBackupEventLogA,
3062                 false,
3063         },
3064         {
3065                 "eventlog_ReadEventLogA",
3066                 sizeof(struct eventlog_ReadEventLogA),
3067                 (ndr_push_flags_fn_t) ndr_push_eventlog_ReadEventLogA,
3068                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_ReadEventLogA,
3069                 (ndr_print_function_t) ndr_print_eventlog_ReadEventLogA,
3070                 false,
3071         },
3072         {
3073                 "eventlog_ReportEventA",
3074                 sizeof(struct eventlog_ReportEventA),
3075                 (ndr_push_flags_fn_t) ndr_push_eventlog_ReportEventA,
3076                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_ReportEventA,
3077                 (ndr_print_function_t) ndr_print_eventlog_ReportEventA,
3078                 false,
3079         },
3080         {
3081                 "eventlog_RegisterClusterSvc",
3082                 sizeof(struct eventlog_RegisterClusterSvc),
3083                 (ndr_push_flags_fn_t) ndr_push_eventlog_RegisterClusterSvc,
3084                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_RegisterClusterSvc,
3085                 (ndr_print_function_t) ndr_print_eventlog_RegisterClusterSvc,
3086                 false,
3087         },
3088         {
3089                 "eventlog_DeregisterClusterSvc",
3090                 sizeof(struct eventlog_DeregisterClusterSvc),
3091                 (ndr_push_flags_fn_t) ndr_push_eventlog_DeregisterClusterSvc,
3092                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_DeregisterClusterSvc,
3093                 (ndr_print_function_t) ndr_print_eventlog_DeregisterClusterSvc,
3094                 false,
3095         },
3096         {
3097                 "eventlog_WriteClusterEvents",
3098                 sizeof(struct eventlog_WriteClusterEvents),
3099                 (ndr_push_flags_fn_t) ndr_push_eventlog_WriteClusterEvents,
3100                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_WriteClusterEvents,
3101                 (ndr_print_function_t) ndr_print_eventlog_WriteClusterEvents,
3102                 false,
3103         },
3104         {
3105                 "eventlog_GetLogInformation",
3106                 sizeof(struct eventlog_GetLogInformation),
3107                 (ndr_push_flags_fn_t) ndr_push_eventlog_GetLogInformation,
3108                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_GetLogInformation,
3109                 (ndr_print_function_t) ndr_print_eventlog_GetLogInformation,
3110                 false,
3111         },
3112         {
3113                 "eventlog_FlushEventLog",
3114                 sizeof(struct eventlog_FlushEventLog),
3115                 (ndr_push_flags_fn_t) ndr_push_eventlog_FlushEventLog,
3116                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_FlushEventLog,
3117                 (ndr_print_function_t) ndr_print_eventlog_FlushEventLog,
3118                 false,
3119         },
3120         {
3121                 "eventlog_ReportEventAndSourceW",
3122                 sizeof(struct eventlog_ReportEventAndSourceW),
3123                 (ndr_push_flags_fn_t) ndr_push_eventlog_ReportEventAndSourceW,
3124                 (ndr_pull_flags_fn_t) ndr_pull_eventlog_ReportEventAndSourceW,
3125                 (ndr_print_function_t) ndr_print_eventlog_ReportEventAndSourceW,
3126                 false,
3127         },
3128         { NULL, 0, NULL, NULL, NULL, false }
3129 };
3130
3131 static const char * const eventlog_endpoint_strings[] = {
3132         "ncacn_np:[\\pipe\\eventlog]",
3133 };
3134
3135 static const struct ndr_interface_string_array eventlog_endpoints = {
3136         .count  = 1,
3137         .names  = eventlog_endpoint_strings
3138 };
3139
3140 static const char * const eventlog_authservice_strings[] = {
3141         "host",
3142 };
3143
3144 static const struct ndr_interface_string_array eventlog_authservices = {
3145         .count  = 1,
3146         .names  = eventlog_authservice_strings
3147 };
3148
3149
3150 const struct ndr_interface_table ndr_table_eventlog = {
3151         .name           = "eventlog",
3152         .syntax_id      = {
3153                 {0x82273fdc,0xe32a,0x18c3,{0x3f,0x78},{0x82,0x79,0x29,0xdc,0x23,0xea}},
3154                 NDR_EVENTLOG_VERSION
3155         },
3156         .helpstring     = NDR_EVENTLOG_HELPSTRING,
3157         .num_calls      = 25,
3158         .calls          = eventlog_calls,
3159         .endpoints      = &eventlog_endpoints,
3160         .authservices   = &eventlog_authservices
3161 };
3162