LCOV - code coverage report
Current view: top level - bin/default/librpc/gen_ndr - ndr_eventlog.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 483 2269 21.3 %
Date: 2021-09-23 10:06:22 Functions: 22 112 19.6 %

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

Generated by: LCOV version 1.13