LCOV - code coverage report
Current view: top level - bin/default/librpc/gen_ndr - ndr_eventlog6.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 0 4254 0.0 %
Date: 2021-09-23 10:06:22 Functions: 0 120 0.0 %

          Line data    Source code
       1             : /* parser auto-generated by pidl */
       2             : 
       3             : #include "includes.h"
       4             : #include "bin/default/librpc/gen_ndr/ndr_eventlog6.h"
       5             : 
       6             : #include "librpc/gen_ndr/ndr_misc.h"
       7           0 : static enum ndr_err_code ndr_push_eventlog6_RpcInfo(struct ndr_push *ndr, int ndr_flags, const struct eventlog6_RpcInfo *r)
       8             : {
       9           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
      10           0 :         if (ndr_flags & NDR_SCALARS) {
      11           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
      12           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->error));
      13           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sub_err));
      14           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sub_err_param));
      15           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
      16             :         }
      17           0 :         if (ndr_flags & NDR_BUFFERS) {
      18             :         }
      19           0 :         return NDR_ERR_SUCCESS;
      20             : }
      21             : 
      22           0 : static enum ndr_err_code ndr_pull_eventlog6_RpcInfo(struct ndr_pull *ndr, int ndr_flags, struct eventlog6_RpcInfo *r)
      23             : {
      24           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
      25           0 :         if (ndr_flags & NDR_SCALARS) {
      26           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
      27           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->error));
      28           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sub_err));
      29           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sub_err_param));
      30           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
      31             :         }
      32           0 :         if (ndr_flags & NDR_BUFFERS) {
      33             :         }
      34           0 :         return NDR_ERR_SUCCESS;
      35             : }
      36             : 
      37           0 : _PUBLIC_ void ndr_print_eventlog6_RpcInfo(struct ndr_print *ndr, const char *name, const struct eventlog6_RpcInfo *r)
      38             : {
      39           0 :         ndr_print_struct(ndr, name, "eventlog6_RpcInfo");
      40           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
      41           0 :         ndr->depth++;
      42           0 :         ndr_print_uint32(ndr, "error", r->error);
      43           0 :         ndr_print_uint32(ndr, "sub_err", r->sub_err);
      44           0 :         ndr_print_uint32(ndr, "sub_err_param", r->sub_err_param);
      45           0 :         ndr->depth--;
      46             : }
      47             : 
      48           0 : static enum ndr_err_code ndr_push_eventlog6_boolean8Array(struct ndr_push *ndr, int ndr_flags, const struct eventlog6_boolean8Array *r)
      49             : {
      50           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
      51           0 :         if (ndr_flags & NDR_SCALARS) {
      52           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
      53           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
      54           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ptr));
      55           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
      56             :         }
      57           0 :         if (ndr_flags & NDR_BUFFERS) {
      58           0 :                 if (r->ptr) {
      59           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
      60           0 :                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->ptr, r->count));
      61             :                 }
      62             :         }
      63           0 :         return NDR_ERR_SUCCESS;
      64             : }
      65             : 
      66           0 : static enum ndr_err_code ndr_pull_eventlog6_boolean8Array(struct ndr_pull *ndr, int ndr_flags, struct eventlog6_boolean8Array *r)
      67             : {
      68             :         uint32_t _ptr_ptr;
      69           0 :         uint32_t size_ptr_1 = 0;
      70           0 :         TALLOC_CTX *_mem_save_ptr_0 = NULL;
      71           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
      72           0 :         if (ndr_flags & NDR_SCALARS) {
      73           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
      74           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
      75           0 :                 if (r->count > MAX_RPC_BOOLEAN8_ARRAY_COUNT) {
      76           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
      77             :                 }
      78           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ptr));
      79           0 :                 if (_ptr_ptr) {
      80           0 :                         NDR_PULL_ALLOC(ndr, r->ptr);
      81             :                 } else {
      82           0 :                         r->ptr = NULL;
      83             :                 }
      84           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
      85             :         }
      86           0 :         if (ndr_flags & NDR_BUFFERS) {
      87           0 :                 if (r->ptr) {
      88           0 :                         _mem_save_ptr_0 = NDR_PULL_GET_MEM_CTX(ndr);
      89           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->ptr, 0);
      90           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ptr));
      91           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->ptr, &size_ptr_1));
      92           0 :                         NDR_PULL_ALLOC_N(ndr, r->ptr, size_ptr_1);
      93           0 :                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->ptr, size_ptr_1));
      94           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ptr_0, 0);
      95             :                 }
      96           0 :                 if (r->ptr) {
      97           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->ptr, r->count));
      98             :                 }
      99             :         }
     100           0 :         return NDR_ERR_SUCCESS;
     101             : }
     102             : 
     103           0 : _PUBLIC_ void ndr_print_eventlog6_boolean8Array(struct ndr_print *ndr, const char *name, const struct eventlog6_boolean8Array *r)
     104             : {
     105           0 :         ndr_print_struct(ndr, name, "eventlog6_boolean8Array");
     106           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     107           0 :         ndr->depth++;
     108           0 :         ndr_print_uint32(ndr, "count", r->count);
     109           0 :         ndr_print_ptr(ndr, "ptr", r->ptr);
     110           0 :         ndr->depth++;
     111           0 :         if (r->ptr) {
     112           0 :                 ndr_print_array_uint8(ndr, "ptr", r->ptr, r->count);
     113             :         }
     114           0 :         ndr->depth--;
     115           0 :         ndr->depth--;
     116             : }
     117             : 
     118           0 : static enum ndr_err_code ndr_push_eventlog6_UInt32Array(struct ndr_push *ndr, int ndr_flags, const struct eventlog6_UInt32Array *r)
     119             : {
     120             :         uint32_t cntr_ptr_1;
     121           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     122           0 :         if (ndr_flags & NDR_SCALARS) {
     123           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
     124           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
     125           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ptr));
     126           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
     127             :         }
     128           0 :         if (ndr_flags & NDR_BUFFERS) {
     129           0 :                 if (r->ptr) {
     130           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
     131           0 :                         for (cntr_ptr_1 = 0; cntr_ptr_1 < (r->count); cntr_ptr_1++) {
     132           0 :                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ptr[cntr_ptr_1]));
     133             :                         }
     134             :                 }
     135             :         }
     136           0 :         return NDR_ERR_SUCCESS;
     137             : }
     138             : 
     139           0 : static enum ndr_err_code ndr_pull_eventlog6_UInt32Array(struct ndr_pull *ndr, int ndr_flags, struct eventlog6_UInt32Array *r)
     140             : {
     141             :         uint32_t _ptr_ptr;
     142           0 :         uint32_t size_ptr_1 = 0;
     143             :         uint32_t cntr_ptr_1;
     144           0 :         TALLOC_CTX *_mem_save_ptr_0 = NULL;
     145           0 :         TALLOC_CTX *_mem_save_ptr_1 = NULL;
     146           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     147           0 :         if (ndr_flags & NDR_SCALARS) {
     148           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
     149           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
     150           0 :                 if (r->count > MAX_RPC_UINT32_ARRAY_COUNT) {
     151           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
     152             :                 }
     153           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ptr));
     154           0 :                 if (_ptr_ptr) {
     155           0 :                         NDR_PULL_ALLOC(ndr, r->ptr);
     156             :                 } else {
     157           0 :                         r->ptr = NULL;
     158             :                 }
     159           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
     160             :         }
     161           0 :         if (ndr_flags & NDR_BUFFERS) {
     162           0 :                 if (r->ptr) {
     163           0 :                         _mem_save_ptr_0 = NDR_PULL_GET_MEM_CTX(ndr);
     164           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->ptr, 0);
     165           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ptr));
     166           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->ptr, &size_ptr_1));
     167           0 :                         NDR_PULL_ALLOC_N(ndr, r->ptr, size_ptr_1);
     168           0 :                         _mem_save_ptr_1 = NDR_PULL_GET_MEM_CTX(ndr);
     169           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->ptr, 0);
     170           0 :                         for (cntr_ptr_1 = 0; cntr_ptr_1 < (size_ptr_1); cntr_ptr_1++) {
     171           0 :                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ptr[cntr_ptr_1]));
     172             :                         }
     173           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ptr_1, 0);
     174           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ptr_0, 0);
     175             :                 }
     176           0 :                 if (r->ptr) {
     177           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->ptr, r->count));
     178             :                 }
     179             :         }
     180           0 :         return NDR_ERR_SUCCESS;
     181             : }
     182             : 
     183           0 : _PUBLIC_ void ndr_print_eventlog6_UInt32Array(struct ndr_print *ndr, const char *name, const struct eventlog6_UInt32Array *r)
     184             : {
     185             :         uint32_t cntr_ptr_1;
     186           0 :         ndr_print_struct(ndr, name, "eventlog6_UInt32Array");
     187           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     188           0 :         ndr->depth++;
     189           0 :         ndr_print_uint32(ndr, "count", r->count);
     190           0 :         ndr_print_ptr(ndr, "ptr", r->ptr);
     191           0 :         ndr->depth++;
     192           0 :         if (r->ptr) {
     193           0 :                 ndr->print(ndr, "%s: ARRAY(%d)", "ptr", (int)r->count);
     194           0 :                 ndr->depth++;
     195           0 :                 for (cntr_ptr_1 = 0; cntr_ptr_1 < (r->count); cntr_ptr_1++) {
     196           0 :                         ndr_print_uint32(ndr, "ptr", r->ptr[cntr_ptr_1]);
     197             :                 }
     198           0 :                 ndr->depth--;
     199             :         }
     200           0 :         ndr->depth--;
     201           0 :         ndr->depth--;
     202             : }
     203             : 
     204           0 : static enum ndr_err_code ndr_push_eventlog6_UInt64Array(struct ndr_push *ndr, int ndr_flags, const struct eventlog6_UInt64Array *r)
     205             : {
     206             :         uint32_t cntr_ptr_1;
     207           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     208           0 :         if (ndr_flags & NDR_SCALARS) {
     209           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
     210           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
     211           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ptr));
     212           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
     213             :         }
     214           0 :         if (ndr_flags & NDR_BUFFERS) {
     215           0 :                 if (r->ptr) {
     216           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
     217           0 :                         for (cntr_ptr_1 = 0; cntr_ptr_1 < (r->count); cntr_ptr_1++) {
     218           0 :                                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->ptr[cntr_ptr_1]));
     219             :                         }
     220             :                 }
     221             :         }
     222           0 :         return NDR_ERR_SUCCESS;
     223             : }
     224             : 
     225           0 : static enum ndr_err_code ndr_pull_eventlog6_UInt64Array(struct ndr_pull *ndr, int ndr_flags, struct eventlog6_UInt64Array *r)
     226             : {
     227             :         uint32_t _ptr_ptr;
     228           0 :         uint32_t size_ptr_1 = 0;
     229             :         uint32_t cntr_ptr_1;
     230           0 :         TALLOC_CTX *_mem_save_ptr_0 = NULL;
     231           0 :         TALLOC_CTX *_mem_save_ptr_1 = NULL;
     232           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     233           0 :         if (ndr_flags & NDR_SCALARS) {
     234           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
     235           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
     236           0 :                 if (r->count > MAX_RPC_UINT64_ARRAY_COUNT) {
     237           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
     238             :                 }
     239           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ptr));
     240           0 :                 if (_ptr_ptr) {
     241           0 :                         NDR_PULL_ALLOC(ndr, r->ptr);
     242             :                 } else {
     243           0 :                         r->ptr = NULL;
     244             :                 }
     245           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
     246             :         }
     247           0 :         if (ndr_flags & NDR_BUFFERS) {
     248           0 :                 if (r->ptr) {
     249           0 :                         _mem_save_ptr_0 = NDR_PULL_GET_MEM_CTX(ndr);
     250           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->ptr, 0);
     251           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ptr));
     252           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->ptr, &size_ptr_1));
     253           0 :                         NDR_PULL_ALLOC_N(ndr, r->ptr, size_ptr_1);
     254           0 :                         _mem_save_ptr_1 = NDR_PULL_GET_MEM_CTX(ndr);
     255           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->ptr, 0);
     256           0 :                         for (cntr_ptr_1 = 0; cntr_ptr_1 < (size_ptr_1); cntr_ptr_1++) {
     257           0 :                                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->ptr[cntr_ptr_1]));
     258             :                         }
     259           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ptr_1, 0);
     260           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ptr_0, 0);
     261             :                 }
     262           0 :                 if (r->ptr) {
     263           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->ptr, r->count));
     264             :                 }
     265             :         }
     266           0 :         return NDR_ERR_SUCCESS;
     267             : }
     268             : 
     269           0 : _PUBLIC_ void ndr_print_eventlog6_UInt64Array(struct ndr_print *ndr, const char *name, const struct eventlog6_UInt64Array *r)
     270             : {
     271             :         uint32_t cntr_ptr_1;
     272           0 :         ndr_print_struct(ndr, name, "eventlog6_UInt64Array");
     273           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     274           0 :         ndr->depth++;
     275           0 :         ndr_print_uint32(ndr, "count", r->count);
     276           0 :         ndr_print_ptr(ndr, "ptr", r->ptr);
     277           0 :         ndr->depth++;
     278           0 :         if (r->ptr) {
     279           0 :                 ndr->print(ndr, "%s: ARRAY(%d)", "ptr", (int)r->count);
     280           0 :                 ndr->depth++;
     281           0 :                 for (cntr_ptr_1 = 0; cntr_ptr_1 < (r->count); cntr_ptr_1++) {
     282           0 :                         ndr_print_hyper(ndr, "ptr", r->ptr[cntr_ptr_1]);
     283             :                 }
     284           0 :                 ndr->depth--;
     285             :         }
     286           0 :         ndr->depth--;
     287           0 :         ndr->depth--;
     288             : }
     289             : 
     290           0 : static enum ndr_err_code ndr_push_eventlog6_StringArray(struct ndr_push *ndr, int ndr_flags, const struct eventlog6_StringArray *r)
     291             : {
     292             :         uint32_t cntr_ptr_1;
     293           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     294           0 :         if (ndr_flags & NDR_SCALARS) {
     295           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
     296           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
     297           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ptr));
     298           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
     299             :         }
     300           0 :         if (ndr_flags & NDR_BUFFERS) {
     301           0 :                 if (r->ptr) {
     302           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
     303           0 :                         for (cntr_ptr_1 = 0; cntr_ptr_1 < (r->count); cntr_ptr_1++) {
     304           0 :                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ptr[cntr_ptr_1]));
     305             :                         }
     306           0 :                         for (cntr_ptr_1 = 0; cntr_ptr_1 < (r->count); cntr_ptr_1++) {
     307           0 :                                 if (r->ptr[cntr_ptr_1]) {
     308           0 :                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ptr[cntr_ptr_1], CH_UTF16)));
     309           0 :                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     310           0 :                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ptr[cntr_ptr_1], CH_UTF16)));
     311           0 :                                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ptr[cntr_ptr_1], ndr_charset_length(r->ptr[cntr_ptr_1], CH_UTF16), sizeof(uint16_t), CH_UTF16));
     312             :                                 }
     313             :                         }
     314             :                 }
     315             :         }
     316           0 :         return NDR_ERR_SUCCESS;
     317             : }
     318             : 
     319           0 : static enum ndr_err_code ndr_pull_eventlog6_StringArray(struct ndr_pull *ndr, int ndr_flags, struct eventlog6_StringArray *r)
     320             : {
     321             :         uint32_t _ptr_ptr;
     322           0 :         uint32_t size_ptr_1 = 0;
     323             :         uint32_t cntr_ptr_1;
     324           0 :         uint32_t size_ptr_3 = 0;
     325           0 :         uint32_t length_ptr_3 = 0;
     326           0 :         TALLOC_CTX *_mem_save_ptr_0 = NULL;
     327           0 :         TALLOC_CTX *_mem_save_ptr_1 = NULL;
     328           0 :         TALLOC_CTX *_mem_save_ptr_2 = NULL;
     329           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     330           0 :         if (ndr_flags & NDR_SCALARS) {
     331           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
     332           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
     333           0 :                 if (r->count > MAX_RPC_STRING_ARRAY_COUNT) {
     334           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
     335             :                 }
     336           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ptr));
     337           0 :                 if (_ptr_ptr) {
     338           0 :                         NDR_PULL_ALLOC(ndr, r->ptr);
     339             :                 } else {
     340           0 :                         r->ptr = NULL;
     341             :                 }
     342           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
     343             :         }
     344           0 :         if (ndr_flags & NDR_BUFFERS) {
     345           0 :                 if (r->ptr) {
     346           0 :                         _mem_save_ptr_0 = NDR_PULL_GET_MEM_CTX(ndr);
     347           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->ptr, 0);
     348           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ptr));
     349           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->ptr, &size_ptr_1));
     350           0 :                         NDR_PULL_ALLOC_N(ndr, r->ptr, size_ptr_1);
     351           0 :                         _mem_save_ptr_1 = NDR_PULL_GET_MEM_CTX(ndr);
     352           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->ptr, 0);
     353           0 :                         for (cntr_ptr_1 = 0; cntr_ptr_1 < (size_ptr_1); cntr_ptr_1++) {
     354           0 :                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ptr));
     355           0 :                                 if (_ptr_ptr) {
     356           0 :                                         NDR_PULL_ALLOC(ndr, r->ptr[cntr_ptr_1]);
     357             :                                 } else {
     358           0 :                                         r->ptr[cntr_ptr_1] = NULL;
     359             :                                 }
     360             :                         }
     361           0 :                         for (cntr_ptr_1 = 0; cntr_ptr_1 < (size_ptr_1); cntr_ptr_1++) {
     362           0 :                                 if (r->ptr[cntr_ptr_1]) {
     363           0 :                                         _mem_save_ptr_2 = NDR_PULL_GET_MEM_CTX(ndr);
     364           0 :                                         NDR_PULL_SET_MEM_CTX(ndr, r->ptr[cntr_ptr_1], 0);
     365           0 :                                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ptr[cntr_ptr_1]));
     366           0 :                                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ptr[cntr_ptr_1]));
     367           0 :                                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->ptr[cntr_ptr_1], &size_ptr_3));
     368           0 :                                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->ptr[cntr_ptr_1], &length_ptr_3));
     369           0 :                                         if (length_ptr_3 > size_ptr_3) {
     370           0 :                                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_ptr_3, length_ptr_3);
     371             :                                         }
     372           0 :                                         NDR_CHECK(ndr_check_string_terminator(ndr, length_ptr_3, sizeof(uint16_t)));
     373           0 :                                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ptr[cntr_ptr_1], length_ptr_3, sizeof(uint16_t), CH_UTF16));
     374           0 :                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ptr_2, 0);
     375             :                                 }
     376             :                         }
     377           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ptr_1, 0);
     378           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ptr_0, 0);
     379             :                 }
     380           0 :                 if (r->ptr) {
     381           0 :                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->ptr, r->count));
     382             :                 }
     383           0 :                 for (cntr_ptr_1 = 0; cntr_ptr_1 < (size_ptr_1); cntr_ptr_1++) {
     384             :                 }
     385             :         }
     386           0 :         return NDR_ERR_SUCCESS;
     387             : }
     388             : 
     389           0 : _PUBLIC_ void ndr_print_eventlog6_StringArray(struct ndr_print *ndr, const char *name, const struct eventlog6_StringArray *r)
     390             : {
     391             :         uint32_t cntr_ptr_1;
     392           0 :         ndr_print_struct(ndr, name, "eventlog6_StringArray");
     393           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     394           0 :         ndr->depth++;
     395           0 :         ndr_print_uint32(ndr, "count", r->count);
     396           0 :         ndr_print_ptr(ndr, "ptr", r->ptr);
     397           0 :         ndr->depth++;
     398           0 :         if (r->ptr) {
     399           0 :                 ndr->print(ndr, "%s: ARRAY(%d)", "ptr", (int)r->count);
     400           0 :                 ndr->depth++;
     401           0 :                 for (cntr_ptr_1 = 0; cntr_ptr_1 < (r->count); cntr_ptr_1++) {
     402           0 :                         ndr_print_ptr(ndr, "ptr", r->ptr[cntr_ptr_1]);
     403           0 :                         ndr->depth++;
     404           0 :                         if (r->ptr[cntr_ptr_1]) {
     405           0 :                                 ndr_print_string(ndr, "ptr", r->ptr[cntr_ptr_1]);
     406             :                         }
     407           0 :                         ndr->depth--;
     408             :                 }
     409           0 :                 ndr->depth--;
     410             :         }
     411           0 :         ndr->depth--;
     412           0 :         ndr->depth--;
     413             : }
     414             : 
     415           0 : static enum ndr_err_code ndr_push_eventlog6_GuidArray(struct ndr_push *ndr, int ndr_flags, const struct eventlog6_GuidArray *r)
     416             : {
     417             :         uint32_t cntr_ptr_1;
     418           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     419           0 :         if (ndr_flags & NDR_SCALARS) {
     420           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
     421           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
     422           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ptr));
     423           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
     424             :         }
     425           0 :         if (ndr_flags & NDR_BUFFERS) {
     426           0 :                 if (r->ptr) {
     427           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
     428           0 :                         for (cntr_ptr_1 = 0; cntr_ptr_1 < (r->count); cntr_ptr_1++) {
     429           0 :                                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ptr[cntr_ptr_1]));
     430             :                         }
     431             :                 }
     432             :         }
     433           0 :         return NDR_ERR_SUCCESS;
     434             : }
     435             : 
     436           0 : static enum ndr_err_code ndr_pull_eventlog6_GuidArray(struct ndr_pull *ndr, int ndr_flags, struct eventlog6_GuidArray *r)
     437             : {
     438             :         uint32_t _ptr_ptr;
     439           0 :         uint32_t size_ptr_1 = 0;
     440             :         uint32_t cntr_ptr_1;
     441           0 :         TALLOC_CTX *_mem_save_ptr_0 = NULL;
     442           0 :         TALLOC_CTX *_mem_save_ptr_1 = NULL;
     443           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     444           0 :         if (ndr_flags & NDR_SCALARS) {
     445           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
     446           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
     447           0 :                 if (r->count > MAX_RPC_GUID_ARRAY_COUNT) {
     448           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
     449             :                 }
     450           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ptr));
     451           0 :                 if (_ptr_ptr) {
     452           0 :                         NDR_PULL_ALLOC(ndr, r->ptr);
     453             :                 } else {
     454           0 :                         r->ptr = NULL;
     455             :                 }
     456           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
     457             :         }
     458           0 :         if (ndr_flags & NDR_BUFFERS) {
     459           0 :                 if (r->ptr) {
     460           0 :                         _mem_save_ptr_0 = NDR_PULL_GET_MEM_CTX(ndr);
     461           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->ptr, 0);
     462           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ptr));
     463           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->ptr, &size_ptr_1));
     464           0 :                         NDR_PULL_ALLOC_N(ndr, r->ptr, size_ptr_1);
     465           0 :                         _mem_save_ptr_1 = NDR_PULL_GET_MEM_CTX(ndr);
     466           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->ptr, 0);
     467           0 :                         for (cntr_ptr_1 = 0; cntr_ptr_1 < (size_ptr_1); cntr_ptr_1++) {
     468           0 :                                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ptr[cntr_ptr_1]));
     469             :                         }
     470           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ptr_1, 0);
     471           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ptr_0, 0);
     472             :                 }
     473           0 :                 if (r->ptr) {
     474           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->ptr, r->count));
     475             :                 }
     476             :         }
     477           0 :         return NDR_ERR_SUCCESS;
     478             : }
     479             : 
     480           0 : _PUBLIC_ void ndr_print_eventlog6_GuidArray(struct ndr_print *ndr, const char *name, const struct eventlog6_GuidArray *r)
     481             : {
     482             :         uint32_t cntr_ptr_1;
     483           0 :         ndr_print_struct(ndr, name, "eventlog6_GuidArray");
     484           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     485           0 :         ndr->depth++;
     486           0 :         ndr_print_uint32(ndr, "count", r->count);
     487           0 :         ndr_print_ptr(ndr, "ptr", r->ptr);
     488           0 :         ndr->depth++;
     489           0 :         if (r->ptr) {
     490           0 :                 ndr->print(ndr, "%s: ARRAY(%d)", "ptr", (int)r->count);
     491           0 :                 ndr->depth++;
     492           0 :                 for (cntr_ptr_1 = 0; cntr_ptr_1 < (r->count); cntr_ptr_1++) {
     493           0 :                         ndr_print_GUID(ndr, "ptr", &r->ptr[cntr_ptr_1]);
     494             :                 }
     495           0 :                 ndr->depth--;
     496             :         }
     497           0 :         ndr->depth--;
     498           0 :         ndr->depth--;
     499             : }
     500             : 
     501           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcVariantType(struct ndr_push *ndr, int ndr_flags, enum eventlog6_EvtRpcVariantType r)
     502             : {
     503           0 :         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
     504           0 :         return NDR_ERR_SUCCESS;
     505             : }
     506             : 
     507           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcVariantType(struct ndr_pull *ndr, int ndr_flags, enum eventlog6_EvtRpcVariantType *r)
     508             : {
     509             :         uint32_t v;
     510           0 :         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
     511           0 :         *r = v;
     512           0 :         return NDR_ERR_SUCCESS;
     513             : }
     514             : 
     515           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcVariantType(struct ndr_print *ndr, const char *name, enum eventlog6_EvtRpcVariantType r)
     516             : {
     517           0 :         const char *val = NULL;
     518             : 
     519           0 :         switch (r) {
     520           0 :                 case EvtRpcVarTypeNull: val = "EvtRpcVarTypeNull"; break;
     521           0 :                 case EvtRpcVarTypeboolean8: val = "EvtRpcVarTypeboolean8"; break;
     522           0 :                 case EvtRpcVarTypeUInt32: val = "EvtRpcVarTypeUInt32"; break;
     523           0 :                 case EvtRpcVarTypeUInt64: val = "EvtRpcVarTypeUInt64"; break;
     524           0 :                 case EvtRpcVarTypeString: val = "EvtRpcVarTypeString"; break;
     525           0 :                 case EvtRpcVarTypeGuid: val = "EvtRpcVarTypeGuid"; break;
     526           0 :                 case EvtRpcVarTypeboolean8Array: val = "EvtRpcVarTypeboolean8Array"; break;
     527           0 :                 case EvtRpcVarTypeUInt32Array: val = "EvtRpcVarTypeUInt32Array"; break;
     528           0 :                 case EvtRpcVarTypeUInt64Array: val = "EvtRpcVarTypeUInt64Array"; break;
     529           0 :                 case EvtRpcVarTypeStringArray: val = "EvtRpcVarTypeStringArray"; break;
     530           0 :                 case EvtRpcVarTypeGuidArray: val = "EvtRpcVarTypeGuidArray"; break;
     531             :         }
     532           0 :         ndr_print_enum(ndr, name, "ENUM", val, r);
     533           0 : }
     534             : 
     535           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcVariantUnion(struct ndr_push *ndr, int ndr_flags, const union eventlog6_EvtRpcVariantUnion *r)
     536             : {
     537             :         uint32_t level;
     538           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     539           0 :         if (ndr_flags & NDR_SCALARS) {
     540             :                 /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
     541           0 :                 NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
     542           0 :                 NDR_CHECK(ndr_push_union_align(ndr, 8));
     543           0 :                 NDR_CHECK(ndr_push_eventlog6_EvtRpcVariantType(ndr, NDR_SCALARS, level));
     544           0 :                 NDR_CHECK(ndr_push_union_align(ndr, 8));
     545           0 :                 switch (level) {
     546           0 :                         case EvtRpcVarTypeNull: {
     547           0 :                                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->nullVal));
     548           0 :                         break; }
     549             : 
     550           0 :                         case EvtRpcVarTypeboolean8: {
     551           0 :                                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->boolean8Val));
     552           0 :                         break; }
     553             : 
     554           0 :                         case EvtRpcVarTypeUInt32: {
     555           0 :                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->uint32Val));
     556           0 :                         break; }
     557             : 
     558           0 :                         case EvtRpcVarTypeUInt64: {
     559           0 :                                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->uint64Val));
     560           0 :                         break; }
     561             : 
     562           0 :                         case EvtRpcVarTypeString: {
     563           0 :                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->stringVal));
     564           0 :                         break; }
     565             : 
     566           0 :                         case EvtRpcVarTypeGuid: {
     567           0 :                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guidVal));
     568           0 :                         break; }
     569             : 
     570           0 :                         case EvtRpcVarTypeboolean8Array: {
     571           0 :                                 NDR_CHECK(ndr_push_eventlog6_boolean8Array(ndr, NDR_SCALARS, &r->boolean8Array));
     572           0 :                         break; }
     573             : 
     574           0 :                         case EvtRpcVarTypeUInt32Array: {
     575           0 :                                 NDR_CHECK(ndr_push_eventlog6_UInt32Array(ndr, NDR_SCALARS, &r->uint32Array));
     576           0 :                         break; }
     577             : 
     578           0 :                         case EvtRpcVarTypeUInt64Array: {
     579           0 :                                 NDR_CHECK(ndr_push_eventlog6_UInt64Array(ndr, NDR_SCALARS, &r->uint64Array));
     580           0 :                         break; }
     581             : 
     582           0 :                         case EvtRpcVarTypeStringArray: {
     583           0 :                                 NDR_CHECK(ndr_push_eventlog6_StringArray(ndr, NDR_SCALARS, &r->stringArray));
     584           0 :                         break; }
     585             : 
     586           0 :                         case EvtRpcVarTypeGuidArray: {
     587           0 :                                 NDR_CHECK(ndr_push_eventlog6_GuidArray(ndr, NDR_SCALARS, &r->guidArray));
     588           0 :                         break; }
     589             : 
     590           0 :                         default:
     591           0 :                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
     592             :                 }
     593           0 :         }
     594           0 :         if (ndr_flags & NDR_BUFFERS) {
     595           0 :                 if (!(ndr_flags & NDR_SCALARS)) {
     596             :                         /* We didn't get it above, and the token is not needed after this. */
     597           0 :                         NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
     598             :                 }
     599           0 :                 switch (level) {
     600           0 :                         case EvtRpcVarTypeNull:
     601           0 :                         break;
     602             : 
     603           0 :                         case EvtRpcVarTypeboolean8:
     604           0 :                         break;
     605             : 
     606           0 :                         case EvtRpcVarTypeUInt32:
     607           0 :                         break;
     608             : 
     609           0 :                         case EvtRpcVarTypeUInt64:
     610           0 :                         break;
     611             : 
     612           0 :                         case EvtRpcVarTypeString:
     613           0 :                                 if (r->stringVal) {
     614           0 :                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->stringVal, CH_UTF16)));
     615           0 :                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     616           0 :                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->stringVal, CH_UTF16)));
     617           0 :                                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->stringVal, ndr_charset_length(r->stringVal, CH_UTF16), sizeof(uint16_t), CH_UTF16));
     618             :                                 }
     619           0 :                         break;
     620             : 
     621           0 :                         case EvtRpcVarTypeGuid:
     622           0 :                                 if (r->guidVal) {
     623           0 :                                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->guidVal));
     624             :                                 }
     625           0 :                         break;
     626             : 
     627           0 :                         case EvtRpcVarTypeboolean8Array:
     628           0 :                                 NDR_CHECK(ndr_push_eventlog6_boolean8Array(ndr, NDR_BUFFERS, &r->boolean8Array));
     629           0 :                         break;
     630             : 
     631           0 :                         case EvtRpcVarTypeUInt32Array:
     632           0 :                                 NDR_CHECK(ndr_push_eventlog6_UInt32Array(ndr, NDR_BUFFERS, &r->uint32Array));
     633           0 :                         break;
     634             : 
     635           0 :                         case EvtRpcVarTypeUInt64Array:
     636           0 :                                 NDR_CHECK(ndr_push_eventlog6_UInt64Array(ndr, NDR_BUFFERS, &r->uint64Array));
     637           0 :                         break;
     638             : 
     639           0 :                         case EvtRpcVarTypeStringArray:
     640           0 :                                 NDR_CHECK(ndr_push_eventlog6_StringArray(ndr, NDR_BUFFERS, &r->stringArray));
     641           0 :                         break;
     642             : 
     643           0 :                         case EvtRpcVarTypeGuidArray:
     644           0 :                                 NDR_CHECK(ndr_push_eventlog6_GuidArray(ndr, NDR_BUFFERS, &r->guidArray));
     645           0 :                         break;
     646             : 
     647           0 :                         default:
     648           0 :                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
     649             :                 }
     650           0 :         }
     651           0 :         return NDR_ERR_SUCCESS;
     652             : }
     653             : 
     654           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcVariantUnion(struct ndr_pull *ndr, int ndr_flags, union eventlog6_EvtRpcVariantUnion *r)
     655             : {
     656             :         uint32_t level;
     657             :         uint32_t _level;
     658           0 :         TALLOC_CTX *_mem_save_stringVal_0 = NULL;
     659             :         uint32_t _ptr_stringVal;
     660           0 :         uint32_t size_stringVal_1 = 0;
     661           0 :         uint32_t length_stringVal_1 = 0;
     662           0 :         TALLOC_CTX *_mem_save_guidVal_0 = NULL;
     663             :         uint32_t _ptr_guidVal;
     664           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     665           0 :         if (ndr_flags & NDR_SCALARS) {
     666             :                 /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
     667           0 :                 NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
     668           0 :                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
     669           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
     670           0 :                 if (_level != level) {
     671           0 :                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
     672             :                 }
     673           0 :                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
     674           0 :                 switch (level) {
     675           0 :                         case EvtRpcVarTypeNull: {
     676           0 :                                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->nullVal));
     677           0 :                         break; }
     678             : 
     679           0 :                         case EvtRpcVarTypeboolean8: {
     680           0 :                                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->boolean8Val));
     681           0 :                         break; }
     682             : 
     683           0 :                         case EvtRpcVarTypeUInt32: {
     684           0 :                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->uint32Val));
     685           0 :                         break; }
     686             : 
     687           0 :                         case EvtRpcVarTypeUInt64: {
     688           0 :                                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->uint64Val));
     689           0 :                         break; }
     690             : 
     691           0 :                         case EvtRpcVarTypeString: {
     692           0 :                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_stringVal));
     693           0 :                                 if (_ptr_stringVal) {
     694           0 :                                         NDR_PULL_ALLOC(ndr, r->stringVal);
     695             :                                 } else {
     696           0 :                                         r->stringVal = NULL;
     697             :                                 }
     698           0 :                         break; }
     699             : 
     700           0 :                         case EvtRpcVarTypeGuid: {
     701           0 :                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guidVal));
     702           0 :                                 if (_ptr_guidVal) {
     703           0 :                                         NDR_PULL_ALLOC(ndr, r->guidVal);
     704             :                                 } else {
     705           0 :                                         r->guidVal = NULL;
     706             :                                 }
     707           0 :                         break; }
     708             : 
     709           0 :                         case EvtRpcVarTypeboolean8Array: {
     710           0 :                                 NDR_CHECK(ndr_pull_eventlog6_boolean8Array(ndr, NDR_SCALARS, &r->boolean8Array));
     711           0 :                         break; }
     712             : 
     713           0 :                         case EvtRpcVarTypeUInt32Array: {
     714           0 :                                 NDR_CHECK(ndr_pull_eventlog6_UInt32Array(ndr, NDR_SCALARS, &r->uint32Array));
     715           0 :                         break; }
     716             : 
     717           0 :                         case EvtRpcVarTypeUInt64Array: {
     718           0 :                                 NDR_CHECK(ndr_pull_eventlog6_UInt64Array(ndr, NDR_SCALARS, &r->uint64Array));
     719           0 :                         break; }
     720             : 
     721           0 :                         case EvtRpcVarTypeStringArray: {
     722           0 :                                 NDR_CHECK(ndr_pull_eventlog6_StringArray(ndr, NDR_SCALARS, &r->stringArray));
     723           0 :                         break; }
     724             : 
     725           0 :                         case EvtRpcVarTypeGuidArray: {
     726           0 :                                 NDR_CHECK(ndr_pull_eventlog6_GuidArray(ndr, NDR_SCALARS, &r->guidArray));
     727           0 :                         break; }
     728             : 
     729           0 :                         default:
     730           0 :                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
     731             :                 }
     732           0 :         }
     733           0 :         if (ndr_flags & NDR_BUFFERS) {
     734           0 :                 if (!(ndr_flags & NDR_SCALARS)) {
     735             :                         /* We didn't get it above, and the token is not needed after this. */
     736           0 :                         NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
     737             :                 }
     738           0 :                 switch (level) {
     739           0 :                         case EvtRpcVarTypeNull:
     740           0 :                         break;
     741             : 
     742           0 :                         case EvtRpcVarTypeboolean8:
     743           0 :                         break;
     744             : 
     745           0 :                         case EvtRpcVarTypeUInt32:
     746           0 :                         break;
     747             : 
     748           0 :                         case EvtRpcVarTypeUInt64:
     749           0 :                         break;
     750             : 
     751           0 :                         case EvtRpcVarTypeString:
     752           0 :                                 if (r->stringVal) {
     753           0 :                                         _mem_save_stringVal_0 = NDR_PULL_GET_MEM_CTX(ndr);
     754           0 :                                         NDR_PULL_SET_MEM_CTX(ndr, r->stringVal, 0);
     755           0 :                                         NDR_CHECK(ndr_pull_array_size(ndr, &r->stringVal));
     756           0 :                                         NDR_CHECK(ndr_pull_array_length(ndr, &r->stringVal));
     757           0 :                                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->stringVal, &size_stringVal_1));
     758           0 :                                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->stringVal, &length_stringVal_1));
     759           0 :                                         if (length_stringVal_1 > size_stringVal_1) {
     760           0 :                                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_stringVal_1, length_stringVal_1);
     761             :                                         }
     762           0 :                                         NDR_CHECK(ndr_check_string_terminator(ndr, length_stringVal_1, sizeof(uint16_t)));
     763           0 :                                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->stringVal, length_stringVal_1, sizeof(uint16_t), CH_UTF16));
     764           0 :                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_stringVal_0, 0);
     765             :                                 }
     766           0 :                         break;
     767             : 
     768           0 :                         case EvtRpcVarTypeGuid:
     769           0 :                                 if (r->guidVal) {
     770           0 :                                         _mem_save_guidVal_0 = NDR_PULL_GET_MEM_CTX(ndr);
     771           0 :                                         NDR_PULL_SET_MEM_CTX(ndr, r->guidVal, 0);
     772           0 :                                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->guidVal));
     773           0 :                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guidVal_0, 0);
     774             :                                 }
     775           0 :                         break;
     776             : 
     777           0 :                         case EvtRpcVarTypeboolean8Array:
     778           0 :                                 NDR_CHECK(ndr_pull_eventlog6_boolean8Array(ndr, NDR_BUFFERS, &r->boolean8Array));
     779           0 :                         break;
     780             : 
     781           0 :                         case EvtRpcVarTypeUInt32Array:
     782           0 :                                 NDR_CHECK(ndr_pull_eventlog6_UInt32Array(ndr, NDR_BUFFERS, &r->uint32Array));
     783           0 :                         break;
     784             : 
     785           0 :                         case EvtRpcVarTypeUInt64Array:
     786           0 :                                 NDR_CHECK(ndr_pull_eventlog6_UInt64Array(ndr, NDR_BUFFERS, &r->uint64Array));
     787           0 :                         break;
     788             : 
     789           0 :                         case EvtRpcVarTypeStringArray:
     790           0 :                                 NDR_CHECK(ndr_pull_eventlog6_StringArray(ndr, NDR_BUFFERS, &r->stringArray));
     791           0 :                         break;
     792             : 
     793           0 :                         case EvtRpcVarTypeGuidArray:
     794           0 :                                 NDR_CHECK(ndr_pull_eventlog6_GuidArray(ndr, NDR_BUFFERS, &r->guidArray));
     795           0 :                         break;
     796             : 
     797           0 :                         default:
     798           0 :                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
     799             :                 }
     800           0 :         }
     801           0 :         return NDR_ERR_SUCCESS;
     802             : }
     803             : 
     804           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcVariantUnion(struct ndr_print *ndr, const char *name, const union eventlog6_EvtRpcVariantUnion *r)
     805             : {
     806             :         uint32_t level;
     807           0 :         level = ndr_print_steal_switch_value(ndr, r);
     808           0 :         ndr_print_union(ndr, name, level, "eventlog6_EvtRpcVariantUnion");
     809           0 :         switch (level) {
     810           0 :                 case EvtRpcVarTypeNull:
     811           0 :                         ndr_print_int32(ndr, "nullVal", r->nullVal);
     812           0 :                 break;
     813             : 
     814           0 :                 case EvtRpcVarTypeboolean8:
     815           0 :                         ndr_print_uint8(ndr, "boolean8Val", r->boolean8Val);
     816           0 :                 break;
     817             : 
     818           0 :                 case EvtRpcVarTypeUInt32:
     819           0 :                         ndr_print_uint32(ndr, "uint32Val", r->uint32Val);
     820           0 :                 break;
     821             : 
     822           0 :                 case EvtRpcVarTypeUInt64:
     823           0 :                         ndr_print_hyper(ndr, "uint64Val", r->uint64Val);
     824           0 :                 break;
     825             : 
     826           0 :                 case EvtRpcVarTypeString:
     827           0 :                         ndr_print_ptr(ndr, "stringVal", r->stringVal);
     828           0 :                         ndr->depth++;
     829           0 :                         if (r->stringVal) {
     830           0 :                                 ndr_print_string(ndr, "stringVal", r->stringVal);
     831             :                         }
     832           0 :                         ndr->depth--;
     833           0 :                 break;
     834             : 
     835           0 :                 case EvtRpcVarTypeGuid:
     836           0 :                         ndr_print_ptr(ndr, "guidVal", r->guidVal);
     837           0 :                         ndr->depth++;
     838           0 :                         if (r->guidVal) {
     839           0 :                                 ndr_print_GUID(ndr, "guidVal", r->guidVal);
     840             :                         }
     841           0 :                         ndr->depth--;
     842           0 :                 break;
     843             : 
     844           0 :                 case EvtRpcVarTypeboolean8Array:
     845           0 :                         ndr_print_eventlog6_boolean8Array(ndr, "boolean8Array", &r->boolean8Array);
     846           0 :                 break;
     847             : 
     848           0 :                 case EvtRpcVarTypeUInt32Array:
     849           0 :                         ndr_print_eventlog6_UInt32Array(ndr, "uint32Array", &r->uint32Array);
     850           0 :                 break;
     851             : 
     852           0 :                 case EvtRpcVarTypeUInt64Array:
     853           0 :                         ndr_print_eventlog6_UInt64Array(ndr, "uint64Array", &r->uint64Array);
     854           0 :                 break;
     855             : 
     856           0 :                 case EvtRpcVarTypeStringArray:
     857           0 :                         ndr_print_eventlog6_StringArray(ndr, "stringArray", &r->stringArray);
     858           0 :                 break;
     859             : 
     860           0 :                 case EvtRpcVarTypeGuidArray:
     861           0 :                         ndr_print_eventlog6_GuidArray(ndr, "guidArray", &r->guidArray);
     862           0 :                 break;
     863             : 
     864           0 :                 default:
     865           0 :                         ndr_print_bad_level(ndr, name, level);
     866             :         }
     867           0 : }
     868             : 
     869           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcVariant(struct ndr_push *ndr, int ndr_flags, const struct eventlog6_EvtRpcVariant *r)
     870             : {
     871           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     872           0 :         if (ndr_flags & NDR_SCALARS) {
     873           0 :                 if (r->var == NULL) {
     874           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
     875             :                 }
     876           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
     877           0 :                 NDR_CHECK(ndr_push_eventlog6_EvtRpcVariantType(ndr, NDR_SCALARS, r->type));
     878           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
     879           0 :                 NDR_CHECK(ndr_push_ref_ptr(ndr)); /* r->var */
     880           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
     881             :         }
     882           0 :         if (ndr_flags & NDR_BUFFERS) {
     883           0 :                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->var, r->type));
     884           0 :                 NDR_CHECK(ndr_push_eventlog6_EvtRpcVariantUnion(ndr, NDR_SCALARS|NDR_BUFFERS, r->var));
     885             :         }
     886           0 :         return NDR_ERR_SUCCESS;
     887             : }
     888             : 
     889           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcVariant(struct ndr_pull *ndr, int ndr_flags, struct eventlog6_EvtRpcVariant *r)
     890             : {
     891             :         uint32_t _ptr_var;
     892           0 :         TALLOC_CTX *_mem_save_var_0 = NULL;
     893           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     894           0 :         if (ndr_flags & NDR_SCALARS) {
     895           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
     896           0 :                 NDR_CHECK(ndr_pull_eventlog6_EvtRpcVariantType(ndr, NDR_SCALARS, &r->type));
     897           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
     898           0 :                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_var));
     899           0 :                 if (_ptr_var) {
     900           0 :                         NDR_PULL_ALLOC(ndr, r->var);
     901             :                 } else {
     902           0 :                         r->var = NULL;
     903             :                 }
     904           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
     905             :         }
     906           0 :         if (ndr_flags & NDR_BUFFERS) {
     907           0 :                 _mem_save_var_0 = NDR_PULL_GET_MEM_CTX(ndr);
     908           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->var, 0);
     909           0 :                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->var, r->type));
     910           0 :                 NDR_CHECK(ndr_pull_eventlog6_EvtRpcVariantUnion(ndr, NDR_SCALARS|NDR_BUFFERS, r->var));
     911           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_var_0, 0);
     912             :         }
     913           0 :         return NDR_ERR_SUCCESS;
     914             : }
     915             : 
     916           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcVariant(struct ndr_print *ndr, const char *name, const struct eventlog6_EvtRpcVariant *r)
     917             : {
     918           0 :         ndr_print_struct(ndr, name, "eventlog6_EvtRpcVariant");
     919           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     920           0 :         ndr->depth++;
     921           0 :         ndr_print_eventlog6_EvtRpcVariantType(ndr, "type", r->type);
     922           0 :         ndr_print_uint32(ndr, "flags", r->flags);
     923           0 :         ndr_print_ptr(ndr, "var", r->var);
     924           0 :         ndr->depth++;
     925           0 :         ndr_print_set_switch_value(ndr, r->var, r->type);
     926           0 :         ndr_print_eventlog6_EvtRpcVariantUnion(ndr, "var", r->var);
     927           0 :         ndr->depth--;
     928           0 :         ndr->depth--;
     929             : }
     930             : 
     931           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcVariantList(struct ndr_push *ndr, int ndr_flags, const struct eventlog6_EvtRpcVariantList *r)
     932             : {
     933             :         uint32_t cntr_props_1;
     934           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     935           0 :         if (ndr_flags & NDR_SCALARS) {
     936           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
     937           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
     938           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->props));
     939           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
     940             :         }
     941           0 :         if (ndr_flags & NDR_BUFFERS) {
     942           0 :                 if (r->props) {
     943           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
     944           0 :                         for (cntr_props_1 = 0; cntr_props_1 < (r->count); cntr_props_1++) {
     945           0 :                                 NDR_CHECK(ndr_push_eventlog6_EvtRpcVariant(ndr, NDR_SCALARS, &r->props[cntr_props_1]));
     946             :                         }
     947           0 :                         for (cntr_props_1 = 0; cntr_props_1 < (r->count); cntr_props_1++) {
     948           0 :                                 NDR_CHECK(ndr_push_eventlog6_EvtRpcVariant(ndr, NDR_BUFFERS, &r->props[cntr_props_1]));
     949             :                         }
     950             :                 }
     951             :         }
     952           0 :         return NDR_ERR_SUCCESS;
     953             : }
     954             : 
     955           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcVariantList(struct ndr_pull *ndr, int ndr_flags, struct eventlog6_EvtRpcVariantList *r)
     956             : {
     957             :         uint32_t _ptr_props;
     958           0 :         uint32_t size_props_1 = 0;
     959             :         uint32_t cntr_props_1;
     960           0 :         TALLOC_CTX *_mem_save_props_0 = NULL;
     961           0 :         TALLOC_CTX *_mem_save_props_1 = NULL;
     962           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     963           0 :         if (ndr_flags & NDR_SCALARS) {
     964           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
     965           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
     966           0 :                 if (r->count > MAX_RPC_VARIANT_LIST_COUNT) {
     967           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
     968             :                 }
     969           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_props));
     970           0 :                 if (_ptr_props) {
     971           0 :                         NDR_PULL_ALLOC(ndr, r->props);
     972             :                 } else {
     973           0 :                         r->props = NULL;
     974             :                 }
     975           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
     976             :         }
     977           0 :         if (ndr_flags & NDR_BUFFERS) {
     978           0 :                 if (r->props) {
     979           0 :                         _mem_save_props_0 = NDR_PULL_GET_MEM_CTX(ndr);
     980           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->props, 0);
     981           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->props));
     982           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->props, &size_props_1));
     983           0 :                         NDR_PULL_ALLOC_N(ndr, r->props, size_props_1);
     984           0 :                         _mem_save_props_1 = NDR_PULL_GET_MEM_CTX(ndr);
     985           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->props, 0);
     986           0 :                         for (cntr_props_1 = 0; cntr_props_1 < (size_props_1); cntr_props_1++) {
     987           0 :                                 NDR_CHECK(ndr_pull_eventlog6_EvtRpcVariant(ndr, NDR_SCALARS, &r->props[cntr_props_1]));
     988             :                         }
     989           0 :                         for (cntr_props_1 = 0; cntr_props_1 < (size_props_1); cntr_props_1++) {
     990           0 :                                 NDR_CHECK(ndr_pull_eventlog6_EvtRpcVariant(ndr, NDR_BUFFERS, &r->props[cntr_props_1]));
     991             :                         }
     992           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_props_1, 0);
     993           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_props_0, 0);
     994             :                 }
     995           0 :                 if (r->props) {
     996           0 :                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->props, r->count));
     997             :                 }
     998           0 :                 for (cntr_props_1 = 0; cntr_props_1 < (size_props_1); cntr_props_1++) {
     999             :                 }
    1000             :         }
    1001           0 :         return NDR_ERR_SUCCESS;
    1002             : }
    1003             : 
    1004           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcVariantList(struct ndr_print *ndr, const char *name, const struct eventlog6_EvtRpcVariantList *r)
    1005             : {
    1006             :         uint32_t cntr_props_1;
    1007           0 :         ndr_print_struct(ndr, name, "eventlog6_EvtRpcVariantList");
    1008           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1009           0 :         ndr->depth++;
    1010           0 :         ndr_print_uint32(ndr, "count", r->count);
    1011           0 :         ndr_print_ptr(ndr, "props", r->props);
    1012           0 :         ndr->depth++;
    1013           0 :         if (r->props) {
    1014           0 :                 ndr->print(ndr, "%s: ARRAY(%d)", "props", (int)r->count);
    1015           0 :                 ndr->depth++;
    1016           0 :                 for (cntr_props_1 = 0; cntr_props_1 < (r->count); cntr_props_1++) {
    1017           0 :                         ndr_print_eventlog6_EvtRpcVariant(ndr, "props", &r->props[cntr_props_1]);
    1018             :                 }
    1019           0 :                 ndr->depth--;
    1020             :         }
    1021           0 :         ndr->depth--;
    1022           0 :         ndr->depth--;
    1023             : }
    1024             : 
    1025           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcQueryChannelInfo(struct ndr_push *ndr, int ndr_flags, const struct eventlog6_EvtRpcQueryChannelInfo *r)
    1026             : {
    1027           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1028           0 :         if (ndr_flags & NDR_SCALARS) {
    1029           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
    1030           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
    1031           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
    1032           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
    1033             :         }
    1034           0 :         if (ndr_flags & NDR_BUFFERS) {
    1035           0 :                 if (r->name) {
    1036           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
    1037           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    1038           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
    1039           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    1040             :                 }
    1041             :         }
    1042           0 :         return NDR_ERR_SUCCESS;
    1043             : }
    1044             : 
    1045           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcQueryChannelInfo(struct ndr_pull *ndr, int ndr_flags, struct eventlog6_EvtRpcQueryChannelInfo *r)
    1046             : {
    1047             :         uint32_t _ptr_name;
    1048           0 :         uint32_t size_name_1 = 0;
    1049           0 :         uint32_t length_name_1 = 0;
    1050           0 :         TALLOC_CTX *_mem_save_name_0 = NULL;
    1051           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1052           0 :         if (ndr_flags & NDR_SCALARS) {
    1053           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
    1054           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
    1055           0 :                 if (_ptr_name) {
    1056           0 :                         NDR_PULL_ALLOC(ndr, r->name);
    1057             :                 } else {
    1058           0 :                         r->name = NULL;
    1059             :                 }
    1060           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
    1061           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
    1062             :         }
    1063           0 :         if (ndr_flags & NDR_BUFFERS) {
    1064           0 :                 if (r->name) {
    1065           0 :                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1066           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
    1067           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
    1068           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
    1069           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->name, &size_name_1));
    1070           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->name, &length_name_1));
    1071           0 :                         if (length_name_1 > size_name_1) {
    1072           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_name_1, length_name_1);
    1073             :                         }
    1074           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_name_1, sizeof(uint16_t)));
    1075           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, length_name_1, sizeof(uint16_t), CH_UTF16));
    1076           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
    1077             :                 }
    1078             :         }
    1079           0 :         return NDR_ERR_SUCCESS;
    1080             : }
    1081             : 
    1082           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcQueryChannelInfo(struct ndr_print *ndr, const char *name, const struct eventlog6_EvtRpcQueryChannelInfo *r)
    1083             : {
    1084           0 :         ndr_print_struct(ndr, name, "eventlog6_EvtRpcQueryChannelInfo");
    1085           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1086           0 :         ndr->depth++;
    1087           0 :         ndr_print_ptr(ndr, "name", r->name);
    1088           0 :         ndr->depth++;
    1089           0 :         if (r->name) {
    1090           0 :                 ndr_print_string(ndr, "name", r->name);
    1091             :         }
    1092           0 :         ndr->depth--;
    1093           0 :         ndr_print_uint32(ndr, "status", r->status);
    1094           0 :         ndr->depth--;
    1095             : }
    1096             : 
    1097           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcRegisterRemoteSubscription(struct ndr_push *ndr, int flags, const struct eventlog6_EvtRpcRegisterRemoteSubscription *r)
    1098             : {
    1099             :         uint32_t cntr_queryChannelInfo_2;
    1100           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1101           0 :         if (flags & NDR_IN) {
    1102           0 :                 if (r->in.query == NULL) {
    1103           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    1104             :                 }
    1105           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.channelPath));
    1106           0 :                 if (r->in.channelPath) {
    1107           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.channelPath, CH_UTF16)));
    1108           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    1109           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.channelPath, CH_UTF16)));
    1110           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.channelPath, ndr_charset_length(r->in.channelPath, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    1111             :                 }
    1112           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.query, CH_UTF16)));
    1113           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    1114           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.query, CH_UTF16)));
    1115           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.query, ndr_charset_length(r->in.query, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    1116           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bookmarkXml));
    1117           0 :                 if (r->in.bookmarkXml) {
    1118           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.bookmarkXml, CH_UTF16)));
    1119           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    1120           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.bookmarkXml, CH_UTF16)));
    1121           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.bookmarkXml, ndr_charset_length(r->in.bookmarkXml, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    1122             :                 }
    1123           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
    1124             :         }
    1125           0 :         if (flags & NDR_OUT) {
    1126           0 :                 if (r->out.handle == NULL) {
    1127           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    1128             :                 }
    1129           0 :                 if (r->out.control == NULL) {
    1130           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    1131             :                 }
    1132           0 :                 if (r->out.queryChannelInfoSize == NULL) {
    1133           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    1134             :                 }
    1135           0 :                 if (r->out.queryChannelInfo == NULL) {
    1136           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    1137             :                 }
    1138           0 :                 if (r->out.error == NULL) {
    1139           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    1140             :                 }
    1141           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
    1142           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.control));
    1143           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.queryChannelInfoSize));
    1144           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.queryChannelInfo));
    1145           0 :                 if (*r->out.queryChannelInfo) {
    1146           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.queryChannelInfoSize));
    1147           0 :                         for (cntr_queryChannelInfo_2 = 0; cntr_queryChannelInfo_2 < (*r->out.queryChannelInfoSize); cntr_queryChannelInfo_2++) {
    1148           0 :                                 NDR_CHECK(ndr_push_eventlog6_EvtRpcQueryChannelInfo(ndr, NDR_SCALARS, &(*r->out.queryChannelInfo)[cntr_queryChannelInfo_2]));
    1149             :                         }
    1150           0 :                         for (cntr_queryChannelInfo_2 = 0; cntr_queryChannelInfo_2 < (*r->out.queryChannelInfoSize); cntr_queryChannelInfo_2++) {
    1151           0 :                                 NDR_CHECK(ndr_push_eventlog6_EvtRpcQueryChannelInfo(ndr, NDR_BUFFERS, &(*r->out.queryChannelInfo)[cntr_queryChannelInfo_2]));
    1152             :                         }
    1153             :                 }
    1154           0 :                 NDR_CHECK(ndr_push_eventlog6_RpcInfo(ndr, NDR_SCALARS, r->out.error));
    1155           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1156             :         }
    1157           0 :         return NDR_ERR_SUCCESS;
    1158             : }
    1159             : 
    1160           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcRegisterRemoteSubscription(struct ndr_pull *ndr, int flags, struct eventlog6_EvtRpcRegisterRemoteSubscription *r)
    1161             : {
    1162             :         uint32_t _ptr_channelPath;
    1163           0 :         uint32_t size_channelPath_1 = 0;
    1164           0 :         uint32_t length_channelPath_1 = 0;
    1165           0 :         uint32_t size_query_1 = 0;
    1166           0 :         uint32_t length_query_1 = 0;
    1167             :         uint32_t _ptr_bookmarkXml;
    1168           0 :         uint32_t size_bookmarkXml_1 = 0;
    1169           0 :         uint32_t length_bookmarkXml_1 = 0;
    1170             :         uint32_t _ptr_queryChannelInfo;
    1171           0 :         uint32_t size_queryChannelInfo_2 = 0;
    1172             :         uint32_t cntr_queryChannelInfo_2;
    1173           0 :         TALLOC_CTX *_mem_save_channelPath_0 = NULL;
    1174           0 :         TALLOC_CTX *_mem_save_bookmarkXml_0 = NULL;
    1175           0 :         TALLOC_CTX *_mem_save_handle_0 = NULL;
    1176           0 :         TALLOC_CTX *_mem_save_control_0 = NULL;
    1177           0 :         TALLOC_CTX *_mem_save_queryChannelInfoSize_0 = NULL;
    1178           0 :         TALLOC_CTX *_mem_save_queryChannelInfo_0 = NULL;
    1179           0 :         TALLOC_CTX *_mem_save_queryChannelInfo_1 = NULL;
    1180           0 :         TALLOC_CTX *_mem_save_queryChannelInfo_2 = NULL;
    1181           0 :         TALLOC_CTX *_mem_save_error_0 = NULL;
    1182           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1183           0 :         if (flags & NDR_IN) {
    1184           0 :                 NDR_ZERO_STRUCT(r->out);
    1185             : 
    1186           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_channelPath));
    1187           0 :                 if (_ptr_channelPath) {
    1188           0 :                         NDR_PULL_ALLOC(ndr, r->in.channelPath);
    1189             :                 } else {
    1190           0 :                         r->in.channelPath = NULL;
    1191             :                 }
    1192           0 :                 if (r->in.channelPath) {
    1193           0 :                         _mem_save_channelPath_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1194           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->in.channelPath, 0);
    1195           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.channelPath));
    1196           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.channelPath));
    1197           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.channelPath, &size_channelPath_1));
    1198           0 :                         if (size_channelPath_1 > MAX_RPC_CHANNEL_NAME_LENGTH) {
    1199           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    1200             :                         }
    1201           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.channelPath, &length_channelPath_1));
    1202           0 :                         if (length_channelPath_1 > MAX_RPC_CHANNEL_NAME_LENGTH) {
    1203           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    1204             :                         }
    1205           0 :                         if (length_channelPath_1 > size_channelPath_1) {
    1206           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_channelPath_1, length_channelPath_1);
    1207             :                         }
    1208           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_channelPath_1, sizeof(uint16_t)));
    1209           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.channelPath, length_channelPath_1, sizeof(uint16_t), CH_UTF16));
    1210           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_channelPath_0, 0);
    1211             :                 }
    1212           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.query));
    1213           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.query));
    1214           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.query, &size_query_1));
    1215           0 :                 if (size_query_1 < 1 || size_query_1 > MAX_RPC_QUERY_LENGTH) {
    1216           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    1217             :                 }
    1218           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.query, &length_query_1));
    1219           0 :                 if (length_query_1 < 1 || length_query_1 > MAX_RPC_QUERY_LENGTH) {
    1220           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    1221             :                 }
    1222           0 :                 if (length_query_1 > size_query_1) {
    1223           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_query_1, length_query_1);
    1224             :                 }
    1225           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_query_1, sizeof(uint16_t)));
    1226           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.query, length_query_1, sizeof(uint16_t), CH_UTF16));
    1227           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bookmarkXml));
    1228           0 :                 if (_ptr_bookmarkXml) {
    1229           0 :                         NDR_PULL_ALLOC(ndr, r->in.bookmarkXml);
    1230             :                 } else {
    1231           0 :                         r->in.bookmarkXml = NULL;
    1232             :                 }
    1233           0 :                 if (r->in.bookmarkXml) {
    1234           0 :                         _mem_save_bookmarkXml_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1235           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bookmarkXml, 0);
    1236           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.bookmarkXml));
    1237           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.bookmarkXml));
    1238           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.bookmarkXml, &size_bookmarkXml_1));
    1239           0 :                         if (size_bookmarkXml_1 > MAX_RPC_BOOKMARK_LENGTH) {
    1240           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    1241             :                         }
    1242           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.bookmarkXml, &length_bookmarkXml_1));
    1243           0 :                         if (length_bookmarkXml_1 > MAX_RPC_BOOKMARK_LENGTH) {
    1244           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    1245             :                         }
    1246           0 :                         if (length_bookmarkXml_1 > size_bookmarkXml_1) {
    1247           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_bookmarkXml_1, length_bookmarkXml_1);
    1248             :                         }
    1249           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_bookmarkXml_1, sizeof(uint16_t)));
    1250           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.bookmarkXml, length_bookmarkXml_1, sizeof(uint16_t), CH_UTF16));
    1251           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bookmarkXml_0, 0);
    1252             :                 }
    1253           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
    1254           0 :                 NDR_PULL_ALLOC(ndr, r->out.handle);
    1255           0 :                 NDR_ZERO_STRUCTP(r->out.handle);
    1256           0 :                 NDR_PULL_ALLOC(ndr, r->out.control);
    1257           0 :                 NDR_ZERO_STRUCTP(r->out.control);
    1258           0 :                 NDR_PULL_ALLOC(ndr, r->out.queryChannelInfoSize);
    1259           0 :                 NDR_ZERO_STRUCTP(r->out.queryChannelInfoSize);
    1260           0 :                 NDR_PULL_ALLOC(ndr, r->out.queryChannelInfo);
    1261           0 :                 NDR_ZERO_STRUCTP(r->out.queryChannelInfo);
    1262           0 :                 NDR_PULL_ALLOC(ndr, r->out.error);
    1263           0 :                 NDR_ZERO_STRUCTP(r->out.error);
    1264             :         }
    1265           0 :         if (flags & NDR_OUT) {
    1266             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1267             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1268           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1269           0 :                         NDR_PULL_ALLOC(ndr, r->out.handle);
    1270             :                 }
    1271           0 :                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1272           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
    1273           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
    1274           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
    1275           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1276           0 :                         NDR_PULL_ALLOC(ndr, r->out.control);
    1277             :                 }
    1278           0 :                 _mem_save_control_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1279           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.control, LIBNDR_FLAG_REF_ALLOC);
    1280           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.control));
    1281           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_control_0, LIBNDR_FLAG_REF_ALLOC);
    1282           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1283           0 :                         NDR_PULL_ALLOC(ndr, r->out.queryChannelInfoSize);
    1284             :                 }
    1285           0 :                 _mem_save_queryChannelInfoSize_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1286           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.queryChannelInfoSize, LIBNDR_FLAG_REF_ALLOC);
    1287           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.queryChannelInfoSize));
    1288           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_queryChannelInfoSize_0, LIBNDR_FLAG_REF_ALLOC);
    1289           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1290           0 :                         NDR_PULL_ALLOC(ndr, r->out.queryChannelInfo);
    1291             :                 }
    1292           0 :                 _mem_save_queryChannelInfo_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1293           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.queryChannelInfo, LIBNDR_FLAG_REF_ALLOC);
    1294           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_queryChannelInfo));
    1295           0 :                 if (_ptr_queryChannelInfo) {
    1296           0 :                         NDR_PULL_ALLOC(ndr, *r->out.queryChannelInfo);
    1297             :                 } else {
    1298           0 :                         *r->out.queryChannelInfo = NULL;
    1299             :                 }
    1300           0 :                 if (*r->out.queryChannelInfo) {
    1301           0 :                         _mem_save_queryChannelInfo_1 = NDR_PULL_GET_MEM_CTX(ndr);
    1302           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.queryChannelInfo, 0);
    1303           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.queryChannelInfo));
    1304           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)r->out.queryChannelInfo, &size_queryChannelInfo_2));
    1305           0 :                         if (size_queryChannelInfo_2 > MAX_RPC_QUERY_CHANNEL_SIZE) {
    1306           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    1307             :                         }
    1308           0 :                         NDR_PULL_ALLOC_N(ndr, *r->out.queryChannelInfo, size_queryChannelInfo_2);
    1309           0 :                         _mem_save_queryChannelInfo_2 = NDR_PULL_GET_MEM_CTX(ndr);
    1310           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.queryChannelInfo, 0);
    1311           0 :                         for (cntr_queryChannelInfo_2 = 0; cntr_queryChannelInfo_2 < (size_queryChannelInfo_2); cntr_queryChannelInfo_2++) {
    1312           0 :                                 NDR_CHECK(ndr_pull_eventlog6_EvtRpcQueryChannelInfo(ndr, NDR_SCALARS, &(*r->out.queryChannelInfo)[cntr_queryChannelInfo_2]));
    1313             :                         }
    1314           0 :                         for (cntr_queryChannelInfo_2 = 0; cntr_queryChannelInfo_2 < (size_queryChannelInfo_2); cntr_queryChannelInfo_2++) {
    1315           0 :                                 NDR_CHECK(ndr_pull_eventlog6_EvtRpcQueryChannelInfo(ndr, NDR_BUFFERS, &(*r->out.queryChannelInfo)[cntr_queryChannelInfo_2]));
    1316             :                         }
    1317           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_queryChannelInfo_2, 0);
    1318           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_queryChannelInfo_1, 0);
    1319             :                 }
    1320           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_queryChannelInfo_0, LIBNDR_FLAG_REF_ALLOC);
    1321           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1322           0 :                         NDR_PULL_ALLOC(ndr, r->out.error);
    1323             :                 }
    1324           0 :                 _mem_save_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1325           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.error, LIBNDR_FLAG_REF_ALLOC);
    1326           0 :                 NDR_CHECK(ndr_pull_eventlog6_RpcInfo(ndr, NDR_SCALARS, r->out.error));
    1327           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_error_0, LIBNDR_FLAG_REF_ALLOC);
    1328           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1329           0 :                 if (*r->out.queryChannelInfo) {
    1330           0 :                         NDR_CHECK(ndr_check_array_size(ndr, (void*)r->out.queryChannelInfo, *r->out.queryChannelInfoSize));
    1331             :                 }
    1332           0 :                 for (cntr_queryChannelInfo_2 = 0; cntr_queryChannelInfo_2 < (size_queryChannelInfo_2); cntr_queryChannelInfo_2++) {
    1333             :                 }
    1334             :         }
    1335           0 :         return NDR_ERR_SUCCESS;
    1336             : }
    1337             : 
    1338           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcRegisterRemoteSubscription(struct ndr_print *ndr, const char *name, int flags, const struct eventlog6_EvtRpcRegisterRemoteSubscription *r)
    1339             : {
    1340             :         uint32_t cntr_queryChannelInfo_2;
    1341           0 :         ndr_print_struct(ndr, name, "eventlog6_EvtRpcRegisterRemoteSubscription");
    1342           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1343           0 :         ndr->depth++;
    1344           0 :         if (flags & NDR_SET_VALUES) {
    1345           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1346             :         }
    1347           0 :         if (flags & NDR_IN) {
    1348           0 :                 ndr_print_struct(ndr, "in", "eventlog6_EvtRpcRegisterRemoteSubscription");
    1349           0 :                 ndr->depth++;
    1350           0 :                 ndr_print_ptr(ndr, "channelPath", r->in.channelPath);
    1351           0 :                 ndr->depth++;
    1352           0 :                 if (r->in.channelPath) {
    1353           0 :                         ndr_print_string(ndr, "channelPath", r->in.channelPath);
    1354             :                 }
    1355           0 :                 ndr->depth--;
    1356           0 :                 ndr_print_ptr(ndr, "query", r->in.query);
    1357           0 :                 ndr->depth++;
    1358           0 :                 ndr_print_string(ndr, "query", r->in.query);
    1359           0 :                 ndr->depth--;
    1360           0 :                 ndr_print_ptr(ndr, "bookmarkXml", r->in.bookmarkXml);
    1361           0 :                 ndr->depth++;
    1362           0 :                 if (r->in.bookmarkXml) {
    1363           0 :                         ndr_print_string(ndr, "bookmarkXml", r->in.bookmarkXml);
    1364             :                 }
    1365           0 :                 ndr->depth--;
    1366           0 :                 ndr_print_uint32(ndr, "flags", r->in.flags);
    1367           0 :                 ndr->depth--;
    1368             :         }
    1369           0 :         if (flags & NDR_OUT) {
    1370           0 :                 ndr_print_struct(ndr, "out", "eventlog6_EvtRpcRegisterRemoteSubscription");
    1371           0 :                 ndr->depth++;
    1372           0 :                 ndr_print_ptr(ndr, "handle", r->out.handle);
    1373           0 :                 ndr->depth++;
    1374           0 :                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
    1375           0 :                 ndr->depth--;
    1376           0 :                 ndr_print_ptr(ndr, "control", r->out.control);
    1377           0 :                 ndr->depth++;
    1378           0 :                 ndr_print_policy_handle(ndr, "control", r->out.control);
    1379           0 :                 ndr->depth--;
    1380           0 :                 ndr_print_ptr(ndr, "queryChannelInfoSize", r->out.queryChannelInfoSize);
    1381           0 :                 ndr->depth++;
    1382           0 :                 ndr_print_uint32(ndr, "queryChannelInfoSize", *r->out.queryChannelInfoSize);
    1383           0 :                 ndr->depth--;
    1384           0 :                 ndr_print_ptr(ndr, "queryChannelInfo", r->out.queryChannelInfo);
    1385           0 :                 ndr->depth++;
    1386           0 :                 ndr_print_ptr(ndr, "queryChannelInfo", *r->out.queryChannelInfo);
    1387           0 :                 ndr->depth++;
    1388           0 :                 if (*r->out.queryChannelInfo) {
    1389           0 :                         ndr->print(ndr, "%s: ARRAY(%d)", "queryChannelInfo", (int)*r->out.queryChannelInfoSize);
    1390           0 :                         ndr->depth++;
    1391           0 :                         for (cntr_queryChannelInfo_2 = 0; cntr_queryChannelInfo_2 < (*r->out.queryChannelInfoSize); cntr_queryChannelInfo_2++) {
    1392           0 :                                 ndr_print_eventlog6_EvtRpcQueryChannelInfo(ndr, "queryChannelInfo", &(*r->out.queryChannelInfo)[cntr_queryChannelInfo_2]);
    1393             :                         }
    1394           0 :                         ndr->depth--;
    1395             :                 }
    1396           0 :                 ndr->depth--;
    1397           0 :                 ndr->depth--;
    1398           0 :                 ndr_print_ptr(ndr, "error", r->out.error);
    1399           0 :                 ndr->depth++;
    1400           0 :                 ndr_print_eventlog6_RpcInfo(ndr, "error", r->out.error);
    1401           0 :                 ndr->depth--;
    1402           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1403           0 :                 ndr->depth--;
    1404             :         }
    1405           0 :         ndr->depth--;
    1406             : }
    1407             : 
    1408           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcRemoteSubscriptionNextAsync(struct ndr_push *ndr, int flags, const struct eventlog6_EvtRpcRemoteSubscriptionNextAsync *r)
    1409             : {
    1410             :         uint32_t cntr_eventDataIndices_2;
    1411             :         uint32_t cntr_eventDataSizes_2;
    1412           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1413           0 :         if (flags & NDR_IN) {
    1414           0 :                 if (r->in.handle == NULL) {
    1415           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    1416             :                 }
    1417           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
    1418           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numRequestedRecords));
    1419           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
    1420             :         }
    1421           0 :         if (flags & NDR_OUT) {
    1422           0 :                 if (r->out.numActualRecords == NULL) {
    1423           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    1424             :                 }
    1425           0 :                 if (r->out.eventDataIndices == NULL) {
    1426           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    1427             :                 }
    1428           0 :                 if (r->out.eventDataSizes == NULL) {
    1429           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    1430             :                 }
    1431           0 :                 if (r->out.resultBufferSize == NULL) {
    1432           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    1433             :                 }
    1434           0 :                 if (r->out.resultBuffer == NULL) {
    1435           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    1436             :                 }
    1437           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.numActualRecords));
    1438           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.eventDataIndices));
    1439           0 :                 if (*r->out.eventDataIndices) {
    1440           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.numActualRecords));
    1441           0 :                         for (cntr_eventDataIndices_2 = 0; cntr_eventDataIndices_2 < (*r->out.numActualRecords); cntr_eventDataIndices_2++) {
    1442           0 :                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (*r->out.eventDataIndices)[cntr_eventDataIndices_2]));
    1443             :                         }
    1444             :                 }
    1445           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.eventDataSizes));
    1446           0 :                 if (*r->out.eventDataSizes) {
    1447           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.numActualRecords));
    1448           0 :                         for (cntr_eventDataSizes_2 = 0; cntr_eventDataSizes_2 < (*r->out.numActualRecords); cntr_eventDataSizes_2++) {
    1449           0 :                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (*r->out.eventDataSizes)[cntr_eventDataSizes_2]));
    1450             :                         }
    1451             :                 }
    1452           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resultBufferSize));
    1453           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.resultBuffer));
    1454           0 :                 if (*r->out.resultBuffer) {
    1455           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.resultBufferSize));
    1456           0 :                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, *r->out.resultBuffer, *r->out.resultBufferSize));
    1457             :                 }
    1458           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1459             :         }
    1460           0 :         return NDR_ERR_SUCCESS;
    1461             : }
    1462             : 
    1463           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcRemoteSubscriptionNextAsync(struct ndr_pull *ndr, int flags, struct eventlog6_EvtRpcRemoteSubscriptionNextAsync *r)
    1464             : {
    1465             :         uint32_t _ptr_eventDataIndices;
    1466           0 :         uint32_t size_eventDataIndices_2 = 0;
    1467             :         uint32_t cntr_eventDataIndices_2;
    1468             :         uint32_t _ptr_eventDataSizes;
    1469           0 :         uint32_t size_eventDataSizes_2 = 0;
    1470             :         uint32_t cntr_eventDataSizes_2;
    1471             :         uint32_t _ptr_resultBuffer;
    1472           0 :         uint32_t size_resultBuffer_2 = 0;
    1473           0 :         TALLOC_CTX *_mem_save_handle_0 = NULL;
    1474           0 :         TALLOC_CTX *_mem_save_numActualRecords_0 = NULL;
    1475           0 :         TALLOC_CTX *_mem_save_eventDataIndices_0 = NULL;
    1476           0 :         TALLOC_CTX *_mem_save_eventDataIndices_1 = NULL;
    1477           0 :         TALLOC_CTX *_mem_save_eventDataIndices_2 = NULL;
    1478           0 :         TALLOC_CTX *_mem_save_eventDataSizes_0 = NULL;
    1479           0 :         TALLOC_CTX *_mem_save_eventDataSizes_1 = NULL;
    1480           0 :         TALLOC_CTX *_mem_save_eventDataSizes_2 = NULL;
    1481           0 :         TALLOC_CTX *_mem_save_resultBufferSize_0 = NULL;
    1482           0 :         TALLOC_CTX *_mem_save_resultBuffer_0 = NULL;
    1483           0 :         TALLOC_CTX *_mem_save_resultBuffer_1 = NULL;
    1484           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1485           0 :         if (flags & NDR_IN) {
    1486           0 :                 NDR_ZERO_STRUCT(r->out);
    1487             : 
    1488           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1489           0 :                         NDR_PULL_ALLOC(ndr, r->in.handle);
    1490             :                 }
    1491           0 :                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1492           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
    1493           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
    1494           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
    1495           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numRequestedRecords));
    1496           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
    1497           0 :                 NDR_PULL_ALLOC(ndr, r->out.numActualRecords);
    1498           0 :                 NDR_ZERO_STRUCTP(r->out.numActualRecords);
    1499           0 :                 NDR_PULL_ALLOC(ndr, r->out.eventDataIndices);
    1500           0 :                 NDR_ZERO_STRUCTP(r->out.eventDataIndices);
    1501           0 :                 NDR_PULL_ALLOC(ndr, r->out.eventDataSizes);
    1502           0 :                 NDR_ZERO_STRUCTP(r->out.eventDataSizes);
    1503           0 :                 NDR_PULL_ALLOC(ndr, r->out.resultBufferSize);
    1504           0 :                 NDR_ZERO_STRUCTP(r->out.resultBufferSize);
    1505           0 :                 NDR_PULL_ALLOC(ndr, r->out.resultBuffer);
    1506           0 :                 NDR_ZERO_STRUCTP(r->out.resultBuffer);
    1507             :         }
    1508           0 :         if (flags & NDR_OUT) {
    1509             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1510             :                 if (r->in.handle == NULL) {
    1511             :                         NDR_PULL_ALLOC(ndr, r->in.handle);
    1512             :                         NDR_ZERO_STRUCTP(r->in.handle);
    1513             :                 }
    1514             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1515           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1516           0 :                         NDR_PULL_ALLOC(ndr, r->out.numActualRecords);
    1517             :                 }
    1518           0 :                 _mem_save_numActualRecords_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1519           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.numActualRecords, LIBNDR_FLAG_REF_ALLOC);
    1520           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.numActualRecords));
    1521           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_numActualRecords_0, LIBNDR_FLAG_REF_ALLOC);
    1522           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1523           0 :                         NDR_PULL_ALLOC(ndr, r->out.eventDataIndices);
    1524             :                 }
    1525           0 :                 _mem_save_eventDataIndices_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1526           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.eventDataIndices, LIBNDR_FLAG_REF_ALLOC);
    1527           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_eventDataIndices));
    1528           0 :                 if (_ptr_eventDataIndices) {
    1529           0 :                         NDR_PULL_ALLOC(ndr, *r->out.eventDataIndices);
    1530             :                 } else {
    1531           0 :                         *r->out.eventDataIndices = NULL;
    1532             :                 }
    1533           0 :                 if (*r->out.eventDataIndices) {
    1534           0 :                         _mem_save_eventDataIndices_1 = NDR_PULL_GET_MEM_CTX(ndr);
    1535           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.eventDataIndices, 0);
    1536           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.eventDataIndices));
    1537           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)r->out.eventDataIndices, &size_eventDataIndices_2));
    1538           0 :                         if (size_eventDataIndices_2 > MAX_RPC_RECORD_COUNT) {
    1539           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    1540             :                         }
    1541           0 :                         NDR_PULL_ALLOC_N(ndr, *r->out.eventDataIndices, size_eventDataIndices_2);
    1542           0 :                         _mem_save_eventDataIndices_2 = NDR_PULL_GET_MEM_CTX(ndr);
    1543           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.eventDataIndices, 0);
    1544           0 :                         for (cntr_eventDataIndices_2 = 0; cntr_eventDataIndices_2 < (size_eventDataIndices_2); cntr_eventDataIndices_2++) {
    1545           0 :                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &(*r->out.eventDataIndices)[cntr_eventDataIndices_2]));
    1546             :                         }
    1547           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eventDataIndices_2, 0);
    1548           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eventDataIndices_1, 0);
    1549             :                 }
    1550           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eventDataIndices_0, LIBNDR_FLAG_REF_ALLOC);
    1551           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1552           0 :                         NDR_PULL_ALLOC(ndr, r->out.eventDataSizes);
    1553             :                 }
    1554           0 :                 _mem_save_eventDataSizes_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1555           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.eventDataSizes, LIBNDR_FLAG_REF_ALLOC);
    1556           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_eventDataSizes));
    1557           0 :                 if (_ptr_eventDataSizes) {
    1558           0 :                         NDR_PULL_ALLOC(ndr, *r->out.eventDataSizes);
    1559             :                 } else {
    1560           0 :                         *r->out.eventDataSizes = NULL;
    1561             :                 }
    1562           0 :                 if (*r->out.eventDataSizes) {
    1563           0 :                         _mem_save_eventDataSizes_1 = NDR_PULL_GET_MEM_CTX(ndr);
    1564           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.eventDataSizes, 0);
    1565           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.eventDataSizes));
    1566           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)r->out.eventDataSizes, &size_eventDataSizes_2));
    1567           0 :                         if (size_eventDataSizes_2 > MAX_RPC_RECORD_COUNT) {
    1568           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    1569             :                         }
    1570           0 :                         NDR_PULL_ALLOC_N(ndr, *r->out.eventDataSizes, size_eventDataSizes_2);
    1571           0 :                         _mem_save_eventDataSizes_2 = NDR_PULL_GET_MEM_CTX(ndr);
    1572           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.eventDataSizes, 0);
    1573           0 :                         for (cntr_eventDataSizes_2 = 0; cntr_eventDataSizes_2 < (size_eventDataSizes_2); cntr_eventDataSizes_2++) {
    1574           0 :                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &(*r->out.eventDataSizes)[cntr_eventDataSizes_2]));
    1575             :                         }
    1576           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eventDataSizes_2, 0);
    1577           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eventDataSizes_1, 0);
    1578             :                 }
    1579           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eventDataSizes_0, LIBNDR_FLAG_REF_ALLOC);
    1580           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1581           0 :                         NDR_PULL_ALLOC(ndr, r->out.resultBufferSize);
    1582             :                 }
    1583           0 :                 _mem_save_resultBufferSize_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1584           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resultBufferSize, LIBNDR_FLAG_REF_ALLOC);
    1585           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resultBufferSize));
    1586           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resultBufferSize_0, LIBNDR_FLAG_REF_ALLOC);
    1587           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1588           0 :                         NDR_PULL_ALLOC(ndr, r->out.resultBuffer);
    1589             :                 }
    1590           0 :                 _mem_save_resultBuffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1591           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resultBuffer, LIBNDR_FLAG_REF_ALLOC);
    1592           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resultBuffer));
    1593           0 :                 if (_ptr_resultBuffer) {
    1594           0 :                         NDR_PULL_ALLOC(ndr, *r->out.resultBuffer);
    1595             :                 } else {
    1596           0 :                         *r->out.resultBuffer = NULL;
    1597             :                 }
    1598           0 :                 if (*r->out.resultBuffer) {
    1599           0 :                         _mem_save_resultBuffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
    1600           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.resultBuffer, 0);
    1601           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.resultBuffer));
    1602           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)r->out.resultBuffer, &size_resultBuffer_2));
    1603           0 :                         if (size_resultBuffer_2 > MAX_RPC_BATCH_SIZE) {
    1604           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    1605             :                         }
    1606           0 :                         NDR_PULL_ALLOC_N(ndr, *r->out.resultBuffer, size_resultBuffer_2);
    1607           0 :                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, *r->out.resultBuffer, size_resultBuffer_2));
    1608           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resultBuffer_1, 0);
    1609             :                 }
    1610           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resultBuffer_0, LIBNDR_FLAG_REF_ALLOC);
    1611           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1612           0 :                 if (*r->out.eventDataIndices) {
    1613           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)r->out.eventDataIndices, *r->out.numActualRecords));
    1614             :                 }
    1615           0 :                 if (*r->out.eventDataSizes) {
    1616           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)r->out.eventDataSizes, *r->out.numActualRecords));
    1617             :                 }
    1618           0 :                 if (*r->out.resultBuffer) {
    1619           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)r->out.resultBuffer, *r->out.resultBufferSize));
    1620             :                 }
    1621             :         }
    1622           0 :         return NDR_ERR_SUCCESS;
    1623             : }
    1624             : 
    1625           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcRemoteSubscriptionNextAsync(struct ndr_print *ndr, const char *name, int flags, const struct eventlog6_EvtRpcRemoteSubscriptionNextAsync *r)
    1626             : {
    1627             :         uint32_t cntr_eventDataIndices_2;
    1628             :         uint32_t cntr_eventDataSizes_2;
    1629           0 :         ndr_print_struct(ndr, name, "eventlog6_EvtRpcRemoteSubscriptionNextAsync");
    1630           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1631           0 :         ndr->depth++;
    1632           0 :         if (flags & NDR_SET_VALUES) {
    1633           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1634             :         }
    1635           0 :         if (flags & NDR_IN) {
    1636           0 :                 ndr_print_struct(ndr, "in", "eventlog6_EvtRpcRemoteSubscriptionNextAsync");
    1637           0 :                 ndr->depth++;
    1638           0 :                 ndr_print_ptr(ndr, "handle", r->in.handle);
    1639           0 :                 ndr->depth++;
    1640           0 :                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
    1641           0 :                 ndr->depth--;
    1642           0 :                 ndr_print_uint32(ndr, "numRequestedRecords", r->in.numRequestedRecords);
    1643           0 :                 ndr_print_uint32(ndr, "flags", r->in.flags);
    1644           0 :                 ndr->depth--;
    1645             :         }
    1646           0 :         if (flags & NDR_OUT) {
    1647           0 :                 ndr_print_struct(ndr, "out", "eventlog6_EvtRpcRemoteSubscriptionNextAsync");
    1648           0 :                 ndr->depth++;
    1649           0 :                 ndr_print_ptr(ndr, "numActualRecords", r->out.numActualRecords);
    1650           0 :                 ndr->depth++;
    1651           0 :                 ndr_print_uint32(ndr, "numActualRecords", *r->out.numActualRecords);
    1652           0 :                 ndr->depth--;
    1653           0 :                 ndr_print_ptr(ndr, "eventDataIndices", r->out.eventDataIndices);
    1654           0 :                 ndr->depth++;
    1655           0 :                 ndr_print_ptr(ndr, "eventDataIndices", *r->out.eventDataIndices);
    1656           0 :                 ndr->depth++;
    1657           0 :                 if (*r->out.eventDataIndices) {
    1658           0 :                         ndr->print(ndr, "%s: ARRAY(%d)", "eventDataIndices", (int)*r->out.numActualRecords);
    1659           0 :                         ndr->depth++;
    1660           0 :                         for (cntr_eventDataIndices_2 = 0; cntr_eventDataIndices_2 < (*r->out.numActualRecords); cntr_eventDataIndices_2++) {
    1661           0 :                                 ndr_print_uint32(ndr, "eventDataIndices", (*r->out.eventDataIndices)[cntr_eventDataIndices_2]);
    1662             :                         }
    1663           0 :                         ndr->depth--;
    1664             :                 }
    1665           0 :                 ndr->depth--;
    1666           0 :                 ndr->depth--;
    1667           0 :                 ndr_print_ptr(ndr, "eventDataSizes", r->out.eventDataSizes);
    1668           0 :                 ndr->depth++;
    1669           0 :                 ndr_print_ptr(ndr, "eventDataSizes", *r->out.eventDataSizes);
    1670           0 :                 ndr->depth++;
    1671           0 :                 if (*r->out.eventDataSizes) {
    1672           0 :                         ndr->print(ndr, "%s: ARRAY(%d)", "eventDataSizes", (int)*r->out.numActualRecords);
    1673           0 :                         ndr->depth++;
    1674           0 :                         for (cntr_eventDataSizes_2 = 0; cntr_eventDataSizes_2 < (*r->out.numActualRecords); cntr_eventDataSizes_2++) {
    1675           0 :                                 ndr_print_uint32(ndr, "eventDataSizes", (*r->out.eventDataSizes)[cntr_eventDataSizes_2]);
    1676             :                         }
    1677           0 :                         ndr->depth--;
    1678             :                 }
    1679           0 :                 ndr->depth--;
    1680           0 :                 ndr->depth--;
    1681           0 :                 ndr_print_ptr(ndr, "resultBufferSize", r->out.resultBufferSize);
    1682           0 :                 ndr->depth++;
    1683           0 :                 ndr_print_uint32(ndr, "resultBufferSize", *r->out.resultBufferSize);
    1684           0 :                 ndr->depth--;
    1685           0 :                 ndr_print_ptr(ndr, "resultBuffer", r->out.resultBuffer);
    1686           0 :                 ndr->depth++;
    1687           0 :                 ndr_print_ptr(ndr, "resultBuffer", *r->out.resultBuffer);
    1688           0 :                 ndr->depth++;
    1689           0 :                 if (*r->out.resultBuffer) {
    1690           0 :                         ndr_print_array_uint8(ndr, "resultBuffer", *r->out.resultBuffer, *r->out.resultBufferSize);
    1691             :                 }
    1692           0 :                 ndr->depth--;
    1693           0 :                 ndr->depth--;
    1694           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1695           0 :                 ndr->depth--;
    1696             :         }
    1697           0 :         ndr->depth--;
    1698             : }
    1699             : 
    1700           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcRemoteSubscriptionNext(struct ndr_push *ndr, int flags, const struct eventlog6_EvtRpcRemoteSubscriptionNext *r)
    1701             : {
    1702             :         uint32_t cntr_eventDataIndices_2;
    1703             :         uint32_t cntr_eventDataSizes_2;
    1704           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1705           0 :         if (flags & NDR_IN) {
    1706           0 :                 if (r->in.handle == NULL) {
    1707           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    1708             :                 }
    1709           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
    1710           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numRequestedRecords));
    1711           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.timeOut));
    1712           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
    1713             :         }
    1714           0 :         if (flags & NDR_OUT) {
    1715           0 :                 if (r->out.numActualRecords == NULL) {
    1716           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    1717             :                 }
    1718           0 :                 if (r->out.eventDataIndices == NULL) {
    1719           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    1720             :                 }
    1721           0 :                 if (r->out.eventDataSizes == NULL) {
    1722           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    1723             :                 }
    1724           0 :                 if (r->out.resultBufferSize == NULL) {
    1725           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    1726             :                 }
    1727           0 :                 if (r->out.resultBuffer == NULL) {
    1728           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    1729             :                 }
    1730           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.numActualRecords));
    1731           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.eventDataIndices));
    1732           0 :                 if (*r->out.eventDataIndices) {
    1733           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.numActualRecords));
    1734           0 :                         for (cntr_eventDataIndices_2 = 0; cntr_eventDataIndices_2 < (*r->out.numActualRecords); cntr_eventDataIndices_2++) {
    1735           0 :                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (*r->out.eventDataIndices)[cntr_eventDataIndices_2]));
    1736             :                         }
    1737             :                 }
    1738           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.eventDataSizes));
    1739           0 :                 if (*r->out.eventDataSizes) {
    1740           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.numActualRecords));
    1741           0 :                         for (cntr_eventDataSizes_2 = 0; cntr_eventDataSizes_2 < (*r->out.numActualRecords); cntr_eventDataSizes_2++) {
    1742           0 :                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (*r->out.eventDataSizes)[cntr_eventDataSizes_2]));
    1743             :                         }
    1744             :                 }
    1745           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resultBufferSize));
    1746           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.resultBuffer));
    1747           0 :                 if (*r->out.resultBuffer) {
    1748           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.resultBufferSize));
    1749           0 :                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, *r->out.resultBuffer, *r->out.resultBufferSize));
    1750             :                 }
    1751           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1752             :         }
    1753           0 :         return NDR_ERR_SUCCESS;
    1754             : }
    1755             : 
    1756           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcRemoteSubscriptionNext(struct ndr_pull *ndr, int flags, struct eventlog6_EvtRpcRemoteSubscriptionNext *r)
    1757             : {
    1758             :         uint32_t _ptr_eventDataIndices;
    1759           0 :         uint32_t size_eventDataIndices_2 = 0;
    1760             :         uint32_t cntr_eventDataIndices_2;
    1761             :         uint32_t _ptr_eventDataSizes;
    1762           0 :         uint32_t size_eventDataSizes_2 = 0;
    1763             :         uint32_t cntr_eventDataSizes_2;
    1764             :         uint32_t _ptr_resultBuffer;
    1765           0 :         uint32_t size_resultBuffer_2 = 0;
    1766           0 :         TALLOC_CTX *_mem_save_handle_0 = NULL;
    1767           0 :         TALLOC_CTX *_mem_save_numActualRecords_0 = NULL;
    1768           0 :         TALLOC_CTX *_mem_save_eventDataIndices_0 = NULL;
    1769           0 :         TALLOC_CTX *_mem_save_eventDataIndices_1 = NULL;
    1770           0 :         TALLOC_CTX *_mem_save_eventDataIndices_2 = NULL;
    1771           0 :         TALLOC_CTX *_mem_save_eventDataSizes_0 = NULL;
    1772           0 :         TALLOC_CTX *_mem_save_eventDataSizes_1 = NULL;
    1773           0 :         TALLOC_CTX *_mem_save_eventDataSizes_2 = NULL;
    1774           0 :         TALLOC_CTX *_mem_save_resultBufferSize_0 = NULL;
    1775           0 :         TALLOC_CTX *_mem_save_resultBuffer_0 = NULL;
    1776           0 :         TALLOC_CTX *_mem_save_resultBuffer_1 = NULL;
    1777           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1778           0 :         if (flags & NDR_IN) {
    1779           0 :                 NDR_ZERO_STRUCT(r->out);
    1780             : 
    1781           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1782           0 :                         NDR_PULL_ALLOC(ndr, r->in.handle);
    1783             :                 }
    1784           0 :                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1785           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
    1786           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
    1787           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
    1788           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numRequestedRecords));
    1789           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.timeOut));
    1790           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
    1791           0 :                 NDR_PULL_ALLOC(ndr, r->out.numActualRecords);
    1792           0 :                 NDR_ZERO_STRUCTP(r->out.numActualRecords);
    1793           0 :                 NDR_PULL_ALLOC(ndr, r->out.eventDataIndices);
    1794           0 :                 NDR_ZERO_STRUCTP(r->out.eventDataIndices);
    1795           0 :                 NDR_PULL_ALLOC(ndr, r->out.eventDataSizes);
    1796           0 :                 NDR_ZERO_STRUCTP(r->out.eventDataSizes);
    1797           0 :                 NDR_PULL_ALLOC(ndr, r->out.resultBufferSize);
    1798           0 :                 NDR_ZERO_STRUCTP(r->out.resultBufferSize);
    1799           0 :                 NDR_PULL_ALLOC(ndr, r->out.resultBuffer);
    1800           0 :                 NDR_ZERO_STRUCTP(r->out.resultBuffer);
    1801             :         }
    1802           0 :         if (flags & NDR_OUT) {
    1803             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1804             :                 if (r->in.handle == NULL) {
    1805             :                         NDR_PULL_ALLOC(ndr, r->in.handle);
    1806             :                         NDR_ZERO_STRUCTP(r->in.handle);
    1807             :                 }
    1808             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1809           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1810           0 :                         NDR_PULL_ALLOC(ndr, r->out.numActualRecords);
    1811             :                 }
    1812           0 :                 _mem_save_numActualRecords_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1813           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.numActualRecords, LIBNDR_FLAG_REF_ALLOC);
    1814           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.numActualRecords));
    1815           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_numActualRecords_0, LIBNDR_FLAG_REF_ALLOC);
    1816           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1817           0 :                         NDR_PULL_ALLOC(ndr, r->out.eventDataIndices);
    1818             :                 }
    1819           0 :                 _mem_save_eventDataIndices_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1820           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.eventDataIndices, LIBNDR_FLAG_REF_ALLOC);
    1821           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_eventDataIndices));
    1822           0 :                 if (_ptr_eventDataIndices) {
    1823           0 :                         NDR_PULL_ALLOC(ndr, *r->out.eventDataIndices);
    1824             :                 } else {
    1825           0 :                         *r->out.eventDataIndices = NULL;
    1826             :                 }
    1827           0 :                 if (*r->out.eventDataIndices) {
    1828           0 :                         _mem_save_eventDataIndices_1 = NDR_PULL_GET_MEM_CTX(ndr);
    1829           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.eventDataIndices, 0);
    1830           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.eventDataIndices));
    1831           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)r->out.eventDataIndices, &size_eventDataIndices_2));
    1832           0 :                         if (size_eventDataIndices_2 > MAX_RPC_RECORD_COUNT) {
    1833           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    1834             :                         }
    1835           0 :                         NDR_PULL_ALLOC_N(ndr, *r->out.eventDataIndices, size_eventDataIndices_2);
    1836           0 :                         _mem_save_eventDataIndices_2 = NDR_PULL_GET_MEM_CTX(ndr);
    1837           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.eventDataIndices, 0);
    1838           0 :                         for (cntr_eventDataIndices_2 = 0; cntr_eventDataIndices_2 < (size_eventDataIndices_2); cntr_eventDataIndices_2++) {
    1839           0 :                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &(*r->out.eventDataIndices)[cntr_eventDataIndices_2]));
    1840             :                         }
    1841           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eventDataIndices_2, 0);
    1842           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eventDataIndices_1, 0);
    1843             :                 }
    1844           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eventDataIndices_0, LIBNDR_FLAG_REF_ALLOC);
    1845           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1846           0 :                         NDR_PULL_ALLOC(ndr, r->out.eventDataSizes);
    1847             :                 }
    1848           0 :                 _mem_save_eventDataSizes_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1849           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.eventDataSizes, LIBNDR_FLAG_REF_ALLOC);
    1850           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_eventDataSizes));
    1851           0 :                 if (_ptr_eventDataSizes) {
    1852           0 :                         NDR_PULL_ALLOC(ndr, *r->out.eventDataSizes);
    1853             :                 } else {
    1854           0 :                         *r->out.eventDataSizes = NULL;
    1855             :                 }
    1856           0 :                 if (*r->out.eventDataSizes) {
    1857           0 :                         _mem_save_eventDataSizes_1 = NDR_PULL_GET_MEM_CTX(ndr);
    1858           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.eventDataSizes, 0);
    1859           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.eventDataSizes));
    1860           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)r->out.eventDataSizes, &size_eventDataSizes_2));
    1861           0 :                         if (size_eventDataSizes_2 > MAX_RPC_RECORD_COUNT) {
    1862           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    1863             :                         }
    1864           0 :                         NDR_PULL_ALLOC_N(ndr, *r->out.eventDataSizes, size_eventDataSizes_2);
    1865           0 :                         _mem_save_eventDataSizes_2 = NDR_PULL_GET_MEM_CTX(ndr);
    1866           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.eventDataSizes, 0);
    1867           0 :                         for (cntr_eventDataSizes_2 = 0; cntr_eventDataSizes_2 < (size_eventDataSizes_2); cntr_eventDataSizes_2++) {
    1868           0 :                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &(*r->out.eventDataSizes)[cntr_eventDataSizes_2]));
    1869             :                         }
    1870           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eventDataSizes_2, 0);
    1871           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eventDataSizes_1, 0);
    1872             :                 }
    1873           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eventDataSizes_0, LIBNDR_FLAG_REF_ALLOC);
    1874           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1875           0 :                         NDR_PULL_ALLOC(ndr, r->out.resultBufferSize);
    1876             :                 }
    1877           0 :                 _mem_save_resultBufferSize_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1878           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resultBufferSize, LIBNDR_FLAG_REF_ALLOC);
    1879           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resultBufferSize));
    1880           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resultBufferSize_0, LIBNDR_FLAG_REF_ALLOC);
    1881           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1882           0 :                         NDR_PULL_ALLOC(ndr, r->out.resultBuffer);
    1883             :                 }
    1884           0 :                 _mem_save_resultBuffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1885           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resultBuffer, LIBNDR_FLAG_REF_ALLOC);
    1886           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resultBuffer));
    1887           0 :                 if (_ptr_resultBuffer) {
    1888           0 :                         NDR_PULL_ALLOC(ndr, *r->out.resultBuffer);
    1889             :                 } else {
    1890           0 :                         *r->out.resultBuffer = NULL;
    1891             :                 }
    1892           0 :                 if (*r->out.resultBuffer) {
    1893           0 :                         _mem_save_resultBuffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
    1894           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.resultBuffer, 0);
    1895           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.resultBuffer));
    1896           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)r->out.resultBuffer, &size_resultBuffer_2));
    1897           0 :                         if (size_resultBuffer_2 > MAX_RPC_BATCH_SIZE) {
    1898           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    1899             :                         }
    1900           0 :                         NDR_PULL_ALLOC_N(ndr, *r->out.resultBuffer, size_resultBuffer_2);
    1901           0 :                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, *r->out.resultBuffer, size_resultBuffer_2));
    1902           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resultBuffer_1, 0);
    1903             :                 }
    1904           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resultBuffer_0, LIBNDR_FLAG_REF_ALLOC);
    1905           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1906           0 :                 if (*r->out.eventDataIndices) {
    1907           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)r->out.eventDataIndices, *r->out.numActualRecords));
    1908             :                 }
    1909           0 :                 if (*r->out.eventDataSizes) {
    1910           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)r->out.eventDataSizes, *r->out.numActualRecords));
    1911             :                 }
    1912           0 :                 if (*r->out.resultBuffer) {
    1913           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)r->out.resultBuffer, *r->out.resultBufferSize));
    1914             :                 }
    1915             :         }
    1916           0 :         return NDR_ERR_SUCCESS;
    1917             : }
    1918             : 
    1919           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcRemoteSubscriptionNext(struct ndr_print *ndr, const char *name, int flags, const struct eventlog6_EvtRpcRemoteSubscriptionNext *r)
    1920             : {
    1921             :         uint32_t cntr_eventDataIndices_2;
    1922             :         uint32_t cntr_eventDataSizes_2;
    1923           0 :         ndr_print_struct(ndr, name, "eventlog6_EvtRpcRemoteSubscriptionNext");
    1924           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1925           0 :         ndr->depth++;
    1926           0 :         if (flags & NDR_SET_VALUES) {
    1927           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1928             :         }
    1929           0 :         if (flags & NDR_IN) {
    1930           0 :                 ndr_print_struct(ndr, "in", "eventlog6_EvtRpcRemoteSubscriptionNext");
    1931           0 :                 ndr->depth++;
    1932           0 :                 ndr_print_ptr(ndr, "handle", r->in.handle);
    1933           0 :                 ndr->depth++;
    1934           0 :                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
    1935           0 :                 ndr->depth--;
    1936           0 :                 ndr_print_uint32(ndr, "numRequestedRecords", r->in.numRequestedRecords);
    1937           0 :                 ndr_print_uint32(ndr, "timeOut", r->in.timeOut);
    1938           0 :                 ndr_print_uint32(ndr, "flags", r->in.flags);
    1939           0 :                 ndr->depth--;
    1940             :         }
    1941           0 :         if (flags & NDR_OUT) {
    1942           0 :                 ndr_print_struct(ndr, "out", "eventlog6_EvtRpcRemoteSubscriptionNext");
    1943           0 :                 ndr->depth++;
    1944           0 :                 ndr_print_ptr(ndr, "numActualRecords", r->out.numActualRecords);
    1945           0 :                 ndr->depth++;
    1946           0 :                 ndr_print_uint32(ndr, "numActualRecords", *r->out.numActualRecords);
    1947           0 :                 ndr->depth--;
    1948           0 :                 ndr_print_ptr(ndr, "eventDataIndices", r->out.eventDataIndices);
    1949           0 :                 ndr->depth++;
    1950           0 :                 ndr_print_ptr(ndr, "eventDataIndices", *r->out.eventDataIndices);
    1951           0 :                 ndr->depth++;
    1952           0 :                 if (*r->out.eventDataIndices) {
    1953           0 :                         ndr->print(ndr, "%s: ARRAY(%d)", "eventDataIndices", (int)*r->out.numActualRecords);
    1954           0 :                         ndr->depth++;
    1955           0 :                         for (cntr_eventDataIndices_2 = 0; cntr_eventDataIndices_2 < (*r->out.numActualRecords); cntr_eventDataIndices_2++) {
    1956           0 :                                 ndr_print_uint32(ndr, "eventDataIndices", (*r->out.eventDataIndices)[cntr_eventDataIndices_2]);
    1957             :                         }
    1958           0 :                         ndr->depth--;
    1959             :                 }
    1960           0 :                 ndr->depth--;
    1961           0 :                 ndr->depth--;
    1962           0 :                 ndr_print_ptr(ndr, "eventDataSizes", r->out.eventDataSizes);
    1963           0 :                 ndr->depth++;
    1964           0 :                 ndr_print_ptr(ndr, "eventDataSizes", *r->out.eventDataSizes);
    1965           0 :                 ndr->depth++;
    1966           0 :                 if (*r->out.eventDataSizes) {
    1967           0 :                         ndr->print(ndr, "%s: ARRAY(%d)", "eventDataSizes", (int)*r->out.numActualRecords);
    1968           0 :                         ndr->depth++;
    1969           0 :                         for (cntr_eventDataSizes_2 = 0; cntr_eventDataSizes_2 < (*r->out.numActualRecords); cntr_eventDataSizes_2++) {
    1970           0 :                                 ndr_print_uint32(ndr, "eventDataSizes", (*r->out.eventDataSizes)[cntr_eventDataSizes_2]);
    1971             :                         }
    1972           0 :                         ndr->depth--;
    1973             :                 }
    1974           0 :                 ndr->depth--;
    1975           0 :                 ndr->depth--;
    1976           0 :                 ndr_print_ptr(ndr, "resultBufferSize", r->out.resultBufferSize);
    1977           0 :                 ndr->depth++;
    1978           0 :                 ndr_print_uint32(ndr, "resultBufferSize", *r->out.resultBufferSize);
    1979           0 :                 ndr->depth--;
    1980           0 :                 ndr_print_ptr(ndr, "resultBuffer", r->out.resultBuffer);
    1981           0 :                 ndr->depth++;
    1982           0 :                 ndr_print_ptr(ndr, "resultBuffer", *r->out.resultBuffer);
    1983           0 :                 ndr->depth++;
    1984           0 :                 if (*r->out.resultBuffer) {
    1985           0 :                         ndr_print_array_uint8(ndr, "resultBuffer", *r->out.resultBuffer, *r->out.resultBufferSize);
    1986             :                 }
    1987           0 :                 ndr->depth--;
    1988           0 :                 ndr->depth--;
    1989           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1990           0 :                 ndr->depth--;
    1991             :         }
    1992           0 :         ndr->depth--;
    1993             : }
    1994             : 
    1995           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcRemoteSubscriptionWaitAsync(struct ndr_push *ndr, int flags, const struct eventlog6_EvtRpcRemoteSubscriptionWaitAsync *r)
    1996             : {
    1997           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1998           0 :         if (flags & NDR_IN) {
    1999           0 :                 if (r->in.handle == NULL) {
    2000           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2001             :                 }
    2002           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
    2003             :         }
    2004           0 :         if (flags & NDR_OUT) {
    2005           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    2006             :         }
    2007           0 :         return NDR_ERR_SUCCESS;
    2008             : }
    2009             : 
    2010           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcRemoteSubscriptionWaitAsync(struct ndr_pull *ndr, int flags, struct eventlog6_EvtRpcRemoteSubscriptionWaitAsync *r)
    2011             : {
    2012           0 :         TALLOC_CTX *_mem_save_handle_0 = NULL;
    2013           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2014           0 :         if (flags & NDR_IN) {
    2015           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2016           0 :                         NDR_PULL_ALLOC(ndr, r->in.handle);
    2017             :                 }
    2018           0 :                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2019           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
    2020           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
    2021           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
    2022             :         }
    2023           0 :         if (flags & NDR_OUT) {
    2024             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2025             :                 if (r->in.handle == NULL) {
    2026             :                         NDR_PULL_ALLOC(ndr, r->in.handle);
    2027             :                         NDR_ZERO_STRUCTP(r->in.handle);
    2028             :                 }
    2029             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2030           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    2031             :         }
    2032           0 :         return NDR_ERR_SUCCESS;
    2033             : }
    2034             : 
    2035           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcRemoteSubscriptionWaitAsync(struct ndr_print *ndr, const char *name, int flags, const struct eventlog6_EvtRpcRemoteSubscriptionWaitAsync *r)
    2036             : {
    2037           0 :         ndr_print_struct(ndr, name, "eventlog6_EvtRpcRemoteSubscriptionWaitAsync");
    2038           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2039           0 :         ndr->depth++;
    2040           0 :         if (flags & NDR_SET_VALUES) {
    2041           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2042             :         }
    2043           0 :         if (flags & NDR_IN) {
    2044           0 :                 ndr_print_struct(ndr, "in", "eventlog6_EvtRpcRemoteSubscriptionWaitAsync");
    2045           0 :                 ndr->depth++;
    2046           0 :                 ndr_print_ptr(ndr, "handle", r->in.handle);
    2047           0 :                 ndr->depth++;
    2048           0 :                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
    2049           0 :                 ndr->depth--;
    2050           0 :                 ndr->depth--;
    2051             :         }
    2052           0 :         if (flags & NDR_OUT) {
    2053           0 :                 ndr_print_struct(ndr, "out", "eventlog6_EvtRpcRemoteSubscriptionWaitAsync");
    2054           0 :                 ndr->depth++;
    2055           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    2056           0 :                 ndr->depth--;
    2057             :         }
    2058           0 :         ndr->depth--;
    2059             : }
    2060             : 
    2061           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcRegisterControllableOperation(struct ndr_push *ndr, int flags, const struct eventlog6_EvtRpcRegisterControllableOperation *r)
    2062             : {
    2063           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2064           0 :         if (flags & NDR_IN) {
    2065             :         }
    2066           0 :         if (flags & NDR_OUT) {
    2067           0 :                 if (r->out.handle == NULL) {
    2068           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2069             :                 }
    2070           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
    2071           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    2072             :         }
    2073           0 :         return NDR_ERR_SUCCESS;
    2074             : }
    2075             : 
    2076           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcRegisterControllableOperation(struct ndr_pull *ndr, int flags, struct eventlog6_EvtRpcRegisterControllableOperation *r)
    2077             : {
    2078           0 :         TALLOC_CTX *_mem_save_handle_0 = NULL;
    2079           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2080           0 :         if (flags & NDR_IN) {
    2081           0 :                 NDR_ZERO_STRUCT(r->out);
    2082             : 
    2083           0 :                 NDR_PULL_ALLOC(ndr, r->out.handle);
    2084           0 :                 NDR_ZERO_STRUCTP(r->out.handle);
    2085             :         }
    2086           0 :         if (flags & NDR_OUT) {
    2087             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2088             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2089           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2090           0 :                         NDR_PULL_ALLOC(ndr, r->out.handle);
    2091             :                 }
    2092           0 :                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2093           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
    2094           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
    2095           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
    2096           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    2097             :         }
    2098           0 :         return NDR_ERR_SUCCESS;
    2099             : }
    2100             : 
    2101           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcRegisterControllableOperation(struct ndr_print *ndr, const char *name, int flags, const struct eventlog6_EvtRpcRegisterControllableOperation *r)
    2102             : {
    2103           0 :         ndr_print_struct(ndr, name, "eventlog6_EvtRpcRegisterControllableOperation");
    2104           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2105           0 :         ndr->depth++;
    2106           0 :         if (flags & NDR_SET_VALUES) {
    2107           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2108             :         }
    2109           0 :         if (flags & NDR_IN) {
    2110           0 :                 ndr_print_struct(ndr, "in", "eventlog6_EvtRpcRegisterControllableOperation");
    2111           0 :                 ndr->depth++;
    2112           0 :                 ndr->depth--;
    2113             :         }
    2114           0 :         if (flags & NDR_OUT) {
    2115           0 :                 ndr_print_struct(ndr, "out", "eventlog6_EvtRpcRegisterControllableOperation");
    2116           0 :                 ndr->depth++;
    2117           0 :                 ndr_print_ptr(ndr, "handle", r->out.handle);
    2118           0 :                 ndr->depth++;
    2119           0 :                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
    2120           0 :                 ndr->depth--;
    2121           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    2122           0 :                 ndr->depth--;
    2123             :         }
    2124           0 :         ndr->depth--;
    2125             : }
    2126             : 
    2127           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcRegisterLogQuery(struct ndr_push *ndr, int flags, const struct eventlog6_EvtRpcRegisterLogQuery *r)
    2128             : {
    2129             :         uint32_t cntr_queryChannelInfo_2;
    2130           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2131           0 :         if (flags & NDR_IN) {
    2132           0 :                 if (r->in.query == NULL) {
    2133           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2134             :                 }
    2135           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.path));
    2136           0 :                 if (r->in.path) {
    2137           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));
    2138           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    2139           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));
    2140           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.path, ndr_charset_length(r->in.path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    2141             :                 }
    2142           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.query, CH_UTF16)));
    2143           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    2144           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.query, CH_UTF16)));
    2145           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.query, ndr_charset_length(r->in.query, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    2146           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
    2147             :         }
    2148           0 :         if (flags & NDR_OUT) {
    2149           0 :                 if (r->out.handle == NULL) {
    2150           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2151             :                 }
    2152           0 :                 if (r->out.opControl == NULL) {
    2153           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2154             :                 }
    2155           0 :                 if (r->out.queryChannelInfoSize == NULL) {
    2156           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2157             :                 }
    2158           0 :                 if (r->out.queryChannelInfo == NULL) {
    2159           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2160             :                 }
    2161           0 :                 if (r->out.error == NULL) {
    2162           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2163             :                 }
    2164           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
    2165           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.opControl));
    2166           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.queryChannelInfoSize));
    2167           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.queryChannelInfo));
    2168           0 :                 if (*r->out.queryChannelInfo) {
    2169           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.queryChannelInfoSize));
    2170           0 :                         for (cntr_queryChannelInfo_2 = 0; cntr_queryChannelInfo_2 < (*r->out.queryChannelInfoSize); cntr_queryChannelInfo_2++) {
    2171           0 :                                 NDR_CHECK(ndr_push_eventlog6_EvtRpcQueryChannelInfo(ndr, NDR_SCALARS, &(*r->out.queryChannelInfo)[cntr_queryChannelInfo_2]));
    2172             :                         }
    2173           0 :                         for (cntr_queryChannelInfo_2 = 0; cntr_queryChannelInfo_2 < (*r->out.queryChannelInfoSize); cntr_queryChannelInfo_2++) {
    2174           0 :                                 NDR_CHECK(ndr_push_eventlog6_EvtRpcQueryChannelInfo(ndr, NDR_BUFFERS, &(*r->out.queryChannelInfo)[cntr_queryChannelInfo_2]));
    2175             :                         }
    2176             :                 }
    2177           0 :                 NDR_CHECK(ndr_push_eventlog6_RpcInfo(ndr, NDR_SCALARS, r->out.error));
    2178           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    2179             :         }
    2180           0 :         return NDR_ERR_SUCCESS;
    2181             : }
    2182             : 
    2183           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcRegisterLogQuery(struct ndr_pull *ndr, int flags, struct eventlog6_EvtRpcRegisterLogQuery *r)
    2184             : {
    2185             :         uint32_t _ptr_path;
    2186           0 :         uint32_t size_path_1 = 0;
    2187           0 :         uint32_t length_path_1 = 0;
    2188           0 :         uint32_t size_query_1 = 0;
    2189           0 :         uint32_t length_query_1 = 0;
    2190             :         uint32_t _ptr_queryChannelInfo;
    2191           0 :         uint32_t size_queryChannelInfo_2 = 0;
    2192             :         uint32_t cntr_queryChannelInfo_2;
    2193           0 :         TALLOC_CTX *_mem_save_path_0 = NULL;
    2194           0 :         TALLOC_CTX *_mem_save_handle_0 = NULL;
    2195           0 :         TALLOC_CTX *_mem_save_opControl_0 = NULL;
    2196           0 :         TALLOC_CTX *_mem_save_queryChannelInfoSize_0 = NULL;
    2197           0 :         TALLOC_CTX *_mem_save_queryChannelInfo_0 = NULL;
    2198           0 :         TALLOC_CTX *_mem_save_queryChannelInfo_1 = NULL;
    2199           0 :         TALLOC_CTX *_mem_save_queryChannelInfo_2 = NULL;
    2200           0 :         TALLOC_CTX *_mem_save_error_0 = NULL;
    2201           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2202           0 :         if (flags & NDR_IN) {
    2203           0 :                 NDR_ZERO_STRUCT(r->out);
    2204             : 
    2205           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_path));
    2206           0 :                 if (_ptr_path) {
    2207           0 :                         NDR_PULL_ALLOC(ndr, r->in.path);
    2208             :                 } else {
    2209           0 :                         r->in.path = NULL;
    2210             :                 }
    2211           0 :                 if (r->in.path) {
    2212           0 :                         _mem_save_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2213           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->in.path, 0);
    2214           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path));
    2215           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path));
    2216           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.path, &size_path_1));
    2217           0 :                         if (size_path_1 > MAX_RPC_CHANNEL_PATH_LENGTH) {
    2218           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    2219             :                         }
    2220           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.path, &length_path_1));
    2221           0 :                         if (length_path_1 > MAX_RPC_CHANNEL_PATH_LENGTH) {
    2222           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    2223             :                         }
    2224           0 :                         if (length_path_1 > size_path_1) {
    2225           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_path_1, length_path_1);
    2226             :                         }
    2227           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_path_1, sizeof(uint16_t)));
    2228           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.path, length_path_1, sizeof(uint16_t), CH_UTF16));
    2229           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_path_0, 0);
    2230             :                 }
    2231           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.query));
    2232           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.query));
    2233           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.query, &size_query_1));
    2234           0 :                 if (size_query_1 < 1 || size_query_1 > MAX_RPC_QUERY_LENGTH) {
    2235           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    2236             :                 }
    2237           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.query, &length_query_1));
    2238           0 :                 if (length_query_1 < 1 || length_query_1 > MAX_RPC_QUERY_LENGTH) {
    2239           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    2240             :                 }
    2241           0 :                 if (length_query_1 > size_query_1) {
    2242           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_query_1, length_query_1);
    2243             :                 }
    2244           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_query_1, sizeof(uint16_t)));
    2245           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.query, length_query_1, sizeof(uint16_t), CH_UTF16));
    2246           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
    2247           0 :                 NDR_PULL_ALLOC(ndr, r->out.handle);
    2248           0 :                 NDR_ZERO_STRUCTP(r->out.handle);
    2249           0 :                 NDR_PULL_ALLOC(ndr, r->out.opControl);
    2250           0 :                 NDR_ZERO_STRUCTP(r->out.opControl);
    2251           0 :                 NDR_PULL_ALLOC(ndr, r->out.queryChannelInfoSize);
    2252           0 :                 NDR_ZERO_STRUCTP(r->out.queryChannelInfoSize);
    2253           0 :                 NDR_PULL_ALLOC(ndr, r->out.queryChannelInfo);
    2254           0 :                 NDR_ZERO_STRUCTP(r->out.queryChannelInfo);
    2255           0 :                 NDR_PULL_ALLOC(ndr, r->out.error);
    2256           0 :                 NDR_ZERO_STRUCTP(r->out.error);
    2257             :         }
    2258           0 :         if (flags & NDR_OUT) {
    2259             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2260             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2261           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2262           0 :                         NDR_PULL_ALLOC(ndr, r->out.handle);
    2263             :                 }
    2264           0 :                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2265           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
    2266           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
    2267           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
    2268           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2269           0 :                         NDR_PULL_ALLOC(ndr, r->out.opControl);
    2270             :                 }
    2271           0 :                 _mem_save_opControl_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2272           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.opControl, LIBNDR_FLAG_REF_ALLOC);
    2273           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.opControl));
    2274           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_opControl_0, LIBNDR_FLAG_REF_ALLOC);
    2275           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2276           0 :                         NDR_PULL_ALLOC(ndr, r->out.queryChannelInfoSize);
    2277             :                 }
    2278           0 :                 _mem_save_queryChannelInfoSize_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2279           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.queryChannelInfoSize, LIBNDR_FLAG_REF_ALLOC);
    2280           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.queryChannelInfoSize));
    2281           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_queryChannelInfoSize_0, LIBNDR_FLAG_REF_ALLOC);
    2282           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2283           0 :                         NDR_PULL_ALLOC(ndr, r->out.queryChannelInfo);
    2284             :                 }
    2285           0 :                 _mem_save_queryChannelInfo_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2286           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.queryChannelInfo, LIBNDR_FLAG_REF_ALLOC);
    2287           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_queryChannelInfo));
    2288           0 :                 if (_ptr_queryChannelInfo) {
    2289           0 :                         NDR_PULL_ALLOC(ndr, *r->out.queryChannelInfo);
    2290             :                 } else {
    2291           0 :                         *r->out.queryChannelInfo = NULL;
    2292             :                 }
    2293           0 :                 if (*r->out.queryChannelInfo) {
    2294           0 :                         _mem_save_queryChannelInfo_1 = NDR_PULL_GET_MEM_CTX(ndr);
    2295           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.queryChannelInfo, 0);
    2296           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.queryChannelInfo));
    2297           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)r->out.queryChannelInfo, &size_queryChannelInfo_2));
    2298           0 :                         if (size_queryChannelInfo_2 > MAX_RPC_QUERY_CHANNEL_SIZE) {
    2299           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    2300             :                         }
    2301           0 :                         NDR_PULL_ALLOC_N(ndr, *r->out.queryChannelInfo, size_queryChannelInfo_2);
    2302           0 :                         _mem_save_queryChannelInfo_2 = NDR_PULL_GET_MEM_CTX(ndr);
    2303           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.queryChannelInfo, 0);
    2304           0 :                         for (cntr_queryChannelInfo_2 = 0; cntr_queryChannelInfo_2 < (size_queryChannelInfo_2); cntr_queryChannelInfo_2++) {
    2305           0 :                                 NDR_CHECK(ndr_pull_eventlog6_EvtRpcQueryChannelInfo(ndr, NDR_SCALARS, &(*r->out.queryChannelInfo)[cntr_queryChannelInfo_2]));
    2306             :                         }
    2307           0 :                         for (cntr_queryChannelInfo_2 = 0; cntr_queryChannelInfo_2 < (size_queryChannelInfo_2); cntr_queryChannelInfo_2++) {
    2308           0 :                                 NDR_CHECK(ndr_pull_eventlog6_EvtRpcQueryChannelInfo(ndr, NDR_BUFFERS, &(*r->out.queryChannelInfo)[cntr_queryChannelInfo_2]));
    2309             :                         }
    2310           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_queryChannelInfo_2, 0);
    2311           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_queryChannelInfo_1, 0);
    2312             :                 }
    2313           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_queryChannelInfo_0, LIBNDR_FLAG_REF_ALLOC);
    2314           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2315           0 :                         NDR_PULL_ALLOC(ndr, r->out.error);
    2316             :                 }
    2317           0 :                 _mem_save_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2318           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.error, LIBNDR_FLAG_REF_ALLOC);
    2319           0 :                 NDR_CHECK(ndr_pull_eventlog6_RpcInfo(ndr, NDR_SCALARS, r->out.error));
    2320           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_error_0, LIBNDR_FLAG_REF_ALLOC);
    2321           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    2322           0 :                 if (*r->out.queryChannelInfo) {
    2323           0 :                         NDR_CHECK(ndr_check_array_size(ndr, (void*)r->out.queryChannelInfo, *r->out.queryChannelInfoSize));
    2324             :                 }
    2325           0 :                 for (cntr_queryChannelInfo_2 = 0; cntr_queryChannelInfo_2 < (size_queryChannelInfo_2); cntr_queryChannelInfo_2++) {
    2326             :                 }
    2327             :         }
    2328           0 :         return NDR_ERR_SUCCESS;
    2329             : }
    2330             : 
    2331           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcRegisterLogQuery(struct ndr_print *ndr, const char *name, int flags, const struct eventlog6_EvtRpcRegisterLogQuery *r)
    2332             : {
    2333             :         uint32_t cntr_queryChannelInfo_2;
    2334           0 :         ndr_print_struct(ndr, name, "eventlog6_EvtRpcRegisterLogQuery");
    2335           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2336           0 :         ndr->depth++;
    2337           0 :         if (flags & NDR_SET_VALUES) {
    2338           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2339             :         }
    2340           0 :         if (flags & NDR_IN) {
    2341           0 :                 ndr_print_struct(ndr, "in", "eventlog6_EvtRpcRegisterLogQuery");
    2342           0 :                 ndr->depth++;
    2343           0 :                 ndr_print_ptr(ndr, "path", r->in.path);
    2344           0 :                 ndr->depth++;
    2345           0 :                 if (r->in.path) {
    2346           0 :                         ndr_print_string(ndr, "path", r->in.path);
    2347             :                 }
    2348           0 :                 ndr->depth--;
    2349           0 :                 ndr_print_ptr(ndr, "query", r->in.query);
    2350           0 :                 ndr->depth++;
    2351           0 :                 ndr_print_string(ndr, "query", r->in.query);
    2352           0 :                 ndr->depth--;
    2353           0 :                 ndr_print_uint32(ndr, "flags", r->in.flags);
    2354           0 :                 ndr->depth--;
    2355             :         }
    2356           0 :         if (flags & NDR_OUT) {
    2357           0 :                 ndr_print_struct(ndr, "out", "eventlog6_EvtRpcRegisterLogQuery");
    2358           0 :                 ndr->depth++;
    2359           0 :                 ndr_print_ptr(ndr, "handle", r->out.handle);
    2360           0 :                 ndr->depth++;
    2361           0 :                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
    2362           0 :                 ndr->depth--;
    2363           0 :                 ndr_print_ptr(ndr, "opControl", r->out.opControl);
    2364           0 :                 ndr->depth++;
    2365           0 :                 ndr_print_policy_handle(ndr, "opControl", r->out.opControl);
    2366           0 :                 ndr->depth--;
    2367           0 :                 ndr_print_ptr(ndr, "queryChannelInfoSize", r->out.queryChannelInfoSize);
    2368           0 :                 ndr->depth++;
    2369           0 :                 ndr_print_uint32(ndr, "queryChannelInfoSize", *r->out.queryChannelInfoSize);
    2370           0 :                 ndr->depth--;
    2371           0 :                 ndr_print_ptr(ndr, "queryChannelInfo", r->out.queryChannelInfo);
    2372           0 :                 ndr->depth++;
    2373           0 :                 ndr_print_ptr(ndr, "queryChannelInfo", *r->out.queryChannelInfo);
    2374           0 :                 ndr->depth++;
    2375           0 :                 if (*r->out.queryChannelInfo) {
    2376           0 :                         ndr->print(ndr, "%s: ARRAY(%d)", "queryChannelInfo", (int)*r->out.queryChannelInfoSize);
    2377           0 :                         ndr->depth++;
    2378           0 :                         for (cntr_queryChannelInfo_2 = 0; cntr_queryChannelInfo_2 < (*r->out.queryChannelInfoSize); cntr_queryChannelInfo_2++) {
    2379           0 :                                 ndr_print_eventlog6_EvtRpcQueryChannelInfo(ndr, "queryChannelInfo", &(*r->out.queryChannelInfo)[cntr_queryChannelInfo_2]);
    2380             :                         }
    2381           0 :                         ndr->depth--;
    2382             :                 }
    2383           0 :                 ndr->depth--;
    2384           0 :                 ndr->depth--;
    2385           0 :                 ndr_print_ptr(ndr, "error", r->out.error);
    2386           0 :                 ndr->depth++;
    2387           0 :                 ndr_print_eventlog6_RpcInfo(ndr, "error", r->out.error);
    2388           0 :                 ndr->depth--;
    2389           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    2390           0 :                 ndr->depth--;
    2391             :         }
    2392           0 :         ndr->depth--;
    2393             : }
    2394             : 
    2395           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcClearLog(struct ndr_push *ndr, int flags, const struct eventlog6_EvtRpcClearLog *r)
    2396             : {
    2397           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2398           0 :         if (flags & NDR_IN) {
    2399           0 :                 if (r->in.control == NULL) {
    2400           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2401             :                 }
    2402           0 :                 if (r->in.channelPath == NULL) {
    2403           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2404             :                 }
    2405           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.control));
    2406           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.channelPath, CH_UTF16)));
    2407           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    2408           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.channelPath, CH_UTF16)));
    2409           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.channelPath, ndr_charset_length(r->in.channelPath, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    2410           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.backupPath));
    2411           0 :                 if (r->in.backupPath) {
    2412           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.backupPath, CH_UTF16)));
    2413           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    2414           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.backupPath, CH_UTF16)));
    2415           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.backupPath, ndr_charset_length(r->in.backupPath, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    2416             :                 }
    2417           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
    2418             :         }
    2419           0 :         if (flags & NDR_OUT) {
    2420           0 :                 if (r->out.error == NULL) {
    2421           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2422             :                 }
    2423           0 :                 NDR_CHECK(ndr_push_eventlog6_RpcInfo(ndr, NDR_SCALARS, r->out.error));
    2424           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    2425             :         }
    2426           0 :         return NDR_ERR_SUCCESS;
    2427             : }
    2428             : 
    2429           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcClearLog(struct ndr_pull *ndr, int flags, struct eventlog6_EvtRpcClearLog *r)
    2430             : {
    2431           0 :         uint32_t size_channelPath_1 = 0;
    2432           0 :         uint32_t length_channelPath_1 = 0;
    2433             :         uint32_t _ptr_backupPath;
    2434           0 :         uint32_t size_backupPath_1 = 0;
    2435           0 :         uint32_t length_backupPath_1 = 0;
    2436           0 :         TALLOC_CTX *_mem_save_control_0 = NULL;
    2437           0 :         TALLOC_CTX *_mem_save_backupPath_0 = NULL;
    2438           0 :         TALLOC_CTX *_mem_save_error_0 = NULL;
    2439           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2440           0 :         if (flags & NDR_IN) {
    2441           0 :                 NDR_ZERO_STRUCT(r->out);
    2442             : 
    2443           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2444           0 :                         NDR_PULL_ALLOC(ndr, r->in.control);
    2445             :                 }
    2446           0 :                 _mem_save_control_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2447           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.control, LIBNDR_FLAG_REF_ALLOC);
    2448           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.control));
    2449           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_control_0, LIBNDR_FLAG_REF_ALLOC);
    2450           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.channelPath));
    2451           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.channelPath));
    2452           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.channelPath, &size_channelPath_1));
    2453           0 :                 if (size_channelPath_1 > MAX_RPC_CHANNEL_NAME_LENGTH) {
    2454           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    2455             :                 }
    2456           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.channelPath, &length_channelPath_1));
    2457           0 :                 if (length_channelPath_1 > MAX_RPC_CHANNEL_NAME_LENGTH) {
    2458           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    2459             :                 }
    2460           0 :                 if (length_channelPath_1 > size_channelPath_1) {
    2461           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_channelPath_1, length_channelPath_1);
    2462             :                 }
    2463           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_channelPath_1, sizeof(uint16_t)));
    2464           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.channelPath, length_channelPath_1, sizeof(uint16_t), CH_UTF16));
    2465           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_backupPath));
    2466           0 :                 if (_ptr_backupPath) {
    2467           0 :                         NDR_PULL_ALLOC(ndr, r->in.backupPath);
    2468             :                 } else {
    2469           0 :                         r->in.backupPath = NULL;
    2470             :                 }
    2471           0 :                 if (r->in.backupPath) {
    2472           0 :                         _mem_save_backupPath_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2473           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->in.backupPath, 0);
    2474           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.backupPath));
    2475           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.backupPath));
    2476           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.backupPath, &size_backupPath_1));
    2477           0 :                         if (size_backupPath_1 > MAX_RPC_FILE_PATH_LENGTH) {
    2478           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    2479             :                         }
    2480           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.backupPath, &length_backupPath_1));
    2481           0 :                         if (length_backupPath_1 > MAX_RPC_FILE_PATH_LENGTH) {
    2482           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    2483             :                         }
    2484           0 :                         if (length_backupPath_1 > size_backupPath_1) {
    2485           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_backupPath_1, length_backupPath_1);
    2486             :                         }
    2487           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_backupPath_1, sizeof(uint16_t)));
    2488           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.backupPath, length_backupPath_1, sizeof(uint16_t), CH_UTF16));
    2489           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_backupPath_0, 0);
    2490             :                 }
    2491           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
    2492           0 :                 NDR_PULL_ALLOC(ndr, r->out.error);
    2493           0 :                 NDR_ZERO_STRUCTP(r->out.error);
    2494             :         }
    2495           0 :         if (flags & NDR_OUT) {
    2496             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2497             :                 if (r->in.control == NULL) {
    2498             :                         NDR_PULL_ALLOC(ndr, r->in.control);
    2499             :                         NDR_ZERO_STRUCTP(r->in.control);
    2500             :                 }
    2501             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2502           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2503           0 :                         NDR_PULL_ALLOC(ndr, r->out.error);
    2504             :                 }
    2505           0 :                 _mem_save_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2506           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.error, LIBNDR_FLAG_REF_ALLOC);
    2507           0 :                 NDR_CHECK(ndr_pull_eventlog6_RpcInfo(ndr, NDR_SCALARS, r->out.error));
    2508           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_error_0, LIBNDR_FLAG_REF_ALLOC);
    2509           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    2510             :         }
    2511           0 :         return NDR_ERR_SUCCESS;
    2512             : }
    2513             : 
    2514           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcClearLog(struct ndr_print *ndr, const char *name, int flags, const struct eventlog6_EvtRpcClearLog *r)
    2515             : {
    2516           0 :         ndr_print_struct(ndr, name, "eventlog6_EvtRpcClearLog");
    2517           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2518           0 :         ndr->depth++;
    2519           0 :         if (flags & NDR_SET_VALUES) {
    2520           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2521             :         }
    2522           0 :         if (flags & NDR_IN) {
    2523           0 :                 ndr_print_struct(ndr, "in", "eventlog6_EvtRpcClearLog");
    2524           0 :                 ndr->depth++;
    2525           0 :                 ndr_print_ptr(ndr, "control", r->in.control);
    2526           0 :                 ndr->depth++;
    2527           0 :                 ndr_print_policy_handle(ndr, "control", r->in.control);
    2528           0 :                 ndr->depth--;
    2529           0 :                 ndr_print_ptr(ndr, "channelPath", r->in.channelPath);
    2530           0 :                 ndr->depth++;
    2531           0 :                 ndr_print_string(ndr, "channelPath", r->in.channelPath);
    2532           0 :                 ndr->depth--;
    2533           0 :                 ndr_print_ptr(ndr, "backupPath", r->in.backupPath);
    2534           0 :                 ndr->depth++;
    2535           0 :                 if (r->in.backupPath) {
    2536           0 :                         ndr_print_string(ndr, "backupPath", r->in.backupPath);
    2537             :                 }
    2538           0 :                 ndr->depth--;
    2539           0 :                 ndr_print_uint32(ndr, "flags", r->in.flags);
    2540           0 :                 ndr->depth--;
    2541             :         }
    2542           0 :         if (flags & NDR_OUT) {
    2543           0 :                 ndr_print_struct(ndr, "out", "eventlog6_EvtRpcClearLog");
    2544           0 :                 ndr->depth++;
    2545           0 :                 ndr_print_ptr(ndr, "error", r->out.error);
    2546           0 :                 ndr->depth++;
    2547           0 :                 ndr_print_eventlog6_RpcInfo(ndr, "error", r->out.error);
    2548           0 :                 ndr->depth--;
    2549           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    2550           0 :                 ndr->depth--;
    2551             :         }
    2552           0 :         ndr->depth--;
    2553             : }
    2554             : 
    2555           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcExportLog(struct ndr_push *ndr, int flags, const struct eventlog6_EvtRpcExportLog *r)
    2556             : {
    2557           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2558           0 :         if (flags & NDR_IN) {
    2559           0 :                 if (r->in.control == NULL) {
    2560           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2561             :                 }
    2562           0 :                 if (r->in.query == NULL) {
    2563           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2564             :                 }
    2565           0 :                 if (r->in.backupPath == NULL) {
    2566           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2567             :                 }
    2568           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.control));
    2569           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.channelPath));
    2570           0 :                 if (r->in.channelPath) {
    2571           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.channelPath, CH_UTF16)));
    2572           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    2573           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.channelPath, CH_UTF16)));
    2574           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.channelPath, ndr_charset_length(r->in.channelPath, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    2575             :                 }
    2576           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.query, CH_UTF16)));
    2577           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    2578           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.query, CH_UTF16)));
    2579           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.query, ndr_charset_length(r->in.query, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    2580           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.backupPath, CH_UTF16)));
    2581           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    2582           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.backupPath, CH_UTF16)));
    2583           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.backupPath, ndr_charset_length(r->in.backupPath, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    2584           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
    2585             :         }
    2586           0 :         if (flags & NDR_OUT) {
    2587           0 :                 if (r->out.error == NULL) {
    2588           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2589             :                 }
    2590           0 :                 NDR_CHECK(ndr_push_eventlog6_RpcInfo(ndr, NDR_SCALARS, r->out.error));
    2591           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    2592             :         }
    2593           0 :         return NDR_ERR_SUCCESS;
    2594             : }
    2595             : 
    2596           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcExportLog(struct ndr_pull *ndr, int flags, struct eventlog6_EvtRpcExportLog *r)
    2597             : {
    2598             :         uint32_t _ptr_channelPath;
    2599           0 :         uint32_t size_channelPath_1 = 0;
    2600           0 :         uint32_t length_channelPath_1 = 0;
    2601           0 :         uint32_t size_query_1 = 0;
    2602           0 :         uint32_t length_query_1 = 0;
    2603           0 :         uint32_t size_backupPath_1 = 0;
    2604           0 :         uint32_t length_backupPath_1 = 0;
    2605           0 :         TALLOC_CTX *_mem_save_control_0 = NULL;
    2606           0 :         TALLOC_CTX *_mem_save_channelPath_0 = NULL;
    2607           0 :         TALLOC_CTX *_mem_save_error_0 = NULL;
    2608           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2609           0 :         if (flags & NDR_IN) {
    2610           0 :                 NDR_ZERO_STRUCT(r->out);
    2611             : 
    2612           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2613           0 :                         NDR_PULL_ALLOC(ndr, r->in.control);
    2614             :                 }
    2615           0 :                 _mem_save_control_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2616           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.control, LIBNDR_FLAG_REF_ALLOC);
    2617           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.control));
    2618           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_control_0, LIBNDR_FLAG_REF_ALLOC);
    2619           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_channelPath));
    2620           0 :                 if (_ptr_channelPath) {
    2621           0 :                         NDR_PULL_ALLOC(ndr, r->in.channelPath);
    2622             :                 } else {
    2623           0 :                         r->in.channelPath = NULL;
    2624             :                 }
    2625           0 :                 if (r->in.channelPath) {
    2626           0 :                         _mem_save_channelPath_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2627           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->in.channelPath, 0);
    2628           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.channelPath));
    2629           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.channelPath));
    2630           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.channelPath, &size_channelPath_1));
    2631           0 :                         if (size_channelPath_1 > MAX_RPC_CHANNEL_NAME_LENGTH) {
    2632           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    2633             :                         }
    2634           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.channelPath, &length_channelPath_1));
    2635           0 :                         if (length_channelPath_1 > MAX_RPC_CHANNEL_NAME_LENGTH) {
    2636           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    2637             :                         }
    2638           0 :                         if (length_channelPath_1 > size_channelPath_1) {
    2639           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_channelPath_1, length_channelPath_1);
    2640             :                         }
    2641           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_channelPath_1, sizeof(uint16_t)));
    2642           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.channelPath, length_channelPath_1, sizeof(uint16_t), CH_UTF16));
    2643           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_channelPath_0, 0);
    2644             :                 }
    2645           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.query));
    2646           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.query));
    2647           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.query, &size_query_1));
    2648           0 :                 if (size_query_1 < 1 || size_query_1 > MAX_RPC_QUERY_LENGTH) {
    2649           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    2650             :                 }
    2651           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.query, &length_query_1));
    2652           0 :                 if (length_query_1 < 1 || length_query_1 > MAX_RPC_QUERY_LENGTH) {
    2653           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    2654             :                 }
    2655           0 :                 if (length_query_1 > size_query_1) {
    2656           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_query_1, length_query_1);
    2657             :                 }
    2658           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_query_1, sizeof(uint16_t)));
    2659           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.query, length_query_1, sizeof(uint16_t), CH_UTF16));
    2660           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.backupPath));
    2661           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.backupPath));
    2662           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.backupPath, &size_backupPath_1));
    2663           0 :                 if (size_backupPath_1 < 1 || size_backupPath_1 > MAX_RPC_FILE_PATH_LENGTH) {
    2664           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    2665             :                 }
    2666           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.backupPath, &length_backupPath_1));
    2667           0 :                 if (length_backupPath_1 < 1 || length_backupPath_1 > MAX_RPC_FILE_PATH_LENGTH) {
    2668           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    2669             :                 }
    2670           0 :                 if (length_backupPath_1 > size_backupPath_1) {
    2671           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_backupPath_1, length_backupPath_1);
    2672             :                 }
    2673           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_backupPath_1, sizeof(uint16_t)));
    2674           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.backupPath, length_backupPath_1, sizeof(uint16_t), CH_UTF16));
    2675           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
    2676           0 :                 NDR_PULL_ALLOC(ndr, r->out.error);
    2677           0 :                 NDR_ZERO_STRUCTP(r->out.error);
    2678             :         }
    2679           0 :         if (flags & NDR_OUT) {
    2680             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2681             :                 if (r->in.control == NULL) {
    2682             :                         NDR_PULL_ALLOC(ndr, r->in.control);
    2683             :                         NDR_ZERO_STRUCTP(r->in.control);
    2684             :                 }
    2685             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2686           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2687           0 :                         NDR_PULL_ALLOC(ndr, r->out.error);
    2688             :                 }
    2689           0 :                 _mem_save_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2690           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.error, LIBNDR_FLAG_REF_ALLOC);
    2691           0 :                 NDR_CHECK(ndr_pull_eventlog6_RpcInfo(ndr, NDR_SCALARS, r->out.error));
    2692           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_error_0, LIBNDR_FLAG_REF_ALLOC);
    2693           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    2694             :         }
    2695           0 :         return NDR_ERR_SUCCESS;
    2696             : }
    2697             : 
    2698           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcExportLog(struct ndr_print *ndr, const char *name, int flags, const struct eventlog6_EvtRpcExportLog *r)
    2699             : {
    2700           0 :         ndr_print_struct(ndr, name, "eventlog6_EvtRpcExportLog");
    2701           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2702           0 :         ndr->depth++;
    2703           0 :         if (flags & NDR_SET_VALUES) {
    2704           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2705             :         }
    2706           0 :         if (flags & NDR_IN) {
    2707           0 :                 ndr_print_struct(ndr, "in", "eventlog6_EvtRpcExportLog");
    2708           0 :                 ndr->depth++;
    2709           0 :                 ndr_print_ptr(ndr, "control", r->in.control);
    2710           0 :                 ndr->depth++;
    2711           0 :                 ndr_print_policy_handle(ndr, "control", r->in.control);
    2712           0 :                 ndr->depth--;
    2713           0 :                 ndr_print_ptr(ndr, "channelPath", r->in.channelPath);
    2714           0 :                 ndr->depth++;
    2715           0 :                 if (r->in.channelPath) {
    2716           0 :                         ndr_print_string(ndr, "channelPath", r->in.channelPath);
    2717             :                 }
    2718           0 :                 ndr->depth--;
    2719           0 :                 ndr_print_ptr(ndr, "query", r->in.query);
    2720           0 :                 ndr->depth++;
    2721           0 :                 ndr_print_string(ndr, "query", r->in.query);
    2722           0 :                 ndr->depth--;
    2723           0 :                 ndr_print_ptr(ndr, "backupPath", r->in.backupPath);
    2724           0 :                 ndr->depth++;
    2725           0 :                 ndr_print_string(ndr, "backupPath", r->in.backupPath);
    2726           0 :                 ndr->depth--;
    2727           0 :                 ndr_print_uint32(ndr, "flags", r->in.flags);
    2728           0 :                 ndr->depth--;
    2729             :         }
    2730           0 :         if (flags & NDR_OUT) {
    2731           0 :                 ndr_print_struct(ndr, "out", "eventlog6_EvtRpcExportLog");
    2732           0 :                 ndr->depth++;
    2733           0 :                 ndr_print_ptr(ndr, "error", r->out.error);
    2734           0 :                 ndr->depth++;
    2735           0 :                 ndr_print_eventlog6_RpcInfo(ndr, "error", r->out.error);
    2736           0 :                 ndr->depth--;
    2737           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    2738           0 :                 ndr->depth--;
    2739             :         }
    2740           0 :         ndr->depth--;
    2741             : }
    2742             : 
    2743           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcLocalizeExportLog(struct ndr_push *ndr, int flags, const struct eventlog6_EvtRpcLocalizeExportLog *r)
    2744             : {
    2745           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2746           0 :         if (flags & NDR_IN) {
    2747           0 :                 if (r->in.control == NULL) {
    2748           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2749             :                 }
    2750           0 :                 if (r->in.logFilePath == NULL) {
    2751           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2752             :                 }
    2753           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.control));
    2754           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.logFilePath, CH_UTF16)));
    2755           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    2756           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.logFilePath, CH_UTF16)));
    2757           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.logFilePath, ndr_charset_length(r->in.logFilePath, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    2758           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.locale));
    2759           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
    2760             :         }
    2761           0 :         if (flags & NDR_OUT) {
    2762           0 :                 if (r->out.error == NULL) {
    2763           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2764             :                 }
    2765           0 :                 NDR_CHECK(ndr_push_eventlog6_RpcInfo(ndr, NDR_SCALARS, r->out.error));
    2766           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    2767             :         }
    2768           0 :         return NDR_ERR_SUCCESS;
    2769             : }
    2770             : 
    2771           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcLocalizeExportLog(struct ndr_pull *ndr, int flags, struct eventlog6_EvtRpcLocalizeExportLog *r)
    2772             : {
    2773           0 :         uint32_t size_logFilePath_1 = 0;
    2774           0 :         uint32_t length_logFilePath_1 = 0;
    2775           0 :         TALLOC_CTX *_mem_save_control_0 = NULL;
    2776           0 :         TALLOC_CTX *_mem_save_error_0 = NULL;
    2777           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2778           0 :         if (flags & NDR_IN) {
    2779           0 :                 NDR_ZERO_STRUCT(r->out);
    2780             : 
    2781           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2782           0 :                         NDR_PULL_ALLOC(ndr, r->in.control);
    2783             :                 }
    2784           0 :                 _mem_save_control_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2785           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.control, LIBNDR_FLAG_REF_ALLOC);
    2786           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.control));
    2787           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_control_0, LIBNDR_FLAG_REF_ALLOC);
    2788           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.logFilePath));
    2789           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.logFilePath));
    2790           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.logFilePath, &size_logFilePath_1));
    2791           0 :                 if (size_logFilePath_1 < 1 || size_logFilePath_1 > MAX_RPC_FILE_PATH_LENGTH) {
    2792           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    2793             :                 }
    2794           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.logFilePath, &length_logFilePath_1));
    2795           0 :                 if (length_logFilePath_1 < 1 || length_logFilePath_1 > MAX_RPC_FILE_PATH_LENGTH) {
    2796           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    2797             :                 }
    2798           0 :                 if (length_logFilePath_1 > size_logFilePath_1) {
    2799           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_logFilePath_1, length_logFilePath_1);
    2800             :                 }
    2801           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_logFilePath_1, sizeof(uint16_t)));
    2802           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.logFilePath, length_logFilePath_1, sizeof(uint16_t), CH_UTF16));
    2803           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.locale));
    2804           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
    2805           0 :                 NDR_PULL_ALLOC(ndr, r->out.error);
    2806           0 :                 NDR_ZERO_STRUCTP(r->out.error);
    2807             :         }
    2808           0 :         if (flags & NDR_OUT) {
    2809             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2810             :                 if (r->in.control == NULL) {
    2811             :                         NDR_PULL_ALLOC(ndr, r->in.control);
    2812             :                         NDR_ZERO_STRUCTP(r->in.control);
    2813             :                 }
    2814             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2815           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2816           0 :                         NDR_PULL_ALLOC(ndr, r->out.error);
    2817             :                 }
    2818           0 :                 _mem_save_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2819           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.error, LIBNDR_FLAG_REF_ALLOC);
    2820           0 :                 NDR_CHECK(ndr_pull_eventlog6_RpcInfo(ndr, NDR_SCALARS, r->out.error));
    2821           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_error_0, LIBNDR_FLAG_REF_ALLOC);
    2822           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    2823             :         }
    2824           0 :         return NDR_ERR_SUCCESS;
    2825             : }
    2826             : 
    2827           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcLocalizeExportLog(struct ndr_print *ndr, const char *name, int flags, const struct eventlog6_EvtRpcLocalizeExportLog *r)
    2828             : {
    2829           0 :         ndr_print_struct(ndr, name, "eventlog6_EvtRpcLocalizeExportLog");
    2830           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2831           0 :         ndr->depth++;
    2832           0 :         if (flags & NDR_SET_VALUES) {
    2833           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2834             :         }
    2835           0 :         if (flags & NDR_IN) {
    2836           0 :                 ndr_print_struct(ndr, "in", "eventlog6_EvtRpcLocalizeExportLog");
    2837           0 :                 ndr->depth++;
    2838           0 :                 ndr_print_ptr(ndr, "control", r->in.control);
    2839           0 :                 ndr->depth++;
    2840           0 :                 ndr_print_policy_handle(ndr, "control", r->in.control);
    2841           0 :                 ndr->depth--;
    2842           0 :                 ndr_print_ptr(ndr, "logFilePath", r->in.logFilePath);
    2843           0 :                 ndr->depth++;
    2844           0 :                 ndr_print_string(ndr, "logFilePath", r->in.logFilePath);
    2845           0 :                 ndr->depth--;
    2846           0 :                 ndr_print_uint32(ndr, "locale", r->in.locale);
    2847           0 :                 ndr_print_uint32(ndr, "flags", r->in.flags);
    2848           0 :                 ndr->depth--;
    2849             :         }
    2850           0 :         if (flags & NDR_OUT) {
    2851           0 :                 ndr_print_struct(ndr, "out", "eventlog6_EvtRpcLocalizeExportLog");
    2852           0 :                 ndr->depth++;
    2853           0 :                 ndr_print_ptr(ndr, "error", r->out.error);
    2854           0 :                 ndr->depth++;
    2855           0 :                 ndr_print_eventlog6_RpcInfo(ndr, "error", r->out.error);
    2856           0 :                 ndr->depth--;
    2857           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    2858           0 :                 ndr->depth--;
    2859             :         }
    2860           0 :         ndr->depth--;
    2861             : }
    2862             : 
    2863           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcMessageRender(struct ndr_push *ndr, int flags, const struct eventlog6_EvtRpcMessageRender *r)
    2864             : {
    2865           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2866           0 :         if (flags & NDR_IN) {
    2867           0 :                 if (r->in.pubCfgObj == NULL) {
    2868           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2869             :                 }
    2870           0 :                 if (r->in.eventId == NULL) {
    2871           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2872             :                 }
    2873           0 :                 if (r->in.values == NULL) {
    2874           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2875             :                 }
    2876           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.pubCfgObj));
    2877           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.sizeEventId));
    2878           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.sizeEventId));
    2879           0 :                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.eventId, r->in.sizeEventId));
    2880           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.messageId));
    2881           0 :                 NDR_CHECK(ndr_push_eventlog6_EvtRpcVariantList(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.values));
    2882           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
    2883           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.maxSizeString));
    2884             :         }
    2885           0 :         if (flags & NDR_OUT) {
    2886           0 :                 if (r->out.actualSizeString == NULL) {
    2887           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2888             :                 }
    2889           0 :                 if (r->out.neededSizeString == NULL) {
    2890           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2891             :                 }
    2892           0 :                 if (r->out.string == NULL) {
    2893           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2894             :                 }
    2895           0 :                 if (r->out.error == NULL) {
    2896           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2897             :                 }
    2898           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.actualSizeString));
    2899           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.neededSizeString));
    2900           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.string));
    2901           0 :                 if (*r->out.string) {
    2902           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.actualSizeString));
    2903           0 :                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, *r->out.string, *r->out.actualSizeString));
    2904             :                 }
    2905           0 :                 NDR_CHECK(ndr_push_eventlog6_RpcInfo(ndr, NDR_SCALARS, r->out.error));
    2906           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    2907             :         }
    2908           0 :         return NDR_ERR_SUCCESS;
    2909             : }
    2910             : 
    2911           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcMessageRender(struct ndr_pull *ndr, int flags, struct eventlog6_EvtRpcMessageRender *r)
    2912             : {
    2913           0 :         uint32_t size_eventId_1 = 0;
    2914             :         uint32_t _ptr_string;
    2915           0 :         uint32_t size_string_2 = 0;
    2916           0 :         TALLOC_CTX *_mem_save_pubCfgObj_0 = NULL;
    2917           0 :         TALLOC_CTX *_mem_save_values_0 = NULL;
    2918           0 :         TALLOC_CTX *_mem_save_actualSizeString_0 = NULL;
    2919           0 :         TALLOC_CTX *_mem_save_neededSizeString_0 = NULL;
    2920           0 :         TALLOC_CTX *_mem_save_string_0 = NULL;
    2921           0 :         TALLOC_CTX *_mem_save_string_1 = NULL;
    2922           0 :         TALLOC_CTX *_mem_save_error_0 = NULL;
    2923           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2924           0 :         if (flags & NDR_IN) {
    2925           0 :                 NDR_ZERO_STRUCT(r->out);
    2926             : 
    2927           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2928           0 :                         NDR_PULL_ALLOC(ndr, r->in.pubCfgObj);
    2929             :                 }
    2930           0 :                 _mem_save_pubCfgObj_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2931           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.pubCfgObj, LIBNDR_FLAG_REF_ALLOC);
    2932           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.pubCfgObj));
    2933           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pubCfgObj_0, LIBNDR_FLAG_REF_ALLOC);
    2934           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.sizeEventId));
    2935           0 :                 if (r->in.sizeEventId < 1 || r->in.sizeEventId > MAX_RPC_EVENT_ID_SIZE) {
    2936           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    2937             :                 }
    2938           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.eventId));
    2939           0 :                 NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->in.eventId, &size_eventId_1));
    2940           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2941           0 :                         NDR_PULL_ALLOC_N(ndr, r->in.eventId, size_eventId_1);
    2942             :                 }
    2943           0 :                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.eventId, size_eventId_1));
    2944           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.messageId));
    2945           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2946           0 :                         NDR_PULL_ALLOC(ndr, r->in.values);
    2947             :                 }
    2948           0 :                 _mem_save_values_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2949           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.values, LIBNDR_FLAG_REF_ALLOC);
    2950           0 :                 NDR_CHECK(ndr_pull_eventlog6_EvtRpcVariantList(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.values));
    2951           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_0, LIBNDR_FLAG_REF_ALLOC);
    2952           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
    2953           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.maxSizeString));
    2954           0 :                 NDR_PULL_ALLOC(ndr, r->out.actualSizeString);
    2955           0 :                 NDR_ZERO_STRUCTP(r->out.actualSizeString);
    2956           0 :                 NDR_PULL_ALLOC(ndr, r->out.neededSizeString);
    2957           0 :                 NDR_ZERO_STRUCTP(r->out.neededSizeString);
    2958           0 :                 NDR_PULL_ALLOC(ndr, r->out.string);
    2959           0 :                 NDR_ZERO_STRUCTP(r->out.string);
    2960           0 :                 NDR_PULL_ALLOC(ndr, r->out.error);
    2961           0 :                 NDR_ZERO_STRUCTP(r->out.error);
    2962           0 :                 if (r->in.eventId) {
    2963           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->in.eventId, r->in.sizeEventId));
    2964             :                 }
    2965             :         }
    2966           0 :         if (flags & NDR_OUT) {
    2967             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2968             :                 if (r->in.pubCfgObj == NULL) {
    2969             :                         NDR_PULL_ALLOC(ndr, r->in.pubCfgObj);
    2970             :                         NDR_ZERO_STRUCTP(r->in.pubCfgObj);
    2971             :                 }
    2972             :                 if (r->in.values == NULL) {
    2973             :                         NDR_PULL_ALLOC(ndr, r->in.values);
    2974             :                         NDR_ZERO_STRUCTP(r->in.values);
    2975             :                 }
    2976             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2977           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2978           0 :                         NDR_PULL_ALLOC(ndr, r->out.actualSizeString);
    2979             :                 }
    2980           0 :                 _mem_save_actualSizeString_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2981           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.actualSizeString, LIBNDR_FLAG_REF_ALLOC);
    2982           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.actualSizeString));
    2983           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_actualSizeString_0, LIBNDR_FLAG_REF_ALLOC);
    2984           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2985           0 :                         NDR_PULL_ALLOC(ndr, r->out.neededSizeString);
    2986             :                 }
    2987           0 :                 _mem_save_neededSizeString_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2988           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.neededSizeString, LIBNDR_FLAG_REF_ALLOC);
    2989           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.neededSizeString));
    2990           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_neededSizeString_0, LIBNDR_FLAG_REF_ALLOC);
    2991           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2992           0 :                         NDR_PULL_ALLOC(ndr, r->out.string);
    2993             :                 }
    2994           0 :                 _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2995           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.string, LIBNDR_FLAG_REF_ALLOC);
    2996           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
    2997           0 :                 if (_ptr_string) {
    2998           0 :                         NDR_PULL_ALLOC(ndr, *r->out.string);
    2999             :                 } else {
    3000           0 :                         *r->out.string = NULL;
    3001             :                 }
    3002           0 :                 if (*r->out.string) {
    3003           0 :                         _mem_save_string_1 = NDR_PULL_GET_MEM_CTX(ndr);
    3004           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.string, 0);
    3005           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.string));
    3006           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)r->out.string, &size_string_2));
    3007           0 :                         if (size_string_2 > MAX_RPC_RENDERED_STRING_SIZE) {
    3008           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    3009             :                         }
    3010           0 :                         NDR_PULL_ALLOC_N(ndr, *r->out.string, size_string_2);
    3011           0 :                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, *r->out.string, size_string_2));
    3012           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_1, 0);
    3013             :                 }
    3014           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, LIBNDR_FLAG_REF_ALLOC);
    3015           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3016           0 :                         NDR_PULL_ALLOC(ndr, r->out.error);
    3017             :                 }
    3018           0 :                 _mem_save_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3019           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.error, LIBNDR_FLAG_REF_ALLOC);
    3020           0 :                 NDR_CHECK(ndr_pull_eventlog6_RpcInfo(ndr, NDR_SCALARS, r->out.error));
    3021           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_error_0, LIBNDR_FLAG_REF_ALLOC);
    3022           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    3023           0 :                 if (*r->out.string) {
    3024           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)r->out.string, *r->out.actualSizeString));
    3025             :                 }
    3026             :         }
    3027           0 :         return NDR_ERR_SUCCESS;
    3028             : }
    3029             : 
    3030           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcMessageRender(struct ndr_print *ndr, const char *name, int flags, const struct eventlog6_EvtRpcMessageRender *r)
    3031             : {
    3032           0 :         ndr_print_struct(ndr, name, "eventlog6_EvtRpcMessageRender");
    3033           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3034           0 :         ndr->depth++;
    3035           0 :         if (flags & NDR_SET_VALUES) {
    3036           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    3037             :         }
    3038           0 :         if (flags & NDR_IN) {
    3039           0 :                 ndr_print_struct(ndr, "in", "eventlog6_EvtRpcMessageRender");
    3040           0 :                 ndr->depth++;
    3041           0 :                 ndr_print_ptr(ndr, "pubCfgObj", r->in.pubCfgObj);
    3042           0 :                 ndr->depth++;
    3043           0 :                 ndr_print_policy_handle(ndr, "pubCfgObj", r->in.pubCfgObj);
    3044           0 :                 ndr->depth--;
    3045           0 :                 ndr_print_uint32(ndr, "sizeEventId", r->in.sizeEventId);
    3046           0 :                 ndr_print_ptr(ndr, "eventId", r->in.eventId);
    3047           0 :                 ndr->depth++;
    3048           0 :                 ndr_print_array_uint8(ndr, "eventId", r->in.eventId, r->in.sizeEventId);
    3049           0 :                 ndr->depth--;
    3050           0 :                 ndr_print_uint32(ndr, "messageId", r->in.messageId);
    3051           0 :                 ndr_print_ptr(ndr, "values", r->in.values);
    3052           0 :                 ndr->depth++;
    3053           0 :                 ndr_print_eventlog6_EvtRpcVariantList(ndr, "values", r->in.values);
    3054           0 :                 ndr->depth--;
    3055           0 :                 ndr_print_uint32(ndr, "flags", r->in.flags);
    3056           0 :                 ndr_print_uint32(ndr, "maxSizeString", r->in.maxSizeString);
    3057           0 :                 ndr->depth--;
    3058             :         }
    3059           0 :         if (flags & NDR_OUT) {
    3060           0 :                 ndr_print_struct(ndr, "out", "eventlog6_EvtRpcMessageRender");
    3061           0 :                 ndr->depth++;
    3062           0 :                 ndr_print_ptr(ndr, "actualSizeString", r->out.actualSizeString);
    3063           0 :                 ndr->depth++;
    3064           0 :                 ndr_print_uint32(ndr, "actualSizeString", *r->out.actualSizeString);
    3065           0 :                 ndr->depth--;
    3066           0 :                 ndr_print_ptr(ndr, "neededSizeString", r->out.neededSizeString);
    3067           0 :                 ndr->depth++;
    3068           0 :                 ndr_print_uint32(ndr, "neededSizeString", *r->out.neededSizeString);
    3069           0 :                 ndr->depth--;
    3070           0 :                 ndr_print_ptr(ndr, "string", r->out.string);
    3071           0 :                 ndr->depth++;
    3072           0 :                 ndr_print_ptr(ndr, "string", *r->out.string);
    3073           0 :                 ndr->depth++;
    3074           0 :                 if (*r->out.string) {
    3075           0 :                         ndr_print_array_uint8(ndr, "string", *r->out.string, *r->out.actualSizeString);
    3076             :                 }
    3077           0 :                 ndr->depth--;
    3078           0 :                 ndr->depth--;
    3079           0 :                 ndr_print_ptr(ndr, "error", r->out.error);
    3080           0 :                 ndr->depth++;
    3081           0 :                 ndr_print_eventlog6_RpcInfo(ndr, "error", r->out.error);
    3082           0 :                 ndr->depth--;
    3083           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    3084           0 :                 ndr->depth--;
    3085             :         }
    3086           0 :         ndr->depth--;
    3087             : }
    3088             : 
    3089           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcMessageRenderDefault(struct ndr_push *ndr, int flags, const struct eventlog6_EvtRpcMessageRenderDefault *r)
    3090             : {
    3091           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    3092           0 :         if (flags & NDR_IN) {
    3093           0 :                 if (r->in.eventId == NULL) {
    3094           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3095             :                 }
    3096           0 :                 if (r->in.values == NULL) {
    3097           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3098             :                 }
    3099           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.sizeEventId));
    3100           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.sizeEventId));
    3101           0 :                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.eventId, r->in.sizeEventId));
    3102           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.messageId));
    3103           0 :                 NDR_CHECK(ndr_push_eventlog6_EvtRpcVariantList(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.values));
    3104           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
    3105           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.maxSizeString));
    3106             :         }
    3107           0 :         if (flags & NDR_OUT) {
    3108           0 :                 if (r->out.actualSizeString == NULL) {
    3109           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3110             :                 }
    3111           0 :                 if (r->out.neededSizeString == NULL) {
    3112           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3113             :                 }
    3114           0 :                 if (r->out.string == NULL) {
    3115           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3116             :                 }
    3117           0 :                 if (r->out.error == NULL) {
    3118           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3119             :                 }
    3120           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.actualSizeString));
    3121           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.neededSizeString));
    3122           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.string));
    3123           0 :                 if (*r->out.string) {
    3124           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.actualSizeString));
    3125           0 :                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, *r->out.string, *r->out.actualSizeString));
    3126             :                 }
    3127           0 :                 NDR_CHECK(ndr_push_eventlog6_RpcInfo(ndr, NDR_SCALARS, r->out.error));
    3128           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    3129             :         }
    3130           0 :         return NDR_ERR_SUCCESS;
    3131             : }
    3132             : 
    3133           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcMessageRenderDefault(struct ndr_pull *ndr, int flags, struct eventlog6_EvtRpcMessageRenderDefault *r)
    3134             : {
    3135           0 :         uint32_t size_eventId_1 = 0;
    3136             :         uint32_t _ptr_string;
    3137           0 :         uint32_t size_string_2 = 0;
    3138           0 :         TALLOC_CTX *_mem_save_values_0 = NULL;
    3139           0 :         TALLOC_CTX *_mem_save_actualSizeString_0 = NULL;
    3140           0 :         TALLOC_CTX *_mem_save_neededSizeString_0 = NULL;
    3141           0 :         TALLOC_CTX *_mem_save_string_0 = NULL;
    3142           0 :         TALLOC_CTX *_mem_save_string_1 = NULL;
    3143           0 :         TALLOC_CTX *_mem_save_error_0 = NULL;
    3144           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    3145           0 :         if (flags & NDR_IN) {
    3146           0 :                 NDR_ZERO_STRUCT(r->out);
    3147             : 
    3148           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.sizeEventId));
    3149           0 :                 if (r->in.sizeEventId < 1 || r->in.sizeEventId > MAX_RPC_EVENT_ID_SIZE) {
    3150           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    3151             :                 }
    3152           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.eventId));
    3153           0 :                 NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->in.eventId, &size_eventId_1));
    3154           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3155           0 :                         NDR_PULL_ALLOC_N(ndr, r->in.eventId, size_eventId_1);
    3156             :                 }
    3157           0 :                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.eventId, size_eventId_1));
    3158           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.messageId));
    3159           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3160           0 :                         NDR_PULL_ALLOC(ndr, r->in.values);
    3161             :                 }
    3162           0 :                 _mem_save_values_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3163           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.values, LIBNDR_FLAG_REF_ALLOC);
    3164           0 :                 NDR_CHECK(ndr_pull_eventlog6_EvtRpcVariantList(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.values));
    3165           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_0, LIBNDR_FLAG_REF_ALLOC);
    3166           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
    3167           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.maxSizeString));
    3168           0 :                 NDR_PULL_ALLOC(ndr, r->out.actualSizeString);
    3169           0 :                 NDR_ZERO_STRUCTP(r->out.actualSizeString);
    3170           0 :                 NDR_PULL_ALLOC(ndr, r->out.neededSizeString);
    3171           0 :                 NDR_ZERO_STRUCTP(r->out.neededSizeString);
    3172           0 :                 NDR_PULL_ALLOC(ndr, r->out.string);
    3173           0 :                 NDR_ZERO_STRUCTP(r->out.string);
    3174           0 :                 NDR_PULL_ALLOC(ndr, r->out.error);
    3175           0 :                 NDR_ZERO_STRUCTP(r->out.error);
    3176           0 :                 if (r->in.eventId) {
    3177           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->in.eventId, r->in.sizeEventId));
    3178             :                 }
    3179             :         }
    3180           0 :         if (flags & NDR_OUT) {
    3181             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    3182             :                 if (r->in.values == NULL) {
    3183             :                         NDR_PULL_ALLOC(ndr, r->in.values);
    3184             :                         NDR_ZERO_STRUCTP(r->in.values);
    3185             :                 }
    3186             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    3187           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3188           0 :                         NDR_PULL_ALLOC(ndr, r->out.actualSizeString);
    3189             :                 }
    3190           0 :                 _mem_save_actualSizeString_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3191           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.actualSizeString, LIBNDR_FLAG_REF_ALLOC);
    3192           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.actualSizeString));
    3193           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_actualSizeString_0, LIBNDR_FLAG_REF_ALLOC);
    3194           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3195           0 :                         NDR_PULL_ALLOC(ndr, r->out.neededSizeString);
    3196             :                 }
    3197           0 :                 _mem_save_neededSizeString_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3198           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.neededSizeString, LIBNDR_FLAG_REF_ALLOC);
    3199           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.neededSizeString));
    3200           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_neededSizeString_0, LIBNDR_FLAG_REF_ALLOC);
    3201           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3202           0 :                         NDR_PULL_ALLOC(ndr, r->out.string);
    3203             :                 }
    3204           0 :                 _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3205           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.string, LIBNDR_FLAG_REF_ALLOC);
    3206           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
    3207           0 :                 if (_ptr_string) {
    3208           0 :                         NDR_PULL_ALLOC(ndr, *r->out.string);
    3209             :                 } else {
    3210           0 :                         *r->out.string = NULL;
    3211             :                 }
    3212           0 :                 if (*r->out.string) {
    3213           0 :                         _mem_save_string_1 = NDR_PULL_GET_MEM_CTX(ndr);
    3214           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.string, 0);
    3215           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.string));
    3216           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)r->out.string, &size_string_2));
    3217           0 :                         if (size_string_2 > MAX_RPC_RENDERED_STRING_SIZE) {
    3218           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    3219             :                         }
    3220           0 :                         NDR_PULL_ALLOC_N(ndr, *r->out.string, size_string_2);
    3221           0 :                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, *r->out.string, size_string_2));
    3222           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_1, 0);
    3223             :                 }
    3224           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, LIBNDR_FLAG_REF_ALLOC);
    3225           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3226           0 :                         NDR_PULL_ALLOC(ndr, r->out.error);
    3227             :                 }
    3228           0 :                 _mem_save_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3229           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.error, LIBNDR_FLAG_REF_ALLOC);
    3230           0 :                 NDR_CHECK(ndr_pull_eventlog6_RpcInfo(ndr, NDR_SCALARS, r->out.error));
    3231           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_error_0, LIBNDR_FLAG_REF_ALLOC);
    3232           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    3233           0 :                 if (*r->out.string) {
    3234           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)r->out.string, *r->out.actualSizeString));
    3235             :                 }
    3236             :         }
    3237           0 :         return NDR_ERR_SUCCESS;
    3238             : }
    3239             : 
    3240           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcMessageRenderDefault(struct ndr_print *ndr, const char *name, int flags, const struct eventlog6_EvtRpcMessageRenderDefault *r)
    3241             : {
    3242           0 :         ndr_print_struct(ndr, name, "eventlog6_EvtRpcMessageRenderDefault");
    3243           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3244           0 :         ndr->depth++;
    3245           0 :         if (flags & NDR_SET_VALUES) {
    3246           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    3247             :         }
    3248           0 :         if (flags & NDR_IN) {
    3249           0 :                 ndr_print_struct(ndr, "in", "eventlog6_EvtRpcMessageRenderDefault");
    3250           0 :                 ndr->depth++;
    3251           0 :                 ndr_print_uint32(ndr, "sizeEventId", r->in.sizeEventId);
    3252           0 :                 ndr_print_ptr(ndr, "eventId", r->in.eventId);
    3253           0 :                 ndr->depth++;
    3254           0 :                 ndr_print_array_uint8(ndr, "eventId", r->in.eventId, r->in.sizeEventId);
    3255           0 :                 ndr->depth--;
    3256           0 :                 ndr_print_uint32(ndr, "messageId", r->in.messageId);
    3257           0 :                 ndr_print_ptr(ndr, "values", r->in.values);
    3258           0 :                 ndr->depth++;
    3259           0 :                 ndr_print_eventlog6_EvtRpcVariantList(ndr, "values", r->in.values);
    3260           0 :                 ndr->depth--;
    3261           0 :                 ndr_print_uint32(ndr, "flags", r->in.flags);
    3262           0 :                 ndr_print_uint32(ndr, "maxSizeString", r->in.maxSizeString);
    3263           0 :                 ndr->depth--;
    3264             :         }
    3265           0 :         if (flags & NDR_OUT) {
    3266           0 :                 ndr_print_struct(ndr, "out", "eventlog6_EvtRpcMessageRenderDefault");
    3267           0 :                 ndr->depth++;
    3268           0 :                 ndr_print_ptr(ndr, "actualSizeString", r->out.actualSizeString);
    3269           0 :                 ndr->depth++;
    3270           0 :                 ndr_print_uint32(ndr, "actualSizeString", *r->out.actualSizeString);
    3271           0 :                 ndr->depth--;
    3272           0 :                 ndr_print_ptr(ndr, "neededSizeString", r->out.neededSizeString);
    3273           0 :                 ndr->depth++;
    3274           0 :                 ndr_print_uint32(ndr, "neededSizeString", *r->out.neededSizeString);
    3275           0 :                 ndr->depth--;
    3276           0 :                 ndr_print_ptr(ndr, "string", r->out.string);
    3277           0 :                 ndr->depth++;
    3278           0 :                 ndr_print_ptr(ndr, "string", *r->out.string);
    3279           0 :                 ndr->depth++;
    3280           0 :                 if (*r->out.string) {
    3281           0 :                         ndr_print_array_uint8(ndr, "string", *r->out.string, *r->out.actualSizeString);
    3282             :                 }
    3283           0 :                 ndr->depth--;
    3284           0 :                 ndr->depth--;
    3285           0 :                 ndr_print_ptr(ndr, "error", r->out.error);
    3286           0 :                 ndr->depth++;
    3287           0 :                 ndr_print_eventlog6_RpcInfo(ndr, "error", r->out.error);
    3288           0 :                 ndr->depth--;
    3289           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    3290           0 :                 ndr->depth--;
    3291             :         }
    3292           0 :         ndr->depth--;
    3293             : }
    3294             : 
    3295           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcQueryNext(struct ndr_push *ndr, int flags, const struct eventlog6_EvtRpcQueryNext *r)
    3296             : {
    3297             :         uint32_t cntr_eventDataIndices_2;
    3298             :         uint32_t cntr_eventDataSizes_2;
    3299           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    3300           0 :         if (flags & NDR_IN) {
    3301           0 :                 if (r->in.logQuery == NULL) {
    3302           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3303             :                 }
    3304           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.logQuery));
    3305           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numRequestedRecords));
    3306           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.timeOutEnd));
    3307           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
    3308             :         }
    3309           0 :         if (flags & NDR_OUT) {
    3310           0 :                 if (r->out.numActualRecords == NULL) {
    3311           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3312             :                 }
    3313           0 :                 if (r->out.eventDataIndices == NULL) {
    3314           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3315             :                 }
    3316           0 :                 if (r->out.eventDataSizes == NULL) {
    3317           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3318             :                 }
    3319           0 :                 if (r->out.resultBufferSize == NULL) {
    3320           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3321             :                 }
    3322           0 :                 if (r->out.resultBuffer == NULL) {
    3323           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3324             :                 }
    3325           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.numActualRecords));
    3326           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.eventDataIndices));
    3327           0 :                 if (*r->out.eventDataIndices) {
    3328           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.numActualRecords));
    3329           0 :                         for (cntr_eventDataIndices_2 = 0; cntr_eventDataIndices_2 < (*r->out.numActualRecords); cntr_eventDataIndices_2++) {
    3330           0 :                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (*r->out.eventDataIndices)[cntr_eventDataIndices_2]));
    3331             :                         }
    3332             :                 }
    3333           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.eventDataSizes));
    3334           0 :                 if (*r->out.eventDataSizes) {
    3335           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.numActualRecords));
    3336           0 :                         for (cntr_eventDataSizes_2 = 0; cntr_eventDataSizes_2 < (*r->out.numActualRecords); cntr_eventDataSizes_2++) {
    3337           0 :                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (*r->out.eventDataSizes)[cntr_eventDataSizes_2]));
    3338             :                         }
    3339             :                 }
    3340           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resultBufferSize));
    3341           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.resultBuffer));
    3342           0 :                 if (*r->out.resultBuffer) {
    3343           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.resultBufferSize));
    3344           0 :                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, *r->out.resultBuffer, *r->out.resultBufferSize));
    3345             :                 }
    3346           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    3347             :         }
    3348           0 :         return NDR_ERR_SUCCESS;
    3349             : }
    3350             : 
    3351           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcQueryNext(struct ndr_pull *ndr, int flags, struct eventlog6_EvtRpcQueryNext *r)
    3352             : {
    3353             :         uint32_t _ptr_eventDataIndices;
    3354           0 :         uint32_t size_eventDataIndices_2 = 0;
    3355             :         uint32_t cntr_eventDataIndices_2;
    3356             :         uint32_t _ptr_eventDataSizes;
    3357           0 :         uint32_t size_eventDataSizes_2 = 0;
    3358             :         uint32_t cntr_eventDataSizes_2;
    3359             :         uint32_t _ptr_resultBuffer;
    3360           0 :         uint32_t size_resultBuffer_2 = 0;
    3361           0 :         TALLOC_CTX *_mem_save_logQuery_0 = NULL;
    3362           0 :         TALLOC_CTX *_mem_save_numActualRecords_0 = NULL;
    3363           0 :         TALLOC_CTX *_mem_save_eventDataIndices_0 = NULL;
    3364           0 :         TALLOC_CTX *_mem_save_eventDataIndices_1 = NULL;
    3365           0 :         TALLOC_CTX *_mem_save_eventDataIndices_2 = NULL;
    3366           0 :         TALLOC_CTX *_mem_save_eventDataSizes_0 = NULL;
    3367           0 :         TALLOC_CTX *_mem_save_eventDataSizes_1 = NULL;
    3368           0 :         TALLOC_CTX *_mem_save_eventDataSizes_2 = NULL;
    3369           0 :         TALLOC_CTX *_mem_save_resultBufferSize_0 = NULL;
    3370           0 :         TALLOC_CTX *_mem_save_resultBuffer_0 = NULL;
    3371           0 :         TALLOC_CTX *_mem_save_resultBuffer_1 = NULL;
    3372           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    3373           0 :         if (flags & NDR_IN) {
    3374           0 :                 NDR_ZERO_STRUCT(r->out);
    3375             : 
    3376           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3377           0 :                         NDR_PULL_ALLOC(ndr, r->in.logQuery);
    3378             :                 }
    3379           0 :                 _mem_save_logQuery_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3380           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.logQuery, LIBNDR_FLAG_REF_ALLOC);
    3381           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.logQuery));
    3382           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_logQuery_0, LIBNDR_FLAG_REF_ALLOC);
    3383           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numRequestedRecords));
    3384           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.timeOutEnd));
    3385           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
    3386           0 :                 NDR_PULL_ALLOC(ndr, r->out.numActualRecords);
    3387           0 :                 NDR_ZERO_STRUCTP(r->out.numActualRecords);
    3388           0 :                 NDR_PULL_ALLOC(ndr, r->out.eventDataIndices);
    3389           0 :                 NDR_ZERO_STRUCTP(r->out.eventDataIndices);
    3390           0 :                 NDR_PULL_ALLOC(ndr, r->out.eventDataSizes);
    3391           0 :                 NDR_ZERO_STRUCTP(r->out.eventDataSizes);
    3392           0 :                 NDR_PULL_ALLOC(ndr, r->out.resultBufferSize);
    3393           0 :                 NDR_ZERO_STRUCTP(r->out.resultBufferSize);
    3394           0 :                 NDR_PULL_ALLOC(ndr, r->out.resultBuffer);
    3395           0 :                 NDR_ZERO_STRUCTP(r->out.resultBuffer);
    3396             :         }
    3397           0 :         if (flags & NDR_OUT) {
    3398             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    3399             :                 if (r->in.logQuery == NULL) {
    3400             :                         NDR_PULL_ALLOC(ndr, r->in.logQuery);
    3401             :                         NDR_ZERO_STRUCTP(r->in.logQuery);
    3402             :                 }
    3403             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    3404           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3405           0 :                         NDR_PULL_ALLOC(ndr, r->out.numActualRecords);
    3406             :                 }
    3407           0 :                 _mem_save_numActualRecords_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3408           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.numActualRecords, LIBNDR_FLAG_REF_ALLOC);
    3409           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.numActualRecords));
    3410           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_numActualRecords_0, LIBNDR_FLAG_REF_ALLOC);
    3411           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3412           0 :                         NDR_PULL_ALLOC(ndr, r->out.eventDataIndices);
    3413             :                 }
    3414           0 :                 _mem_save_eventDataIndices_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3415           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.eventDataIndices, LIBNDR_FLAG_REF_ALLOC);
    3416           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_eventDataIndices));
    3417           0 :                 if (_ptr_eventDataIndices) {
    3418           0 :                         NDR_PULL_ALLOC(ndr, *r->out.eventDataIndices);
    3419             :                 } else {
    3420           0 :                         *r->out.eventDataIndices = NULL;
    3421             :                 }
    3422           0 :                 if (*r->out.eventDataIndices) {
    3423           0 :                         _mem_save_eventDataIndices_1 = NDR_PULL_GET_MEM_CTX(ndr);
    3424           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.eventDataIndices, 0);
    3425           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.eventDataIndices));
    3426           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)r->out.eventDataIndices, &size_eventDataIndices_2));
    3427           0 :                         if (size_eventDataIndices_2 > MAX_RPC_RECORD_COUNT) {
    3428           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    3429             :                         }
    3430           0 :                         NDR_PULL_ALLOC_N(ndr, *r->out.eventDataIndices, size_eventDataIndices_2);
    3431           0 :                         _mem_save_eventDataIndices_2 = NDR_PULL_GET_MEM_CTX(ndr);
    3432           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.eventDataIndices, 0);
    3433           0 :                         for (cntr_eventDataIndices_2 = 0; cntr_eventDataIndices_2 < (size_eventDataIndices_2); cntr_eventDataIndices_2++) {
    3434           0 :                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &(*r->out.eventDataIndices)[cntr_eventDataIndices_2]));
    3435             :                         }
    3436           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eventDataIndices_2, 0);
    3437           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eventDataIndices_1, 0);
    3438             :                 }
    3439           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eventDataIndices_0, LIBNDR_FLAG_REF_ALLOC);
    3440           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3441           0 :                         NDR_PULL_ALLOC(ndr, r->out.eventDataSizes);
    3442             :                 }
    3443           0 :                 _mem_save_eventDataSizes_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3444           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.eventDataSizes, LIBNDR_FLAG_REF_ALLOC);
    3445           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_eventDataSizes));
    3446           0 :                 if (_ptr_eventDataSizes) {
    3447           0 :                         NDR_PULL_ALLOC(ndr, *r->out.eventDataSizes);
    3448             :                 } else {
    3449           0 :                         *r->out.eventDataSizes = NULL;
    3450             :                 }
    3451           0 :                 if (*r->out.eventDataSizes) {
    3452           0 :                         _mem_save_eventDataSizes_1 = NDR_PULL_GET_MEM_CTX(ndr);
    3453           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.eventDataSizes, 0);
    3454           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.eventDataSizes));
    3455           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)r->out.eventDataSizes, &size_eventDataSizes_2));
    3456           0 :                         if (size_eventDataSizes_2 > MAX_RPC_RECORD_COUNT) {
    3457           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    3458             :                         }
    3459           0 :                         NDR_PULL_ALLOC_N(ndr, *r->out.eventDataSizes, size_eventDataSizes_2);
    3460           0 :                         _mem_save_eventDataSizes_2 = NDR_PULL_GET_MEM_CTX(ndr);
    3461           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.eventDataSizes, 0);
    3462           0 :                         for (cntr_eventDataSizes_2 = 0; cntr_eventDataSizes_2 < (size_eventDataSizes_2); cntr_eventDataSizes_2++) {
    3463           0 :                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &(*r->out.eventDataSizes)[cntr_eventDataSizes_2]));
    3464             :                         }
    3465           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eventDataSizes_2, 0);
    3466           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eventDataSizes_1, 0);
    3467             :                 }
    3468           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eventDataSizes_0, LIBNDR_FLAG_REF_ALLOC);
    3469           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3470           0 :                         NDR_PULL_ALLOC(ndr, r->out.resultBufferSize);
    3471             :                 }
    3472           0 :                 _mem_save_resultBufferSize_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3473           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resultBufferSize, LIBNDR_FLAG_REF_ALLOC);
    3474           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resultBufferSize));
    3475           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resultBufferSize_0, LIBNDR_FLAG_REF_ALLOC);
    3476           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3477           0 :                         NDR_PULL_ALLOC(ndr, r->out.resultBuffer);
    3478             :                 }
    3479           0 :                 _mem_save_resultBuffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3480           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resultBuffer, LIBNDR_FLAG_REF_ALLOC);
    3481           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resultBuffer));
    3482           0 :                 if (_ptr_resultBuffer) {
    3483           0 :                         NDR_PULL_ALLOC(ndr, *r->out.resultBuffer);
    3484             :                 } else {
    3485           0 :                         *r->out.resultBuffer = NULL;
    3486             :                 }
    3487           0 :                 if (*r->out.resultBuffer) {
    3488           0 :                         _mem_save_resultBuffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
    3489           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.resultBuffer, 0);
    3490           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.resultBuffer));
    3491           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)r->out.resultBuffer, &size_resultBuffer_2));
    3492           0 :                         if (size_resultBuffer_2 > MAX_RPC_BATCH_SIZE) {
    3493           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    3494             :                         }
    3495           0 :                         NDR_PULL_ALLOC_N(ndr, *r->out.resultBuffer, size_resultBuffer_2);
    3496           0 :                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, *r->out.resultBuffer, size_resultBuffer_2));
    3497           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resultBuffer_1, 0);
    3498             :                 }
    3499           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resultBuffer_0, LIBNDR_FLAG_REF_ALLOC);
    3500           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    3501           0 :                 if (*r->out.eventDataIndices) {
    3502           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)r->out.eventDataIndices, *r->out.numActualRecords));
    3503             :                 }
    3504           0 :                 if (*r->out.eventDataSizes) {
    3505           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)r->out.eventDataSizes, *r->out.numActualRecords));
    3506             :                 }
    3507           0 :                 if (*r->out.resultBuffer) {
    3508           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)r->out.resultBuffer, *r->out.resultBufferSize));
    3509             :                 }
    3510             :         }
    3511           0 :         return NDR_ERR_SUCCESS;
    3512             : }
    3513             : 
    3514           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcQueryNext(struct ndr_print *ndr, const char *name, int flags, const struct eventlog6_EvtRpcQueryNext *r)
    3515             : {
    3516             :         uint32_t cntr_eventDataIndices_2;
    3517             :         uint32_t cntr_eventDataSizes_2;
    3518           0 :         ndr_print_struct(ndr, name, "eventlog6_EvtRpcQueryNext");
    3519           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3520           0 :         ndr->depth++;
    3521           0 :         if (flags & NDR_SET_VALUES) {
    3522           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    3523             :         }
    3524           0 :         if (flags & NDR_IN) {
    3525           0 :                 ndr_print_struct(ndr, "in", "eventlog6_EvtRpcQueryNext");
    3526           0 :                 ndr->depth++;
    3527           0 :                 ndr_print_ptr(ndr, "logQuery", r->in.logQuery);
    3528           0 :                 ndr->depth++;
    3529           0 :                 ndr_print_policy_handle(ndr, "logQuery", r->in.logQuery);
    3530           0 :                 ndr->depth--;
    3531           0 :                 ndr_print_uint32(ndr, "numRequestedRecords", r->in.numRequestedRecords);
    3532           0 :                 ndr_print_uint32(ndr, "timeOutEnd", r->in.timeOutEnd);
    3533           0 :                 ndr_print_uint32(ndr, "flags", r->in.flags);
    3534           0 :                 ndr->depth--;
    3535             :         }
    3536           0 :         if (flags & NDR_OUT) {
    3537           0 :                 ndr_print_struct(ndr, "out", "eventlog6_EvtRpcQueryNext");
    3538           0 :                 ndr->depth++;
    3539           0 :                 ndr_print_ptr(ndr, "numActualRecords", r->out.numActualRecords);
    3540           0 :                 ndr->depth++;
    3541           0 :                 ndr_print_uint32(ndr, "numActualRecords", *r->out.numActualRecords);
    3542           0 :                 ndr->depth--;
    3543           0 :                 ndr_print_ptr(ndr, "eventDataIndices", r->out.eventDataIndices);
    3544           0 :                 ndr->depth++;
    3545           0 :                 ndr_print_ptr(ndr, "eventDataIndices", *r->out.eventDataIndices);
    3546           0 :                 ndr->depth++;
    3547           0 :                 if (*r->out.eventDataIndices) {
    3548           0 :                         ndr->print(ndr, "%s: ARRAY(%d)", "eventDataIndices", (int)*r->out.numActualRecords);
    3549           0 :                         ndr->depth++;
    3550           0 :                         for (cntr_eventDataIndices_2 = 0; cntr_eventDataIndices_2 < (*r->out.numActualRecords); cntr_eventDataIndices_2++) {
    3551           0 :                                 ndr_print_uint32(ndr, "eventDataIndices", (*r->out.eventDataIndices)[cntr_eventDataIndices_2]);
    3552             :                         }
    3553           0 :                         ndr->depth--;
    3554             :                 }
    3555           0 :                 ndr->depth--;
    3556           0 :                 ndr->depth--;
    3557           0 :                 ndr_print_ptr(ndr, "eventDataSizes", r->out.eventDataSizes);
    3558           0 :                 ndr->depth++;
    3559           0 :                 ndr_print_ptr(ndr, "eventDataSizes", *r->out.eventDataSizes);
    3560           0 :                 ndr->depth++;
    3561           0 :                 if (*r->out.eventDataSizes) {
    3562           0 :                         ndr->print(ndr, "%s: ARRAY(%d)", "eventDataSizes", (int)*r->out.numActualRecords);
    3563           0 :                         ndr->depth++;
    3564           0 :                         for (cntr_eventDataSizes_2 = 0; cntr_eventDataSizes_2 < (*r->out.numActualRecords); cntr_eventDataSizes_2++) {
    3565           0 :                                 ndr_print_uint32(ndr, "eventDataSizes", (*r->out.eventDataSizes)[cntr_eventDataSizes_2]);
    3566             :                         }
    3567           0 :                         ndr->depth--;
    3568             :                 }
    3569           0 :                 ndr->depth--;
    3570           0 :                 ndr->depth--;
    3571           0 :                 ndr_print_ptr(ndr, "resultBufferSize", r->out.resultBufferSize);
    3572           0 :                 ndr->depth++;
    3573           0 :                 ndr_print_uint32(ndr, "resultBufferSize", *r->out.resultBufferSize);
    3574           0 :                 ndr->depth--;
    3575           0 :                 ndr_print_ptr(ndr, "resultBuffer", r->out.resultBuffer);
    3576           0 :                 ndr->depth++;
    3577           0 :                 ndr_print_ptr(ndr, "resultBuffer", *r->out.resultBuffer);
    3578           0 :                 ndr->depth++;
    3579           0 :                 if (*r->out.resultBuffer) {
    3580           0 :                         ndr_print_array_uint8(ndr, "resultBuffer", *r->out.resultBuffer, *r->out.resultBufferSize);
    3581             :                 }
    3582           0 :                 ndr->depth--;
    3583           0 :                 ndr->depth--;
    3584           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    3585           0 :                 ndr->depth--;
    3586             :         }
    3587           0 :         ndr->depth--;
    3588             : }
    3589             : 
    3590           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcQuerySeek(struct ndr_push *ndr, int flags, const struct eventlog6_EvtRpcQuerySeek *r)
    3591             : {
    3592           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    3593           0 :         if (flags & NDR_IN) {
    3594           0 :                 if (r->in.logQuery == NULL) {
    3595           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3596             :                 }
    3597           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.logQuery));
    3598           0 :                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->in.pos));
    3599           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bookmarkXml));
    3600           0 :                 if (r->in.bookmarkXml) {
    3601           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.bookmarkXml, CH_UTF16)));
    3602           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    3603           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.bookmarkXml, CH_UTF16)));
    3604           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.bookmarkXml, ndr_charset_length(r->in.bookmarkXml, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    3605             :                 }
    3606           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.timeOut));
    3607           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
    3608             :         }
    3609           0 :         if (flags & NDR_OUT) {
    3610           0 :                 if (r->out.error == NULL) {
    3611           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3612             :                 }
    3613           0 :                 NDR_CHECK(ndr_push_eventlog6_RpcInfo(ndr, NDR_SCALARS, r->out.error));
    3614           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    3615             :         }
    3616           0 :         return NDR_ERR_SUCCESS;
    3617             : }
    3618             : 
    3619           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcQuerySeek(struct ndr_pull *ndr, int flags, struct eventlog6_EvtRpcQuerySeek *r)
    3620             : {
    3621             :         uint32_t _ptr_bookmarkXml;
    3622           0 :         uint32_t size_bookmarkXml_1 = 0;
    3623           0 :         uint32_t length_bookmarkXml_1 = 0;
    3624           0 :         TALLOC_CTX *_mem_save_logQuery_0 = NULL;
    3625           0 :         TALLOC_CTX *_mem_save_bookmarkXml_0 = NULL;
    3626           0 :         TALLOC_CTX *_mem_save_error_0 = NULL;
    3627           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    3628           0 :         if (flags & NDR_IN) {
    3629           0 :                 NDR_ZERO_STRUCT(r->out);
    3630             : 
    3631           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3632           0 :                         NDR_PULL_ALLOC(ndr, r->in.logQuery);
    3633             :                 }
    3634           0 :                 _mem_save_logQuery_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3635           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.logQuery, LIBNDR_FLAG_REF_ALLOC);
    3636           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.logQuery));
    3637           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_logQuery_0, LIBNDR_FLAG_REF_ALLOC);
    3638           0 :                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->in.pos));
    3639           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bookmarkXml));
    3640           0 :                 if (_ptr_bookmarkXml) {
    3641           0 :                         NDR_PULL_ALLOC(ndr, r->in.bookmarkXml);
    3642             :                 } else {
    3643           0 :                         r->in.bookmarkXml = NULL;
    3644             :                 }
    3645           0 :                 if (r->in.bookmarkXml) {
    3646           0 :                         _mem_save_bookmarkXml_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3647           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bookmarkXml, 0);
    3648           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.bookmarkXml));
    3649           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.bookmarkXml));
    3650           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.bookmarkXml, &size_bookmarkXml_1));
    3651           0 :                         if (size_bookmarkXml_1 > MAX_RPC_BOOKMARK_LENGTH) {
    3652           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    3653             :                         }
    3654           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.bookmarkXml, &length_bookmarkXml_1));
    3655           0 :                         if (length_bookmarkXml_1 > MAX_RPC_BOOKMARK_LENGTH) {
    3656           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    3657             :                         }
    3658           0 :                         if (length_bookmarkXml_1 > size_bookmarkXml_1) {
    3659           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_bookmarkXml_1, length_bookmarkXml_1);
    3660             :                         }
    3661           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_bookmarkXml_1, sizeof(uint16_t)));
    3662           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.bookmarkXml, length_bookmarkXml_1, sizeof(uint16_t), CH_UTF16));
    3663           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bookmarkXml_0, 0);
    3664             :                 }
    3665           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.timeOut));
    3666           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
    3667           0 :                 NDR_PULL_ALLOC(ndr, r->out.error);
    3668           0 :                 NDR_ZERO_STRUCTP(r->out.error);
    3669             :         }
    3670           0 :         if (flags & NDR_OUT) {
    3671             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    3672             :                 if (r->in.logQuery == NULL) {
    3673             :                         NDR_PULL_ALLOC(ndr, r->in.logQuery);
    3674             :                         NDR_ZERO_STRUCTP(r->in.logQuery);
    3675             :                 }
    3676             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    3677           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3678           0 :                         NDR_PULL_ALLOC(ndr, r->out.error);
    3679             :                 }
    3680           0 :                 _mem_save_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3681           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.error, LIBNDR_FLAG_REF_ALLOC);
    3682           0 :                 NDR_CHECK(ndr_pull_eventlog6_RpcInfo(ndr, NDR_SCALARS, r->out.error));
    3683           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_error_0, LIBNDR_FLAG_REF_ALLOC);
    3684           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    3685             :         }
    3686           0 :         return NDR_ERR_SUCCESS;
    3687             : }
    3688             : 
    3689           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcQuerySeek(struct ndr_print *ndr, const char *name, int flags, const struct eventlog6_EvtRpcQuerySeek *r)
    3690             : {
    3691           0 :         ndr_print_struct(ndr, name, "eventlog6_EvtRpcQuerySeek");
    3692           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3693           0 :         ndr->depth++;
    3694           0 :         if (flags & NDR_SET_VALUES) {
    3695           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    3696             :         }
    3697           0 :         if (flags & NDR_IN) {
    3698           0 :                 ndr_print_struct(ndr, "in", "eventlog6_EvtRpcQuerySeek");
    3699           0 :                 ndr->depth++;
    3700           0 :                 ndr_print_ptr(ndr, "logQuery", r->in.logQuery);
    3701           0 :                 ndr->depth++;
    3702           0 :                 ndr_print_policy_handle(ndr, "logQuery", r->in.logQuery);
    3703           0 :                 ndr->depth--;
    3704           0 :                 ndr_print_hyper(ndr, "pos", r->in.pos);
    3705           0 :                 ndr_print_ptr(ndr, "bookmarkXml", r->in.bookmarkXml);
    3706           0 :                 ndr->depth++;
    3707           0 :                 if (r->in.bookmarkXml) {
    3708           0 :                         ndr_print_string(ndr, "bookmarkXml", r->in.bookmarkXml);
    3709             :                 }
    3710           0 :                 ndr->depth--;
    3711           0 :                 ndr_print_uint32(ndr, "timeOut", r->in.timeOut);
    3712           0 :                 ndr_print_uint32(ndr, "flags", r->in.flags);
    3713           0 :                 ndr->depth--;
    3714             :         }
    3715           0 :         if (flags & NDR_OUT) {
    3716           0 :                 ndr_print_struct(ndr, "out", "eventlog6_EvtRpcQuerySeek");
    3717           0 :                 ndr->depth++;
    3718           0 :                 ndr_print_ptr(ndr, "error", r->out.error);
    3719           0 :                 ndr->depth++;
    3720           0 :                 ndr_print_eventlog6_RpcInfo(ndr, "error", r->out.error);
    3721           0 :                 ndr->depth--;
    3722           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    3723           0 :                 ndr->depth--;
    3724             :         }
    3725           0 :         ndr->depth--;
    3726             : }
    3727             : 
    3728           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcClose(struct ndr_push *ndr, int flags, const struct eventlog6_EvtRpcClose *r)
    3729             : {
    3730           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    3731           0 :         if (flags & NDR_IN) {
    3732           0 :                 if (r->in.handle == NULL) {
    3733           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3734             :                 }
    3735           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->in.handle));
    3736           0 :                 if (*r->in.handle) {
    3737           0 :                         NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, *r->in.handle));
    3738             :                 }
    3739             :         }
    3740           0 :         if (flags & NDR_OUT) {
    3741           0 :                 if (r->out.handle == NULL) {
    3742           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3743             :                 }
    3744           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.handle));
    3745           0 :                 if (*r->out.handle) {
    3746           0 :                         NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, *r->out.handle));
    3747             :                 }
    3748           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    3749             :         }
    3750           0 :         return NDR_ERR_SUCCESS;
    3751             : }
    3752             : 
    3753           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcClose(struct ndr_pull *ndr, int flags, struct eventlog6_EvtRpcClose *r)
    3754             : {
    3755             :         uint32_t _ptr_handle;
    3756           0 :         TALLOC_CTX *_mem_save_handle_0 = NULL;
    3757           0 :         TALLOC_CTX *_mem_save_handle_1 = NULL;
    3758           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    3759           0 :         if (flags & NDR_IN) {
    3760           0 :                 NDR_ZERO_STRUCT(r->out);
    3761             : 
    3762           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3763           0 :                         NDR_PULL_ALLOC(ndr, r->in.handle);
    3764             :                 }
    3765           0 :                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3766           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
    3767           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_handle));
    3768           0 :                 if (_ptr_handle) {
    3769           0 :                         NDR_PULL_ALLOC(ndr, *r->in.handle);
    3770             :                 } else {
    3771           0 :                         *r->in.handle = NULL;
    3772             :                 }
    3773           0 :                 if (*r->in.handle) {
    3774           0 :                         _mem_save_handle_1 = NDR_PULL_GET_MEM_CTX(ndr);
    3775           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->in.handle, 0);
    3776           0 :                         NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, *r->in.handle));
    3777           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_1, 0);
    3778             :                 }
    3779           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
    3780           0 :                 NDR_PULL_ALLOC(ndr, r->out.handle);
    3781           0 :                 *r->out.handle = *r->in.handle;
    3782             :         }
    3783           0 :         if (flags & NDR_OUT) {
    3784             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    3785             :                 if (r->in.handle == NULL) {
    3786             :                         NDR_PULL_ALLOC(ndr, r->in.handle);
    3787             :                         NDR_ZERO_STRUCTP(r->in.handle);
    3788             :                 }
    3789             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    3790           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3791           0 :                         NDR_PULL_ALLOC(ndr, r->out.handle);
    3792             :                 }
    3793           0 :                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3794           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
    3795           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_handle));
    3796           0 :                 if (_ptr_handle) {
    3797           0 :                         NDR_PULL_ALLOC(ndr, *r->out.handle);
    3798             :                 } else {
    3799           0 :                         *r->out.handle = NULL;
    3800             :                 }
    3801           0 :                 if (*r->out.handle) {
    3802           0 :                         _mem_save_handle_1 = NDR_PULL_GET_MEM_CTX(ndr);
    3803           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.handle, 0);
    3804           0 :                         NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, *r->out.handle));
    3805           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_1, 0);
    3806             :                 }
    3807           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
    3808           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    3809             :         }
    3810           0 :         return NDR_ERR_SUCCESS;
    3811             : }
    3812             : 
    3813           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcClose(struct ndr_print *ndr, const char *name, int flags, const struct eventlog6_EvtRpcClose *r)
    3814             : {
    3815           0 :         ndr_print_struct(ndr, name, "eventlog6_EvtRpcClose");
    3816           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3817           0 :         ndr->depth++;
    3818           0 :         if (flags & NDR_SET_VALUES) {
    3819           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    3820             :         }
    3821           0 :         if (flags & NDR_IN) {
    3822           0 :                 ndr_print_struct(ndr, "in", "eventlog6_EvtRpcClose");
    3823           0 :                 ndr->depth++;
    3824           0 :                 ndr_print_ptr(ndr, "handle", r->in.handle);
    3825           0 :                 ndr->depth++;
    3826           0 :                 ndr_print_ptr(ndr, "handle", *r->in.handle);
    3827           0 :                 ndr->depth++;
    3828           0 :                 if (*r->in.handle) {
    3829           0 :                         ndr_print_policy_handle(ndr, "handle", *r->in.handle);
    3830             :                 }
    3831           0 :                 ndr->depth--;
    3832           0 :                 ndr->depth--;
    3833           0 :                 ndr->depth--;
    3834             :         }
    3835           0 :         if (flags & NDR_OUT) {
    3836           0 :                 ndr_print_struct(ndr, "out", "eventlog6_EvtRpcClose");
    3837           0 :                 ndr->depth++;
    3838           0 :                 ndr_print_ptr(ndr, "handle", r->out.handle);
    3839           0 :                 ndr->depth++;
    3840           0 :                 ndr_print_ptr(ndr, "handle", *r->out.handle);
    3841           0 :                 ndr->depth++;
    3842           0 :                 if (*r->out.handle) {
    3843           0 :                         ndr_print_policy_handle(ndr, "handle", *r->out.handle);
    3844             :                 }
    3845           0 :                 ndr->depth--;
    3846           0 :                 ndr->depth--;
    3847           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    3848           0 :                 ndr->depth--;
    3849             :         }
    3850           0 :         ndr->depth--;
    3851             : }
    3852             : 
    3853           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcCancel(struct ndr_push *ndr, int flags, const struct eventlog6_EvtRpcCancel *r)
    3854             : {
    3855           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    3856           0 :         if (flags & NDR_IN) {
    3857           0 :                 if (r->in.handle == NULL) {
    3858           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3859             :                 }
    3860           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
    3861             :         }
    3862           0 :         if (flags & NDR_OUT) {
    3863           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    3864             :         }
    3865           0 :         return NDR_ERR_SUCCESS;
    3866             : }
    3867             : 
    3868           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcCancel(struct ndr_pull *ndr, int flags, struct eventlog6_EvtRpcCancel *r)
    3869             : {
    3870           0 :         TALLOC_CTX *_mem_save_handle_0 = NULL;
    3871           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    3872           0 :         if (flags & NDR_IN) {
    3873           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3874           0 :                         NDR_PULL_ALLOC(ndr, r->in.handle);
    3875             :                 }
    3876           0 :                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3877           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
    3878           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
    3879           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
    3880             :         }
    3881           0 :         if (flags & NDR_OUT) {
    3882             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    3883             :                 if (r->in.handle == NULL) {
    3884             :                         NDR_PULL_ALLOC(ndr, r->in.handle);
    3885             :                         NDR_ZERO_STRUCTP(r->in.handle);
    3886             :                 }
    3887             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    3888           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    3889             :         }
    3890           0 :         return NDR_ERR_SUCCESS;
    3891             : }
    3892             : 
    3893           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcCancel(struct ndr_print *ndr, const char *name, int flags, const struct eventlog6_EvtRpcCancel *r)
    3894             : {
    3895           0 :         ndr_print_struct(ndr, name, "eventlog6_EvtRpcCancel");
    3896           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3897           0 :         ndr->depth++;
    3898           0 :         if (flags & NDR_SET_VALUES) {
    3899           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    3900             :         }
    3901           0 :         if (flags & NDR_IN) {
    3902           0 :                 ndr_print_struct(ndr, "in", "eventlog6_EvtRpcCancel");
    3903           0 :                 ndr->depth++;
    3904           0 :                 ndr_print_ptr(ndr, "handle", r->in.handle);
    3905           0 :                 ndr->depth++;
    3906           0 :                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
    3907           0 :                 ndr->depth--;
    3908           0 :                 ndr->depth--;
    3909             :         }
    3910           0 :         if (flags & NDR_OUT) {
    3911           0 :                 ndr_print_struct(ndr, "out", "eventlog6_EvtRpcCancel");
    3912           0 :                 ndr->depth++;
    3913           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    3914           0 :                 ndr->depth--;
    3915             :         }
    3916           0 :         ndr->depth--;
    3917             : }
    3918             : 
    3919           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcAssertConfig(struct ndr_push *ndr, int flags, const struct eventlog6_EvtRpcAssertConfig *r)
    3920             : {
    3921           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    3922           0 :         if (flags & NDR_IN) {
    3923           0 :                 if (r->in.path == NULL) {
    3924           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3925             :                 }
    3926           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));
    3927           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    3928           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));
    3929           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.path, ndr_charset_length(r->in.path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    3930           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
    3931             :         }
    3932           0 :         if (flags & NDR_OUT) {
    3933           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    3934             :         }
    3935           0 :         return NDR_ERR_SUCCESS;
    3936             : }
    3937             : 
    3938           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcAssertConfig(struct ndr_pull *ndr, int flags, struct eventlog6_EvtRpcAssertConfig *r)
    3939             : {
    3940           0 :         uint32_t size_path_1 = 0;
    3941           0 :         uint32_t length_path_1 = 0;
    3942           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    3943           0 :         if (flags & NDR_IN) {
    3944           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path));
    3945           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path));
    3946           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.path, &size_path_1));
    3947           0 :                 if (size_path_1 < 1 || size_path_1 > MAX_RPC_CHANNEL_NAME_LENGTH) {
    3948           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    3949             :                 }
    3950           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.path, &length_path_1));
    3951           0 :                 if (length_path_1 < 1 || length_path_1 > MAX_RPC_CHANNEL_NAME_LENGTH) {
    3952           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    3953             :                 }
    3954           0 :                 if (length_path_1 > size_path_1) {
    3955           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_path_1, length_path_1);
    3956             :                 }
    3957           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_path_1, sizeof(uint16_t)));
    3958           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.path, length_path_1, sizeof(uint16_t), CH_UTF16));
    3959           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
    3960             :         }
    3961           0 :         if (flags & NDR_OUT) {
    3962             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    3963             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    3964           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    3965             :         }
    3966           0 :         return NDR_ERR_SUCCESS;
    3967             : }
    3968             : 
    3969           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcAssertConfig(struct ndr_print *ndr, const char *name, int flags, const struct eventlog6_EvtRpcAssertConfig *r)
    3970             : {
    3971           0 :         ndr_print_struct(ndr, name, "eventlog6_EvtRpcAssertConfig");
    3972           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3973           0 :         ndr->depth++;
    3974           0 :         if (flags & NDR_SET_VALUES) {
    3975           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    3976             :         }
    3977           0 :         if (flags & NDR_IN) {
    3978           0 :                 ndr_print_struct(ndr, "in", "eventlog6_EvtRpcAssertConfig");
    3979           0 :                 ndr->depth++;
    3980           0 :                 ndr_print_ptr(ndr, "path", r->in.path);
    3981           0 :                 ndr->depth++;
    3982           0 :                 ndr_print_string(ndr, "path", r->in.path);
    3983           0 :                 ndr->depth--;
    3984           0 :                 ndr_print_uint32(ndr, "flags", r->in.flags);
    3985           0 :                 ndr->depth--;
    3986             :         }
    3987           0 :         if (flags & NDR_OUT) {
    3988           0 :                 ndr_print_struct(ndr, "out", "eventlog6_EvtRpcAssertConfig");
    3989           0 :                 ndr->depth++;
    3990           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    3991           0 :                 ndr->depth--;
    3992             :         }
    3993           0 :         ndr->depth--;
    3994             : }
    3995             : 
    3996           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcRetractConfig(struct ndr_push *ndr, int flags, const struct eventlog6_EvtRpcRetractConfig *r)
    3997             : {
    3998           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    3999           0 :         if (flags & NDR_IN) {
    4000           0 :                 if (r->in.path == NULL) {
    4001           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4002             :                 }
    4003           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));
    4004           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    4005           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));
    4006           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.path, ndr_charset_length(r->in.path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    4007           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
    4008             :         }
    4009           0 :         if (flags & NDR_OUT) {
    4010           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    4011             :         }
    4012           0 :         return NDR_ERR_SUCCESS;
    4013             : }
    4014             : 
    4015           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcRetractConfig(struct ndr_pull *ndr, int flags, struct eventlog6_EvtRpcRetractConfig *r)
    4016             : {
    4017           0 :         uint32_t size_path_1 = 0;
    4018           0 :         uint32_t length_path_1 = 0;
    4019           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    4020           0 :         if (flags & NDR_IN) {
    4021           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path));
    4022           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path));
    4023           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.path, &size_path_1));
    4024           0 :                 if (size_path_1 < 1 || size_path_1 > MAX_RPC_CHANNEL_NAME_LENGTH) {
    4025           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    4026             :                 }
    4027           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.path, &length_path_1));
    4028           0 :                 if (length_path_1 < 1 || length_path_1 > MAX_RPC_CHANNEL_NAME_LENGTH) {
    4029           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    4030             :                 }
    4031           0 :                 if (length_path_1 > size_path_1) {
    4032           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_path_1, length_path_1);
    4033             :                 }
    4034           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_path_1, sizeof(uint16_t)));
    4035           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.path, length_path_1, sizeof(uint16_t), CH_UTF16));
    4036           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
    4037             :         }
    4038           0 :         if (flags & NDR_OUT) {
    4039             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    4040             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    4041           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    4042             :         }
    4043           0 :         return NDR_ERR_SUCCESS;
    4044             : }
    4045             : 
    4046           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcRetractConfig(struct ndr_print *ndr, const char *name, int flags, const struct eventlog6_EvtRpcRetractConfig *r)
    4047             : {
    4048           0 :         ndr_print_struct(ndr, name, "eventlog6_EvtRpcRetractConfig");
    4049           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    4050           0 :         ndr->depth++;
    4051           0 :         if (flags & NDR_SET_VALUES) {
    4052           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    4053             :         }
    4054           0 :         if (flags & NDR_IN) {
    4055           0 :                 ndr_print_struct(ndr, "in", "eventlog6_EvtRpcRetractConfig");
    4056           0 :                 ndr->depth++;
    4057           0 :                 ndr_print_ptr(ndr, "path", r->in.path);
    4058           0 :                 ndr->depth++;
    4059           0 :                 ndr_print_string(ndr, "path", r->in.path);
    4060           0 :                 ndr->depth--;
    4061           0 :                 ndr_print_uint32(ndr, "flags", r->in.flags);
    4062           0 :                 ndr->depth--;
    4063             :         }
    4064           0 :         if (flags & NDR_OUT) {
    4065           0 :                 ndr_print_struct(ndr, "out", "eventlog6_EvtRpcRetractConfig");
    4066           0 :                 ndr->depth++;
    4067           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    4068           0 :                 ndr->depth--;
    4069             :         }
    4070           0 :         ndr->depth--;
    4071             : }
    4072             : 
    4073           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcOpenLogHandle(struct ndr_push *ndr, int flags, const struct eventlog6_EvtRpcOpenLogHandle *r)
    4074             : {
    4075           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    4076           0 :         if (flags & NDR_IN) {
    4077           0 :                 if (r->in.channel == NULL) {
    4078           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4079             :                 }
    4080           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.channel, CH_UTF16)));
    4081           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    4082           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.channel, CH_UTF16)));
    4083           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.channel, ndr_charset_length(r->in.channel, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    4084           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
    4085             :         }
    4086           0 :         if (flags & NDR_OUT) {
    4087           0 :                 if (r->out.handle == NULL) {
    4088           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4089             :                 }
    4090           0 :                 if (r->out.error == NULL) {
    4091           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4092             :                 }
    4093           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
    4094           0 :                 NDR_CHECK(ndr_push_eventlog6_RpcInfo(ndr, NDR_SCALARS, r->out.error));
    4095           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    4096             :         }
    4097           0 :         return NDR_ERR_SUCCESS;
    4098             : }
    4099             : 
    4100           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcOpenLogHandle(struct ndr_pull *ndr, int flags, struct eventlog6_EvtRpcOpenLogHandle *r)
    4101             : {
    4102           0 :         uint32_t size_channel_1 = 0;
    4103           0 :         uint32_t length_channel_1 = 0;
    4104           0 :         TALLOC_CTX *_mem_save_handle_0 = NULL;
    4105           0 :         TALLOC_CTX *_mem_save_error_0 = NULL;
    4106           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    4107           0 :         if (flags & NDR_IN) {
    4108           0 :                 NDR_ZERO_STRUCT(r->out);
    4109             : 
    4110           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.channel));
    4111           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.channel));
    4112           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.channel, &size_channel_1));
    4113           0 :                 if (size_channel_1 < 1 || size_channel_1 > MAX_RPC_CHANNEL_NAME_LENGTH) {
    4114           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    4115             :                 }
    4116           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.channel, &length_channel_1));
    4117           0 :                 if (length_channel_1 < 1 || length_channel_1 > MAX_RPC_CHANNEL_NAME_LENGTH) {
    4118           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    4119             :                 }
    4120           0 :                 if (length_channel_1 > size_channel_1) {
    4121           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_channel_1, length_channel_1);
    4122             :                 }
    4123           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_channel_1, sizeof(uint16_t)));
    4124           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.channel, length_channel_1, sizeof(uint16_t), CH_UTF16));
    4125           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
    4126           0 :                 NDR_PULL_ALLOC(ndr, r->out.handle);
    4127           0 :                 NDR_ZERO_STRUCTP(r->out.handle);
    4128           0 :                 NDR_PULL_ALLOC(ndr, r->out.error);
    4129           0 :                 NDR_ZERO_STRUCTP(r->out.error);
    4130             :         }
    4131           0 :         if (flags & NDR_OUT) {
    4132             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    4133             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    4134           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    4135           0 :                         NDR_PULL_ALLOC(ndr, r->out.handle);
    4136             :                 }
    4137           0 :                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
    4138           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
    4139           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
    4140           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
    4141           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    4142           0 :                         NDR_PULL_ALLOC(ndr, r->out.error);
    4143             :                 }
    4144           0 :                 _mem_save_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
    4145           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.error, LIBNDR_FLAG_REF_ALLOC);
    4146           0 :                 NDR_CHECK(ndr_pull_eventlog6_RpcInfo(ndr, NDR_SCALARS, r->out.error));
    4147           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_error_0, LIBNDR_FLAG_REF_ALLOC);
    4148           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    4149             :         }
    4150           0 :         return NDR_ERR_SUCCESS;
    4151             : }
    4152             : 
    4153           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcOpenLogHandle(struct ndr_print *ndr, const char *name, int flags, const struct eventlog6_EvtRpcOpenLogHandle *r)
    4154             : {
    4155           0 :         ndr_print_struct(ndr, name, "eventlog6_EvtRpcOpenLogHandle");
    4156           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    4157           0 :         ndr->depth++;
    4158           0 :         if (flags & NDR_SET_VALUES) {
    4159           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    4160             :         }
    4161           0 :         if (flags & NDR_IN) {
    4162           0 :                 ndr_print_struct(ndr, "in", "eventlog6_EvtRpcOpenLogHandle");
    4163           0 :                 ndr->depth++;
    4164           0 :                 ndr_print_ptr(ndr, "channel", r->in.channel);
    4165           0 :                 ndr->depth++;
    4166           0 :                 ndr_print_string(ndr, "channel", r->in.channel);
    4167           0 :                 ndr->depth--;
    4168           0 :                 ndr_print_uint32(ndr, "flags", r->in.flags);
    4169           0 :                 ndr->depth--;
    4170             :         }
    4171           0 :         if (flags & NDR_OUT) {
    4172           0 :                 ndr_print_struct(ndr, "out", "eventlog6_EvtRpcOpenLogHandle");
    4173           0 :                 ndr->depth++;
    4174           0 :                 ndr_print_ptr(ndr, "handle", r->out.handle);
    4175           0 :                 ndr->depth++;
    4176           0 :                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
    4177           0 :                 ndr->depth--;
    4178           0 :                 ndr_print_ptr(ndr, "error", r->out.error);
    4179           0 :                 ndr->depth++;
    4180           0 :                 ndr_print_eventlog6_RpcInfo(ndr, "error", r->out.error);
    4181           0 :                 ndr->depth--;
    4182           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    4183           0 :                 ndr->depth--;
    4184             :         }
    4185           0 :         ndr->depth--;
    4186             : }
    4187             : 
    4188           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcGetLogFileInfo(struct ndr_push *ndr, int flags, const struct eventlog6_EvtRpcGetLogFileInfo *r)
    4189             : {
    4190           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    4191           0 :         if (flags & NDR_IN) {
    4192           0 :                 if (r->in.logHandle == NULL) {
    4193           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4194             :                 }
    4195           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.logHandle));
    4196           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.propertyId));
    4197           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.propertyValueBufferSize));
    4198             :         }
    4199           0 :         if (flags & NDR_OUT) {
    4200           0 :                 if (r->out.propertyValueBuffer == NULL) {
    4201           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4202             :                 }
    4203           0 :                 if (r->out.propertyValueBufferLength == NULL) {
    4204           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4205             :                 }
    4206           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.propertyValueBufferSize));
    4207           0 :                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.propertyValueBuffer, r->in.propertyValueBufferSize));
    4208           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.propertyValueBufferLength));
    4209           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    4210             :         }
    4211           0 :         return NDR_ERR_SUCCESS;
    4212             : }
    4213             : 
    4214           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcGetLogFileInfo(struct ndr_pull *ndr, int flags, struct eventlog6_EvtRpcGetLogFileInfo *r)
    4215             : {
    4216           0 :         uint32_t size_propertyValueBuffer_1 = 0;
    4217           0 :         TALLOC_CTX *_mem_save_logHandle_0 = NULL;
    4218           0 :         TALLOC_CTX *_mem_save_propertyValueBufferLength_0 = NULL;
    4219           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    4220           0 :         if (flags & NDR_IN) {
    4221           0 :                 NDR_ZERO_STRUCT(r->out);
    4222             : 
    4223           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    4224           0 :                         NDR_PULL_ALLOC(ndr, r->in.logHandle);
    4225             :                 }
    4226           0 :                 _mem_save_logHandle_0 = NDR_PULL_GET_MEM_CTX(ndr);
    4227           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.logHandle, LIBNDR_FLAG_REF_ALLOC);
    4228           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.logHandle));
    4229           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_logHandle_0, LIBNDR_FLAG_REF_ALLOC);
    4230           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.propertyId));
    4231           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.propertyValueBufferSize));
    4232           0 :                 if (r->in.propertyValueBufferSize > MAX_RPC_PROPERTY_BUFFER_SIZE) {
    4233           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    4234             :                 }
    4235           0 :                 NDR_PULL_ALLOC_N(ndr, r->out.propertyValueBuffer, r->in.propertyValueBufferSize);
    4236           0 :                 memset(r->out.propertyValueBuffer, 0, (r->in.propertyValueBufferSize) * sizeof(*r->out.propertyValueBuffer));
    4237           0 :                 NDR_PULL_ALLOC(ndr, r->out.propertyValueBufferLength);
    4238           0 :                 NDR_ZERO_STRUCTP(r->out.propertyValueBufferLength);
    4239             :         }
    4240           0 :         if (flags & NDR_OUT) {
    4241             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    4242             :                 if (r->in.logHandle == NULL) {
    4243             :                         NDR_PULL_ALLOC(ndr, r->in.logHandle);
    4244             :                         NDR_ZERO_STRUCTP(r->in.logHandle);
    4245             :                 }
    4246             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    4247           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.propertyValueBuffer));
    4248           0 :                 NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->out.propertyValueBuffer, &size_propertyValueBuffer_1));
    4249           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    4250           0 :                         NDR_PULL_ALLOC_N(ndr, r->out.propertyValueBuffer, size_propertyValueBuffer_1);
    4251             :                 }
    4252           0 :                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.propertyValueBuffer, size_propertyValueBuffer_1));
    4253           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    4254           0 :                         NDR_PULL_ALLOC(ndr, r->out.propertyValueBufferLength);
    4255             :                 }
    4256           0 :                 _mem_save_propertyValueBufferLength_0 = NDR_PULL_GET_MEM_CTX(ndr);
    4257           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.propertyValueBufferLength, LIBNDR_FLAG_REF_ALLOC);
    4258           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.propertyValueBufferLength));
    4259           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_propertyValueBufferLength_0, LIBNDR_FLAG_REF_ALLOC);
    4260           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    4261           0 :                 if (r->out.propertyValueBuffer) {
    4262           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->out.propertyValueBuffer, r->in.propertyValueBufferSize));
    4263             :                 }
    4264             :         }
    4265           0 :         return NDR_ERR_SUCCESS;
    4266             : }
    4267             : 
    4268           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcGetLogFileInfo(struct ndr_print *ndr, const char *name, int flags, const struct eventlog6_EvtRpcGetLogFileInfo *r)
    4269             : {
    4270           0 :         ndr_print_struct(ndr, name, "eventlog6_EvtRpcGetLogFileInfo");
    4271           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    4272           0 :         ndr->depth++;
    4273           0 :         if (flags & NDR_SET_VALUES) {
    4274           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    4275             :         }
    4276           0 :         if (flags & NDR_IN) {
    4277           0 :                 ndr_print_struct(ndr, "in", "eventlog6_EvtRpcGetLogFileInfo");
    4278           0 :                 ndr->depth++;
    4279           0 :                 ndr_print_ptr(ndr, "logHandle", r->in.logHandle);
    4280           0 :                 ndr->depth++;
    4281           0 :                 ndr_print_policy_handle(ndr, "logHandle", r->in.logHandle);
    4282           0 :                 ndr->depth--;
    4283           0 :                 ndr_print_uint32(ndr, "propertyId", r->in.propertyId);
    4284           0 :                 ndr_print_uint32(ndr, "propertyValueBufferSize", r->in.propertyValueBufferSize);
    4285           0 :                 ndr->depth--;
    4286             :         }
    4287           0 :         if (flags & NDR_OUT) {
    4288           0 :                 ndr_print_struct(ndr, "out", "eventlog6_EvtRpcGetLogFileInfo");
    4289           0 :                 ndr->depth++;
    4290           0 :                 ndr_print_ptr(ndr, "propertyValueBuffer", r->out.propertyValueBuffer);
    4291           0 :                 ndr->depth++;
    4292           0 :                 ndr_print_array_uint8(ndr, "propertyValueBuffer", r->out.propertyValueBuffer, r->in.propertyValueBufferSize);
    4293           0 :                 ndr->depth--;
    4294           0 :                 ndr_print_ptr(ndr, "propertyValueBufferLength", r->out.propertyValueBufferLength);
    4295           0 :                 ndr->depth++;
    4296           0 :                 ndr_print_uint32(ndr, "propertyValueBufferLength", *r->out.propertyValueBufferLength);
    4297           0 :                 ndr->depth--;
    4298           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    4299           0 :                 ndr->depth--;
    4300             :         }
    4301           0 :         ndr->depth--;
    4302             : }
    4303             : 
    4304           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcGetChannelList(struct ndr_push *ndr, int flags, const struct eventlog6_EvtRpcGetChannelList *r)
    4305             : {
    4306             :         uint32_t cntr_channelPaths_2;
    4307           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    4308           0 :         if (flags & NDR_IN) {
    4309           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
    4310             :         }
    4311           0 :         if (flags & NDR_OUT) {
    4312           0 :                 if (r->out.numChannelPaths == NULL) {
    4313           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4314             :                 }
    4315           0 :                 if (r->out.channelPaths == NULL) {
    4316           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4317             :                 }
    4318           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.numChannelPaths));
    4319           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.channelPaths));
    4320           0 :                 if (*r->out.channelPaths) {
    4321           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.numChannelPaths));
    4322           0 :                         for (cntr_channelPaths_2 = 0; cntr_channelPaths_2 < (*r->out.numChannelPaths); cntr_channelPaths_2++) {
    4323           0 :                                 NDR_CHECK(ndr_push_unique_ptr(ndr, (*r->out.channelPaths)[cntr_channelPaths_2]));
    4324             :                         }
    4325           0 :                         for (cntr_channelPaths_2 = 0; cntr_channelPaths_2 < (*r->out.numChannelPaths); cntr_channelPaths_2++) {
    4326           0 :                                 if ((*r->out.channelPaths)[cntr_channelPaths_2]) {
    4327           0 :                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length((*r->out.channelPaths)[cntr_channelPaths_2], CH_UTF16)));
    4328           0 :                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    4329           0 :                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length((*r->out.channelPaths)[cntr_channelPaths_2], CH_UTF16)));
    4330           0 :                                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, (*r->out.channelPaths)[cntr_channelPaths_2], ndr_charset_length((*r->out.channelPaths)[cntr_channelPaths_2], CH_UTF16), sizeof(uint16_t), CH_UTF16));
    4331             :                                 }
    4332             :                         }
    4333             :                 }
    4334           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    4335             :         }
    4336           0 :         return NDR_ERR_SUCCESS;
    4337             : }
    4338             : 
    4339           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcGetChannelList(struct ndr_pull *ndr, int flags, struct eventlog6_EvtRpcGetChannelList *r)
    4340             : {
    4341             :         uint32_t _ptr_channelPaths;
    4342           0 :         uint32_t size_channelPaths_2 = 0;
    4343             :         uint32_t cntr_channelPaths_2;
    4344           0 :         uint32_t size_channelPaths_4 = 0;
    4345           0 :         uint32_t length_channelPaths_4 = 0;
    4346           0 :         TALLOC_CTX *_mem_save_numChannelPaths_0 = NULL;
    4347           0 :         TALLOC_CTX *_mem_save_channelPaths_0 = NULL;
    4348           0 :         TALLOC_CTX *_mem_save_channelPaths_1 = NULL;
    4349           0 :         TALLOC_CTX *_mem_save_channelPaths_2 = NULL;
    4350           0 :         TALLOC_CTX *_mem_save_channelPaths_3 = NULL;
    4351           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    4352           0 :         if (flags & NDR_IN) {
    4353           0 :                 NDR_ZERO_STRUCT(r->out);
    4354             : 
    4355           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
    4356           0 :                 NDR_PULL_ALLOC(ndr, r->out.numChannelPaths);
    4357           0 :                 NDR_ZERO_STRUCTP(r->out.numChannelPaths);
    4358           0 :                 NDR_PULL_ALLOC(ndr, r->out.channelPaths);
    4359           0 :                 NDR_ZERO_STRUCTP(r->out.channelPaths);
    4360             :         }
    4361           0 :         if (flags & NDR_OUT) {
    4362             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    4363             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    4364           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    4365           0 :                         NDR_PULL_ALLOC(ndr, r->out.numChannelPaths);
    4366             :                 }
    4367           0 :                 _mem_save_numChannelPaths_0 = NDR_PULL_GET_MEM_CTX(ndr);
    4368           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.numChannelPaths, LIBNDR_FLAG_REF_ALLOC);
    4369           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.numChannelPaths));
    4370           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_numChannelPaths_0, LIBNDR_FLAG_REF_ALLOC);
    4371           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    4372           0 :                         NDR_PULL_ALLOC(ndr, r->out.channelPaths);
    4373             :                 }
    4374           0 :                 _mem_save_channelPaths_0 = NDR_PULL_GET_MEM_CTX(ndr);
    4375           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.channelPaths, LIBNDR_FLAG_REF_ALLOC);
    4376           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_channelPaths));
    4377           0 :                 if (_ptr_channelPaths) {
    4378           0 :                         NDR_PULL_ALLOC(ndr, *r->out.channelPaths);
    4379             :                 } else {
    4380           0 :                         *r->out.channelPaths = NULL;
    4381             :                 }
    4382           0 :                 if (*r->out.channelPaths) {
    4383           0 :                         _mem_save_channelPaths_1 = NDR_PULL_GET_MEM_CTX(ndr);
    4384           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.channelPaths, 0);
    4385           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.channelPaths));
    4386           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)r->out.channelPaths, &size_channelPaths_2));
    4387           0 :                         if (size_channelPaths_2 > MAX_RPC_CHANNEL_COUNT) {
    4388           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    4389             :                         }
    4390           0 :                         NDR_PULL_ALLOC_N(ndr, *r->out.channelPaths, size_channelPaths_2);
    4391           0 :                         _mem_save_channelPaths_2 = NDR_PULL_GET_MEM_CTX(ndr);
    4392           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.channelPaths, 0);
    4393           0 :                         for (cntr_channelPaths_2 = 0; cntr_channelPaths_2 < (size_channelPaths_2); cntr_channelPaths_2++) {
    4394           0 :                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_channelPaths));
    4395           0 :                                 if (_ptr_channelPaths) {
    4396           0 :                                         NDR_PULL_ALLOC(ndr, (*r->out.channelPaths)[cntr_channelPaths_2]);
    4397             :                                 } else {
    4398           0 :                                         (*r->out.channelPaths)[cntr_channelPaths_2] = NULL;
    4399             :                                 }
    4400             :                         }
    4401           0 :                         for (cntr_channelPaths_2 = 0; cntr_channelPaths_2 < (size_channelPaths_2); cntr_channelPaths_2++) {
    4402           0 :                                 if ((*r->out.channelPaths)[cntr_channelPaths_2]) {
    4403           0 :                                         _mem_save_channelPaths_3 = NDR_PULL_GET_MEM_CTX(ndr);
    4404           0 :                                         NDR_PULL_SET_MEM_CTX(ndr, (*r->out.channelPaths)[cntr_channelPaths_2], 0);
    4405           0 :                                         NDR_CHECK(ndr_pull_array_size(ndr, &(*r->out.channelPaths)[cntr_channelPaths_2]));
    4406           0 :                                         NDR_CHECK(ndr_pull_array_length(ndr, &(*r->out.channelPaths)[cntr_channelPaths_2]));
    4407           0 :                                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&(*r->out.channelPaths)[cntr_channelPaths_2], &size_channelPaths_4));
    4408           0 :                                         if (size_channelPaths_4 > MAX_RPC_CHANNEL_COUNT) {
    4409           0 :                                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    4410             :                                         }
    4411           0 :                                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&(*r->out.channelPaths)[cntr_channelPaths_2], &length_channelPaths_4));
    4412           0 :                                         if (length_channelPaths_4 > MAX_RPC_CHANNEL_COUNT) {
    4413           0 :                                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    4414             :                                         }
    4415           0 :                                         if (length_channelPaths_4 > size_channelPaths_4) {
    4416           0 :                                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_channelPaths_4, length_channelPaths_4);
    4417             :                                         }
    4418           0 :                                         NDR_CHECK(ndr_check_string_terminator(ndr, length_channelPaths_4, sizeof(uint16_t)));
    4419           0 :                                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &(*r->out.channelPaths)[cntr_channelPaths_2], length_channelPaths_4, sizeof(uint16_t), CH_UTF16));
    4420           0 :                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_channelPaths_3, 0);
    4421             :                                 }
    4422             :                         }
    4423           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_channelPaths_2, 0);
    4424           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_channelPaths_1, 0);
    4425             :                 }
    4426           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_channelPaths_0, LIBNDR_FLAG_REF_ALLOC);
    4427           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    4428           0 :                 if (*r->out.channelPaths) {
    4429           0 :                         NDR_CHECK(ndr_check_array_size(ndr, (void*)r->out.channelPaths, *r->out.numChannelPaths));
    4430             :                 }
    4431           0 :                 for (cntr_channelPaths_2 = 0; cntr_channelPaths_2 < (size_channelPaths_2); cntr_channelPaths_2++) {
    4432             :                 }
    4433             :         }
    4434           0 :         return NDR_ERR_SUCCESS;
    4435             : }
    4436             : 
    4437           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcGetChannelList(struct ndr_print *ndr, const char *name, int flags, const struct eventlog6_EvtRpcGetChannelList *r)
    4438             : {
    4439             :         uint32_t cntr_channelPaths_2;
    4440           0 :         ndr_print_struct(ndr, name, "eventlog6_EvtRpcGetChannelList");
    4441           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    4442           0 :         ndr->depth++;
    4443           0 :         if (flags & NDR_SET_VALUES) {
    4444           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    4445             :         }
    4446           0 :         if (flags & NDR_IN) {
    4447           0 :                 ndr_print_struct(ndr, "in", "eventlog6_EvtRpcGetChannelList");
    4448           0 :                 ndr->depth++;
    4449           0 :                 ndr_print_uint32(ndr, "flags", r->in.flags);
    4450           0 :                 ndr->depth--;
    4451             :         }
    4452           0 :         if (flags & NDR_OUT) {
    4453           0 :                 ndr_print_struct(ndr, "out", "eventlog6_EvtRpcGetChannelList");
    4454           0 :                 ndr->depth++;
    4455           0 :                 ndr_print_ptr(ndr, "numChannelPaths", r->out.numChannelPaths);
    4456           0 :                 ndr->depth++;
    4457           0 :                 ndr_print_uint32(ndr, "numChannelPaths", *r->out.numChannelPaths);
    4458           0 :                 ndr->depth--;
    4459           0 :                 ndr_print_ptr(ndr, "channelPaths", r->out.channelPaths);
    4460           0 :                 ndr->depth++;
    4461           0 :                 ndr_print_ptr(ndr, "channelPaths", *r->out.channelPaths);
    4462           0 :                 ndr->depth++;
    4463           0 :                 if (*r->out.channelPaths) {
    4464           0 :                         ndr->print(ndr, "%s: ARRAY(%d)", "channelPaths", (int)*r->out.numChannelPaths);
    4465           0 :                         ndr->depth++;
    4466           0 :                         for (cntr_channelPaths_2 = 0; cntr_channelPaths_2 < (*r->out.numChannelPaths); cntr_channelPaths_2++) {
    4467           0 :                                 ndr_print_ptr(ndr, "channelPaths", (*r->out.channelPaths)[cntr_channelPaths_2]);
    4468           0 :                                 ndr->depth++;
    4469           0 :                                 if ((*r->out.channelPaths)[cntr_channelPaths_2]) {
    4470           0 :                                         ndr_print_string(ndr, "channelPaths", (*r->out.channelPaths)[cntr_channelPaths_2]);
    4471             :                                 }
    4472           0 :                                 ndr->depth--;
    4473             :                         }
    4474           0 :                         ndr->depth--;
    4475             :                 }
    4476           0 :                 ndr->depth--;
    4477           0 :                 ndr->depth--;
    4478           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    4479           0 :                 ndr->depth--;
    4480             :         }
    4481           0 :         ndr->depth--;
    4482             : }
    4483             : 
    4484           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcGetChannelConfig(struct ndr_push *ndr, int flags, const struct eventlog6_EvtRpcGetChannelConfig *r)
    4485             : {
    4486           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    4487           0 :         if (flags & NDR_IN) {
    4488           0 :                 if (r->in.channelPath == NULL) {
    4489           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4490             :                 }
    4491           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.channelPath, CH_UTF16)));
    4492           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    4493           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.channelPath, CH_UTF16)));
    4494           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.channelPath, ndr_charset_length(r->in.channelPath, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    4495           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
    4496             :         }
    4497           0 :         if (flags & NDR_OUT) {
    4498           0 :                 if (r->out.props == NULL) {
    4499           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4500             :                 }
    4501           0 :                 NDR_CHECK(ndr_push_eventlog6_EvtRpcVariantList(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.props));
    4502           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    4503             :         }
    4504           0 :         return NDR_ERR_SUCCESS;
    4505             : }
    4506             : 
    4507           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcGetChannelConfig(struct ndr_pull *ndr, int flags, struct eventlog6_EvtRpcGetChannelConfig *r)
    4508             : {
    4509           0 :         uint32_t size_channelPath_1 = 0;
    4510           0 :         uint32_t length_channelPath_1 = 0;
    4511           0 :         TALLOC_CTX *_mem_save_props_0 = NULL;
    4512           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    4513           0 :         if (flags & NDR_IN) {
    4514           0 :                 NDR_ZERO_STRUCT(r->out);
    4515             : 
    4516           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.channelPath));
    4517           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.channelPath));
    4518           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.channelPath, &size_channelPath_1));
    4519           0 :                 if (size_channelPath_1 < 1 || size_channelPath_1 > MAX_RPC_CHANNEL_NAME_LENGTH) {
    4520           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    4521             :                 }
    4522           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.channelPath, &length_channelPath_1));
    4523           0 :                 if (length_channelPath_1 < 1 || length_channelPath_1 > MAX_RPC_CHANNEL_NAME_LENGTH) {
    4524           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    4525             :                 }
    4526           0 :                 if (length_channelPath_1 > size_channelPath_1) {
    4527           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_channelPath_1, length_channelPath_1);
    4528             :                 }
    4529           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_channelPath_1, sizeof(uint16_t)));
    4530           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.channelPath, length_channelPath_1, sizeof(uint16_t), CH_UTF16));
    4531           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
    4532           0 :                 NDR_PULL_ALLOC(ndr, r->out.props);
    4533           0 :                 NDR_ZERO_STRUCTP(r->out.props);
    4534             :         }
    4535           0 :         if (flags & NDR_OUT) {
    4536             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    4537             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    4538           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    4539           0 :                         NDR_PULL_ALLOC(ndr, r->out.props);
    4540             :                 }
    4541           0 :                 _mem_save_props_0 = NDR_PULL_GET_MEM_CTX(ndr);
    4542           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.props, LIBNDR_FLAG_REF_ALLOC);
    4543           0 :                 NDR_CHECK(ndr_pull_eventlog6_EvtRpcVariantList(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.props));
    4544           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_props_0, LIBNDR_FLAG_REF_ALLOC);
    4545           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    4546             :         }
    4547           0 :         return NDR_ERR_SUCCESS;
    4548             : }
    4549             : 
    4550           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcGetChannelConfig(struct ndr_print *ndr, const char *name, int flags, const struct eventlog6_EvtRpcGetChannelConfig *r)
    4551             : {
    4552           0 :         ndr_print_struct(ndr, name, "eventlog6_EvtRpcGetChannelConfig");
    4553           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    4554           0 :         ndr->depth++;
    4555           0 :         if (flags & NDR_SET_VALUES) {
    4556           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    4557             :         }
    4558           0 :         if (flags & NDR_IN) {
    4559           0 :                 ndr_print_struct(ndr, "in", "eventlog6_EvtRpcGetChannelConfig");
    4560           0 :                 ndr->depth++;
    4561           0 :                 ndr_print_ptr(ndr, "channelPath", r->in.channelPath);
    4562           0 :                 ndr->depth++;
    4563           0 :                 ndr_print_string(ndr, "channelPath", r->in.channelPath);
    4564           0 :                 ndr->depth--;
    4565           0 :                 ndr_print_uint32(ndr, "flags", r->in.flags);
    4566           0 :                 ndr->depth--;
    4567             :         }
    4568           0 :         if (flags & NDR_OUT) {
    4569           0 :                 ndr_print_struct(ndr, "out", "eventlog6_EvtRpcGetChannelConfig");
    4570           0 :                 ndr->depth++;
    4571           0 :                 ndr_print_ptr(ndr, "props", r->out.props);
    4572           0 :                 ndr->depth++;
    4573           0 :                 ndr_print_eventlog6_EvtRpcVariantList(ndr, "props", r->out.props);
    4574           0 :                 ndr->depth--;
    4575           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    4576           0 :                 ndr->depth--;
    4577             :         }
    4578           0 :         ndr->depth--;
    4579             : }
    4580             : 
    4581           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcPutChannelConfig(struct ndr_push *ndr, int flags, const struct eventlog6_EvtRpcPutChannelConfig *r)
    4582             : {
    4583           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    4584           0 :         if (flags & NDR_IN) {
    4585           0 :                 if (r->in.channelPath == NULL) {
    4586           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4587             :                 }
    4588           0 :                 if (r->in.props == NULL) {
    4589           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4590             :                 }
    4591           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.channelPath, CH_UTF16)));
    4592           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    4593           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.channelPath, CH_UTF16)));
    4594           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.channelPath, ndr_charset_length(r->in.channelPath, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    4595           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
    4596           0 :                 NDR_CHECK(ndr_push_eventlog6_EvtRpcVariantList(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.props));
    4597             :         }
    4598           0 :         if (flags & NDR_OUT) {
    4599           0 :                 if (r->out.error == NULL) {
    4600           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4601             :                 }
    4602           0 :                 NDR_CHECK(ndr_push_eventlog6_RpcInfo(ndr, NDR_SCALARS, r->out.error));
    4603           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    4604             :         }
    4605           0 :         return NDR_ERR_SUCCESS;
    4606             : }
    4607             : 
    4608           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcPutChannelConfig(struct ndr_pull *ndr, int flags, struct eventlog6_EvtRpcPutChannelConfig *r)
    4609             : {
    4610           0 :         uint32_t size_channelPath_1 = 0;
    4611           0 :         uint32_t length_channelPath_1 = 0;
    4612           0 :         TALLOC_CTX *_mem_save_props_0 = NULL;
    4613           0 :         TALLOC_CTX *_mem_save_error_0 = NULL;
    4614           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    4615           0 :         if (flags & NDR_IN) {
    4616           0 :                 NDR_ZERO_STRUCT(r->out);
    4617             : 
    4618           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.channelPath));
    4619           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.channelPath));
    4620           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.channelPath, &size_channelPath_1));
    4621           0 :                 if (size_channelPath_1 < 1 || size_channelPath_1 > MAX_RPC_CHANNEL_NAME_LENGTH) {
    4622           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    4623             :                 }
    4624           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.channelPath, &length_channelPath_1));
    4625           0 :                 if (length_channelPath_1 < 1 || length_channelPath_1 > MAX_RPC_CHANNEL_NAME_LENGTH) {
    4626           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    4627             :                 }
    4628           0 :                 if (length_channelPath_1 > size_channelPath_1) {
    4629           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_channelPath_1, length_channelPath_1);
    4630             :                 }
    4631           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_channelPath_1, sizeof(uint16_t)));
    4632           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.channelPath, length_channelPath_1, sizeof(uint16_t), CH_UTF16));
    4633           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
    4634           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    4635           0 :                         NDR_PULL_ALLOC(ndr, r->in.props);
    4636             :                 }
    4637           0 :                 _mem_save_props_0 = NDR_PULL_GET_MEM_CTX(ndr);
    4638           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.props, LIBNDR_FLAG_REF_ALLOC);
    4639           0 :                 NDR_CHECK(ndr_pull_eventlog6_EvtRpcVariantList(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.props));
    4640           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_props_0, LIBNDR_FLAG_REF_ALLOC);
    4641           0 :                 NDR_PULL_ALLOC(ndr, r->out.error);
    4642           0 :                 NDR_ZERO_STRUCTP(r->out.error);
    4643             :         }
    4644           0 :         if (flags & NDR_OUT) {
    4645             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    4646             :                 if (r->in.props == NULL) {
    4647             :                         NDR_PULL_ALLOC(ndr, r->in.props);
    4648             :                         NDR_ZERO_STRUCTP(r->in.props);
    4649             :                 }
    4650             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    4651           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    4652           0 :                         NDR_PULL_ALLOC(ndr, r->out.error);
    4653             :                 }
    4654           0 :                 _mem_save_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
    4655           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.error, LIBNDR_FLAG_REF_ALLOC);
    4656           0 :                 NDR_CHECK(ndr_pull_eventlog6_RpcInfo(ndr, NDR_SCALARS, r->out.error));
    4657           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_error_0, LIBNDR_FLAG_REF_ALLOC);
    4658           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    4659             :         }
    4660           0 :         return NDR_ERR_SUCCESS;
    4661             : }
    4662             : 
    4663           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcPutChannelConfig(struct ndr_print *ndr, const char *name, int flags, const struct eventlog6_EvtRpcPutChannelConfig *r)
    4664             : {
    4665           0 :         ndr_print_struct(ndr, name, "eventlog6_EvtRpcPutChannelConfig");
    4666           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    4667           0 :         ndr->depth++;
    4668           0 :         if (flags & NDR_SET_VALUES) {
    4669           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    4670             :         }
    4671           0 :         if (flags & NDR_IN) {
    4672           0 :                 ndr_print_struct(ndr, "in", "eventlog6_EvtRpcPutChannelConfig");
    4673           0 :                 ndr->depth++;
    4674           0 :                 ndr_print_ptr(ndr, "channelPath", r->in.channelPath);
    4675           0 :                 ndr->depth++;
    4676           0 :                 ndr_print_string(ndr, "channelPath", r->in.channelPath);
    4677           0 :                 ndr->depth--;
    4678           0 :                 ndr_print_uint32(ndr, "flags", r->in.flags);
    4679           0 :                 ndr_print_ptr(ndr, "props", r->in.props);
    4680           0 :                 ndr->depth++;
    4681           0 :                 ndr_print_eventlog6_EvtRpcVariantList(ndr, "props", r->in.props);
    4682           0 :                 ndr->depth--;
    4683           0 :                 ndr->depth--;
    4684             :         }
    4685           0 :         if (flags & NDR_OUT) {
    4686           0 :                 ndr_print_struct(ndr, "out", "eventlog6_EvtRpcPutChannelConfig");
    4687           0 :                 ndr->depth++;
    4688           0 :                 ndr_print_ptr(ndr, "error", r->out.error);
    4689           0 :                 ndr->depth++;
    4690           0 :                 ndr_print_eventlog6_RpcInfo(ndr, "error", r->out.error);
    4691           0 :                 ndr->depth--;
    4692           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    4693           0 :                 ndr->depth--;
    4694             :         }
    4695           0 :         ndr->depth--;
    4696             : }
    4697             : 
    4698           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcGetPublisherList(struct ndr_push *ndr, int flags, const struct eventlog6_EvtRpcGetPublisherList *r)
    4699             : {
    4700             :         uint32_t cntr_publisherIds_2;
    4701           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    4702           0 :         if (flags & NDR_IN) {
    4703           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
    4704             :         }
    4705           0 :         if (flags & NDR_OUT) {
    4706           0 :                 if (r->out.numPublisherIds == NULL) {
    4707           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4708             :                 }
    4709           0 :                 if (r->out.publisherIds == NULL) {
    4710           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4711             :                 }
    4712           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.numPublisherIds));
    4713           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.publisherIds));
    4714           0 :                 if (*r->out.publisherIds) {
    4715           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.numPublisherIds));
    4716           0 :                         for (cntr_publisherIds_2 = 0; cntr_publisherIds_2 < (*r->out.numPublisherIds); cntr_publisherIds_2++) {
    4717           0 :                                 NDR_CHECK(ndr_push_unique_ptr(ndr, (*r->out.publisherIds)[cntr_publisherIds_2]));
    4718             :                         }
    4719           0 :                         for (cntr_publisherIds_2 = 0; cntr_publisherIds_2 < (*r->out.numPublisherIds); cntr_publisherIds_2++) {
    4720           0 :                                 if ((*r->out.publisherIds)[cntr_publisherIds_2]) {
    4721           0 :                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length((*r->out.publisherIds)[cntr_publisherIds_2], CH_UTF16)));
    4722           0 :                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    4723           0 :                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length((*r->out.publisherIds)[cntr_publisherIds_2], CH_UTF16)));
    4724           0 :                                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, (*r->out.publisherIds)[cntr_publisherIds_2], ndr_charset_length((*r->out.publisherIds)[cntr_publisherIds_2], CH_UTF16), sizeof(uint16_t), CH_UTF16));
    4725             :                                 }
    4726             :                         }
    4727             :                 }
    4728           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    4729             :         }
    4730           0 :         return NDR_ERR_SUCCESS;
    4731             : }
    4732             : 
    4733           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcGetPublisherList(struct ndr_pull *ndr, int flags, struct eventlog6_EvtRpcGetPublisherList *r)
    4734             : {
    4735             :         uint32_t _ptr_publisherIds;
    4736           0 :         uint32_t size_publisherIds_2 = 0;
    4737             :         uint32_t cntr_publisherIds_2;
    4738           0 :         uint32_t size_publisherIds_4 = 0;
    4739           0 :         uint32_t length_publisherIds_4 = 0;
    4740           0 :         TALLOC_CTX *_mem_save_numPublisherIds_0 = NULL;
    4741           0 :         TALLOC_CTX *_mem_save_publisherIds_0 = NULL;
    4742           0 :         TALLOC_CTX *_mem_save_publisherIds_1 = NULL;
    4743           0 :         TALLOC_CTX *_mem_save_publisherIds_2 = NULL;
    4744           0 :         TALLOC_CTX *_mem_save_publisherIds_3 = NULL;
    4745           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    4746           0 :         if (flags & NDR_IN) {
    4747           0 :                 NDR_ZERO_STRUCT(r->out);
    4748             : 
    4749           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
    4750           0 :                 NDR_PULL_ALLOC(ndr, r->out.numPublisherIds);
    4751           0 :                 NDR_ZERO_STRUCTP(r->out.numPublisherIds);
    4752           0 :                 NDR_PULL_ALLOC(ndr, r->out.publisherIds);
    4753           0 :                 NDR_ZERO_STRUCTP(r->out.publisherIds);
    4754             :         }
    4755           0 :         if (flags & NDR_OUT) {
    4756             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    4757             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    4758           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    4759           0 :                         NDR_PULL_ALLOC(ndr, r->out.numPublisherIds);
    4760             :                 }
    4761           0 :                 _mem_save_numPublisherIds_0 = NDR_PULL_GET_MEM_CTX(ndr);
    4762           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.numPublisherIds, LIBNDR_FLAG_REF_ALLOC);
    4763           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.numPublisherIds));
    4764           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_numPublisherIds_0, LIBNDR_FLAG_REF_ALLOC);
    4765           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    4766           0 :                         NDR_PULL_ALLOC(ndr, r->out.publisherIds);
    4767             :                 }
    4768           0 :                 _mem_save_publisherIds_0 = NDR_PULL_GET_MEM_CTX(ndr);
    4769           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.publisherIds, LIBNDR_FLAG_REF_ALLOC);
    4770           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_publisherIds));
    4771           0 :                 if (_ptr_publisherIds) {
    4772           0 :                         NDR_PULL_ALLOC(ndr, *r->out.publisherIds);
    4773             :                 } else {
    4774           0 :                         *r->out.publisherIds = NULL;
    4775             :                 }
    4776           0 :                 if (*r->out.publisherIds) {
    4777           0 :                         _mem_save_publisherIds_1 = NDR_PULL_GET_MEM_CTX(ndr);
    4778           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.publisherIds, 0);
    4779           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.publisherIds));
    4780           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)r->out.publisherIds, &size_publisherIds_2));
    4781           0 :                         if (size_publisherIds_2 > MAX_RPC_PUBLISHER_COUNT) {
    4782           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    4783             :                         }
    4784           0 :                         NDR_PULL_ALLOC_N(ndr, *r->out.publisherIds, size_publisherIds_2);
    4785           0 :                         _mem_save_publisherIds_2 = NDR_PULL_GET_MEM_CTX(ndr);
    4786           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.publisherIds, 0);
    4787           0 :                         for (cntr_publisherIds_2 = 0; cntr_publisherIds_2 < (size_publisherIds_2); cntr_publisherIds_2++) {
    4788           0 :                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_publisherIds));
    4789           0 :                                 if (_ptr_publisherIds) {
    4790           0 :                                         NDR_PULL_ALLOC(ndr, (*r->out.publisherIds)[cntr_publisherIds_2]);
    4791             :                                 } else {
    4792           0 :                                         (*r->out.publisherIds)[cntr_publisherIds_2] = NULL;
    4793             :                                 }
    4794             :                         }
    4795           0 :                         for (cntr_publisherIds_2 = 0; cntr_publisherIds_2 < (size_publisherIds_2); cntr_publisherIds_2++) {
    4796           0 :                                 if ((*r->out.publisherIds)[cntr_publisherIds_2]) {
    4797           0 :                                         _mem_save_publisherIds_3 = NDR_PULL_GET_MEM_CTX(ndr);
    4798           0 :                                         NDR_PULL_SET_MEM_CTX(ndr, (*r->out.publisherIds)[cntr_publisherIds_2], 0);
    4799           0 :                                         NDR_CHECK(ndr_pull_array_size(ndr, &(*r->out.publisherIds)[cntr_publisherIds_2]));
    4800           0 :                                         NDR_CHECK(ndr_pull_array_length(ndr, &(*r->out.publisherIds)[cntr_publisherIds_2]));
    4801           0 :                                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&(*r->out.publisherIds)[cntr_publisherIds_2], &size_publisherIds_4));
    4802           0 :                                         if (size_publisherIds_4 > MAX_RPC_PUBLISHER_COUNT) {
    4803           0 :                                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    4804             :                                         }
    4805           0 :                                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&(*r->out.publisherIds)[cntr_publisherIds_2], &length_publisherIds_4));
    4806           0 :                                         if (length_publisherIds_4 > MAX_RPC_PUBLISHER_COUNT) {
    4807           0 :                                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    4808             :                                         }
    4809           0 :                                         if (length_publisherIds_4 > size_publisherIds_4) {
    4810           0 :                                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_publisherIds_4, length_publisherIds_4);
    4811             :                                         }
    4812           0 :                                         NDR_CHECK(ndr_check_string_terminator(ndr, length_publisherIds_4, sizeof(uint16_t)));
    4813           0 :                                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &(*r->out.publisherIds)[cntr_publisherIds_2], length_publisherIds_4, sizeof(uint16_t), CH_UTF16));
    4814           0 :                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_publisherIds_3, 0);
    4815             :                                 }
    4816             :                         }
    4817           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_publisherIds_2, 0);
    4818           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_publisherIds_1, 0);
    4819             :                 }
    4820           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_publisherIds_0, LIBNDR_FLAG_REF_ALLOC);
    4821           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    4822           0 :                 if (*r->out.publisherIds) {
    4823           0 :                         NDR_CHECK(ndr_check_array_size(ndr, (void*)r->out.publisherIds, *r->out.numPublisherIds));
    4824             :                 }
    4825           0 :                 for (cntr_publisherIds_2 = 0; cntr_publisherIds_2 < (size_publisherIds_2); cntr_publisherIds_2++) {
    4826             :                 }
    4827             :         }
    4828           0 :         return NDR_ERR_SUCCESS;
    4829             : }
    4830             : 
    4831           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcGetPublisherList(struct ndr_print *ndr, const char *name, int flags, const struct eventlog6_EvtRpcGetPublisherList *r)
    4832             : {
    4833             :         uint32_t cntr_publisherIds_2;
    4834           0 :         ndr_print_struct(ndr, name, "eventlog6_EvtRpcGetPublisherList");
    4835           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    4836           0 :         ndr->depth++;
    4837           0 :         if (flags & NDR_SET_VALUES) {
    4838           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    4839             :         }
    4840           0 :         if (flags & NDR_IN) {
    4841           0 :                 ndr_print_struct(ndr, "in", "eventlog6_EvtRpcGetPublisherList");
    4842           0 :                 ndr->depth++;
    4843           0 :                 ndr_print_uint32(ndr, "flags", r->in.flags);
    4844           0 :                 ndr->depth--;
    4845             :         }
    4846           0 :         if (flags & NDR_OUT) {
    4847           0 :                 ndr_print_struct(ndr, "out", "eventlog6_EvtRpcGetPublisherList");
    4848           0 :                 ndr->depth++;
    4849           0 :                 ndr_print_ptr(ndr, "numPublisherIds", r->out.numPublisherIds);
    4850           0 :                 ndr->depth++;
    4851           0 :                 ndr_print_uint32(ndr, "numPublisherIds", *r->out.numPublisherIds);
    4852           0 :                 ndr->depth--;
    4853           0 :                 ndr_print_ptr(ndr, "publisherIds", r->out.publisherIds);
    4854           0 :                 ndr->depth++;
    4855           0 :                 ndr_print_ptr(ndr, "publisherIds", *r->out.publisherIds);
    4856           0 :                 ndr->depth++;
    4857           0 :                 if (*r->out.publisherIds) {
    4858           0 :                         ndr->print(ndr, "%s: ARRAY(%d)", "publisherIds", (int)*r->out.numPublisherIds);
    4859           0 :                         ndr->depth++;
    4860           0 :                         for (cntr_publisherIds_2 = 0; cntr_publisherIds_2 < (*r->out.numPublisherIds); cntr_publisherIds_2++) {
    4861           0 :                                 ndr_print_ptr(ndr, "publisherIds", (*r->out.publisherIds)[cntr_publisherIds_2]);
    4862           0 :                                 ndr->depth++;
    4863           0 :                                 if ((*r->out.publisherIds)[cntr_publisherIds_2]) {
    4864           0 :                                         ndr_print_string(ndr, "publisherIds", (*r->out.publisherIds)[cntr_publisherIds_2]);
    4865             :                                 }
    4866           0 :                                 ndr->depth--;
    4867             :                         }
    4868           0 :                         ndr->depth--;
    4869             :                 }
    4870           0 :                 ndr->depth--;
    4871           0 :                 ndr->depth--;
    4872           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    4873           0 :                 ndr->depth--;
    4874             :         }
    4875           0 :         ndr->depth--;
    4876             : }
    4877             : 
    4878           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcGetPublisherListForChannel(struct ndr_push *ndr, int flags, const struct eventlog6_EvtRpcGetPublisherListForChannel *r)
    4879             : {
    4880             :         uint32_t cntr_publisherIds_2;
    4881           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    4882           0 :         if (flags & NDR_IN) {
    4883           0 :                 if (r->in.channelName == NULL) {
    4884           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4885             :                 }
    4886           0 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.channelName));
    4887           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
    4888             :         }
    4889           0 :         if (flags & NDR_OUT) {
    4890           0 :                 if (r->out.numPublisherIds == NULL) {
    4891           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4892             :                 }
    4893           0 :                 if (r->out.publisherIds == NULL) {
    4894           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4895             :                 }
    4896           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.numPublisherIds));
    4897           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.publisherIds));
    4898           0 :                 if (*r->out.publisherIds) {
    4899           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.numPublisherIds));
    4900           0 :                         for (cntr_publisherIds_2 = 0; cntr_publisherIds_2 < (*r->out.numPublisherIds); cntr_publisherIds_2++) {
    4901           0 :                                 NDR_CHECK(ndr_push_unique_ptr(ndr, (*r->out.publisherIds)[cntr_publisherIds_2]));
    4902             :                         }
    4903           0 :                         for (cntr_publisherIds_2 = 0; cntr_publisherIds_2 < (*r->out.numPublisherIds); cntr_publisherIds_2++) {
    4904           0 :                                 if ((*r->out.publisherIds)[cntr_publisherIds_2]) {
    4905           0 :                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length((*r->out.publisherIds)[cntr_publisherIds_2], CH_UTF16)));
    4906           0 :                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    4907           0 :                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length((*r->out.publisherIds)[cntr_publisherIds_2], CH_UTF16)));
    4908           0 :                                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, (*r->out.publisherIds)[cntr_publisherIds_2], ndr_charset_length((*r->out.publisherIds)[cntr_publisherIds_2], CH_UTF16), sizeof(uint16_t), CH_UTF16));
    4909             :                                 }
    4910             :                         }
    4911             :                 }
    4912           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    4913             :         }
    4914           0 :         return NDR_ERR_SUCCESS;
    4915             : }
    4916             : 
    4917           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcGetPublisherListForChannel(struct ndr_pull *ndr, int flags, struct eventlog6_EvtRpcGetPublisherListForChannel *r)
    4918             : {
    4919             :         uint32_t _ptr_publisherIds;
    4920           0 :         uint32_t size_publisherIds_2 = 0;
    4921             :         uint32_t cntr_publisherIds_2;
    4922           0 :         uint32_t size_publisherIds_4 = 0;
    4923           0 :         uint32_t length_publisherIds_4 = 0;
    4924           0 :         TALLOC_CTX *_mem_save_channelName_0 = NULL;
    4925           0 :         TALLOC_CTX *_mem_save_numPublisherIds_0 = NULL;
    4926           0 :         TALLOC_CTX *_mem_save_publisherIds_0 = NULL;
    4927           0 :         TALLOC_CTX *_mem_save_publisherIds_1 = NULL;
    4928           0 :         TALLOC_CTX *_mem_save_publisherIds_2 = NULL;
    4929           0 :         TALLOC_CTX *_mem_save_publisherIds_3 = NULL;
    4930           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    4931           0 :         if (flags & NDR_IN) {
    4932           0 :                 NDR_ZERO_STRUCT(r->out);
    4933             : 
    4934           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    4935           0 :                         NDR_PULL_ALLOC(ndr, r->in.channelName);
    4936             :                 }
    4937           0 :                 _mem_save_channelName_0 = NDR_PULL_GET_MEM_CTX(ndr);
    4938           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.channelName, LIBNDR_FLAG_REF_ALLOC);
    4939           0 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.channelName));
    4940           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_channelName_0, LIBNDR_FLAG_REF_ALLOC);
    4941           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
    4942           0 :                 NDR_PULL_ALLOC(ndr, r->out.numPublisherIds);
    4943           0 :                 NDR_ZERO_STRUCTP(r->out.numPublisherIds);
    4944           0 :                 NDR_PULL_ALLOC(ndr, r->out.publisherIds);
    4945           0 :                 NDR_ZERO_STRUCTP(r->out.publisherIds);
    4946             :         }
    4947           0 :         if (flags & NDR_OUT) {
    4948             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    4949             :                 if (r->in.channelName == NULL) {
    4950             :                         NDR_PULL_ALLOC(ndr, r->in.channelName);
    4951             :                         NDR_ZERO_STRUCTP(r->in.channelName);
    4952             :                 }
    4953             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    4954           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    4955           0 :                         NDR_PULL_ALLOC(ndr, r->out.numPublisherIds);
    4956             :                 }
    4957           0 :                 _mem_save_numPublisherIds_0 = NDR_PULL_GET_MEM_CTX(ndr);
    4958           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.numPublisherIds, LIBNDR_FLAG_REF_ALLOC);
    4959           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.numPublisherIds));
    4960           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_numPublisherIds_0, LIBNDR_FLAG_REF_ALLOC);
    4961           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    4962           0 :                         NDR_PULL_ALLOC(ndr, r->out.publisherIds);
    4963             :                 }
    4964           0 :                 _mem_save_publisherIds_0 = NDR_PULL_GET_MEM_CTX(ndr);
    4965           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.publisherIds, LIBNDR_FLAG_REF_ALLOC);
    4966           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_publisherIds));
    4967           0 :                 if (_ptr_publisherIds) {
    4968           0 :                         NDR_PULL_ALLOC(ndr, *r->out.publisherIds);
    4969             :                 } else {
    4970           0 :                         *r->out.publisherIds = NULL;
    4971             :                 }
    4972           0 :                 if (*r->out.publisherIds) {
    4973           0 :                         _mem_save_publisherIds_1 = NDR_PULL_GET_MEM_CTX(ndr);
    4974           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.publisherIds, 0);
    4975           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.publisherIds));
    4976           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)r->out.publisherIds, &size_publisherIds_2));
    4977           0 :                         if (size_publisherIds_2 > MAX_RPC_PUBLISHER_COUNT) {
    4978           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    4979             :                         }
    4980           0 :                         NDR_PULL_ALLOC_N(ndr, *r->out.publisherIds, size_publisherIds_2);
    4981           0 :                         _mem_save_publisherIds_2 = NDR_PULL_GET_MEM_CTX(ndr);
    4982           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.publisherIds, 0);
    4983           0 :                         for (cntr_publisherIds_2 = 0; cntr_publisherIds_2 < (size_publisherIds_2); cntr_publisherIds_2++) {
    4984           0 :                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_publisherIds));
    4985           0 :                                 if (_ptr_publisherIds) {
    4986           0 :                                         NDR_PULL_ALLOC(ndr, (*r->out.publisherIds)[cntr_publisherIds_2]);
    4987             :                                 } else {
    4988           0 :                                         (*r->out.publisherIds)[cntr_publisherIds_2] = NULL;
    4989             :                                 }
    4990             :                         }
    4991           0 :                         for (cntr_publisherIds_2 = 0; cntr_publisherIds_2 < (size_publisherIds_2); cntr_publisherIds_2++) {
    4992           0 :                                 if ((*r->out.publisherIds)[cntr_publisherIds_2]) {
    4993           0 :                                         _mem_save_publisherIds_3 = NDR_PULL_GET_MEM_CTX(ndr);
    4994           0 :                                         NDR_PULL_SET_MEM_CTX(ndr, (*r->out.publisherIds)[cntr_publisherIds_2], 0);
    4995           0 :                                         NDR_CHECK(ndr_pull_array_size(ndr, &(*r->out.publisherIds)[cntr_publisherIds_2]));
    4996           0 :                                         NDR_CHECK(ndr_pull_array_length(ndr, &(*r->out.publisherIds)[cntr_publisherIds_2]));
    4997           0 :                                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&(*r->out.publisherIds)[cntr_publisherIds_2], &size_publisherIds_4));
    4998           0 :                                         if (size_publisherIds_4 > MAX_RPC_PUBLISHER_COUNT) {
    4999           0 :                                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    5000             :                                         }
    5001           0 :                                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&(*r->out.publisherIds)[cntr_publisherIds_2], &length_publisherIds_4));
    5002           0 :                                         if (length_publisherIds_4 > MAX_RPC_PUBLISHER_COUNT) {
    5003           0 :                                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    5004             :                                         }
    5005           0 :                                         if (length_publisherIds_4 > size_publisherIds_4) {
    5006           0 :                                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_publisherIds_4, length_publisherIds_4);
    5007             :                                         }
    5008           0 :                                         NDR_CHECK(ndr_check_string_terminator(ndr, length_publisherIds_4, sizeof(uint16_t)));
    5009           0 :                                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &(*r->out.publisherIds)[cntr_publisherIds_2], length_publisherIds_4, sizeof(uint16_t), CH_UTF16));
    5010           0 :                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_publisherIds_3, 0);
    5011             :                                 }
    5012             :                         }
    5013           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_publisherIds_2, 0);
    5014           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_publisherIds_1, 0);
    5015             :                 }
    5016           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_publisherIds_0, LIBNDR_FLAG_REF_ALLOC);
    5017           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    5018           0 :                 if (*r->out.publisherIds) {
    5019           0 :                         NDR_CHECK(ndr_check_array_size(ndr, (void*)r->out.publisherIds, *r->out.numPublisherIds));
    5020             :                 }
    5021           0 :                 for (cntr_publisherIds_2 = 0; cntr_publisherIds_2 < (size_publisherIds_2); cntr_publisherIds_2++) {
    5022             :                 }
    5023             :         }
    5024           0 :         return NDR_ERR_SUCCESS;
    5025             : }
    5026             : 
    5027           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcGetPublisherListForChannel(struct ndr_print *ndr, const char *name, int flags, const struct eventlog6_EvtRpcGetPublisherListForChannel *r)
    5028             : {
    5029             :         uint32_t cntr_publisherIds_2;
    5030           0 :         ndr_print_struct(ndr, name, "eventlog6_EvtRpcGetPublisherListForChannel");
    5031           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    5032           0 :         ndr->depth++;
    5033           0 :         if (flags & NDR_SET_VALUES) {
    5034           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    5035             :         }
    5036           0 :         if (flags & NDR_IN) {
    5037           0 :                 ndr_print_struct(ndr, "in", "eventlog6_EvtRpcGetPublisherListForChannel");
    5038           0 :                 ndr->depth++;
    5039           0 :                 ndr_print_ptr(ndr, "channelName", r->in.channelName);
    5040           0 :                 ndr->depth++;
    5041           0 :                 ndr_print_uint16(ndr, "channelName", *r->in.channelName);
    5042           0 :                 ndr->depth--;
    5043           0 :                 ndr_print_uint32(ndr, "flags", r->in.flags);
    5044           0 :                 ndr->depth--;
    5045             :         }
    5046           0 :         if (flags & NDR_OUT) {
    5047           0 :                 ndr_print_struct(ndr, "out", "eventlog6_EvtRpcGetPublisherListForChannel");
    5048           0 :                 ndr->depth++;
    5049           0 :                 ndr_print_ptr(ndr, "numPublisherIds", r->out.numPublisherIds);
    5050           0 :                 ndr->depth++;
    5051           0 :                 ndr_print_uint32(ndr, "numPublisherIds", *r->out.numPublisherIds);
    5052           0 :                 ndr->depth--;
    5053           0 :                 ndr_print_ptr(ndr, "publisherIds", r->out.publisherIds);
    5054           0 :                 ndr->depth++;
    5055           0 :                 ndr_print_ptr(ndr, "publisherIds", *r->out.publisherIds);
    5056           0 :                 ndr->depth++;
    5057           0 :                 if (*r->out.publisherIds) {
    5058           0 :                         ndr->print(ndr, "%s: ARRAY(%d)", "publisherIds", (int)*r->out.numPublisherIds);
    5059           0 :                         ndr->depth++;
    5060           0 :                         for (cntr_publisherIds_2 = 0; cntr_publisherIds_2 < (*r->out.numPublisherIds); cntr_publisherIds_2++) {
    5061           0 :                                 ndr_print_ptr(ndr, "publisherIds", (*r->out.publisherIds)[cntr_publisherIds_2]);
    5062           0 :                                 ndr->depth++;
    5063           0 :                                 if ((*r->out.publisherIds)[cntr_publisherIds_2]) {
    5064           0 :                                         ndr_print_string(ndr, "publisherIds", (*r->out.publisherIds)[cntr_publisherIds_2]);
    5065             :                                 }
    5066           0 :                                 ndr->depth--;
    5067             :                         }
    5068           0 :                         ndr->depth--;
    5069             :                 }
    5070           0 :                 ndr->depth--;
    5071           0 :                 ndr->depth--;
    5072           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    5073           0 :                 ndr->depth--;
    5074             :         }
    5075           0 :         ndr->depth--;
    5076             : }
    5077             : 
    5078           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcGetPublisherMetadata(struct ndr_push *ndr, int flags, const struct eventlog6_EvtRpcGetPublisherMetadata *r)
    5079             : {
    5080           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    5081           0 :         if (flags & NDR_IN) {
    5082           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.publisherId));
    5083           0 :                 if (r->in.publisherId) {
    5084           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.publisherId, CH_UTF16)));
    5085           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    5086           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.publisherId, CH_UTF16)));
    5087           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.publisherId, ndr_charset_length(r->in.publisherId, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    5088             :                 }
    5089           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.logFilePath));
    5090           0 :                 if (r->in.logFilePath) {
    5091           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.logFilePath, CH_UTF16)));
    5092           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    5093           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.logFilePath, CH_UTF16)));
    5094           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.logFilePath, ndr_charset_length(r->in.logFilePath, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    5095             :                 }
    5096           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.locale));
    5097           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
    5098             :         }
    5099           0 :         if (flags & NDR_OUT) {
    5100           0 :                 if (r->out.pubMetadataProps == NULL) {
    5101           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5102             :                 }
    5103           0 :                 if (r->out.pubMetadata == NULL) {
    5104           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5105             :                 }
    5106           0 :                 NDR_CHECK(ndr_push_eventlog6_EvtRpcVariantList(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.pubMetadataProps));
    5107           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.pubMetadata));
    5108           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    5109             :         }
    5110           0 :         return NDR_ERR_SUCCESS;
    5111             : }
    5112             : 
    5113           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcGetPublisherMetadata(struct ndr_pull *ndr, int flags, struct eventlog6_EvtRpcGetPublisherMetadata *r)
    5114             : {
    5115             :         uint32_t _ptr_publisherId;
    5116           0 :         uint32_t size_publisherId_1 = 0;
    5117           0 :         uint32_t length_publisherId_1 = 0;
    5118             :         uint32_t _ptr_logFilePath;
    5119           0 :         uint32_t size_logFilePath_1 = 0;
    5120           0 :         uint32_t length_logFilePath_1 = 0;
    5121           0 :         TALLOC_CTX *_mem_save_publisherId_0 = NULL;
    5122           0 :         TALLOC_CTX *_mem_save_logFilePath_0 = NULL;
    5123           0 :         TALLOC_CTX *_mem_save_pubMetadataProps_0 = NULL;
    5124           0 :         TALLOC_CTX *_mem_save_pubMetadata_0 = NULL;
    5125           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    5126           0 :         if (flags & NDR_IN) {
    5127           0 :                 NDR_ZERO_STRUCT(r->out);
    5128             : 
    5129           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_publisherId));
    5130           0 :                 if (_ptr_publisherId) {
    5131           0 :                         NDR_PULL_ALLOC(ndr, r->in.publisherId);
    5132             :                 } else {
    5133           0 :                         r->in.publisherId = NULL;
    5134             :                 }
    5135           0 :                 if (r->in.publisherId) {
    5136           0 :                         _mem_save_publisherId_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5137           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->in.publisherId, 0);
    5138           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.publisherId));
    5139           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.publisherId));
    5140           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.publisherId, &size_publisherId_1));
    5141           0 :                         if (size_publisherId_1 > MAX_RPC_PUBLISHER_ID_LENGTH) {
    5142           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    5143             :                         }
    5144           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.publisherId, &length_publisherId_1));
    5145           0 :                         if (length_publisherId_1 > MAX_RPC_PUBLISHER_ID_LENGTH) {
    5146           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    5147             :                         }
    5148           0 :                         if (length_publisherId_1 > size_publisherId_1) {
    5149           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_publisherId_1, length_publisherId_1);
    5150             :                         }
    5151           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_publisherId_1, sizeof(uint16_t)));
    5152           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.publisherId, length_publisherId_1, sizeof(uint16_t), CH_UTF16));
    5153           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_publisherId_0, 0);
    5154             :                 }
    5155           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_logFilePath));
    5156           0 :                 if (_ptr_logFilePath) {
    5157           0 :                         NDR_PULL_ALLOC(ndr, r->in.logFilePath);
    5158             :                 } else {
    5159           0 :                         r->in.logFilePath = NULL;
    5160             :                 }
    5161           0 :                 if (r->in.logFilePath) {
    5162           0 :                         _mem_save_logFilePath_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5163           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->in.logFilePath, 0);
    5164           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.logFilePath));
    5165           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.logFilePath));
    5166           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.logFilePath, &size_logFilePath_1));
    5167           0 :                         if (size_logFilePath_1 > MAX_RPC_FILE_PATH_LENGTH) {
    5168           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    5169             :                         }
    5170           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.logFilePath, &length_logFilePath_1));
    5171           0 :                         if (length_logFilePath_1 > MAX_RPC_FILE_PATH_LENGTH) {
    5172           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    5173             :                         }
    5174           0 :                         if (length_logFilePath_1 > size_logFilePath_1) {
    5175           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_logFilePath_1, length_logFilePath_1);
    5176             :                         }
    5177           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_logFilePath_1, sizeof(uint16_t)));
    5178           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.logFilePath, length_logFilePath_1, sizeof(uint16_t), CH_UTF16));
    5179           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_logFilePath_0, 0);
    5180             :                 }
    5181           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.locale));
    5182           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
    5183           0 :                 NDR_PULL_ALLOC(ndr, r->out.pubMetadataProps);
    5184           0 :                 NDR_ZERO_STRUCTP(r->out.pubMetadataProps);
    5185           0 :                 NDR_PULL_ALLOC(ndr, r->out.pubMetadata);
    5186           0 :                 NDR_ZERO_STRUCTP(r->out.pubMetadata);
    5187             :         }
    5188           0 :         if (flags & NDR_OUT) {
    5189             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    5190             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    5191           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    5192           0 :                         NDR_PULL_ALLOC(ndr, r->out.pubMetadataProps);
    5193             :                 }
    5194           0 :                 _mem_save_pubMetadataProps_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5195           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.pubMetadataProps, LIBNDR_FLAG_REF_ALLOC);
    5196           0 :                 NDR_CHECK(ndr_pull_eventlog6_EvtRpcVariantList(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.pubMetadataProps));
    5197           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pubMetadataProps_0, LIBNDR_FLAG_REF_ALLOC);
    5198           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    5199           0 :                         NDR_PULL_ALLOC(ndr, r->out.pubMetadata);
    5200             :                 }
    5201           0 :                 _mem_save_pubMetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5202           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.pubMetadata, LIBNDR_FLAG_REF_ALLOC);
    5203           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.pubMetadata));
    5204           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pubMetadata_0, LIBNDR_FLAG_REF_ALLOC);
    5205           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    5206             :         }
    5207           0 :         return NDR_ERR_SUCCESS;
    5208             : }
    5209             : 
    5210           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcGetPublisherMetadata(struct ndr_print *ndr, const char *name, int flags, const struct eventlog6_EvtRpcGetPublisherMetadata *r)
    5211             : {
    5212           0 :         ndr_print_struct(ndr, name, "eventlog6_EvtRpcGetPublisherMetadata");
    5213           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    5214           0 :         ndr->depth++;
    5215           0 :         if (flags & NDR_SET_VALUES) {
    5216           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    5217             :         }
    5218           0 :         if (flags & NDR_IN) {
    5219           0 :                 ndr_print_struct(ndr, "in", "eventlog6_EvtRpcGetPublisherMetadata");
    5220           0 :                 ndr->depth++;
    5221           0 :                 ndr_print_ptr(ndr, "publisherId", r->in.publisherId);
    5222           0 :                 ndr->depth++;
    5223           0 :                 if (r->in.publisherId) {
    5224           0 :                         ndr_print_string(ndr, "publisherId", r->in.publisherId);
    5225             :                 }
    5226           0 :                 ndr->depth--;
    5227           0 :                 ndr_print_ptr(ndr, "logFilePath", r->in.logFilePath);
    5228           0 :                 ndr->depth++;
    5229           0 :                 if (r->in.logFilePath) {
    5230           0 :                         ndr_print_string(ndr, "logFilePath", r->in.logFilePath);
    5231             :                 }
    5232           0 :                 ndr->depth--;
    5233           0 :                 ndr_print_uint32(ndr, "locale", r->in.locale);
    5234           0 :                 ndr_print_uint32(ndr, "flags", r->in.flags);
    5235           0 :                 ndr->depth--;
    5236             :         }
    5237           0 :         if (flags & NDR_OUT) {
    5238           0 :                 ndr_print_struct(ndr, "out", "eventlog6_EvtRpcGetPublisherMetadata");
    5239           0 :                 ndr->depth++;
    5240           0 :                 ndr_print_ptr(ndr, "pubMetadataProps", r->out.pubMetadataProps);
    5241           0 :                 ndr->depth++;
    5242           0 :                 ndr_print_eventlog6_EvtRpcVariantList(ndr, "pubMetadataProps", r->out.pubMetadataProps);
    5243           0 :                 ndr->depth--;
    5244           0 :                 ndr_print_ptr(ndr, "pubMetadata", r->out.pubMetadata);
    5245           0 :                 ndr->depth++;
    5246           0 :                 ndr_print_policy_handle(ndr, "pubMetadata", r->out.pubMetadata);
    5247           0 :                 ndr->depth--;
    5248           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    5249           0 :                 ndr->depth--;
    5250             :         }
    5251           0 :         ndr->depth--;
    5252             : }
    5253             : 
    5254           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcGetPublisherResourceMetadata(struct ndr_push *ndr, int flags, const struct eventlog6_EvtRpcGetPublisherResourceMetadata *r)
    5255             : {
    5256           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    5257           0 :         if (flags & NDR_IN) {
    5258           0 :                 if (r->in.handle == NULL) {
    5259           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5260             :                 }
    5261           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
    5262           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.propertyId));
    5263           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
    5264             :         }
    5265           0 :         if (flags & NDR_OUT) {
    5266           0 :                 if (r->out.pubMetadataProps == NULL) {
    5267           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5268             :                 }
    5269           0 :                 NDR_CHECK(ndr_push_eventlog6_EvtRpcVariantList(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.pubMetadataProps));
    5270           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    5271             :         }
    5272           0 :         return NDR_ERR_SUCCESS;
    5273             : }
    5274             : 
    5275           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcGetPublisherResourceMetadata(struct ndr_pull *ndr, int flags, struct eventlog6_EvtRpcGetPublisherResourceMetadata *r)
    5276             : {
    5277           0 :         TALLOC_CTX *_mem_save_handle_0 = NULL;
    5278           0 :         TALLOC_CTX *_mem_save_pubMetadataProps_0 = NULL;
    5279           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    5280           0 :         if (flags & NDR_IN) {
    5281           0 :                 NDR_ZERO_STRUCT(r->out);
    5282             : 
    5283           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    5284           0 :                         NDR_PULL_ALLOC(ndr, r->in.handle);
    5285             :                 }
    5286           0 :                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5287           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
    5288           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
    5289           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
    5290           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.propertyId));
    5291           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
    5292           0 :                 NDR_PULL_ALLOC(ndr, r->out.pubMetadataProps);
    5293           0 :                 NDR_ZERO_STRUCTP(r->out.pubMetadataProps);
    5294             :         }
    5295           0 :         if (flags & NDR_OUT) {
    5296             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    5297             :                 if (r->in.handle == NULL) {
    5298             :                         NDR_PULL_ALLOC(ndr, r->in.handle);
    5299             :                         NDR_ZERO_STRUCTP(r->in.handle);
    5300             :                 }
    5301             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    5302           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    5303           0 :                         NDR_PULL_ALLOC(ndr, r->out.pubMetadataProps);
    5304             :                 }
    5305           0 :                 _mem_save_pubMetadataProps_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5306           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.pubMetadataProps, LIBNDR_FLAG_REF_ALLOC);
    5307           0 :                 NDR_CHECK(ndr_pull_eventlog6_EvtRpcVariantList(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.pubMetadataProps));
    5308           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pubMetadataProps_0, LIBNDR_FLAG_REF_ALLOC);
    5309           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    5310             :         }
    5311           0 :         return NDR_ERR_SUCCESS;
    5312             : }
    5313             : 
    5314           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcGetPublisherResourceMetadata(struct ndr_print *ndr, const char *name, int flags, const struct eventlog6_EvtRpcGetPublisherResourceMetadata *r)
    5315             : {
    5316           0 :         ndr_print_struct(ndr, name, "eventlog6_EvtRpcGetPublisherResourceMetadata");
    5317           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    5318           0 :         ndr->depth++;
    5319           0 :         if (flags & NDR_SET_VALUES) {
    5320           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    5321             :         }
    5322           0 :         if (flags & NDR_IN) {
    5323           0 :                 ndr_print_struct(ndr, "in", "eventlog6_EvtRpcGetPublisherResourceMetadata");
    5324           0 :                 ndr->depth++;
    5325           0 :                 ndr_print_ptr(ndr, "handle", r->in.handle);
    5326           0 :                 ndr->depth++;
    5327           0 :                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
    5328           0 :                 ndr->depth--;
    5329           0 :                 ndr_print_uint32(ndr, "propertyId", r->in.propertyId);
    5330           0 :                 ndr_print_uint32(ndr, "flags", r->in.flags);
    5331           0 :                 ndr->depth--;
    5332             :         }
    5333           0 :         if (flags & NDR_OUT) {
    5334           0 :                 ndr_print_struct(ndr, "out", "eventlog6_EvtRpcGetPublisherResourceMetadata");
    5335           0 :                 ndr->depth++;
    5336           0 :                 ndr_print_ptr(ndr, "pubMetadataProps", r->out.pubMetadataProps);
    5337           0 :                 ndr->depth++;
    5338           0 :                 ndr_print_eventlog6_EvtRpcVariantList(ndr, "pubMetadataProps", r->out.pubMetadataProps);
    5339           0 :                 ndr->depth--;
    5340           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    5341           0 :                 ndr->depth--;
    5342             :         }
    5343           0 :         ndr->depth--;
    5344             : }
    5345             : 
    5346           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcGetEventMetadataEnum(struct ndr_push *ndr, int flags, const struct eventlog6_EvtRpcGetEventMetadataEnum *r)
    5347             : {
    5348           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    5349           0 :         if (flags & NDR_IN) {
    5350           0 :                 if (r->in.pubMetadata == NULL) {
    5351           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5352             :                 }
    5353           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.pubMetadata));
    5354           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
    5355           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.reservedForFilter));
    5356           0 :                 if (r->in.reservedForFilter) {
    5357           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.reservedForFilter, CH_UTF16)));
    5358           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    5359           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.reservedForFilter, CH_UTF16)));
    5360           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.reservedForFilter, ndr_charset_length(r->in.reservedForFilter, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    5361             :                 }
    5362             :         }
    5363           0 :         if (flags & NDR_OUT) {
    5364           0 :                 if (r->out.eventMetaDataEnum == NULL) {
    5365           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5366             :                 }
    5367           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.eventMetaDataEnum));
    5368           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    5369             :         }
    5370           0 :         return NDR_ERR_SUCCESS;
    5371             : }
    5372             : 
    5373           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcGetEventMetadataEnum(struct ndr_pull *ndr, int flags, struct eventlog6_EvtRpcGetEventMetadataEnum *r)
    5374             : {
    5375             :         uint32_t _ptr_reservedForFilter;
    5376           0 :         uint32_t size_reservedForFilter_1 = 0;
    5377           0 :         uint32_t length_reservedForFilter_1 = 0;
    5378           0 :         TALLOC_CTX *_mem_save_pubMetadata_0 = NULL;
    5379           0 :         TALLOC_CTX *_mem_save_reservedForFilter_0 = NULL;
    5380           0 :         TALLOC_CTX *_mem_save_eventMetaDataEnum_0 = NULL;
    5381           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    5382           0 :         if (flags & NDR_IN) {
    5383           0 :                 NDR_ZERO_STRUCT(r->out);
    5384             : 
    5385           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    5386           0 :                         NDR_PULL_ALLOC(ndr, r->in.pubMetadata);
    5387             :                 }
    5388           0 :                 _mem_save_pubMetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5389           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.pubMetadata, LIBNDR_FLAG_REF_ALLOC);
    5390           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.pubMetadata));
    5391           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pubMetadata_0, LIBNDR_FLAG_REF_ALLOC);
    5392           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
    5393           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_reservedForFilter));
    5394           0 :                 if (_ptr_reservedForFilter) {
    5395           0 :                         NDR_PULL_ALLOC(ndr, r->in.reservedForFilter);
    5396             :                 } else {
    5397           0 :                         r->in.reservedForFilter = NULL;
    5398             :                 }
    5399           0 :                 if (r->in.reservedForFilter) {
    5400           0 :                         _mem_save_reservedForFilter_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5401           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->in.reservedForFilter, 0);
    5402           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.reservedForFilter));
    5403           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.reservedForFilter));
    5404           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.reservedForFilter, &size_reservedForFilter_1));
    5405           0 :                         if (size_reservedForFilter_1 > MAX_RPC_FILTER_LENGTH) {
    5406           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    5407             :                         }
    5408           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.reservedForFilter, &length_reservedForFilter_1));
    5409           0 :                         if (length_reservedForFilter_1 > MAX_RPC_FILTER_LENGTH) {
    5410           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    5411             :                         }
    5412           0 :                         if (length_reservedForFilter_1 > size_reservedForFilter_1) {
    5413           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_reservedForFilter_1, length_reservedForFilter_1);
    5414             :                         }
    5415           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_reservedForFilter_1, sizeof(uint16_t)));
    5416           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.reservedForFilter, length_reservedForFilter_1, sizeof(uint16_t), CH_UTF16));
    5417           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reservedForFilter_0, 0);
    5418             :                 }
    5419           0 :                 NDR_PULL_ALLOC(ndr, r->out.eventMetaDataEnum);
    5420           0 :                 NDR_ZERO_STRUCTP(r->out.eventMetaDataEnum);
    5421             :         }
    5422           0 :         if (flags & NDR_OUT) {
    5423             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    5424             :                 if (r->in.pubMetadata == NULL) {
    5425             :                         NDR_PULL_ALLOC(ndr, r->in.pubMetadata);
    5426             :                         NDR_ZERO_STRUCTP(r->in.pubMetadata);
    5427             :                 }
    5428             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    5429           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    5430           0 :                         NDR_PULL_ALLOC(ndr, r->out.eventMetaDataEnum);
    5431             :                 }
    5432           0 :                 _mem_save_eventMetaDataEnum_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5433           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.eventMetaDataEnum, LIBNDR_FLAG_REF_ALLOC);
    5434           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.eventMetaDataEnum));
    5435           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eventMetaDataEnum_0, LIBNDR_FLAG_REF_ALLOC);
    5436           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    5437             :         }
    5438           0 :         return NDR_ERR_SUCCESS;
    5439             : }
    5440             : 
    5441           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcGetEventMetadataEnum(struct ndr_print *ndr, const char *name, int flags, const struct eventlog6_EvtRpcGetEventMetadataEnum *r)
    5442             : {
    5443           0 :         ndr_print_struct(ndr, name, "eventlog6_EvtRpcGetEventMetadataEnum");
    5444           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    5445           0 :         ndr->depth++;
    5446           0 :         if (flags & NDR_SET_VALUES) {
    5447           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    5448             :         }
    5449           0 :         if (flags & NDR_IN) {
    5450           0 :                 ndr_print_struct(ndr, "in", "eventlog6_EvtRpcGetEventMetadataEnum");
    5451           0 :                 ndr->depth++;
    5452           0 :                 ndr_print_ptr(ndr, "pubMetadata", r->in.pubMetadata);
    5453           0 :                 ndr->depth++;
    5454           0 :                 ndr_print_policy_handle(ndr, "pubMetadata", r->in.pubMetadata);
    5455           0 :                 ndr->depth--;
    5456           0 :                 ndr_print_uint32(ndr, "flags", r->in.flags);
    5457           0 :                 ndr_print_ptr(ndr, "reservedForFilter", r->in.reservedForFilter);
    5458           0 :                 ndr->depth++;
    5459           0 :                 if (r->in.reservedForFilter) {
    5460           0 :                         ndr_print_string(ndr, "reservedForFilter", r->in.reservedForFilter);
    5461             :                 }
    5462           0 :                 ndr->depth--;
    5463           0 :                 ndr->depth--;
    5464             :         }
    5465           0 :         if (flags & NDR_OUT) {
    5466           0 :                 ndr_print_struct(ndr, "out", "eventlog6_EvtRpcGetEventMetadataEnum");
    5467           0 :                 ndr->depth++;
    5468           0 :                 ndr_print_ptr(ndr, "eventMetaDataEnum", r->out.eventMetaDataEnum);
    5469           0 :                 ndr->depth++;
    5470           0 :                 ndr_print_policy_handle(ndr, "eventMetaDataEnum", r->out.eventMetaDataEnum);
    5471           0 :                 ndr->depth--;
    5472           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    5473           0 :                 ndr->depth--;
    5474             :         }
    5475           0 :         ndr->depth--;
    5476             : }
    5477             : 
    5478           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcGetNextEventMetadata(struct ndr_push *ndr, int flags, const struct eventlog6_EvtRpcGetNextEventMetadata *r)
    5479             : {
    5480             :         uint32_t cntr_eventMetadataInstances_2;
    5481           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    5482           0 :         if (flags & NDR_IN) {
    5483           0 :                 if (r->in.eventMetaDataEnum == NULL) {
    5484           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5485             :                 }
    5486           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.eventMetaDataEnum));
    5487           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
    5488           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numRequested));
    5489             :         }
    5490           0 :         if (flags & NDR_OUT) {
    5491           0 :                 if (r->out.numReturned == NULL) {
    5492           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5493             :                 }
    5494           0 :                 if (r->out.eventMetadataInstances == NULL) {
    5495           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5496             :                 }
    5497           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.numReturned));
    5498           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.eventMetadataInstances));
    5499           0 :                 if (*r->out.eventMetadataInstances) {
    5500           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.numReturned));
    5501           0 :                         for (cntr_eventMetadataInstances_2 = 0; cntr_eventMetadataInstances_2 < (*r->out.numReturned); cntr_eventMetadataInstances_2++) {
    5502           0 :                                 NDR_CHECK(ndr_push_eventlog6_EvtRpcVariantList(ndr, NDR_SCALARS, &(*r->out.eventMetadataInstances)[cntr_eventMetadataInstances_2]));
    5503             :                         }
    5504           0 :                         for (cntr_eventMetadataInstances_2 = 0; cntr_eventMetadataInstances_2 < (*r->out.numReturned); cntr_eventMetadataInstances_2++) {
    5505           0 :                                 NDR_CHECK(ndr_push_eventlog6_EvtRpcVariantList(ndr, NDR_BUFFERS, &(*r->out.eventMetadataInstances)[cntr_eventMetadataInstances_2]));
    5506             :                         }
    5507             :                 }
    5508           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    5509             :         }
    5510           0 :         return NDR_ERR_SUCCESS;
    5511             : }
    5512             : 
    5513           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcGetNextEventMetadata(struct ndr_pull *ndr, int flags, struct eventlog6_EvtRpcGetNextEventMetadata *r)
    5514             : {
    5515             :         uint32_t _ptr_eventMetadataInstances;
    5516           0 :         uint32_t size_eventMetadataInstances_2 = 0;
    5517             :         uint32_t cntr_eventMetadataInstances_2;
    5518           0 :         TALLOC_CTX *_mem_save_eventMetaDataEnum_0 = NULL;
    5519           0 :         TALLOC_CTX *_mem_save_numReturned_0 = NULL;
    5520           0 :         TALLOC_CTX *_mem_save_eventMetadataInstances_0 = NULL;
    5521           0 :         TALLOC_CTX *_mem_save_eventMetadataInstances_1 = NULL;
    5522           0 :         TALLOC_CTX *_mem_save_eventMetadataInstances_2 = NULL;
    5523           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    5524           0 :         if (flags & NDR_IN) {
    5525           0 :                 NDR_ZERO_STRUCT(r->out);
    5526             : 
    5527           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    5528           0 :                         NDR_PULL_ALLOC(ndr, r->in.eventMetaDataEnum);
    5529             :                 }
    5530           0 :                 _mem_save_eventMetaDataEnum_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5531           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.eventMetaDataEnum, LIBNDR_FLAG_REF_ALLOC);
    5532           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.eventMetaDataEnum));
    5533           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eventMetaDataEnum_0, LIBNDR_FLAG_REF_ALLOC);
    5534           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
    5535           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numRequested));
    5536           0 :                 NDR_PULL_ALLOC(ndr, r->out.numReturned);
    5537           0 :                 NDR_ZERO_STRUCTP(r->out.numReturned);
    5538           0 :                 NDR_PULL_ALLOC(ndr, r->out.eventMetadataInstances);
    5539           0 :                 NDR_ZERO_STRUCTP(r->out.eventMetadataInstances);
    5540             :         }
    5541           0 :         if (flags & NDR_OUT) {
    5542             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    5543             :                 if (r->in.eventMetaDataEnum == NULL) {
    5544             :                         NDR_PULL_ALLOC(ndr, r->in.eventMetaDataEnum);
    5545             :                         NDR_ZERO_STRUCTP(r->in.eventMetaDataEnum);
    5546             :                 }
    5547             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    5548           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    5549           0 :                         NDR_PULL_ALLOC(ndr, r->out.numReturned);
    5550             :                 }
    5551           0 :                 _mem_save_numReturned_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5552           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.numReturned, LIBNDR_FLAG_REF_ALLOC);
    5553           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.numReturned));
    5554           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_numReturned_0, LIBNDR_FLAG_REF_ALLOC);
    5555           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    5556           0 :                         NDR_PULL_ALLOC(ndr, r->out.eventMetadataInstances);
    5557             :                 }
    5558           0 :                 _mem_save_eventMetadataInstances_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5559           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.eventMetadataInstances, LIBNDR_FLAG_REF_ALLOC);
    5560           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_eventMetadataInstances));
    5561           0 :                 if (_ptr_eventMetadataInstances) {
    5562           0 :                         NDR_PULL_ALLOC(ndr, *r->out.eventMetadataInstances);
    5563             :                 } else {
    5564           0 :                         *r->out.eventMetadataInstances = NULL;
    5565             :                 }
    5566           0 :                 if (*r->out.eventMetadataInstances) {
    5567           0 :                         _mem_save_eventMetadataInstances_1 = NDR_PULL_GET_MEM_CTX(ndr);
    5568           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.eventMetadataInstances, 0);
    5569           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.eventMetadataInstances));
    5570           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)r->out.eventMetadataInstances, &size_eventMetadataInstances_2));
    5571           0 :                         if (size_eventMetadataInstances_2 > MAX_RPC_EVENT_METADATA_COUNT) {
    5572           0 :                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    5573             :                         }
    5574           0 :                         NDR_PULL_ALLOC_N(ndr, *r->out.eventMetadataInstances, size_eventMetadataInstances_2);
    5575           0 :                         _mem_save_eventMetadataInstances_2 = NDR_PULL_GET_MEM_CTX(ndr);
    5576           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.eventMetadataInstances, 0);
    5577           0 :                         for (cntr_eventMetadataInstances_2 = 0; cntr_eventMetadataInstances_2 < (size_eventMetadataInstances_2); cntr_eventMetadataInstances_2++) {
    5578           0 :                                 NDR_CHECK(ndr_pull_eventlog6_EvtRpcVariantList(ndr, NDR_SCALARS, &(*r->out.eventMetadataInstances)[cntr_eventMetadataInstances_2]));
    5579             :                         }
    5580           0 :                         for (cntr_eventMetadataInstances_2 = 0; cntr_eventMetadataInstances_2 < (size_eventMetadataInstances_2); cntr_eventMetadataInstances_2++) {
    5581           0 :                                 NDR_CHECK(ndr_pull_eventlog6_EvtRpcVariantList(ndr, NDR_BUFFERS, &(*r->out.eventMetadataInstances)[cntr_eventMetadataInstances_2]));
    5582             :                         }
    5583           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eventMetadataInstances_2, 0);
    5584           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eventMetadataInstances_1, 0);
    5585             :                 }
    5586           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eventMetadataInstances_0, LIBNDR_FLAG_REF_ALLOC);
    5587           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    5588           0 :                 if (*r->out.eventMetadataInstances) {
    5589           0 :                         NDR_CHECK(ndr_check_array_size(ndr, (void*)r->out.eventMetadataInstances, *r->out.numReturned));
    5590             :                 }
    5591           0 :                 for (cntr_eventMetadataInstances_2 = 0; cntr_eventMetadataInstances_2 < (size_eventMetadataInstances_2); cntr_eventMetadataInstances_2++) {
    5592             :                 }
    5593             :         }
    5594           0 :         return NDR_ERR_SUCCESS;
    5595             : }
    5596             : 
    5597           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcGetNextEventMetadata(struct ndr_print *ndr, const char *name, int flags, const struct eventlog6_EvtRpcGetNextEventMetadata *r)
    5598             : {
    5599             :         uint32_t cntr_eventMetadataInstances_2;
    5600           0 :         ndr_print_struct(ndr, name, "eventlog6_EvtRpcGetNextEventMetadata");
    5601           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    5602           0 :         ndr->depth++;
    5603           0 :         if (flags & NDR_SET_VALUES) {
    5604           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    5605             :         }
    5606           0 :         if (flags & NDR_IN) {
    5607           0 :                 ndr_print_struct(ndr, "in", "eventlog6_EvtRpcGetNextEventMetadata");
    5608           0 :                 ndr->depth++;
    5609           0 :                 ndr_print_ptr(ndr, "eventMetaDataEnum", r->in.eventMetaDataEnum);
    5610           0 :                 ndr->depth++;
    5611           0 :                 ndr_print_policy_handle(ndr, "eventMetaDataEnum", r->in.eventMetaDataEnum);
    5612           0 :                 ndr->depth--;
    5613           0 :                 ndr_print_uint32(ndr, "flags", r->in.flags);
    5614           0 :                 ndr_print_uint32(ndr, "numRequested", r->in.numRequested);
    5615           0 :                 ndr->depth--;
    5616             :         }
    5617           0 :         if (flags & NDR_OUT) {
    5618           0 :                 ndr_print_struct(ndr, "out", "eventlog6_EvtRpcGetNextEventMetadata");
    5619           0 :                 ndr->depth++;
    5620           0 :                 ndr_print_ptr(ndr, "numReturned", r->out.numReturned);
    5621           0 :                 ndr->depth++;
    5622           0 :                 ndr_print_uint32(ndr, "numReturned", *r->out.numReturned);
    5623           0 :                 ndr->depth--;
    5624           0 :                 ndr_print_ptr(ndr, "eventMetadataInstances", r->out.eventMetadataInstances);
    5625           0 :                 ndr->depth++;
    5626           0 :                 ndr_print_ptr(ndr, "eventMetadataInstances", *r->out.eventMetadataInstances);
    5627           0 :                 ndr->depth++;
    5628           0 :                 if (*r->out.eventMetadataInstances) {
    5629           0 :                         ndr->print(ndr, "%s: ARRAY(%d)", "eventMetadataInstances", (int)*r->out.numReturned);
    5630           0 :                         ndr->depth++;
    5631           0 :                         for (cntr_eventMetadataInstances_2 = 0; cntr_eventMetadataInstances_2 < (*r->out.numReturned); cntr_eventMetadataInstances_2++) {
    5632           0 :                                 ndr_print_eventlog6_EvtRpcVariantList(ndr, "eventMetadataInstances", &(*r->out.eventMetadataInstances)[cntr_eventMetadataInstances_2]);
    5633             :                         }
    5634           0 :                         ndr->depth--;
    5635             :                 }
    5636           0 :                 ndr->depth--;
    5637           0 :                 ndr->depth--;
    5638           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    5639           0 :                 ndr->depth--;
    5640             :         }
    5641           0 :         ndr->depth--;
    5642             : }
    5643             : 
    5644           0 : static enum ndr_err_code ndr_push_eventlog6_EvtRpcGetClassicLogDisplayName(struct ndr_push *ndr, int flags, const struct eventlog6_EvtRpcGetClassicLogDisplayName *r)
    5645             : {
    5646           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    5647           0 :         if (flags & NDR_IN) {
    5648           0 :                 if (r->in.logName == NULL) {
    5649           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5650             :                 }
    5651           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.logName, CH_UTF16)));
    5652           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    5653           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.logName, CH_UTF16)));
    5654           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.logName, ndr_charset_length(r->in.logName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    5655           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.locale));
    5656           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
    5657             :         }
    5658           0 :         if (flags & NDR_OUT) {
    5659           0 :                 if (r->out.displayName == NULL) {
    5660           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5661             :                 }
    5662           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.displayName));
    5663           0 :                 if (*r->out.displayName) {
    5664           0 :                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, **r->out.displayName));
    5665             :                 }
    5666           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    5667             :         }
    5668           0 :         return NDR_ERR_SUCCESS;
    5669             : }
    5670             : 
    5671           0 : static enum ndr_err_code ndr_pull_eventlog6_EvtRpcGetClassicLogDisplayName(struct ndr_pull *ndr, int flags, struct eventlog6_EvtRpcGetClassicLogDisplayName *r)
    5672             : {
    5673           0 :         uint32_t size_logName_1 = 0;
    5674           0 :         uint32_t length_logName_1 = 0;
    5675             :         uint32_t _ptr_displayName;
    5676           0 :         TALLOC_CTX *_mem_save_displayName_0 = NULL;
    5677           0 :         TALLOC_CTX *_mem_save_displayName_1 = NULL;
    5678           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    5679           0 :         if (flags & NDR_IN) {
    5680           0 :                 NDR_ZERO_STRUCT(r->out);
    5681             : 
    5682           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.logName));
    5683           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.logName));
    5684           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.logName, &size_logName_1));
    5685           0 :                 if (size_logName_1 < 1 || size_logName_1 > MAX_RPC_CHANNEL_NAME_LENGTH) {
    5686           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    5687             :                 }
    5688           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.logName, &length_logName_1));
    5689           0 :                 if (length_logName_1 < 1 || length_logName_1 > MAX_RPC_CHANNEL_NAME_LENGTH) {
    5690           0 :                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    5691             :                 }
    5692           0 :                 if (length_logName_1 > size_logName_1) {
    5693           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_logName_1, length_logName_1);
    5694             :                 }
    5695           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_logName_1, sizeof(uint16_t)));
    5696           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.logName, length_logName_1, sizeof(uint16_t), CH_UTF16));
    5697           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.locale));
    5698           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
    5699           0 :                 NDR_PULL_ALLOC(ndr, r->out.displayName);
    5700           0 :                 NDR_ZERO_STRUCTP(r->out.displayName);
    5701             :         }
    5702           0 :         if (flags & NDR_OUT) {
    5703             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    5704             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    5705           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    5706           0 :                         NDR_PULL_ALLOC(ndr, r->out.displayName);
    5707             :                 }
    5708           0 :                 _mem_save_displayName_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5709           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.displayName, LIBNDR_FLAG_REF_ALLOC);
    5710           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_displayName));
    5711           0 :                 if (_ptr_displayName) {
    5712           0 :                         NDR_PULL_ALLOC(ndr, *r->out.displayName);
    5713             :                 } else {
    5714           0 :                         *r->out.displayName = NULL;
    5715             :                 }
    5716           0 :                 if (*r->out.displayName) {
    5717           0 :                         _mem_save_displayName_1 = NDR_PULL_GET_MEM_CTX(ndr);
    5718           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.displayName, 0);
    5719           0 :                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, *r->out.displayName));
    5720           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_displayName_1, 0);
    5721             :                 }
    5722           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_displayName_0, LIBNDR_FLAG_REF_ALLOC);
    5723           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    5724             :         }
    5725           0 :         return NDR_ERR_SUCCESS;
    5726             : }
    5727             : 
    5728           0 : _PUBLIC_ void ndr_print_eventlog6_EvtRpcGetClassicLogDisplayName(struct ndr_print *ndr, const char *name, int flags, const struct eventlog6_EvtRpcGetClassicLogDisplayName *r)
    5729             : {
    5730           0 :         ndr_print_struct(ndr, name, "eventlog6_EvtRpcGetClassicLogDisplayName");
    5731           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    5732           0 :         ndr->depth++;
    5733           0 :         if (flags & NDR_SET_VALUES) {
    5734           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    5735             :         }
    5736           0 :         if (flags & NDR_IN) {
    5737           0 :                 ndr_print_struct(ndr, "in", "eventlog6_EvtRpcGetClassicLogDisplayName");
    5738           0 :                 ndr->depth++;
    5739           0 :                 ndr_print_ptr(ndr, "logName", r->in.logName);
    5740           0 :                 ndr->depth++;
    5741           0 :                 ndr_print_string(ndr, "logName", r->in.logName);
    5742           0 :                 ndr->depth--;
    5743           0 :                 ndr_print_uint32(ndr, "locale", r->in.locale);
    5744           0 :                 ndr_print_uint32(ndr, "flags", r->in.flags);
    5745           0 :                 ndr->depth--;
    5746             :         }
    5747           0 :         if (flags & NDR_OUT) {
    5748           0 :                 ndr_print_struct(ndr, "out", "eventlog6_EvtRpcGetClassicLogDisplayName");
    5749           0 :                 ndr->depth++;
    5750           0 :                 ndr_print_ptr(ndr, "displayName", r->out.displayName);
    5751           0 :                 ndr->depth++;
    5752           0 :                 ndr_print_ptr(ndr, "displayName", *r->out.displayName);
    5753           0 :                 ndr->depth++;
    5754           0 :                 if (*r->out.displayName) {
    5755           0 :                         ndr_print_uint16(ndr, "displayName", **r->out.displayName);
    5756             :                 }
    5757           0 :                 ndr->depth--;
    5758           0 :                 ndr->depth--;
    5759           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    5760           0 :                 ndr->depth--;
    5761             :         }
    5762           0 :         ndr->depth--;
    5763             : }
    5764             : 
    5765             : #ifndef SKIP_NDR_TABLE_eventlog6
    5766             : static const struct ndr_interface_public_struct eventlog6_public_structs[] = {
    5767             :         { .name = NULL }
    5768             : };
    5769             : 
    5770             : static const struct ndr_interface_call eventlog6_calls[] = {
    5771             :         {
    5772             :                 "eventlog6_EvtRpcRegisterRemoteSubscription",
    5773             :                 sizeof(struct eventlog6_EvtRpcRegisterRemoteSubscription),
    5774             :                 (ndr_push_flags_fn_t) ndr_push_eventlog6_EvtRpcRegisterRemoteSubscription,
    5775             :                 (ndr_pull_flags_fn_t) ndr_pull_eventlog6_EvtRpcRegisterRemoteSubscription,
    5776             :                 (ndr_print_function_t) ndr_print_eventlog6_EvtRpcRegisterRemoteSubscription,
    5777             :                 { 0, NULL },
    5778             :                 { 0, NULL },
    5779             :         },
    5780             :         {
    5781             :                 "eventlog6_EvtRpcRemoteSubscriptionNextAsync",
    5782             :                 sizeof(struct eventlog6_EvtRpcRemoteSubscriptionNextAsync),
    5783             :                 (ndr_push_flags_fn_t) ndr_push_eventlog6_EvtRpcRemoteSubscriptionNextAsync,
    5784             :                 (ndr_pull_flags_fn_t) ndr_pull_eventlog6_EvtRpcRemoteSubscriptionNextAsync,
    5785             :                 (ndr_print_function_t) ndr_print_eventlog6_EvtRpcRemoteSubscriptionNextAsync,
    5786             :                 { 0, NULL },
    5787             :                 { 0, NULL },
    5788             :         },
    5789             :         {
    5790             :                 "eventlog6_EvtRpcRemoteSubscriptionNext",
    5791             :                 sizeof(struct eventlog6_EvtRpcRemoteSubscriptionNext),
    5792             :                 (ndr_push_flags_fn_t) ndr_push_eventlog6_EvtRpcRemoteSubscriptionNext,
    5793             :                 (ndr_pull_flags_fn_t) ndr_pull_eventlog6_EvtRpcRemoteSubscriptionNext,
    5794             :                 (ndr_print_function_t) ndr_print_eventlog6_EvtRpcRemoteSubscriptionNext,
    5795             :                 { 0, NULL },
    5796             :                 { 0, NULL },
    5797             :         },
    5798             :         {
    5799             :                 "eventlog6_EvtRpcRemoteSubscriptionWaitAsync",
    5800             :                 sizeof(struct eventlog6_EvtRpcRemoteSubscriptionWaitAsync),
    5801             :                 (ndr_push_flags_fn_t) ndr_push_eventlog6_EvtRpcRemoteSubscriptionWaitAsync,
    5802             :                 (ndr_pull_flags_fn_t) ndr_pull_eventlog6_EvtRpcRemoteSubscriptionWaitAsync,
    5803             :                 (ndr_print_function_t) ndr_print_eventlog6_EvtRpcRemoteSubscriptionWaitAsync,
    5804             :                 { 0, NULL },
    5805             :                 { 0, NULL },
    5806             :         },
    5807             :         {
    5808             :                 "eventlog6_EvtRpcRegisterControllableOperation",
    5809             :                 sizeof(struct eventlog6_EvtRpcRegisterControllableOperation),
    5810             :                 (ndr_push_flags_fn_t) ndr_push_eventlog6_EvtRpcRegisterControllableOperation,
    5811             :                 (ndr_pull_flags_fn_t) ndr_pull_eventlog6_EvtRpcRegisterControllableOperation,
    5812             :                 (ndr_print_function_t) ndr_print_eventlog6_EvtRpcRegisterControllableOperation,
    5813             :                 { 0, NULL },
    5814             :                 { 0, NULL },
    5815             :         },
    5816             :         {
    5817             :                 "eventlog6_EvtRpcRegisterLogQuery",
    5818             :                 sizeof(struct eventlog6_EvtRpcRegisterLogQuery),
    5819             :                 (ndr_push_flags_fn_t) ndr_push_eventlog6_EvtRpcRegisterLogQuery,
    5820             :                 (ndr_pull_flags_fn_t) ndr_pull_eventlog6_EvtRpcRegisterLogQuery,
    5821             :                 (ndr_print_function_t) ndr_print_eventlog6_EvtRpcRegisterLogQuery,
    5822             :                 { 0, NULL },
    5823             :                 { 0, NULL },
    5824             :         },
    5825             :         {
    5826             :                 "eventlog6_EvtRpcClearLog",
    5827             :                 sizeof(struct eventlog6_EvtRpcClearLog),
    5828             :                 (ndr_push_flags_fn_t) ndr_push_eventlog6_EvtRpcClearLog,
    5829             :                 (ndr_pull_flags_fn_t) ndr_pull_eventlog6_EvtRpcClearLog,
    5830             :                 (ndr_print_function_t) ndr_print_eventlog6_EvtRpcClearLog,
    5831             :                 { 0, NULL },
    5832             :                 { 0, NULL },
    5833             :         },
    5834             :         {
    5835             :                 "eventlog6_EvtRpcExportLog",
    5836             :                 sizeof(struct eventlog6_EvtRpcExportLog),
    5837             :                 (ndr_push_flags_fn_t) ndr_push_eventlog6_EvtRpcExportLog,
    5838             :                 (ndr_pull_flags_fn_t) ndr_pull_eventlog6_EvtRpcExportLog,
    5839             :                 (ndr_print_function_t) ndr_print_eventlog6_EvtRpcExportLog,
    5840             :                 { 0, NULL },
    5841             :                 { 0, NULL },
    5842             :         },
    5843             :         {
    5844             :                 "eventlog6_EvtRpcLocalizeExportLog",
    5845             :                 sizeof(struct eventlog6_EvtRpcLocalizeExportLog),
    5846             :                 (ndr_push_flags_fn_t) ndr_push_eventlog6_EvtRpcLocalizeExportLog,
    5847             :                 (ndr_pull_flags_fn_t) ndr_pull_eventlog6_EvtRpcLocalizeExportLog,
    5848             :                 (ndr_print_function_t) ndr_print_eventlog6_EvtRpcLocalizeExportLog,
    5849             :                 { 0, NULL },
    5850             :                 { 0, NULL },
    5851             :         },
    5852             :         {
    5853             :                 "eventlog6_EvtRpcMessageRender",
    5854             :                 sizeof(struct eventlog6_EvtRpcMessageRender),
    5855             :                 (ndr_push_flags_fn_t) ndr_push_eventlog6_EvtRpcMessageRender,
    5856             :                 (ndr_pull_flags_fn_t) ndr_pull_eventlog6_EvtRpcMessageRender,
    5857             :                 (ndr_print_function_t) ndr_print_eventlog6_EvtRpcMessageRender,
    5858             :                 { 0, NULL },
    5859             :                 { 0, NULL },
    5860             :         },
    5861             :         {
    5862             :                 "eventlog6_EvtRpcMessageRenderDefault",
    5863             :                 sizeof(struct eventlog6_EvtRpcMessageRenderDefault),
    5864             :                 (ndr_push_flags_fn_t) ndr_push_eventlog6_EvtRpcMessageRenderDefault,
    5865             :                 (ndr_pull_flags_fn_t) ndr_pull_eventlog6_EvtRpcMessageRenderDefault,
    5866             :                 (ndr_print_function_t) ndr_print_eventlog6_EvtRpcMessageRenderDefault,
    5867             :                 { 0, NULL },
    5868             :                 { 0, NULL },
    5869             :         },
    5870             :         {
    5871             :                 "eventlog6_EvtRpcQueryNext",
    5872             :                 sizeof(struct eventlog6_EvtRpcQueryNext),
    5873             :                 (ndr_push_flags_fn_t) ndr_push_eventlog6_EvtRpcQueryNext,
    5874             :                 (ndr_pull_flags_fn_t) ndr_pull_eventlog6_EvtRpcQueryNext,
    5875             :                 (ndr_print_function_t) ndr_print_eventlog6_EvtRpcQueryNext,
    5876             :                 { 0, NULL },
    5877             :                 { 0, NULL },
    5878             :         },
    5879             :         {
    5880             :                 "eventlog6_EvtRpcQuerySeek",
    5881             :                 sizeof(struct eventlog6_EvtRpcQuerySeek),
    5882             :                 (ndr_push_flags_fn_t) ndr_push_eventlog6_EvtRpcQuerySeek,
    5883             :                 (ndr_pull_flags_fn_t) ndr_pull_eventlog6_EvtRpcQuerySeek,
    5884             :                 (ndr_print_function_t) ndr_print_eventlog6_EvtRpcQuerySeek,
    5885             :                 { 0, NULL },
    5886             :                 { 0, NULL },
    5887             :         },
    5888             :         {
    5889             :                 "eventlog6_EvtRpcClose",
    5890             :                 sizeof(struct eventlog6_EvtRpcClose),
    5891             :                 (ndr_push_flags_fn_t) ndr_push_eventlog6_EvtRpcClose,
    5892             :                 (ndr_pull_flags_fn_t) ndr_pull_eventlog6_EvtRpcClose,
    5893             :                 (ndr_print_function_t) ndr_print_eventlog6_EvtRpcClose,
    5894             :                 { 0, NULL },
    5895             :                 { 0, NULL },
    5896             :         },
    5897             :         {
    5898             :                 "eventlog6_EvtRpcCancel",
    5899             :                 sizeof(struct eventlog6_EvtRpcCancel),
    5900             :                 (ndr_push_flags_fn_t) ndr_push_eventlog6_EvtRpcCancel,
    5901             :                 (ndr_pull_flags_fn_t) ndr_pull_eventlog6_EvtRpcCancel,
    5902             :                 (ndr_print_function_t) ndr_print_eventlog6_EvtRpcCancel,
    5903             :                 { 0, NULL },
    5904             :                 { 0, NULL },
    5905             :         },
    5906             :         {
    5907             :                 "eventlog6_EvtRpcAssertConfig",
    5908             :                 sizeof(struct eventlog6_EvtRpcAssertConfig),
    5909             :                 (ndr_push_flags_fn_t) ndr_push_eventlog6_EvtRpcAssertConfig,
    5910             :                 (ndr_pull_flags_fn_t) ndr_pull_eventlog6_EvtRpcAssertConfig,
    5911             :                 (ndr_print_function_t) ndr_print_eventlog6_EvtRpcAssertConfig,
    5912             :                 { 0, NULL },
    5913             :                 { 0, NULL },
    5914             :         },
    5915             :         {
    5916             :                 "eventlog6_EvtRpcRetractConfig",
    5917             :                 sizeof(struct eventlog6_EvtRpcRetractConfig),
    5918             :                 (ndr_push_flags_fn_t) ndr_push_eventlog6_EvtRpcRetractConfig,
    5919             :                 (ndr_pull_flags_fn_t) ndr_pull_eventlog6_EvtRpcRetractConfig,
    5920             :                 (ndr_print_function_t) ndr_print_eventlog6_EvtRpcRetractConfig,
    5921             :                 { 0, NULL },
    5922             :                 { 0, NULL },
    5923             :         },
    5924             :         {
    5925             :                 "eventlog6_EvtRpcOpenLogHandle",
    5926             :                 sizeof(struct eventlog6_EvtRpcOpenLogHandle),
    5927             :                 (ndr_push_flags_fn_t) ndr_push_eventlog6_EvtRpcOpenLogHandle,
    5928             :                 (ndr_pull_flags_fn_t) ndr_pull_eventlog6_EvtRpcOpenLogHandle,
    5929             :                 (ndr_print_function_t) ndr_print_eventlog6_EvtRpcOpenLogHandle,
    5930             :                 { 0, NULL },
    5931             :                 { 0, NULL },
    5932             :         },
    5933             :         {
    5934             :                 "eventlog6_EvtRpcGetLogFileInfo",
    5935             :                 sizeof(struct eventlog6_EvtRpcGetLogFileInfo),
    5936             :                 (ndr_push_flags_fn_t) ndr_push_eventlog6_EvtRpcGetLogFileInfo,
    5937             :                 (ndr_pull_flags_fn_t) ndr_pull_eventlog6_EvtRpcGetLogFileInfo,
    5938             :                 (ndr_print_function_t) ndr_print_eventlog6_EvtRpcGetLogFileInfo,
    5939             :                 { 0, NULL },
    5940             :                 { 0, NULL },
    5941             :         },
    5942             :         {
    5943             :                 "eventlog6_EvtRpcGetChannelList",
    5944             :                 sizeof(struct eventlog6_EvtRpcGetChannelList),
    5945             :                 (ndr_push_flags_fn_t) ndr_push_eventlog6_EvtRpcGetChannelList,
    5946             :                 (ndr_pull_flags_fn_t) ndr_pull_eventlog6_EvtRpcGetChannelList,
    5947             :                 (ndr_print_function_t) ndr_print_eventlog6_EvtRpcGetChannelList,
    5948             :                 { 0, NULL },
    5949             :                 { 0, NULL },
    5950             :         },
    5951             :         {
    5952             :                 "eventlog6_EvtRpcGetChannelConfig",
    5953             :                 sizeof(struct eventlog6_EvtRpcGetChannelConfig),
    5954             :                 (ndr_push_flags_fn_t) ndr_push_eventlog6_EvtRpcGetChannelConfig,
    5955             :                 (ndr_pull_flags_fn_t) ndr_pull_eventlog6_EvtRpcGetChannelConfig,
    5956             :                 (ndr_print_function_t) ndr_print_eventlog6_EvtRpcGetChannelConfig,
    5957             :                 { 0, NULL },
    5958             :                 { 0, NULL },
    5959             :         },
    5960             :         {
    5961             :                 "eventlog6_EvtRpcPutChannelConfig",
    5962             :                 sizeof(struct eventlog6_EvtRpcPutChannelConfig),
    5963             :                 (ndr_push_flags_fn_t) ndr_push_eventlog6_EvtRpcPutChannelConfig,
    5964             :                 (ndr_pull_flags_fn_t) ndr_pull_eventlog6_EvtRpcPutChannelConfig,
    5965             :                 (ndr_print_function_t) ndr_print_eventlog6_EvtRpcPutChannelConfig,
    5966             :                 { 0, NULL },
    5967             :                 { 0, NULL },
    5968             :         },
    5969             :         {
    5970             :                 "eventlog6_EvtRpcGetPublisherList",
    5971             :                 sizeof(struct eventlog6_EvtRpcGetPublisherList),
    5972             :                 (ndr_push_flags_fn_t) ndr_push_eventlog6_EvtRpcGetPublisherList,
    5973             :                 (ndr_pull_flags_fn_t) ndr_pull_eventlog6_EvtRpcGetPublisherList,
    5974             :                 (ndr_print_function_t) ndr_print_eventlog6_EvtRpcGetPublisherList,
    5975             :                 { 0, NULL },
    5976             :                 { 0, NULL },
    5977             :         },
    5978             :         {
    5979             :                 "eventlog6_EvtRpcGetPublisherListForChannel",
    5980             :                 sizeof(struct eventlog6_EvtRpcGetPublisherListForChannel),
    5981             :                 (ndr_push_flags_fn_t) ndr_push_eventlog6_EvtRpcGetPublisherListForChannel,
    5982             :                 (ndr_pull_flags_fn_t) ndr_pull_eventlog6_EvtRpcGetPublisherListForChannel,
    5983             :                 (ndr_print_function_t) ndr_print_eventlog6_EvtRpcGetPublisherListForChannel,
    5984             :                 { 0, NULL },
    5985             :                 { 0, NULL },
    5986             :         },
    5987             :         {
    5988             :                 "eventlog6_EvtRpcGetPublisherMetadata",
    5989             :                 sizeof(struct eventlog6_EvtRpcGetPublisherMetadata),
    5990             :                 (ndr_push_flags_fn_t) ndr_push_eventlog6_EvtRpcGetPublisherMetadata,
    5991             :                 (ndr_pull_flags_fn_t) ndr_pull_eventlog6_EvtRpcGetPublisherMetadata,
    5992             :                 (ndr_print_function_t) ndr_print_eventlog6_EvtRpcGetPublisherMetadata,
    5993             :                 { 0, NULL },
    5994             :                 { 0, NULL },
    5995             :         },
    5996             :         {
    5997             :                 "eventlog6_EvtRpcGetPublisherResourceMetadata",
    5998             :                 sizeof(struct eventlog6_EvtRpcGetPublisherResourceMetadata),
    5999             :                 (ndr_push_flags_fn_t) ndr_push_eventlog6_EvtRpcGetPublisherResourceMetadata,
    6000             :                 (ndr_pull_flags_fn_t) ndr_pull_eventlog6_EvtRpcGetPublisherResourceMetadata,
    6001             :                 (ndr_print_function_t) ndr_print_eventlog6_EvtRpcGetPublisherResourceMetadata,
    6002             :                 { 0, NULL },
    6003             :                 { 0, NULL },
    6004             :         },
    6005             :         {
    6006             :                 "eventlog6_EvtRpcGetEventMetadataEnum",
    6007             :                 sizeof(struct eventlog6_EvtRpcGetEventMetadataEnum),
    6008             :                 (ndr_push_flags_fn_t) ndr_push_eventlog6_EvtRpcGetEventMetadataEnum,
    6009             :                 (ndr_pull_flags_fn_t) ndr_pull_eventlog6_EvtRpcGetEventMetadataEnum,
    6010             :                 (ndr_print_function_t) ndr_print_eventlog6_EvtRpcGetEventMetadataEnum,
    6011             :                 { 0, NULL },
    6012             :                 { 0, NULL },
    6013             :         },
    6014             :         {
    6015             :                 "eventlog6_EvtRpcGetNextEventMetadata",
    6016             :                 sizeof(struct eventlog6_EvtRpcGetNextEventMetadata),
    6017             :                 (ndr_push_flags_fn_t) ndr_push_eventlog6_EvtRpcGetNextEventMetadata,
    6018             :                 (ndr_pull_flags_fn_t) ndr_pull_eventlog6_EvtRpcGetNextEventMetadata,
    6019             :                 (ndr_print_function_t) ndr_print_eventlog6_EvtRpcGetNextEventMetadata,
    6020             :                 { 0, NULL },
    6021             :                 { 0, NULL },
    6022             :         },
    6023             :         {
    6024             :                 "eventlog6_EvtRpcGetClassicLogDisplayName",
    6025             :                 sizeof(struct eventlog6_EvtRpcGetClassicLogDisplayName),
    6026             :                 (ndr_push_flags_fn_t) ndr_push_eventlog6_EvtRpcGetClassicLogDisplayName,
    6027             :                 (ndr_pull_flags_fn_t) ndr_pull_eventlog6_EvtRpcGetClassicLogDisplayName,
    6028             :                 (ndr_print_function_t) ndr_print_eventlog6_EvtRpcGetClassicLogDisplayName,
    6029             :                 { 0, NULL },
    6030             :                 { 0, NULL },
    6031             :         },
    6032             :         { .name = NULL }
    6033             : };
    6034             : 
    6035             : static const char * const eventlog6_endpoint_strings[] = {
    6036             :         "ncacn_ip_tcp:", 
    6037             : };
    6038             : 
    6039             : static const struct ndr_interface_string_array eventlog6_endpoints = {
    6040             :         .count  = 1,
    6041             :         .names  = eventlog6_endpoint_strings
    6042             : };
    6043             : 
    6044             : static const char * const eventlog6_authservice_strings[] = {
    6045             :         "host", 
    6046             : };
    6047             : 
    6048             : static const struct ndr_interface_string_array eventlog6_authservices = {
    6049             :         .count  = 1,
    6050             :         .names  = eventlog6_authservice_strings
    6051             : };
    6052             : 
    6053             : 
    6054             : const struct ndr_interface_table ndr_table_eventlog6 = {
    6055             :         .name           = "eventlog6",
    6056             :         .syntax_id      = {
    6057             :                 {0xf6beaff7,0x1e19,0x4fbb,{0x9f,0x8f},{0xb8,0x9e,0x20,0x18,0x33,0x7c}},
    6058             :                 NDR_EVENTLOG6_VERSION
    6059             :         },
    6060             :         .helpstring     = NDR_EVENTLOG6_HELPSTRING,
    6061             :         .num_calls      = 29,
    6062             :         .calls          = eventlog6_calls,
    6063             :         .num_public_structs     = 0,
    6064             :         .public_structs         = eventlog6_public_structs,
    6065             :         .endpoints      = &eventlog6_endpoints,
    6066             :         .authservices   = &eventlog6_authservices
    6067             : };
    6068             : 
    6069             : #endif /* SKIP_NDR_TABLE_eventlog6 */

Generated by: LCOV version 1.13