LCOV - code coverage report
Current view: top level - bin/default/librpc/gen_ndr - ndr_ntsvcs.c (source / functions) Hit Total Coverage
Test: coverage report for master 2b515b7d Lines: 267 2551 10.5 %
Date: 2024-02-28 12:06:22 Functions: 10 201 5.0 %

          Line data    Source code
       1             : /* parser auto-generated by pidl */
       2             : 
       3             : #include "includes.h"
       4             : #include "bin/default/librpc/gen_ndr/ndr_ntsvcs.h"
       5             : 
       6             : #include "librpc/gen_ndr/ndr_misc.h"
       7          24 : static enum ndr_err_code ndr_push_PNP_GetIdListFlags(struct ndr_push *ndr, ndr_flags_type ndr_flags, uint32_t r)
       8             : {
       9          24 :         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
      10          24 :         return NDR_ERR_SUCCESS;
      11             : }
      12             : 
      13          24 : static enum ndr_err_code ndr_pull_PNP_GetIdListFlags(struct ndr_pull *ndr, ndr_flags_type ndr_flags, uint32_t *r)
      14             : {
      15           0 :         uint32_t v;
      16          24 :         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
      17          24 :         *r = v;
      18          24 :         return NDR_ERR_SUCCESS;
      19             : }
      20             : 
      21           0 : _PUBLIC_ void ndr_print_PNP_GetIdListFlags(struct ndr_print *ndr, const char *name, uint32_t r)
      22             : {
      23           0 :         ndr_print_uint32(ndr, name, r);
      24           0 :         ndr->depth++;
      25           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "CM_GETIDLIST_FILTER_ENUMERATOR", CM_GETIDLIST_FILTER_ENUMERATOR, r);
      26           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "CM_GETIDLIST_FILTER_SERVICE", CM_GETIDLIST_FILTER_SERVICE, r);
      27           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "CM_GETIDLIST_FILTER_EJECTRELATIONS", CM_GETIDLIST_FILTER_EJECTRELATIONS, r);
      28           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "CM_GETIDLIST_FILTER_REMOVALRELATIONS", CM_GETIDLIST_FILTER_REMOVALRELATIONS, r);
      29           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "CM_GETIDLIST_FILTER_POWERRELATIONS", CM_GETIDLIST_FILTER_POWERRELATIONS, r);
      30           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "CM_GETIDLIST_FILTER_BUSRELATIONS", CM_GETIDLIST_FILTER_BUSRELATIONS, r);
      31           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "CM_GETIDLIST_DONOTGENERATE", CM_GETIDLIST_DONOTGENERATE, r);
      32           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "CM_GETIDLIST_FILTER_TRANSPORTRELATIONS", CM_GETIDLIST_FILTER_TRANSPORTRELATIONS, r);
      33           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "CM_GETIDLIST_FILTER_PRESENT", CM_GETIDLIST_FILTER_PRESENT, r);
      34           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "CM_GETIDLIST_FILTER_CLASS", CM_GETIDLIST_FILTER_CLASS, r);
      35           0 :         ndr->depth--;
      36           0 : }
      37             : 
      38           0 : static enum ndr_err_code ndr_push_PNP_HwProfInfo(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct PNP_HwProfInfo *r)
      39             : {
      40           0 :         uint32_t cntr_friendly_name_0;
      41           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
      42           0 :         if (ndr_flags & NDR_SCALARS) {
      43           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
      44           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->profile_handle));
      45           0 :                 for (cntr_friendly_name_0 = 0; cntr_friendly_name_0 < (80); cntr_friendly_name_0++) {
      46           0 :                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->friendly_name[cntr_friendly_name_0]));
      47             :                 }
      48           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
      49           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
      50             :         }
      51           0 :         if (ndr_flags & NDR_BUFFERS) {
      52           0 :         }
      53           0 :         return NDR_ERR_SUCCESS;
      54             : }
      55             : 
      56           0 : static enum ndr_err_code ndr_pull_PNP_HwProfInfo(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct PNP_HwProfInfo *r)
      57             : {
      58           0 :         uint32_t size_friendly_name_0 = 0;
      59           0 :         uint32_t cntr_friendly_name_0;
      60           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
      61           0 :         if (ndr_flags & NDR_SCALARS) {
      62           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
      63           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->profile_handle));
      64           0 :                 size_friendly_name_0 = 80;
      65           0 :                 for (cntr_friendly_name_0 = 0; cntr_friendly_name_0 < (size_friendly_name_0); cntr_friendly_name_0++) {
      66           0 :                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->friendly_name[cntr_friendly_name_0]));
      67             :                 }
      68           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
      69           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
      70             :         }
      71           0 :         if (ndr_flags & NDR_BUFFERS) {
      72           0 :         }
      73           0 :         return NDR_ERR_SUCCESS;
      74             : }
      75             : 
      76           0 : _PUBLIC_ void ndr_print_PNP_HwProfInfo(struct ndr_print *ndr, const char *name, const struct PNP_HwProfInfo *r)
      77             : {
      78           0 :         uint32_t cntr_friendly_name_0;
      79           0 :         ndr_print_struct(ndr, name, "PNP_HwProfInfo");
      80           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
      81           0 :         ndr->depth++;
      82           0 :         ndr_print_uint32(ndr, "profile_handle", r->profile_handle);
      83           0 :         ndr->print(ndr, "%s: ARRAY(%"PRIu32")", "friendly_name", (uint32_t)(80));
      84           0 :         ndr->depth++;
      85           0 :         for (cntr_friendly_name_0 = 0; cntr_friendly_name_0 < (80); cntr_friendly_name_0++) {
      86           0 :                 ndr_print_uint16(ndr, "friendly_name", r->friendly_name[cntr_friendly_name_0]);
      87             :         }
      88           0 :         ndr->depth--;
      89           0 :         ndr_print_uint32(ndr, "flags", r->flags);
      90           0 :         ndr->depth--;
      91             : }
      92             : 
      93           0 : static enum ndr_err_code ndr_push_PNP_Disconnect(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_Disconnect *r)
      94             : {
      95           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
      96           0 :         if (flags & NDR_IN) {
      97           0 :         }
      98           0 :         if (flags & NDR_OUT) {
      99           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
     100             :         }
     101           0 :         return NDR_ERR_SUCCESS;
     102             : }
     103             : 
     104           0 : static enum ndr_err_code ndr_pull_PNP_Disconnect(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_Disconnect *r)
     105             : {
     106           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     107           0 :         if (flags & NDR_IN) {
     108           0 :         }
     109           0 :         if (flags & NDR_OUT) {
     110             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     111             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     112           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
     113             :         }
     114           0 :         return NDR_ERR_SUCCESS;
     115             : }
     116             : 
     117           0 : _PUBLIC_ void ndr_print_PNP_Disconnect(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_Disconnect *r)
     118             : {
     119           0 :         ndr_print_struct(ndr, name, "PNP_Disconnect");
     120           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     121           0 :         ndr->depth++;
     122           0 :         if (flags & NDR_SET_VALUES) {
     123           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     124             :         }
     125           0 :         if (flags & NDR_IN) {
     126           0 :                 ndr_print_struct(ndr, "in", "PNP_Disconnect");
     127           0 :                 ndr->depth++;
     128           0 :                 ndr->depth--;
     129             :         }
     130           0 :         if (flags & NDR_OUT) {
     131           0 :                 ndr_print_struct(ndr, "out", "PNP_Disconnect");
     132           0 :                 ndr->depth++;
     133           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
     134           0 :                 ndr->depth--;
     135             :         }
     136           0 :         ndr->depth--;
     137             : }
     138             : 
     139           0 : static enum ndr_err_code ndr_push_PNP_Connect(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_Connect *r)
     140             : {
     141           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     142           0 :         if (flags & NDR_IN) {
     143           0 :         }
     144           0 :         if (flags & NDR_OUT) {
     145           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
     146             :         }
     147           0 :         return NDR_ERR_SUCCESS;
     148             : }
     149             : 
     150           0 : static enum ndr_err_code ndr_pull_PNP_Connect(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_Connect *r)
     151             : {
     152           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     153           0 :         if (flags & NDR_IN) {
     154           0 :         }
     155           0 :         if (flags & NDR_OUT) {
     156             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     157             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     158           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
     159             :         }
     160           0 :         return NDR_ERR_SUCCESS;
     161             : }
     162             : 
     163           0 : _PUBLIC_ void ndr_print_PNP_Connect(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_Connect *r)
     164             : {
     165           0 :         ndr_print_struct(ndr, name, "PNP_Connect");
     166           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     167           0 :         ndr->depth++;
     168           0 :         if (flags & NDR_SET_VALUES) {
     169           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     170             :         }
     171           0 :         if (flags & NDR_IN) {
     172           0 :                 ndr_print_struct(ndr, "in", "PNP_Connect");
     173           0 :                 ndr->depth++;
     174           0 :                 ndr->depth--;
     175             :         }
     176           0 :         if (flags & NDR_OUT) {
     177           0 :                 ndr_print_struct(ndr, "out", "PNP_Connect");
     178           0 :                 ndr->depth++;
     179           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
     180           0 :                 ndr->depth--;
     181             :         }
     182           0 :         ndr->depth--;
     183             : }
     184             : 
     185           8 : static enum ndr_err_code ndr_push_PNP_GetVersion(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_GetVersion *r)
     186             : {
     187           8 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     188           8 :         if (flags & NDR_IN) {
     189           0 :         }
     190           8 :         if (flags & NDR_OUT) {
     191           4 :                 if (r->out.version == NULL) {
     192           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
     193             :                 }
     194           4 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->out.version));
     195           4 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
     196             :         }
     197           8 :         return NDR_ERR_SUCCESS;
     198             : }
     199             : 
     200           8 : static enum ndr_err_code ndr_pull_PNP_GetVersion(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_GetVersion *r)
     201             : {
     202           8 :         TALLOC_CTX *_mem_save_version_0 = NULL;
     203           8 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     204           8 :         if (flags & NDR_IN) {
     205           4 :                 NDR_ZERO_STRUCT(r->out);
     206             : 
     207           4 :                 NDR_PULL_ALLOC(ndr, r->out.version);
     208           4 :                 NDR_ZERO_STRUCTP(r->out.version);
     209             :         }
     210           8 :         if (flags & NDR_OUT) {
     211             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     212             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     213           4 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
     214           0 :                         NDR_PULL_ALLOC(ndr, r->out.version);
     215             :                 }
     216           4 :                 _mem_save_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
     217           4 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.version, LIBNDR_FLAG_REF_ALLOC);
     218           4 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->out.version));
     219           4 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_version_0, LIBNDR_FLAG_REF_ALLOC);
     220           4 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
     221             :         }
     222           8 :         return NDR_ERR_SUCCESS;
     223             : }
     224             : 
     225           0 : _PUBLIC_ void ndr_print_PNP_GetVersion(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_GetVersion *r)
     226             : {
     227           0 :         ndr_print_struct(ndr, name, "PNP_GetVersion");
     228           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     229           0 :         ndr->depth++;
     230           0 :         if (flags & NDR_SET_VALUES) {
     231           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     232             :         }
     233           0 :         if (flags & NDR_IN) {
     234           0 :                 ndr_print_struct(ndr, "in", "PNP_GetVersion");
     235           0 :                 ndr->depth++;
     236           0 :                 ndr->depth--;
     237             :         }
     238           0 :         if (flags & NDR_OUT) {
     239           0 :                 ndr_print_struct(ndr, "out", "PNP_GetVersion");
     240           0 :                 ndr->depth++;
     241           0 :                 ndr_print_ptr(ndr, "version", r->out.version);
     242           0 :                 ndr->depth++;
     243           0 :                 ndr_print_uint16(ndr, "version", *r->out.version);
     244           0 :                 ndr->depth--;
     245           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
     246           0 :                 ndr->depth--;
     247             :         }
     248           0 :         ndr->depth--;
     249             : }
     250             : 
     251           0 : static enum ndr_err_code ndr_push_PNP_GetGlobalState(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_GetGlobalState *r)
     252             : {
     253           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     254           0 :         if (flags & NDR_IN) {
     255           0 :         }
     256           0 :         if (flags & NDR_OUT) {
     257           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
     258             :         }
     259           0 :         return NDR_ERR_SUCCESS;
     260             : }
     261             : 
     262           0 : static enum ndr_err_code ndr_pull_PNP_GetGlobalState(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_GetGlobalState *r)
     263             : {
     264           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     265           0 :         if (flags & NDR_IN) {
     266           0 :         }
     267           0 :         if (flags & NDR_OUT) {
     268             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     269             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     270           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
     271             :         }
     272           0 :         return NDR_ERR_SUCCESS;
     273             : }
     274             : 
     275           0 : _PUBLIC_ void ndr_print_PNP_GetGlobalState(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_GetGlobalState *r)
     276             : {
     277           0 :         ndr_print_struct(ndr, name, "PNP_GetGlobalState");
     278           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     279           0 :         ndr->depth++;
     280           0 :         if (flags & NDR_SET_VALUES) {
     281           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     282             :         }
     283           0 :         if (flags & NDR_IN) {
     284           0 :                 ndr_print_struct(ndr, "in", "PNP_GetGlobalState");
     285           0 :                 ndr->depth++;
     286           0 :                 ndr->depth--;
     287             :         }
     288           0 :         if (flags & NDR_OUT) {
     289           0 :                 ndr_print_struct(ndr, "out", "PNP_GetGlobalState");
     290           0 :                 ndr->depth++;
     291           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
     292           0 :                 ndr->depth--;
     293             :         }
     294           0 :         ndr->depth--;
     295             : }
     296             : 
     297           0 : static enum ndr_err_code ndr_push_PNP_InitDetection(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_InitDetection *r)
     298             : {
     299           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     300           0 :         if (flags & NDR_IN) {
     301           0 :         }
     302           0 :         if (flags & NDR_OUT) {
     303           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
     304             :         }
     305           0 :         return NDR_ERR_SUCCESS;
     306             : }
     307             : 
     308           0 : static enum ndr_err_code ndr_pull_PNP_InitDetection(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_InitDetection *r)
     309             : {
     310           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     311           0 :         if (flags & NDR_IN) {
     312           0 :         }
     313           0 :         if (flags & NDR_OUT) {
     314             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     315             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     316           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
     317             :         }
     318           0 :         return NDR_ERR_SUCCESS;
     319             : }
     320             : 
     321           0 : _PUBLIC_ void ndr_print_PNP_InitDetection(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_InitDetection *r)
     322             : {
     323           0 :         ndr_print_struct(ndr, name, "PNP_InitDetection");
     324           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     325           0 :         ndr->depth++;
     326           0 :         if (flags & NDR_SET_VALUES) {
     327           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     328             :         }
     329           0 :         if (flags & NDR_IN) {
     330           0 :                 ndr_print_struct(ndr, "in", "PNP_InitDetection");
     331           0 :                 ndr->depth++;
     332           0 :                 ndr->depth--;
     333             :         }
     334           0 :         if (flags & NDR_OUT) {
     335           0 :                 ndr_print_struct(ndr, "out", "PNP_InitDetection");
     336           0 :                 ndr->depth++;
     337           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
     338           0 :                 ndr->depth--;
     339             :         }
     340           0 :         ndr->depth--;
     341             : }
     342             : 
     343           0 : static enum ndr_err_code ndr_push_PNP_ReportLogOn(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_ReportLogOn *r)
     344             : {
     345           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     346           0 :         if (flags & NDR_IN) {
     347           0 :         }
     348           0 :         if (flags & NDR_OUT) {
     349           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
     350             :         }
     351           0 :         return NDR_ERR_SUCCESS;
     352             : }
     353             : 
     354           0 : static enum ndr_err_code ndr_pull_PNP_ReportLogOn(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_ReportLogOn *r)
     355             : {
     356           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     357           0 :         if (flags & NDR_IN) {
     358           0 :         }
     359           0 :         if (flags & NDR_OUT) {
     360             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     361             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     362           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
     363             :         }
     364           0 :         return NDR_ERR_SUCCESS;
     365             : }
     366             : 
     367           0 : _PUBLIC_ void ndr_print_PNP_ReportLogOn(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_ReportLogOn *r)
     368             : {
     369           0 :         ndr_print_struct(ndr, name, "PNP_ReportLogOn");
     370           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     371           0 :         ndr->depth++;
     372           0 :         if (flags & NDR_SET_VALUES) {
     373           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     374             :         }
     375           0 :         if (flags & NDR_IN) {
     376           0 :                 ndr_print_struct(ndr, "in", "PNP_ReportLogOn");
     377           0 :                 ndr->depth++;
     378           0 :                 ndr->depth--;
     379             :         }
     380           0 :         if (flags & NDR_OUT) {
     381           0 :                 ndr_print_struct(ndr, "out", "PNP_ReportLogOn");
     382           0 :                 ndr->depth++;
     383           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
     384           0 :                 ndr->depth--;
     385             :         }
     386           0 :         ndr->depth--;
     387             : }
     388             : 
     389           0 : static enum ndr_err_code ndr_push_PNP_ValidateDeviceInstance(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_ValidateDeviceInstance *r)
     390             : {
     391           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     392           0 :         if (flags & NDR_IN) {
     393           0 :                 if (r->in.devicepath == NULL) {
     394           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
     395             :                 }
     396           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.devicepath, CH_UTF16)));
     397           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     398           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.devicepath, CH_UTF16)));
     399           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.devicepath, ndr_charset_length(r->in.devicepath, CH_UTF16), sizeof(uint16_t), CH_UTF16));
     400           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
     401             :         }
     402           0 :         if (flags & NDR_OUT) {
     403           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
     404             :         }
     405           0 :         return NDR_ERR_SUCCESS;
     406             : }
     407             : 
     408           0 : static enum ndr_err_code ndr_pull_PNP_ValidateDeviceInstance(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_ValidateDeviceInstance *r)
     409             : {
     410           0 :         uint32_t size_devicepath_1 = 0;
     411           0 :         uint32_t length_devicepath_1 = 0;
     412           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     413           0 :         if (flags & NDR_IN) {
     414           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.devicepath));
     415           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.devicepath));
     416           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.devicepath, &size_devicepath_1));
     417           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.devicepath, &length_devicepath_1));
     418           0 :                 if (length_devicepath_1 > size_devicepath_1) {
     419           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %"PRIu32": should exceed array length %"PRIu32"", size_devicepath_1, length_devicepath_1);
     420             :                 }
     421           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_devicepath_1, sizeof(uint16_t)));
     422           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.devicepath, length_devicepath_1, sizeof(uint16_t), CH_UTF16));
     423           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
     424             :         }
     425           0 :         if (flags & NDR_OUT) {
     426             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     427             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     428           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
     429             :         }
     430           0 :         return NDR_ERR_SUCCESS;
     431             : }
     432             : 
     433           0 : _PUBLIC_ void ndr_print_PNP_ValidateDeviceInstance(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_ValidateDeviceInstance *r)
     434             : {
     435           0 :         ndr_print_struct(ndr, name, "PNP_ValidateDeviceInstance");
     436           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     437           0 :         ndr->depth++;
     438           0 :         if (flags & NDR_SET_VALUES) {
     439           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     440             :         }
     441           0 :         if (flags & NDR_IN) {
     442           0 :                 ndr_print_struct(ndr, "in", "PNP_ValidateDeviceInstance");
     443           0 :                 ndr->depth++;
     444           0 :                 ndr_print_ptr(ndr, "devicepath", r->in.devicepath);
     445           0 :                 ndr->depth++;
     446           0 :                 ndr_print_string(ndr, "devicepath", r->in.devicepath);
     447           0 :                 ndr->depth--;
     448           0 :                 ndr_print_uint32(ndr, "flags", r->in.flags);
     449           0 :                 ndr->depth--;
     450             :         }
     451           0 :         if (flags & NDR_OUT) {
     452           0 :                 ndr_print_struct(ndr, "out", "PNP_ValidateDeviceInstance");
     453           0 :                 ndr->depth++;
     454           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
     455           0 :                 ndr->depth--;
     456             :         }
     457           0 :         ndr->depth--;
     458             : }
     459             : 
     460           0 : static enum ndr_err_code ndr_push_PNP_GetRootDeviceInstance(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_GetRootDeviceInstance *r)
     461             : {
     462           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     463           0 :         if (flags & NDR_IN) {
     464           0 :         }
     465           0 :         if (flags & NDR_OUT) {
     466           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
     467             :         }
     468           0 :         return NDR_ERR_SUCCESS;
     469             : }
     470             : 
     471           0 : static enum ndr_err_code ndr_pull_PNP_GetRootDeviceInstance(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_GetRootDeviceInstance *r)
     472             : {
     473           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     474           0 :         if (flags & NDR_IN) {
     475           0 :         }
     476           0 :         if (flags & NDR_OUT) {
     477             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     478             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     479           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
     480             :         }
     481           0 :         return NDR_ERR_SUCCESS;
     482             : }
     483             : 
     484           0 : _PUBLIC_ void ndr_print_PNP_GetRootDeviceInstance(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_GetRootDeviceInstance *r)
     485             : {
     486           0 :         ndr_print_struct(ndr, name, "PNP_GetRootDeviceInstance");
     487           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     488           0 :         ndr->depth++;
     489           0 :         if (flags & NDR_SET_VALUES) {
     490           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     491             :         }
     492           0 :         if (flags & NDR_IN) {
     493           0 :                 ndr_print_struct(ndr, "in", "PNP_GetRootDeviceInstance");
     494           0 :                 ndr->depth++;
     495           0 :                 ndr->depth--;
     496             :         }
     497           0 :         if (flags & NDR_OUT) {
     498           0 :                 ndr_print_struct(ndr, "out", "PNP_GetRootDeviceInstance");
     499           0 :                 ndr->depth++;
     500           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
     501           0 :                 ndr->depth--;
     502             :         }
     503           0 :         ndr->depth--;
     504             : }
     505             : 
     506           0 : static enum ndr_err_code ndr_push_PNP_GetRelatedDeviceInstance(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_GetRelatedDeviceInstance *r)
     507             : {
     508           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     509           0 :         if (flags & NDR_IN) {
     510           0 :         }
     511           0 :         if (flags & NDR_OUT) {
     512           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
     513             :         }
     514           0 :         return NDR_ERR_SUCCESS;
     515             : }
     516             : 
     517           0 : static enum ndr_err_code ndr_pull_PNP_GetRelatedDeviceInstance(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_GetRelatedDeviceInstance *r)
     518             : {
     519           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     520           0 :         if (flags & NDR_IN) {
     521           0 :         }
     522           0 :         if (flags & NDR_OUT) {
     523             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     524             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     525           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
     526             :         }
     527           0 :         return NDR_ERR_SUCCESS;
     528             : }
     529             : 
     530           0 : _PUBLIC_ void ndr_print_PNP_GetRelatedDeviceInstance(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_GetRelatedDeviceInstance *r)
     531             : {
     532           0 :         ndr_print_struct(ndr, name, "PNP_GetRelatedDeviceInstance");
     533           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     534           0 :         ndr->depth++;
     535           0 :         if (flags & NDR_SET_VALUES) {
     536           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     537             :         }
     538           0 :         if (flags & NDR_IN) {
     539           0 :                 ndr_print_struct(ndr, "in", "PNP_GetRelatedDeviceInstance");
     540           0 :                 ndr->depth++;
     541           0 :                 ndr->depth--;
     542             :         }
     543           0 :         if (flags & NDR_OUT) {
     544           0 :                 ndr_print_struct(ndr, "out", "PNP_GetRelatedDeviceInstance");
     545           0 :                 ndr->depth++;
     546           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
     547           0 :                 ndr->depth--;
     548             :         }
     549           0 :         ndr->depth--;
     550             : }
     551             : 
     552           0 : static enum ndr_err_code ndr_push_PNP_EnumerateSubKeys(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_EnumerateSubKeys *r)
     553             : {
     554           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     555           0 :         if (flags & NDR_IN) {
     556           0 :         }
     557           0 :         if (flags & NDR_OUT) {
     558           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
     559             :         }
     560           0 :         return NDR_ERR_SUCCESS;
     561             : }
     562             : 
     563           0 : static enum ndr_err_code ndr_pull_PNP_EnumerateSubKeys(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_EnumerateSubKeys *r)
     564             : {
     565           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     566           0 :         if (flags & NDR_IN) {
     567           0 :         }
     568           0 :         if (flags & NDR_OUT) {
     569             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     570             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     571           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
     572             :         }
     573           0 :         return NDR_ERR_SUCCESS;
     574             : }
     575             : 
     576           0 : _PUBLIC_ void ndr_print_PNP_EnumerateSubKeys(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_EnumerateSubKeys *r)
     577             : {
     578           0 :         ndr_print_struct(ndr, name, "PNP_EnumerateSubKeys");
     579           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     580           0 :         ndr->depth++;
     581           0 :         if (flags & NDR_SET_VALUES) {
     582           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     583             :         }
     584           0 :         if (flags & NDR_IN) {
     585           0 :                 ndr_print_struct(ndr, "in", "PNP_EnumerateSubKeys");
     586           0 :                 ndr->depth++;
     587           0 :                 ndr->depth--;
     588             :         }
     589           0 :         if (flags & NDR_OUT) {
     590           0 :                 ndr_print_struct(ndr, "out", "PNP_EnumerateSubKeys");
     591           0 :                 ndr->depth++;
     592           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
     593           0 :                 ndr->depth--;
     594             :         }
     595           0 :         ndr->depth--;
     596             : }
     597             : 
     598          24 : static enum ndr_err_code ndr_push_PNP_GetDeviceList(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_GetDeviceList *r)
     599             : {
     600           0 :         uint32_t cntr_buffer_1;
     601          24 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     602          24 :         if (flags & NDR_IN) {
     603          12 :                 if (r->in.length == NULL) {
     604           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
     605             :                 }
     606          12 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.filter));
     607          12 :                 if (r->in.filter) {
     608           8 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.filter, CH_UTF16)));
     609           8 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     610           8 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.filter, CH_UTF16)));
     611           8 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.filter, ndr_charset_length(r->in.filter, CH_UTF16), sizeof(uint16_t), CH_UTF16));
     612             :                 }
     613          12 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.length));
     614          12 :                 NDR_CHECK(ndr_push_PNP_GetIdListFlags(ndr, NDR_SCALARS, r->in.flags));
     615             :         }
     616          24 :         if (flags & NDR_OUT) {
     617          12 :                 if (r->out.buffer == NULL) {
     618           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
     619             :                 }
     620          12 :                 if (r->out.length == NULL) {
     621           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
     622             :                 }
     623          12 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.length));
     624          12 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     625          12 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.length));
     626         116 :                 for (cntr_buffer_1 = 0; cntr_buffer_1 < (*r->out.length); cntr_buffer_1++) {
     627         104 :                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->out.buffer[cntr_buffer_1]));
     628             :                 }
     629          12 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.length));
     630          12 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
     631             :         }
     632          24 :         return NDR_ERR_SUCCESS;
     633             : }
     634             : 
     635          24 : static enum ndr_err_code ndr_pull_PNP_GetDeviceList(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_GetDeviceList *r)
     636             : {
     637           0 :         uint32_t _ptr_filter;
     638          24 :         uint32_t size_filter_1 = 0;
     639          24 :         uint32_t length_filter_1 = 0;
     640          24 :         uint32_t size_buffer_1 = 0;
     641          24 :         uint32_t length_buffer_1 = 0;
     642           0 :         uint32_t cntr_buffer_1;
     643          24 :         TALLOC_CTX *_mem_save_filter_0 = NULL;
     644          24 :         TALLOC_CTX *_mem_save_buffer_1 = NULL;
     645          24 :         TALLOC_CTX *_mem_save_length_0 = NULL;
     646          24 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     647          24 :         if (flags & NDR_IN) {
     648          12 :                 NDR_ZERO_STRUCT(r->out);
     649             : 
     650          12 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_filter));
     651          12 :                 if (_ptr_filter) {
     652           8 :                         NDR_PULL_ALLOC(ndr, r->in.filter);
     653             :                 } else {
     654           4 :                         r->in.filter = NULL;
     655             :                 }
     656          12 :                 if (r->in.filter) {
     657           8 :                         _mem_save_filter_0 = NDR_PULL_GET_MEM_CTX(ndr);
     658           8 :                         NDR_PULL_SET_MEM_CTX(ndr, r->in.filter, 0);
     659           8 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.filter));
     660           8 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.filter));
     661           8 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.filter, &size_filter_1));
     662           8 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.filter, &length_filter_1));
     663           8 :                         if (length_filter_1 > size_filter_1) {
     664           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %"PRIu32": should exceed array length %"PRIu32"", size_filter_1, length_filter_1);
     665             :                         }
     666           8 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_filter_1, sizeof(uint16_t)));
     667           8 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.filter, length_filter_1, sizeof(uint16_t), CH_UTF16));
     668           8 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_filter_0, 0);
     669             :                 }
     670          12 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
     671          12 :                         NDR_PULL_ALLOC(ndr, r->in.length);
     672             :                 }
     673          12 :                 _mem_save_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
     674          12 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.length, LIBNDR_FLAG_REF_ALLOC);
     675          12 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.length));
     676          12 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_length_0, LIBNDR_FLAG_REF_ALLOC);
     677          12 :                 NDR_CHECK(ndr_pull_PNP_GetIdListFlags(ndr, NDR_SCALARS, &r->in.flags));
     678          12 :                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, *r->in.length);
     679          12 :                 memset(r->out.buffer, 0, (*r->in.length) * sizeof(*r->out.buffer));
     680          12 :                 NDR_PULL_ALLOC(ndr, r->out.length);
     681          12 :                 *r->out.length = *r->in.length;
     682             :         }
     683          24 :         if (flags & NDR_OUT) {
     684             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     685             :                 if (r->in.length == NULL) {
     686             :                         NDR_PULL_ALLOC(ndr, r->in.length);
     687             :                         NDR_ZERO_STRUCTP(r->in.length);
     688             :                 }
     689             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     690          12 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
     691          12 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->out.buffer));
     692          12 :                 NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->out.buffer, &size_buffer_1));
     693          12 :                 NDR_CHECK(ndr_get_array_length(ndr, (void*)&r->out.buffer, &length_buffer_1));
     694          12 :                 if (length_buffer_1 > size_buffer_1) {
     695           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %"PRIu32": should exceed array length %"PRIu32"", size_buffer_1, length_buffer_1);
     696             :                 }
     697          12 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
     698           0 :                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, size_buffer_1);
     699             :                 }
     700          12 :                 _mem_save_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
     701          12 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
     702         116 :                 for (cntr_buffer_1 = 0; cntr_buffer_1 < (length_buffer_1); cntr_buffer_1++) {
     703         104 :                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->out.buffer[cntr_buffer_1]));
     704             :                 }
     705          12 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_1, 0);
     706          12 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
     707           0 :                         NDR_PULL_ALLOC(ndr, r->out.length);
     708             :                 }
     709          12 :                 _mem_save_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
     710          12 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.length, LIBNDR_FLAG_REF_ALLOC);
     711          12 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.length));
     712          12 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_length_0, LIBNDR_FLAG_REF_ALLOC);
     713          12 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
     714          12 :                 if (r->out.buffer) {
     715          12 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->out.buffer, *r->out.length));
     716             :                 }
     717          12 :                 if (r->out.buffer) {
     718          12 :                         NDR_CHECK(ndr_check_steal_array_length(ndr, (void*)&r->out.buffer, *r->out.length));
     719             :                 }
     720             :         }
     721          24 :         return NDR_ERR_SUCCESS;
     722             : }
     723             : 
     724           0 : _PUBLIC_ void ndr_print_PNP_GetDeviceList(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_GetDeviceList *r)
     725             : {
     726           0 :         uint32_t cntr_buffer_1;
     727           0 :         ndr_print_struct(ndr, name, "PNP_GetDeviceList");
     728           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     729           0 :         ndr->depth++;
     730           0 :         if (flags & NDR_SET_VALUES) {
     731           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     732             :         }
     733           0 :         if (flags & NDR_IN) {
     734           0 :                 ndr_print_struct(ndr, "in", "PNP_GetDeviceList");
     735           0 :                 ndr->depth++;
     736           0 :                 ndr_print_ptr(ndr, "filter", r->in.filter);
     737           0 :                 ndr->depth++;
     738           0 :                 if (r->in.filter) {
     739           0 :                         ndr_print_string(ndr, "filter", r->in.filter);
     740             :                 }
     741           0 :                 ndr->depth--;
     742           0 :                 ndr_print_ptr(ndr, "length", r->in.length);
     743           0 :                 ndr->depth++;
     744           0 :                 ndr_print_uint32(ndr, "length", *r->in.length);
     745           0 :                 ndr->depth--;
     746           0 :                 ndr_print_PNP_GetIdListFlags(ndr, "flags", r->in.flags);
     747           0 :                 ndr->depth--;
     748             :         }
     749           0 :         if (flags & NDR_OUT) {
     750           0 :                 ndr_print_struct(ndr, "out", "PNP_GetDeviceList");
     751           0 :                 ndr->depth++;
     752           0 :                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
     753           0 :                 ndr->depth++;
     754           0 :                 ndr->print(ndr, "%s: ARRAY(%"PRIu32")", "buffer", (uint32_t)(*r->out.length));
     755           0 :                 ndr->depth++;
     756           0 :                 for (cntr_buffer_1 = 0; cntr_buffer_1 < (*r->out.length); cntr_buffer_1++) {
     757           0 :                         ndr_print_uint16(ndr, "buffer", r->out.buffer[cntr_buffer_1]);
     758             :                 }
     759           0 :                 ndr->depth--;
     760           0 :                 ndr->depth--;
     761           0 :                 ndr_print_ptr(ndr, "length", r->out.length);
     762           0 :                 ndr->depth++;
     763           0 :                 ndr_print_uint32(ndr, "length", *r->out.length);
     764           0 :                 ndr->depth--;
     765           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
     766           0 :                 ndr->depth--;
     767             :         }
     768           0 :         ndr->depth--;
     769             : }
     770             : 
     771          24 : static enum ndr_err_code ndr_push_PNP_GetDeviceListSize(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_GetDeviceListSize *r)
     772             : {
     773          24 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     774          24 :         if (flags & NDR_IN) {
     775          12 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.devicename));
     776          12 :                 if (r->in.devicename) {
     777           8 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.devicename, CH_UTF16)));
     778           8 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     779           8 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.devicename, CH_UTF16)));
     780           8 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.devicename, ndr_charset_length(r->in.devicename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
     781             :                 }
     782          12 :                 NDR_CHECK(ndr_push_PNP_GetIdListFlags(ndr, NDR_SCALARS, r->in.flags));
     783             :         }
     784          24 :         if (flags & NDR_OUT) {
     785          12 :                 if (r->out.size == NULL) {
     786           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
     787             :                 }
     788          12 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.size));
     789          12 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
     790             :         }
     791          24 :         return NDR_ERR_SUCCESS;
     792             : }
     793             : 
     794          24 : static enum ndr_err_code ndr_pull_PNP_GetDeviceListSize(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_GetDeviceListSize *r)
     795             : {
     796           0 :         uint32_t _ptr_devicename;
     797          24 :         uint32_t size_devicename_1 = 0;
     798          24 :         uint32_t length_devicename_1 = 0;
     799          24 :         TALLOC_CTX *_mem_save_devicename_0 = NULL;
     800          24 :         TALLOC_CTX *_mem_save_size_0 = NULL;
     801          24 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     802          24 :         if (flags & NDR_IN) {
     803          12 :                 NDR_ZERO_STRUCT(r->out);
     804             : 
     805          12 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devicename));
     806          12 :                 if (_ptr_devicename) {
     807           8 :                         NDR_PULL_ALLOC(ndr, r->in.devicename);
     808             :                 } else {
     809           4 :                         r->in.devicename = NULL;
     810             :                 }
     811          12 :                 if (r->in.devicename) {
     812           8 :                         _mem_save_devicename_0 = NDR_PULL_GET_MEM_CTX(ndr);
     813           8 :                         NDR_PULL_SET_MEM_CTX(ndr, r->in.devicename, 0);
     814           8 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.devicename));
     815           8 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.devicename));
     816           8 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.devicename, &size_devicename_1));
     817           8 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.devicename, &length_devicename_1));
     818           8 :                         if (length_devicename_1 > size_devicename_1) {
     819           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %"PRIu32": should exceed array length %"PRIu32"", size_devicename_1, length_devicename_1);
     820             :                         }
     821           8 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_devicename_1, sizeof(uint16_t)));
     822           8 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.devicename, length_devicename_1, sizeof(uint16_t), CH_UTF16));
     823           8 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devicename_0, 0);
     824             :                 }
     825          12 :                 NDR_CHECK(ndr_pull_PNP_GetIdListFlags(ndr, NDR_SCALARS, &r->in.flags));
     826          12 :                 NDR_PULL_ALLOC(ndr, r->out.size);
     827          12 :                 NDR_ZERO_STRUCTP(r->out.size);
     828             :         }
     829          24 :         if (flags & NDR_OUT) {
     830             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     831             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     832          12 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
     833           0 :                         NDR_PULL_ALLOC(ndr, r->out.size);
     834             :                 }
     835          12 :                 _mem_save_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
     836          12 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.size, LIBNDR_FLAG_REF_ALLOC);
     837          12 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.size));
     838          12 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_size_0, LIBNDR_FLAG_REF_ALLOC);
     839          12 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
     840             :         }
     841          24 :         return NDR_ERR_SUCCESS;
     842             : }
     843             : 
     844           0 : _PUBLIC_ void ndr_print_PNP_GetDeviceListSize(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_GetDeviceListSize *r)
     845             : {
     846           0 :         ndr_print_struct(ndr, name, "PNP_GetDeviceListSize");
     847           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     848           0 :         ndr->depth++;
     849           0 :         if (flags & NDR_SET_VALUES) {
     850           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     851             :         }
     852           0 :         if (flags & NDR_IN) {
     853           0 :                 ndr_print_struct(ndr, "in", "PNP_GetDeviceListSize");
     854           0 :                 ndr->depth++;
     855           0 :                 ndr_print_ptr(ndr, "devicename", r->in.devicename);
     856           0 :                 ndr->depth++;
     857           0 :                 if (r->in.devicename) {
     858           0 :                         ndr_print_string(ndr, "devicename", r->in.devicename);
     859             :                 }
     860           0 :                 ndr->depth--;
     861           0 :                 ndr_print_PNP_GetIdListFlags(ndr, "flags", r->in.flags);
     862           0 :                 ndr->depth--;
     863             :         }
     864           0 :         if (flags & NDR_OUT) {
     865           0 :                 ndr_print_struct(ndr, "out", "PNP_GetDeviceListSize");
     866           0 :                 ndr->depth++;
     867           0 :                 ndr_print_ptr(ndr, "size", r->out.size);
     868           0 :                 ndr->depth++;
     869           0 :                 ndr_print_uint32(ndr, "size", *r->out.size);
     870           0 :                 ndr->depth--;
     871           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
     872           0 :                 ndr->depth--;
     873             :         }
     874           0 :         ndr->depth--;
     875             : }
     876             : 
     877           0 : static enum ndr_err_code ndr_push_PNP_GetDepth(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_GetDepth *r)
     878             : {
     879           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     880           0 :         if (flags & NDR_IN) {
     881           0 :         }
     882           0 :         if (flags & NDR_OUT) {
     883           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
     884             :         }
     885           0 :         return NDR_ERR_SUCCESS;
     886             : }
     887             : 
     888           0 : static enum ndr_err_code ndr_pull_PNP_GetDepth(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_GetDepth *r)
     889             : {
     890           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     891           0 :         if (flags & NDR_IN) {
     892           0 :         }
     893           0 :         if (flags & NDR_OUT) {
     894             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     895             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     896           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
     897             :         }
     898           0 :         return NDR_ERR_SUCCESS;
     899             : }
     900             : 
     901           0 : _PUBLIC_ void ndr_print_PNP_GetDepth(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_GetDepth *r)
     902             : {
     903           0 :         ndr_print_struct(ndr, name, "PNP_GetDepth");
     904           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     905           0 :         ndr->depth++;
     906           0 :         if (flags & NDR_SET_VALUES) {
     907           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     908             :         }
     909           0 :         if (flags & NDR_IN) {
     910           0 :                 ndr_print_struct(ndr, "in", "PNP_GetDepth");
     911           0 :                 ndr->depth++;
     912           0 :                 ndr->depth--;
     913             :         }
     914           0 :         if (flags & NDR_OUT) {
     915           0 :                 ndr_print_struct(ndr, "out", "PNP_GetDepth");
     916           0 :                 ndr->depth++;
     917           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
     918           0 :                 ndr->depth--;
     919             :         }
     920           0 :         ndr->depth--;
     921             : }
     922             : 
     923           8 : static enum ndr_err_code ndr_push_PNP_GetDeviceRegProp(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_GetDeviceRegProp *r)
     924             : {
     925           8 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     926           8 :         if (flags & NDR_IN) {
     927           4 :                 if (r->in.devicepath == NULL) {
     928           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
     929             :                 }
     930           4 :                 if (r->in.reg_data_type == NULL) {
     931           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
     932             :                 }
     933           4 :                 if (r->in.buffer_size == NULL) {
     934           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
     935             :                 }
     936           4 :                 if (r->in.needed == NULL) {
     937           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
     938             :                 }
     939           4 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.devicepath, CH_UTF16)));
     940           4 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     941           4 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.devicepath, CH_UTF16)));
     942           4 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.devicepath, ndr_charset_length(r->in.devicepath, CH_UTF16), sizeof(uint16_t), CH_UTF16));
     943           4 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.property));
     944           4 :                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->in.reg_data_type));
     945           4 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.buffer_size));
     946           4 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.needed));
     947           4 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
     948             :         }
     949           8 :         if (flags & NDR_OUT) {
     950           4 :                 if (r->out.reg_data_type == NULL) {
     951           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
     952             :                 }
     953           4 :                 if (r->out.buffer == NULL) {
     954           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
     955             :                 }
     956           4 :                 if (r->out.buffer_size == NULL) {
     957           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
     958             :                 }
     959           4 :                 if (r->out.needed == NULL) {
     960           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
     961             :                 }
     962           4 :                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.reg_data_type));
     963           4 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.buffer_size));
     964           4 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     965           4 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.buffer_size));
     966           4 :                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, *r->out.buffer_size));
     967           4 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.buffer_size));
     968           4 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
     969           4 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
     970             :         }
     971           8 :         return NDR_ERR_SUCCESS;
     972             : }
     973             : 
     974           8 : static enum ndr_err_code ndr_pull_PNP_GetDeviceRegProp(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_GetDeviceRegProp *r)
     975             : {
     976           8 :         uint32_t size_devicepath_1 = 0;
     977           8 :         uint32_t length_devicepath_1 = 0;
     978           8 :         uint32_t size_buffer_1 = 0;
     979           8 :         uint32_t length_buffer_1 = 0;
     980           8 :         TALLOC_CTX *_mem_save_reg_data_type_0 = NULL;
     981           8 :         TALLOC_CTX *_mem_save_buffer_size_0 = NULL;
     982           8 :         TALLOC_CTX *_mem_save_needed_0 = NULL;
     983           8 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     984           8 :         if (flags & NDR_IN) {
     985           4 :                 NDR_ZERO_STRUCT(r->out);
     986             : 
     987           4 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.devicepath));
     988           4 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.devicepath));
     989           4 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.devicepath, &size_devicepath_1));
     990           4 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.devicepath, &length_devicepath_1));
     991           4 :                 if (length_devicepath_1 > size_devicepath_1) {
     992           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %"PRIu32": should exceed array length %"PRIu32"", size_devicepath_1, length_devicepath_1);
     993             :                 }
     994           4 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_devicepath_1, sizeof(uint16_t)));
     995           4 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.devicepath, length_devicepath_1, sizeof(uint16_t), CH_UTF16));
     996           4 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.property));
     997           4 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
     998           4 :                         NDR_PULL_ALLOC(ndr, r->in.reg_data_type);
     999             :                 }
    1000           4 :                 _mem_save_reg_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1001           4 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.reg_data_type, LIBNDR_FLAG_REF_ALLOC);
    1002           4 :                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->in.reg_data_type));
    1003           4 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reg_data_type_0, LIBNDR_FLAG_REF_ALLOC);
    1004           4 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1005           4 :                         NDR_PULL_ALLOC(ndr, r->in.buffer_size);
    1006             :                 }
    1007           4 :                 _mem_save_buffer_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1008           4 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer_size, LIBNDR_FLAG_REF_ALLOC);
    1009           4 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.buffer_size));
    1010           4 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_size_0, LIBNDR_FLAG_REF_ALLOC);
    1011           4 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1012           4 :                         NDR_PULL_ALLOC(ndr, r->in.needed);
    1013             :                 }
    1014           4 :                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1015           4 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.needed, LIBNDR_FLAG_REF_ALLOC);
    1016           4 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.needed));
    1017           4 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
    1018           4 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
    1019           4 :                 NDR_PULL_ALLOC(ndr, r->out.reg_data_type);
    1020           4 :                 *r->out.reg_data_type = *r->in.reg_data_type;
    1021           4 :                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, *r->in.buffer_size);
    1022           4 :                 memset(r->out.buffer, 0, (*r->in.buffer_size) * sizeof(*r->out.buffer));
    1023           4 :                 NDR_PULL_ALLOC(ndr, r->out.buffer_size);
    1024           4 :                 *r->out.buffer_size = *r->in.buffer_size;
    1025           4 :                 NDR_PULL_ALLOC(ndr, r->out.needed);
    1026           4 :                 *r->out.needed = *r->in.needed;
    1027             :         }
    1028           8 :         if (flags & NDR_OUT) {
    1029             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1030             :                 if (r->in.reg_data_type == NULL) {
    1031             :                         NDR_PULL_ALLOC(ndr, r->in.reg_data_type);
    1032             :                         NDR_ZERO_STRUCTP(r->in.reg_data_type);
    1033             :                 }
    1034             :                 if (r->in.buffer_size == NULL) {
    1035             :                         NDR_PULL_ALLOC(ndr, r->in.buffer_size);
    1036             :                         NDR_ZERO_STRUCTP(r->in.buffer_size);
    1037             :                 }
    1038             :                 if (r->in.needed == NULL) {
    1039             :                         NDR_PULL_ALLOC(ndr, r->in.needed);
    1040             :                         NDR_ZERO_STRUCTP(r->in.needed);
    1041             :                 }
    1042             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1043           4 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1044           0 :                         NDR_PULL_ALLOC(ndr, r->out.reg_data_type);
    1045             :                 }
    1046           4 :                 _mem_save_reg_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1047           4 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reg_data_type, LIBNDR_FLAG_REF_ALLOC);
    1048           4 :                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.reg_data_type));
    1049           4 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reg_data_type_0, LIBNDR_FLAG_REF_ALLOC);
    1050           4 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
    1051           4 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->out.buffer));
    1052           4 :                 NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->out.buffer, &size_buffer_1));
    1053           4 :                 NDR_CHECK(ndr_get_array_length(ndr, (void*)&r->out.buffer, &length_buffer_1));
    1054           4 :                 if (length_buffer_1 > size_buffer_1) {
    1055           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %"PRIu32": should exceed array length %"PRIu32"", size_buffer_1, length_buffer_1);
    1056             :                 }
    1057           4 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1058           0 :                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, size_buffer_1);
    1059             :                 }
    1060           4 :                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, length_buffer_1));
    1061           4 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1062           0 :                         NDR_PULL_ALLOC(ndr, r->out.buffer_size);
    1063             :                 }
    1064           4 :                 _mem_save_buffer_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1065           4 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer_size, LIBNDR_FLAG_REF_ALLOC);
    1066           4 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.buffer_size));
    1067           4 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_size_0, LIBNDR_FLAG_REF_ALLOC);
    1068           4 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1069           0 :                         NDR_PULL_ALLOC(ndr, r->out.needed);
    1070             :                 }
    1071           4 :                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1072           4 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
    1073           4 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
    1074           4 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
    1075           4 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1076           4 :                 if (r->out.buffer) {
    1077           4 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->out.buffer, *r->out.buffer_size));
    1078             :                 }
    1079           4 :                 if (r->out.buffer) {
    1080           4 :                         NDR_CHECK(ndr_check_steal_array_length(ndr, (void*)&r->out.buffer, *r->out.buffer_size));
    1081             :                 }
    1082             :         }
    1083           8 :         return NDR_ERR_SUCCESS;
    1084             : }
    1085             : 
    1086           0 : _PUBLIC_ void ndr_print_PNP_GetDeviceRegProp(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_GetDeviceRegProp *r)
    1087             : {
    1088           0 :         ndr_print_struct(ndr, name, "PNP_GetDeviceRegProp");
    1089           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1090           0 :         ndr->depth++;
    1091           0 :         if (flags & NDR_SET_VALUES) {
    1092           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1093             :         }
    1094           0 :         if (flags & NDR_IN) {
    1095           0 :                 ndr_print_struct(ndr, "in", "PNP_GetDeviceRegProp");
    1096           0 :                 ndr->depth++;
    1097           0 :                 ndr_print_ptr(ndr, "devicepath", r->in.devicepath);
    1098           0 :                 ndr->depth++;
    1099           0 :                 ndr_print_string(ndr, "devicepath", r->in.devicepath);
    1100           0 :                 ndr->depth--;
    1101           0 :                 ndr_print_uint32(ndr, "property", r->in.property);
    1102           0 :                 ndr_print_ptr(ndr, "reg_data_type", r->in.reg_data_type);
    1103           0 :                 ndr->depth++;
    1104           0 :                 ndr_print_winreg_Type(ndr, "reg_data_type", *r->in.reg_data_type);
    1105           0 :                 ndr->depth--;
    1106           0 :                 ndr_print_ptr(ndr, "buffer_size", r->in.buffer_size);
    1107           0 :                 ndr->depth++;
    1108           0 :                 ndr_print_uint32(ndr, "buffer_size", *r->in.buffer_size);
    1109           0 :                 ndr->depth--;
    1110           0 :                 ndr_print_ptr(ndr, "needed", r->in.needed);
    1111           0 :                 ndr->depth++;
    1112           0 :                 ndr_print_uint32(ndr, "needed", *r->in.needed);
    1113           0 :                 ndr->depth--;
    1114           0 :                 ndr_print_uint32(ndr, "flags", r->in.flags);
    1115           0 :                 ndr->depth--;
    1116             :         }
    1117           0 :         if (flags & NDR_OUT) {
    1118           0 :                 ndr_print_struct(ndr, "out", "PNP_GetDeviceRegProp");
    1119           0 :                 ndr->depth++;
    1120           0 :                 ndr_print_ptr(ndr, "reg_data_type", r->out.reg_data_type);
    1121           0 :                 ndr->depth++;
    1122           0 :                 ndr_print_winreg_Type(ndr, "reg_data_type", *r->out.reg_data_type);
    1123           0 :                 ndr->depth--;
    1124           0 :                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
    1125           0 :                 ndr->depth++;
    1126           0 :                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, *r->out.buffer_size);
    1127           0 :                 ndr->depth--;
    1128           0 :                 ndr_print_ptr(ndr, "buffer_size", r->out.buffer_size);
    1129           0 :                 ndr->depth++;
    1130           0 :                 ndr_print_uint32(ndr, "buffer_size", *r->out.buffer_size);
    1131           0 :                 ndr->depth--;
    1132           0 :                 ndr_print_ptr(ndr, "needed", r->out.needed);
    1133           0 :                 ndr->depth++;
    1134           0 :                 ndr_print_uint32(ndr, "needed", *r->out.needed);
    1135           0 :                 ndr->depth--;
    1136           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1137           0 :                 ndr->depth--;
    1138             :         }
    1139           0 :         ndr->depth--;
    1140             : }
    1141             : 
    1142           0 : static enum ndr_err_code ndr_push_PNP_SetDeviceRegProp(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_SetDeviceRegProp *r)
    1143             : {
    1144           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1145           0 :         if (flags & NDR_IN) {
    1146           0 :         }
    1147           0 :         if (flags & NDR_OUT) {
    1148           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1149             :         }
    1150           0 :         return NDR_ERR_SUCCESS;
    1151             : }
    1152             : 
    1153           0 : static enum ndr_err_code ndr_pull_PNP_SetDeviceRegProp(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_SetDeviceRegProp *r)
    1154             : {
    1155           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1156           0 :         if (flags & NDR_IN) {
    1157           0 :         }
    1158           0 :         if (flags & NDR_OUT) {
    1159             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1160             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1161           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1162             :         }
    1163           0 :         return NDR_ERR_SUCCESS;
    1164             : }
    1165             : 
    1166           0 : _PUBLIC_ void ndr_print_PNP_SetDeviceRegProp(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_SetDeviceRegProp *r)
    1167             : {
    1168           0 :         ndr_print_struct(ndr, name, "PNP_SetDeviceRegProp");
    1169           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1170           0 :         ndr->depth++;
    1171           0 :         if (flags & NDR_SET_VALUES) {
    1172           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1173             :         }
    1174           0 :         if (flags & NDR_IN) {
    1175           0 :                 ndr_print_struct(ndr, "in", "PNP_SetDeviceRegProp");
    1176           0 :                 ndr->depth++;
    1177           0 :                 ndr->depth--;
    1178             :         }
    1179           0 :         if (flags & NDR_OUT) {
    1180           0 :                 ndr_print_struct(ndr, "out", "PNP_SetDeviceRegProp");
    1181           0 :                 ndr->depth++;
    1182           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1183           0 :                 ndr->depth--;
    1184             :         }
    1185           0 :         ndr->depth--;
    1186             : }
    1187             : 
    1188           0 : static enum ndr_err_code ndr_push_PNP_GetClassInstance(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_GetClassInstance *r)
    1189             : {
    1190           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1191           0 :         if (flags & NDR_IN) {
    1192           0 :         }
    1193           0 :         if (flags & NDR_OUT) {
    1194           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1195             :         }
    1196           0 :         return NDR_ERR_SUCCESS;
    1197             : }
    1198             : 
    1199           0 : static enum ndr_err_code ndr_pull_PNP_GetClassInstance(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_GetClassInstance *r)
    1200             : {
    1201           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1202           0 :         if (flags & NDR_IN) {
    1203           0 :         }
    1204           0 :         if (flags & NDR_OUT) {
    1205             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1206             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1207           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1208             :         }
    1209           0 :         return NDR_ERR_SUCCESS;
    1210             : }
    1211             : 
    1212           0 : _PUBLIC_ void ndr_print_PNP_GetClassInstance(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_GetClassInstance *r)
    1213             : {
    1214           0 :         ndr_print_struct(ndr, name, "PNP_GetClassInstance");
    1215           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1216           0 :         ndr->depth++;
    1217           0 :         if (flags & NDR_SET_VALUES) {
    1218           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1219             :         }
    1220           0 :         if (flags & NDR_IN) {
    1221           0 :                 ndr_print_struct(ndr, "in", "PNP_GetClassInstance");
    1222           0 :                 ndr->depth++;
    1223           0 :                 ndr->depth--;
    1224             :         }
    1225           0 :         if (flags & NDR_OUT) {
    1226           0 :                 ndr_print_struct(ndr, "out", "PNP_GetClassInstance");
    1227           0 :                 ndr->depth++;
    1228           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1229           0 :                 ndr->depth--;
    1230             :         }
    1231           0 :         ndr->depth--;
    1232             : }
    1233             : 
    1234           0 : static enum ndr_err_code ndr_push_PNP_CreateKey(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_CreateKey *r)
    1235             : {
    1236           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1237           0 :         if (flags & NDR_IN) {
    1238           0 :         }
    1239           0 :         if (flags & NDR_OUT) {
    1240           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1241             :         }
    1242           0 :         return NDR_ERR_SUCCESS;
    1243             : }
    1244             : 
    1245           0 : static enum ndr_err_code ndr_pull_PNP_CreateKey(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_CreateKey *r)
    1246             : {
    1247           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1248           0 :         if (flags & NDR_IN) {
    1249           0 :         }
    1250           0 :         if (flags & NDR_OUT) {
    1251             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1252             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1253           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1254             :         }
    1255           0 :         return NDR_ERR_SUCCESS;
    1256             : }
    1257             : 
    1258           0 : _PUBLIC_ void ndr_print_PNP_CreateKey(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_CreateKey *r)
    1259             : {
    1260           0 :         ndr_print_struct(ndr, name, "PNP_CreateKey");
    1261           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1262           0 :         ndr->depth++;
    1263           0 :         if (flags & NDR_SET_VALUES) {
    1264           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1265             :         }
    1266           0 :         if (flags & NDR_IN) {
    1267           0 :                 ndr_print_struct(ndr, "in", "PNP_CreateKey");
    1268           0 :                 ndr->depth++;
    1269           0 :                 ndr->depth--;
    1270             :         }
    1271           0 :         if (flags & NDR_OUT) {
    1272           0 :                 ndr_print_struct(ndr, "out", "PNP_CreateKey");
    1273           0 :                 ndr->depth++;
    1274           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1275           0 :                 ndr->depth--;
    1276             :         }
    1277           0 :         ndr->depth--;
    1278             : }
    1279             : 
    1280           0 : static enum ndr_err_code ndr_push_PNP_DeleteRegistryKey(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_DeleteRegistryKey *r)
    1281             : {
    1282           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1283           0 :         if (flags & NDR_IN) {
    1284           0 :         }
    1285           0 :         if (flags & NDR_OUT) {
    1286           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1287             :         }
    1288           0 :         return NDR_ERR_SUCCESS;
    1289             : }
    1290             : 
    1291           0 : static enum ndr_err_code ndr_pull_PNP_DeleteRegistryKey(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_DeleteRegistryKey *r)
    1292             : {
    1293           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1294           0 :         if (flags & NDR_IN) {
    1295           0 :         }
    1296           0 :         if (flags & NDR_OUT) {
    1297             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1298             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1299           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1300             :         }
    1301           0 :         return NDR_ERR_SUCCESS;
    1302             : }
    1303             : 
    1304           0 : _PUBLIC_ void ndr_print_PNP_DeleteRegistryKey(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_DeleteRegistryKey *r)
    1305             : {
    1306           0 :         ndr_print_struct(ndr, name, "PNP_DeleteRegistryKey");
    1307           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1308           0 :         ndr->depth++;
    1309           0 :         if (flags & NDR_SET_VALUES) {
    1310           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1311             :         }
    1312           0 :         if (flags & NDR_IN) {
    1313           0 :                 ndr_print_struct(ndr, "in", "PNP_DeleteRegistryKey");
    1314           0 :                 ndr->depth++;
    1315           0 :                 ndr->depth--;
    1316             :         }
    1317           0 :         if (flags & NDR_OUT) {
    1318           0 :                 ndr_print_struct(ndr, "out", "PNP_DeleteRegistryKey");
    1319           0 :                 ndr->depth++;
    1320           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1321           0 :                 ndr->depth--;
    1322             :         }
    1323           0 :         ndr->depth--;
    1324             : }
    1325             : 
    1326           0 : static enum ndr_err_code ndr_push_PNP_GetClassCount(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_GetClassCount *r)
    1327             : {
    1328           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1329           0 :         if (flags & NDR_IN) {
    1330           0 :         }
    1331           0 :         if (flags & NDR_OUT) {
    1332           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1333             :         }
    1334           0 :         return NDR_ERR_SUCCESS;
    1335             : }
    1336             : 
    1337           0 : static enum ndr_err_code ndr_pull_PNP_GetClassCount(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_GetClassCount *r)
    1338             : {
    1339           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1340           0 :         if (flags & NDR_IN) {
    1341           0 :         }
    1342           0 :         if (flags & NDR_OUT) {
    1343             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1344             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1345           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1346             :         }
    1347           0 :         return NDR_ERR_SUCCESS;
    1348             : }
    1349             : 
    1350           0 : _PUBLIC_ void ndr_print_PNP_GetClassCount(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_GetClassCount *r)
    1351             : {
    1352           0 :         ndr_print_struct(ndr, name, "PNP_GetClassCount");
    1353           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1354           0 :         ndr->depth++;
    1355           0 :         if (flags & NDR_SET_VALUES) {
    1356           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1357             :         }
    1358           0 :         if (flags & NDR_IN) {
    1359           0 :                 ndr_print_struct(ndr, "in", "PNP_GetClassCount");
    1360           0 :                 ndr->depth++;
    1361           0 :                 ndr->depth--;
    1362             :         }
    1363           0 :         if (flags & NDR_OUT) {
    1364           0 :                 ndr_print_struct(ndr, "out", "PNP_GetClassCount");
    1365           0 :                 ndr->depth++;
    1366           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1367           0 :                 ndr->depth--;
    1368             :         }
    1369           0 :         ndr->depth--;
    1370             : }
    1371             : 
    1372           0 : static enum ndr_err_code ndr_push_PNP_GetClassName(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_GetClassName *r)
    1373             : {
    1374           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1375           0 :         if (flags & NDR_IN) {
    1376           0 :         }
    1377           0 :         if (flags & NDR_OUT) {
    1378           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1379             :         }
    1380           0 :         return NDR_ERR_SUCCESS;
    1381             : }
    1382             : 
    1383           0 : static enum ndr_err_code ndr_pull_PNP_GetClassName(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_GetClassName *r)
    1384             : {
    1385           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1386           0 :         if (flags & NDR_IN) {
    1387           0 :         }
    1388           0 :         if (flags & NDR_OUT) {
    1389             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1390             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1391           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1392             :         }
    1393           0 :         return NDR_ERR_SUCCESS;
    1394             : }
    1395             : 
    1396           0 : _PUBLIC_ void ndr_print_PNP_GetClassName(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_GetClassName *r)
    1397             : {
    1398           0 :         ndr_print_struct(ndr, name, "PNP_GetClassName");
    1399           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1400           0 :         ndr->depth++;
    1401           0 :         if (flags & NDR_SET_VALUES) {
    1402           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1403             :         }
    1404           0 :         if (flags & NDR_IN) {
    1405           0 :                 ndr_print_struct(ndr, "in", "PNP_GetClassName");
    1406           0 :                 ndr->depth++;
    1407           0 :                 ndr->depth--;
    1408             :         }
    1409           0 :         if (flags & NDR_OUT) {
    1410           0 :                 ndr_print_struct(ndr, "out", "PNP_GetClassName");
    1411           0 :                 ndr->depth++;
    1412           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1413           0 :                 ndr->depth--;
    1414             :         }
    1415           0 :         ndr->depth--;
    1416             : }
    1417             : 
    1418           0 : static enum ndr_err_code ndr_push_PNP_DeleteClassKey(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_DeleteClassKey *r)
    1419             : {
    1420           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1421           0 :         if (flags & NDR_IN) {
    1422           0 :         }
    1423           0 :         if (flags & NDR_OUT) {
    1424           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1425             :         }
    1426           0 :         return NDR_ERR_SUCCESS;
    1427             : }
    1428             : 
    1429           0 : static enum ndr_err_code ndr_pull_PNP_DeleteClassKey(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_DeleteClassKey *r)
    1430             : {
    1431           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1432           0 :         if (flags & NDR_IN) {
    1433           0 :         }
    1434           0 :         if (flags & NDR_OUT) {
    1435             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1436             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1437           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1438             :         }
    1439           0 :         return NDR_ERR_SUCCESS;
    1440             : }
    1441             : 
    1442           0 : _PUBLIC_ void ndr_print_PNP_DeleteClassKey(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_DeleteClassKey *r)
    1443             : {
    1444           0 :         ndr_print_struct(ndr, name, "PNP_DeleteClassKey");
    1445           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1446           0 :         ndr->depth++;
    1447           0 :         if (flags & NDR_SET_VALUES) {
    1448           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1449             :         }
    1450           0 :         if (flags & NDR_IN) {
    1451           0 :                 ndr_print_struct(ndr, "in", "PNP_DeleteClassKey");
    1452           0 :                 ndr->depth++;
    1453           0 :                 ndr->depth--;
    1454             :         }
    1455           0 :         if (flags & NDR_OUT) {
    1456           0 :                 ndr_print_struct(ndr, "out", "PNP_DeleteClassKey");
    1457           0 :                 ndr->depth++;
    1458           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1459           0 :                 ndr->depth--;
    1460             :         }
    1461           0 :         ndr->depth--;
    1462             : }
    1463             : 
    1464           0 : static enum ndr_err_code ndr_push_PNP_GetInterfaceDeviceAlias(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_GetInterfaceDeviceAlias *r)
    1465             : {
    1466           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1467           0 :         if (flags & NDR_IN) {
    1468           0 :         }
    1469           0 :         if (flags & NDR_OUT) {
    1470           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1471             :         }
    1472           0 :         return NDR_ERR_SUCCESS;
    1473             : }
    1474             : 
    1475           0 : static enum ndr_err_code ndr_pull_PNP_GetInterfaceDeviceAlias(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_GetInterfaceDeviceAlias *r)
    1476             : {
    1477           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1478           0 :         if (flags & NDR_IN) {
    1479           0 :         }
    1480           0 :         if (flags & NDR_OUT) {
    1481             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1482             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1483           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1484             :         }
    1485           0 :         return NDR_ERR_SUCCESS;
    1486             : }
    1487             : 
    1488           0 : _PUBLIC_ void ndr_print_PNP_GetInterfaceDeviceAlias(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_GetInterfaceDeviceAlias *r)
    1489             : {
    1490           0 :         ndr_print_struct(ndr, name, "PNP_GetInterfaceDeviceAlias");
    1491           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1492           0 :         ndr->depth++;
    1493           0 :         if (flags & NDR_SET_VALUES) {
    1494           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1495             :         }
    1496           0 :         if (flags & NDR_IN) {
    1497           0 :                 ndr_print_struct(ndr, "in", "PNP_GetInterfaceDeviceAlias");
    1498           0 :                 ndr->depth++;
    1499           0 :                 ndr->depth--;
    1500             :         }
    1501           0 :         if (flags & NDR_OUT) {
    1502           0 :                 ndr_print_struct(ndr, "out", "PNP_GetInterfaceDeviceAlias");
    1503           0 :                 ndr->depth++;
    1504           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1505           0 :                 ndr->depth--;
    1506             :         }
    1507           0 :         ndr->depth--;
    1508             : }
    1509             : 
    1510           0 : static enum ndr_err_code ndr_push_PNP_GetInterfaceDeviceList(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_GetInterfaceDeviceList *r)
    1511             : {
    1512           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1513           0 :         if (flags & NDR_IN) {
    1514           0 :         }
    1515           0 :         if (flags & NDR_OUT) {
    1516           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1517             :         }
    1518           0 :         return NDR_ERR_SUCCESS;
    1519             : }
    1520             : 
    1521           0 : static enum ndr_err_code ndr_pull_PNP_GetInterfaceDeviceList(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_GetInterfaceDeviceList *r)
    1522             : {
    1523           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1524           0 :         if (flags & NDR_IN) {
    1525           0 :         }
    1526           0 :         if (flags & NDR_OUT) {
    1527             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1528             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1529           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1530             :         }
    1531           0 :         return NDR_ERR_SUCCESS;
    1532             : }
    1533             : 
    1534           0 : _PUBLIC_ void ndr_print_PNP_GetInterfaceDeviceList(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_GetInterfaceDeviceList *r)
    1535             : {
    1536           0 :         ndr_print_struct(ndr, name, "PNP_GetInterfaceDeviceList");
    1537           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1538           0 :         ndr->depth++;
    1539           0 :         if (flags & NDR_SET_VALUES) {
    1540           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1541             :         }
    1542           0 :         if (flags & NDR_IN) {
    1543           0 :                 ndr_print_struct(ndr, "in", "PNP_GetInterfaceDeviceList");
    1544           0 :                 ndr->depth++;
    1545           0 :                 ndr->depth--;
    1546             :         }
    1547           0 :         if (flags & NDR_OUT) {
    1548           0 :                 ndr_print_struct(ndr, "out", "PNP_GetInterfaceDeviceList");
    1549           0 :                 ndr->depth++;
    1550           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1551           0 :                 ndr->depth--;
    1552             :         }
    1553           0 :         ndr->depth--;
    1554             : }
    1555             : 
    1556           0 : static enum ndr_err_code ndr_push_PNP_GetInterfaceDeviceListSize(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_GetInterfaceDeviceListSize *r)
    1557             : {
    1558           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1559           0 :         if (flags & NDR_IN) {
    1560           0 :         }
    1561           0 :         if (flags & NDR_OUT) {
    1562           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1563             :         }
    1564           0 :         return NDR_ERR_SUCCESS;
    1565             : }
    1566             : 
    1567           0 : static enum ndr_err_code ndr_pull_PNP_GetInterfaceDeviceListSize(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_GetInterfaceDeviceListSize *r)
    1568             : {
    1569           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1570           0 :         if (flags & NDR_IN) {
    1571           0 :         }
    1572           0 :         if (flags & NDR_OUT) {
    1573             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1574             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1575           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1576             :         }
    1577           0 :         return NDR_ERR_SUCCESS;
    1578             : }
    1579             : 
    1580           0 : _PUBLIC_ void ndr_print_PNP_GetInterfaceDeviceListSize(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_GetInterfaceDeviceListSize *r)
    1581             : {
    1582           0 :         ndr_print_struct(ndr, name, "PNP_GetInterfaceDeviceListSize");
    1583           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1584           0 :         ndr->depth++;
    1585           0 :         if (flags & NDR_SET_VALUES) {
    1586           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1587             :         }
    1588           0 :         if (flags & NDR_IN) {
    1589           0 :                 ndr_print_struct(ndr, "in", "PNP_GetInterfaceDeviceListSize");
    1590           0 :                 ndr->depth++;
    1591           0 :                 ndr->depth--;
    1592             :         }
    1593           0 :         if (flags & NDR_OUT) {
    1594           0 :                 ndr_print_struct(ndr, "out", "PNP_GetInterfaceDeviceListSize");
    1595           0 :                 ndr->depth++;
    1596           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1597           0 :                 ndr->depth--;
    1598             :         }
    1599           0 :         ndr->depth--;
    1600             : }
    1601             : 
    1602           0 : static enum ndr_err_code ndr_push_PNP_RegisterDeviceClassAssociation(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_RegisterDeviceClassAssociation *r)
    1603             : {
    1604           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1605           0 :         if (flags & NDR_IN) {
    1606           0 :         }
    1607           0 :         if (flags & NDR_OUT) {
    1608           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1609             :         }
    1610           0 :         return NDR_ERR_SUCCESS;
    1611             : }
    1612             : 
    1613           0 : static enum ndr_err_code ndr_pull_PNP_RegisterDeviceClassAssociation(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_RegisterDeviceClassAssociation *r)
    1614             : {
    1615           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1616           0 :         if (flags & NDR_IN) {
    1617           0 :         }
    1618           0 :         if (flags & NDR_OUT) {
    1619             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1620             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1621           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1622             :         }
    1623           0 :         return NDR_ERR_SUCCESS;
    1624             : }
    1625             : 
    1626           0 : _PUBLIC_ void ndr_print_PNP_RegisterDeviceClassAssociation(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_RegisterDeviceClassAssociation *r)
    1627             : {
    1628           0 :         ndr_print_struct(ndr, name, "PNP_RegisterDeviceClassAssociation");
    1629           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1630           0 :         ndr->depth++;
    1631           0 :         if (flags & NDR_SET_VALUES) {
    1632           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1633             :         }
    1634           0 :         if (flags & NDR_IN) {
    1635           0 :                 ndr_print_struct(ndr, "in", "PNP_RegisterDeviceClassAssociation");
    1636           0 :                 ndr->depth++;
    1637           0 :                 ndr->depth--;
    1638             :         }
    1639           0 :         if (flags & NDR_OUT) {
    1640           0 :                 ndr_print_struct(ndr, "out", "PNP_RegisterDeviceClassAssociation");
    1641           0 :                 ndr->depth++;
    1642           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1643           0 :                 ndr->depth--;
    1644             :         }
    1645           0 :         ndr->depth--;
    1646             : }
    1647             : 
    1648           0 : static enum ndr_err_code ndr_push_PNP_UnregisterDeviceClassAssociation(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_UnregisterDeviceClassAssociation *r)
    1649             : {
    1650           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1651           0 :         if (flags & NDR_IN) {
    1652           0 :         }
    1653           0 :         if (flags & NDR_OUT) {
    1654           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1655             :         }
    1656           0 :         return NDR_ERR_SUCCESS;
    1657             : }
    1658             : 
    1659           0 : static enum ndr_err_code ndr_pull_PNP_UnregisterDeviceClassAssociation(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_UnregisterDeviceClassAssociation *r)
    1660             : {
    1661           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1662           0 :         if (flags & NDR_IN) {
    1663           0 :         }
    1664           0 :         if (flags & NDR_OUT) {
    1665             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1666             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1667           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1668             :         }
    1669           0 :         return NDR_ERR_SUCCESS;
    1670             : }
    1671             : 
    1672           0 : _PUBLIC_ void ndr_print_PNP_UnregisterDeviceClassAssociation(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_UnregisterDeviceClassAssociation *r)
    1673             : {
    1674           0 :         ndr_print_struct(ndr, name, "PNP_UnregisterDeviceClassAssociation");
    1675           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1676           0 :         ndr->depth++;
    1677           0 :         if (flags & NDR_SET_VALUES) {
    1678           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1679             :         }
    1680           0 :         if (flags & NDR_IN) {
    1681           0 :                 ndr_print_struct(ndr, "in", "PNP_UnregisterDeviceClassAssociation");
    1682           0 :                 ndr->depth++;
    1683           0 :                 ndr->depth--;
    1684             :         }
    1685           0 :         if (flags & NDR_OUT) {
    1686           0 :                 ndr_print_struct(ndr, "out", "PNP_UnregisterDeviceClassAssociation");
    1687           0 :                 ndr->depth++;
    1688           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1689           0 :                 ndr->depth--;
    1690             :         }
    1691           0 :         ndr->depth--;
    1692             : }
    1693             : 
    1694           0 : static enum ndr_err_code ndr_push_PNP_GetClassRegProp(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_GetClassRegProp *r)
    1695             : {
    1696           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1697           0 :         if (flags & NDR_IN) {
    1698           0 :         }
    1699           0 :         if (flags & NDR_OUT) {
    1700           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1701             :         }
    1702           0 :         return NDR_ERR_SUCCESS;
    1703             : }
    1704             : 
    1705           0 : static enum ndr_err_code ndr_pull_PNP_GetClassRegProp(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_GetClassRegProp *r)
    1706             : {
    1707           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1708           0 :         if (flags & NDR_IN) {
    1709           0 :         }
    1710           0 :         if (flags & NDR_OUT) {
    1711             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1712             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1713           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1714             :         }
    1715           0 :         return NDR_ERR_SUCCESS;
    1716             : }
    1717             : 
    1718           0 : _PUBLIC_ void ndr_print_PNP_GetClassRegProp(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_GetClassRegProp *r)
    1719             : {
    1720           0 :         ndr_print_struct(ndr, name, "PNP_GetClassRegProp");
    1721           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1722           0 :         ndr->depth++;
    1723           0 :         if (flags & NDR_SET_VALUES) {
    1724           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1725             :         }
    1726           0 :         if (flags & NDR_IN) {
    1727           0 :                 ndr_print_struct(ndr, "in", "PNP_GetClassRegProp");
    1728           0 :                 ndr->depth++;
    1729           0 :                 ndr->depth--;
    1730             :         }
    1731           0 :         if (flags & NDR_OUT) {
    1732           0 :                 ndr_print_struct(ndr, "out", "PNP_GetClassRegProp");
    1733           0 :                 ndr->depth++;
    1734           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1735           0 :                 ndr->depth--;
    1736             :         }
    1737           0 :         ndr->depth--;
    1738             : }
    1739             : 
    1740           0 : static enum ndr_err_code ndr_push_PNP_SetClassRegProp(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_SetClassRegProp *r)
    1741             : {
    1742           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1743           0 :         if (flags & NDR_IN) {
    1744           0 :         }
    1745           0 :         if (flags & NDR_OUT) {
    1746           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1747             :         }
    1748           0 :         return NDR_ERR_SUCCESS;
    1749             : }
    1750             : 
    1751           0 : static enum ndr_err_code ndr_pull_PNP_SetClassRegProp(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_SetClassRegProp *r)
    1752             : {
    1753           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1754           0 :         if (flags & NDR_IN) {
    1755           0 :         }
    1756           0 :         if (flags & NDR_OUT) {
    1757             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1758             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1759           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1760             :         }
    1761           0 :         return NDR_ERR_SUCCESS;
    1762             : }
    1763             : 
    1764           0 : _PUBLIC_ void ndr_print_PNP_SetClassRegProp(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_SetClassRegProp *r)
    1765             : {
    1766           0 :         ndr_print_struct(ndr, name, "PNP_SetClassRegProp");
    1767           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1768           0 :         ndr->depth++;
    1769           0 :         if (flags & NDR_SET_VALUES) {
    1770           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1771             :         }
    1772           0 :         if (flags & NDR_IN) {
    1773           0 :                 ndr_print_struct(ndr, "in", "PNP_SetClassRegProp");
    1774           0 :                 ndr->depth++;
    1775           0 :                 ndr->depth--;
    1776             :         }
    1777           0 :         if (flags & NDR_OUT) {
    1778           0 :                 ndr_print_struct(ndr, "out", "PNP_SetClassRegProp");
    1779           0 :                 ndr->depth++;
    1780           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1781           0 :                 ndr->depth--;
    1782             :         }
    1783           0 :         ndr->depth--;
    1784             : }
    1785             : 
    1786           0 : static enum ndr_err_code ndr_push_PNP_CreateDevInst(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_CreateDevInst *r)
    1787             : {
    1788           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1789           0 :         if (flags & NDR_IN) {
    1790           0 :         }
    1791           0 :         if (flags & NDR_OUT) {
    1792           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1793             :         }
    1794           0 :         return NDR_ERR_SUCCESS;
    1795             : }
    1796             : 
    1797           0 : static enum ndr_err_code ndr_pull_PNP_CreateDevInst(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_CreateDevInst *r)
    1798             : {
    1799           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1800           0 :         if (flags & NDR_IN) {
    1801           0 :         }
    1802           0 :         if (flags & NDR_OUT) {
    1803             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1804             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1805           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1806             :         }
    1807           0 :         return NDR_ERR_SUCCESS;
    1808             : }
    1809             : 
    1810           0 : _PUBLIC_ void ndr_print_PNP_CreateDevInst(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_CreateDevInst *r)
    1811             : {
    1812           0 :         ndr_print_struct(ndr, name, "PNP_CreateDevInst");
    1813           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1814           0 :         ndr->depth++;
    1815           0 :         if (flags & NDR_SET_VALUES) {
    1816           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1817             :         }
    1818           0 :         if (flags & NDR_IN) {
    1819           0 :                 ndr_print_struct(ndr, "in", "PNP_CreateDevInst");
    1820           0 :                 ndr->depth++;
    1821           0 :                 ndr->depth--;
    1822             :         }
    1823           0 :         if (flags & NDR_OUT) {
    1824           0 :                 ndr_print_struct(ndr, "out", "PNP_CreateDevInst");
    1825           0 :                 ndr->depth++;
    1826           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1827           0 :                 ndr->depth--;
    1828             :         }
    1829           0 :         ndr->depth--;
    1830             : }
    1831             : 
    1832           0 : static enum ndr_err_code ndr_push_PNP_DeviceInstanceAction(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_DeviceInstanceAction *r)
    1833             : {
    1834           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1835           0 :         if (flags & NDR_IN) {
    1836           0 :         }
    1837           0 :         if (flags & NDR_OUT) {
    1838           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1839             :         }
    1840           0 :         return NDR_ERR_SUCCESS;
    1841             : }
    1842             : 
    1843           0 : static enum ndr_err_code ndr_pull_PNP_DeviceInstanceAction(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_DeviceInstanceAction *r)
    1844             : {
    1845           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1846           0 :         if (flags & NDR_IN) {
    1847           0 :         }
    1848           0 :         if (flags & NDR_OUT) {
    1849             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1850             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1851           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1852             :         }
    1853           0 :         return NDR_ERR_SUCCESS;
    1854             : }
    1855             : 
    1856           0 : _PUBLIC_ void ndr_print_PNP_DeviceInstanceAction(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_DeviceInstanceAction *r)
    1857             : {
    1858           0 :         ndr_print_struct(ndr, name, "PNP_DeviceInstanceAction");
    1859           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1860           0 :         ndr->depth++;
    1861           0 :         if (flags & NDR_SET_VALUES) {
    1862           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1863             :         }
    1864           0 :         if (flags & NDR_IN) {
    1865           0 :                 ndr_print_struct(ndr, "in", "PNP_DeviceInstanceAction");
    1866           0 :                 ndr->depth++;
    1867           0 :                 ndr->depth--;
    1868             :         }
    1869           0 :         if (flags & NDR_OUT) {
    1870           0 :                 ndr_print_struct(ndr, "out", "PNP_DeviceInstanceAction");
    1871           0 :                 ndr->depth++;
    1872           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1873           0 :                 ndr->depth--;
    1874             :         }
    1875           0 :         ndr->depth--;
    1876             : }
    1877             : 
    1878           0 : static enum ndr_err_code ndr_push_PNP_GetDeviceStatus(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_GetDeviceStatus *r)
    1879             : {
    1880           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1881           0 :         if (flags & NDR_IN) {
    1882           0 :         }
    1883           0 :         if (flags & NDR_OUT) {
    1884           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1885             :         }
    1886           0 :         return NDR_ERR_SUCCESS;
    1887             : }
    1888             : 
    1889           0 : static enum ndr_err_code ndr_pull_PNP_GetDeviceStatus(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_GetDeviceStatus *r)
    1890             : {
    1891           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1892           0 :         if (flags & NDR_IN) {
    1893           0 :         }
    1894           0 :         if (flags & NDR_OUT) {
    1895             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1896             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1897           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1898             :         }
    1899           0 :         return NDR_ERR_SUCCESS;
    1900             : }
    1901             : 
    1902           0 : _PUBLIC_ void ndr_print_PNP_GetDeviceStatus(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_GetDeviceStatus *r)
    1903             : {
    1904           0 :         ndr_print_struct(ndr, name, "PNP_GetDeviceStatus");
    1905           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1906           0 :         ndr->depth++;
    1907           0 :         if (flags & NDR_SET_VALUES) {
    1908           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1909             :         }
    1910           0 :         if (flags & NDR_IN) {
    1911           0 :                 ndr_print_struct(ndr, "in", "PNP_GetDeviceStatus");
    1912           0 :                 ndr->depth++;
    1913           0 :                 ndr->depth--;
    1914             :         }
    1915           0 :         if (flags & NDR_OUT) {
    1916           0 :                 ndr_print_struct(ndr, "out", "PNP_GetDeviceStatus");
    1917           0 :                 ndr->depth++;
    1918           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1919           0 :                 ndr->depth--;
    1920             :         }
    1921           0 :         ndr->depth--;
    1922             : }
    1923             : 
    1924           0 : static enum ndr_err_code ndr_push_PNP_SetDeviceProblem(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_SetDeviceProblem *r)
    1925             : {
    1926           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1927           0 :         if (flags & NDR_IN) {
    1928           0 :         }
    1929           0 :         if (flags & NDR_OUT) {
    1930           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1931             :         }
    1932           0 :         return NDR_ERR_SUCCESS;
    1933             : }
    1934             : 
    1935           0 : static enum ndr_err_code ndr_pull_PNP_SetDeviceProblem(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_SetDeviceProblem *r)
    1936             : {
    1937           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1938           0 :         if (flags & NDR_IN) {
    1939           0 :         }
    1940           0 :         if (flags & NDR_OUT) {
    1941             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1942             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1943           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1944             :         }
    1945           0 :         return NDR_ERR_SUCCESS;
    1946             : }
    1947             : 
    1948           0 : _PUBLIC_ void ndr_print_PNP_SetDeviceProblem(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_SetDeviceProblem *r)
    1949             : {
    1950           0 :         ndr_print_struct(ndr, name, "PNP_SetDeviceProblem");
    1951           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1952           0 :         ndr->depth++;
    1953           0 :         if (flags & NDR_SET_VALUES) {
    1954           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1955             :         }
    1956           0 :         if (flags & NDR_IN) {
    1957           0 :                 ndr_print_struct(ndr, "in", "PNP_SetDeviceProblem");
    1958           0 :                 ndr->depth++;
    1959           0 :                 ndr->depth--;
    1960             :         }
    1961           0 :         if (flags & NDR_OUT) {
    1962           0 :                 ndr_print_struct(ndr, "out", "PNP_SetDeviceProblem");
    1963           0 :                 ndr->depth++;
    1964           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1965           0 :                 ndr->depth--;
    1966             :         }
    1967           0 :         ndr->depth--;
    1968             : }
    1969             : 
    1970           0 : static enum ndr_err_code ndr_push_PNP_DisableDevInst(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_DisableDevInst *r)
    1971             : {
    1972           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1973           0 :         if (flags & NDR_IN) {
    1974           0 :         }
    1975           0 :         if (flags & NDR_OUT) {
    1976           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1977             :         }
    1978           0 :         return NDR_ERR_SUCCESS;
    1979             : }
    1980             : 
    1981           0 : static enum ndr_err_code ndr_pull_PNP_DisableDevInst(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_DisableDevInst *r)
    1982             : {
    1983           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1984           0 :         if (flags & NDR_IN) {
    1985           0 :         }
    1986           0 :         if (flags & NDR_OUT) {
    1987             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1988             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1989           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1990             :         }
    1991           0 :         return NDR_ERR_SUCCESS;
    1992             : }
    1993             : 
    1994           0 : _PUBLIC_ void ndr_print_PNP_DisableDevInst(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_DisableDevInst *r)
    1995             : {
    1996           0 :         ndr_print_struct(ndr, name, "PNP_DisableDevInst");
    1997           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1998           0 :         ndr->depth++;
    1999           0 :         if (flags & NDR_SET_VALUES) {
    2000           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2001             :         }
    2002           0 :         if (flags & NDR_IN) {
    2003           0 :                 ndr_print_struct(ndr, "in", "PNP_DisableDevInst");
    2004           0 :                 ndr->depth++;
    2005           0 :                 ndr->depth--;
    2006             :         }
    2007           0 :         if (flags & NDR_OUT) {
    2008           0 :                 ndr_print_struct(ndr, "out", "PNP_DisableDevInst");
    2009           0 :                 ndr->depth++;
    2010           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    2011           0 :                 ndr->depth--;
    2012             :         }
    2013           0 :         ndr->depth--;
    2014             : }
    2015             : 
    2016           0 : static enum ndr_err_code ndr_push_PNP_UninstallDevInst(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_UninstallDevInst *r)
    2017             : {
    2018           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2019           0 :         if (flags & NDR_IN) {
    2020           0 :         }
    2021           0 :         if (flags & NDR_OUT) {
    2022           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    2023             :         }
    2024           0 :         return NDR_ERR_SUCCESS;
    2025             : }
    2026             : 
    2027           0 : static enum ndr_err_code ndr_pull_PNP_UninstallDevInst(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_UninstallDevInst *r)
    2028             : {
    2029           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2030           0 :         if (flags & NDR_IN) {
    2031           0 :         }
    2032           0 :         if (flags & NDR_OUT) {
    2033             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2034             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2035           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    2036             :         }
    2037           0 :         return NDR_ERR_SUCCESS;
    2038             : }
    2039             : 
    2040           0 : _PUBLIC_ void ndr_print_PNP_UninstallDevInst(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_UninstallDevInst *r)
    2041             : {
    2042           0 :         ndr_print_struct(ndr, name, "PNP_UninstallDevInst");
    2043           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2044           0 :         ndr->depth++;
    2045           0 :         if (flags & NDR_SET_VALUES) {
    2046           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2047             :         }
    2048           0 :         if (flags & NDR_IN) {
    2049           0 :                 ndr_print_struct(ndr, "in", "PNP_UninstallDevInst");
    2050           0 :                 ndr->depth++;
    2051           0 :                 ndr->depth--;
    2052             :         }
    2053           0 :         if (flags & NDR_OUT) {
    2054           0 :                 ndr_print_struct(ndr, "out", "PNP_UninstallDevInst");
    2055           0 :                 ndr->depth++;
    2056           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    2057           0 :                 ndr->depth--;
    2058             :         }
    2059           0 :         ndr->depth--;
    2060             : }
    2061             : 
    2062           0 : static enum ndr_err_code ndr_push_PNP_AddID(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_AddID *r)
    2063             : {
    2064           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2065           0 :         if (flags & NDR_IN) {
    2066           0 :         }
    2067           0 :         if (flags & NDR_OUT) {
    2068           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    2069             :         }
    2070           0 :         return NDR_ERR_SUCCESS;
    2071             : }
    2072             : 
    2073           0 : static enum ndr_err_code ndr_pull_PNP_AddID(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_AddID *r)
    2074             : {
    2075           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2076           0 :         if (flags & NDR_IN) {
    2077           0 :         }
    2078           0 :         if (flags & NDR_OUT) {
    2079             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2080             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2081           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    2082             :         }
    2083           0 :         return NDR_ERR_SUCCESS;
    2084             : }
    2085             : 
    2086           0 : _PUBLIC_ void ndr_print_PNP_AddID(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_AddID *r)
    2087             : {
    2088           0 :         ndr_print_struct(ndr, name, "PNP_AddID");
    2089           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2090           0 :         ndr->depth++;
    2091           0 :         if (flags & NDR_SET_VALUES) {
    2092           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2093             :         }
    2094           0 :         if (flags & NDR_IN) {
    2095           0 :                 ndr_print_struct(ndr, "in", "PNP_AddID");
    2096           0 :                 ndr->depth++;
    2097           0 :                 ndr->depth--;
    2098             :         }
    2099           0 :         if (flags & NDR_OUT) {
    2100           0 :                 ndr_print_struct(ndr, "out", "PNP_AddID");
    2101           0 :                 ndr->depth++;
    2102           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    2103           0 :                 ndr->depth--;
    2104             :         }
    2105           0 :         ndr->depth--;
    2106             : }
    2107             : 
    2108           0 : static enum ndr_err_code ndr_push_PNP_RegisterDriver(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_RegisterDriver *r)
    2109             : {
    2110           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2111           0 :         if (flags & NDR_IN) {
    2112           0 :         }
    2113           0 :         if (flags & NDR_OUT) {
    2114           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    2115             :         }
    2116           0 :         return NDR_ERR_SUCCESS;
    2117             : }
    2118             : 
    2119           0 : static enum ndr_err_code ndr_pull_PNP_RegisterDriver(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_RegisterDriver *r)
    2120             : {
    2121           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2122           0 :         if (flags & NDR_IN) {
    2123           0 :         }
    2124           0 :         if (flags & NDR_OUT) {
    2125             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2126             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2127           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    2128             :         }
    2129           0 :         return NDR_ERR_SUCCESS;
    2130             : }
    2131             : 
    2132           0 : _PUBLIC_ void ndr_print_PNP_RegisterDriver(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_RegisterDriver *r)
    2133             : {
    2134           0 :         ndr_print_struct(ndr, name, "PNP_RegisterDriver");
    2135           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2136           0 :         ndr->depth++;
    2137           0 :         if (flags & NDR_SET_VALUES) {
    2138           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2139             :         }
    2140           0 :         if (flags & NDR_IN) {
    2141           0 :                 ndr_print_struct(ndr, "in", "PNP_RegisterDriver");
    2142           0 :                 ndr->depth++;
    2143           0 :                 ndr->depth--;
    2144             :         }
    2145           0 :         if (flags & NDR_OUT) {
    2146           0 :                 ndr_print_struct(ndr, "out", "PNP_RegisterDriver");
    2147           0 :                 ndr->depth++;
    2148           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    2149           0 :                 ndr->depth--;
    2150             :         }
    2151           0 :         ndr->depth--;
    2152             : }
    2153             : 
    2154           0 : static enum ndr_err_code ndr_push_PNP_QueryRemove(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_QueryRemove *r)
    2155             : {
    2156           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2157           0 :         if (flags & NDR_IN) {
    2158           0 :         }
    2159           0 :         if (flags & NDR_OUT) {
    2160           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    2161             :         }
    2162           0 :         return NDR_ERR_SUCCESS;
    2163             : }
    2164             : 
    2165           0 : static enum ndr_err_code ndr_pull_PNP_QueryRemove(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_QueryRemove *r)
    2166             : {
    2167           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2168           0 :         if (flags & NDR_IN) {
    2169           0 :         }
    2170           0 :         if (flags & NDR_OUT) {
    2171             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2172             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2173           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    2174             :         }
    2175           0 :         return NDR_ERR_SUCCESS;
    2176             : }
    2177             : 
    2178           0 : _PUBLIC_ void ndr_print_PNP_QueryRemove(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_QueryRemove *r)
    2179             : {
    2180           0 :         ndr_print_struct(ndr, name, "PNP_QueryRemove");
    2181           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2182           0 :         ndr->depth++;
    2183           0 :         if (flags & NDR_SET_VALUES) {
    2184           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2185             :         }
    2186           0 :         if (flags & NDR_IN) {
    2187           0 :                 ndr_print_struct(ndr, "in", "PNP_QueryRemove");
    2188           0 :                 ndr->depth++;
    2189           0 :                 ndr->depth--;
    2190             :         }
    2191           0 :         if (flags & NDR_OUT) {
    2192           0 :                 ndr_print_struct(ndr, "out", "PNP_QueryRemove");
    2193           0 :                 ndr->depth++;
    2194           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    2195           0 :                 ndr->depth--;
    2196             :         }
    2197           0 :         ndr->depth--;
    2198             : }
    2199             : 
    2200           0 : static enum ndr_err_code ndr_push_PNP_RequestDeviceEject(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_RequestDeviceEject *r)
    2201             : {
    2202           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2203           0 :         if (flags & NDR_IN) {
    2204           0 :         }
    2205           0 :         if (flags & NDR_OUT) {
    2206           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    2207             :         }
    2208           0 :         return NDR_ERR_SUCCESS;
    2209             : }
    2210             : 
    2211           0 : static enum ndr_err_code ndr_pull_PNP_RequestDeviceEject(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_RequestDeviceEject *r)
    2212             : {
    2213           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2214           0 :         if (flags & NDR_IN) {
    2215           0 :         }
    2216           0 :         if (flags & NDR_OUT) {
    2217             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2218             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2219           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    2220             :         }
    2221           0 :         return NDR_ERR_SUCCESS;
    2222             : }
    2223             : 
    2224           0 : _PUBLIC_ void ndr_print_PNP_RequestDeviceEject(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_RequestDeviceEject *r)
    2225             : {
    2226           0 :         ndr_print_struct(ndr, name, "PNP_RequestDeviceEject");
    2227           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2228           0 :         ndr->depth++;
    2229           0 :         if (flags & NDR_SET_VALUES) {
    2230           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2231             :         }
    2232           0 :         if (flags & NDR_IN) {
    2233           0 :                 ndr_print_struct(ndr, "in", "PNP_RequestDeviceEject");
    2234           0 :                 ndr->depth++;
    2235           0 :                 ndr->depth--;
    2236             :         }
    2237           0 :         if (flags & NDR_OUT) {
    2238           0 :                 ndr_print_struct(ndr, "out", "PNP_RequestDeviceEject");
    2239           0 :                 ndr->depth++;
    2240           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    2241           0 :                 ndr->depth--;
    2242             :         }
    2243           0 :         ndr->depth--;
    2244             : }
    2245             : 
    2246           0 : static enum ndr_err_code ndr_push_PNP_IsDockStationPresent(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_IsDockStationPresent *r)
    2247             : {
    2248           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2249           0 :         if (flags & NDR_IN) {
    2250           0 :         }
    2251           0 :         if (flags & NDR_OUT) {
    2252           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    2253             :         }
    2254           0 :         return NDR_ERR_SUCCESS;
    2255             : }
    2256             : 
    2257           0 : static enum ndr_err_code ndr_pull_PNP_IsDockStationPresent(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_IsDockStationPresent *r)
    2258             : {
    2259           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2260           0 :         if (flags & NDR_IN) {
    2261           0 :         }
    2262           0 :         if (flags & NDR_OUT) {
    2263             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2264             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2265           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    2266             :         }
    2267           0 :         return NDR_ERR_SUCCESS;
    2268             : }
    2269             : 
    2270           0 : _PUBLIC_ void ndr_print_PNP_IsDockStationPresent(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_IsDockStationPresent *r)
    2271             : {
    2272           0 :         ndr_print_struct(ndr, name, "PNP_IsDockStationPresent");
    2273           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2274           0 :         ndr->depth++;
    2275           0 :         if (flags & NDR_SET_VALUES) {
    2276           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2277             :         }
    2278           0 :         if (flags & NDR_IN) {
    2279           0 :                 ndr_print_struct(ndr, "in", "PNP_IsDockStationPresent");
    2280           0 :                 ndr->depth++;
    2281           0 :                 ndr->depth--;
    2282             :         }
    2283           0 :         if (flags & NDR_OUT) {
    2284           0 :                 ndr_print_struct(ndr, "out", "PNP_IsDockStationPresent");
    2285           0 :                 ndr->depth++;
    2286           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    2287           0 :                 ndr->depth--;
    2288             :         }
    2289           0 :         ndr->depth--;
    2290             : }
    2291             : 
    2292           0 : static enum ndr_err_code ndr_push_PNP_RequestEjectPC(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_RequestEjectPC *r)
    2293             : {
    2294           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2295           0 :         if (flags & NDR_IN) {
    2296           0 :         }
    2297           0 :         if (flags & NDR_OUT) {
    2298           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    2299             :         }
    2300           0 :         return NDR_ERR_SUCCESS;
    2301             : }
    2302             : 
    2303           0 : static enum ndr_err_code ndr_pull_PNP_RequestEjectPC(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_RequestEjectPC *r)
    2304             : {
    2305           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2306           0 :         if (flags & NDR_IN) {
    2307           0 :         }
    2308           0 :         if (flags & NDR_OUT) {
    2309             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2310             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2311           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    2312             :         }
    2313           0 :         return NDR_ERR_SUCCESS;
    2314             : }
    2315             : 
    2316           0 : _PUBLIC_ void ndr_print_PNP_RequestEjectPC(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_RequestEjectPC *r)
    2317             : {
    2318           0 :         ndr_print_struct(ndr, name, "PNP_RequestEjectPC");
    2319           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2320           0 :         ndr->depth++;
    2321           0 :         if (flags & NDR_SET_VALUES) {
    2322           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2323             :         }
    2324           0 :         if (flags & NDR_IN) {
    2325           0 :                 ndr_print_struct(ndr, "in", "PNP_RequestEjectPC");
    2326           0 :                 ndr->depth++;
    2327           0 :                 ndr->depth--;
    2328             :         }
    2329           0 :         if (flags & NDR_OUT) {
    2330           0 :                 ndr_print_struct(ndr, "out", "PNP_RequestEjectPC");
    2331           0 :                 ndr->depth++;
    2332           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    2333           0 :                 ndr->depth--;
    2334             :         }
    2335           0 :         ndr->depth--;
    2336             : }
    2337             : 
    2338           0 : static enum ndr_err_code ndr_push_PNP_HwProfFlags(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_HwProfFlags *r)
    2339             : {
    2340           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2341           0 :         if (flags & NDR_IN) {
    2342           0 :                 if (r->in.devicepath == NULL) {
    2343           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2344             :                 }
    2345           0 :                 if (r->in.profile_flags == NULL) {
    2346           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2347             :                 }
    2348           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.action));
    2349           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.devicepath, CH_UTF16)));
    2350           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    2351           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.devicepath, CH_UTF16)));
    2352           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.devicepath, ndr_charset_length(r->in.devicepath, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    2353           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.config));
    2354           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.profile_flags));
    2355           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.veto_type));
    2356           0 :                 if (r->in.veto_type) {
    2357           0 :                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.veto_type));
    2358             :                 }
    2359           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown5));
    2360           0 :                 if (r->in.unknown5) {
    2361           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown5, CH_UTF16)));
    2362           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    2363           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown5, CH_UTF16)));
    2364           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.unknown5, ndr_charset_length(r->in.unknown5, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    2365             :                 }
    2366           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.name_length));
    2367           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
    2368             :         }
    2369           0 :         if (flags & NDR_OUT) {
    2370           0 :                 if (r->out.profile_flags == NULL) {
    2371           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2372             :                 }
    2373           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.profile_flags));
    2374           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.veto_type));
    2375           0 :                 if (r->out.veto_type) {
    2376           0 :                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->out.veto_type));
    2377             :                 }
    2378           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.unknown5a));
    2379           0 :                 if (r->out.unknown5a) {
    2380           0 :                         NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.unknown5a));
    2381           0 :                         if (*r->out.unknown5a) {
    2382           0 :                                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.unknown5a, CH_UTF16)));
    2383           0 :                                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    2384           0 :                                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.unknown5a, CH_UTF16)));
    2385           0 :                                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.unknown5a, ndr_charset_length(*r->out.unknown5a, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    2386             :                         }
    2387             :                 }
    2388           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    2389             :         }
    2390           0 :         return NDR_ERR_SUCCESS;
    2391             : }
    2392             : 
    2393           0 : static enum ndr_err_code ndr_pull_PNP_HwProfFlags(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_HwProfFlags *r)
    2394             : {
    2395           0 :         uint32_t size_devicepath_1 = 0;
    2396           0 :         uint32_t length_devicepath_1 = 0;
    2397           0 :         uint32_t _ptr_veto_type;
    2398           0 :         uint32_t _ptr_unknown5;
    2399           0 :         uint32_t size_unknown5_1 = 0;
    2400           0 :         uint32_t length_unknown5_1 = 0;
    2401           0 :         uint32_t _ptr_unknown5a;
    2402           0 :         uint32_t size_unknown5a_2 = 0;
    2403           0 :         uint32_t length_unknown5a_2 = 0;
    2404           0 :         TALLOC_CTX *_mem_save_profile_flags_0 = NULL;
    2405           0 :         TALLOC_CTX *_mem_save_veto_type_0 = NULL;
    2406           0 :         TALLOC_CTX *_mem_save_unknown5_0 = NULL;
    2407           0 :         TALLOC_CTX *_mem_save_unknown5a_0 = NULL;
    2408           0 :         TALLOC_CTX *_mem_save_unknown5a_1 = NULL;
    2409           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2410           0 :         if (flags & NDR_IN) {
    2411           0 :                 NDR_ZERO_STRUCT(r->out);
    2412             : 
    2413           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.action));
    2414           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.devicepath));
    2415           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.devicepath));
    2416           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.devicepath, &size_devicepath_1));
    2417           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.devicepath, &length_devicepath_1));
    2418           0 :                 if (length_devicepath_1 > size_devicepath_1) {
    2419           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %"PRIu32": should exceed array length %"PRIu32"", size_devicepath_1, length_devicepath_1);
    2420             :                 }
    2421           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_devicepath_1, sizeof(uint16_t)));
    2422           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.devicepath, length_devicepath_1, sizeof(uint16_t), CH_UTF16));
    2423           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.config));
    2424           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2425           0 :                         NDR_PULL_ALLOC(ndr, r->in.profile_flags);
    2426             :                 }
    2427           0 :                 _mem_save_profile_flags_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2428           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.profile_flags, LIBNDR_FLAG_REF_ALLOC);
    2429           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.profile_flags));
    2430           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_profile_flags_0, LIBNDR_FLAG_REF_ALLOC);
    2431           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_veto_type));
    2432           0 :                 if (_ptr_veto_type) {
    2433           0 :                         NDR_PULL_ALLOC(ndr, r->in.veto_type);
    2434             :                 } else {
    2435           0 :                         r->in.veto_type = NULL;
    2436             :                 }
    2437           0 :                 if (r->in.veto_type) {
    2438           0 :                         _mem_save_veto_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2439           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->in.veto_type, 0);
    2440           0 :                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.veto_type));
    2441           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_veto_type_0, 0);
    2442             :                 }
    2443           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown5));
    2444           0 :                 if (_ptr_unknown5) {
    2445           0 :                         NDR_PULL_ALLOC(ndr, r->in.unknown5);
    2446             :                 } else {
    2447           0 :                         r->in.unknown5 = NULL;
    2448             :                 }
    2449           0 :                 if (r->in.unknown5) {
    2450           0 :                         _mem_save_unknown5_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2451           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown5, 0);
    2452           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.unknown5));
    2453           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.unknown5));
    2454           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.unknown5, &size_unknown5_1));
    2455           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.unknown5, &length_unknown5_1));
    2456           0 :                         if (length_unknown5_1 > size_unknown5_1) {
    2457           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %"PRIu32": should exceed array length %"PRIu32"", size_unknown5_1, length_unknown5_1);
    2458             :                         }
    2459           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_unknown5_1, sizeof(uint16_t)));
    2460           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.unknown5, length_unknown5_1, sizeof(uint16_t), CH_UTF16));
    2461           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown5_0, 0);
    2462             :                 }
    2463           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.name_length));
    2464           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
    2465           0 :                 NDR_PULL_ALLOC(ndr, r->out.profile_flags);
    2466           0 :                 *r->out.profile_flags = *r->in.profile_flags;
    2467             :         }
    2468           0 :         if (flags & NDR_OUT) {
    2469             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2470             :                 if (r->in.profile_flags == NULL) {
    2471             :                         NDR_PULL_ALLOC(ndr, r->in.profile_flags);
    2472             :                         NDR_ZERO_STRUCTP(r->in.profile_flags);
    2473             :                 }
    2474             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2475           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2476           0 :                         NDR_PULL_ALLOC(ndr, r->out.profile_flags);
    2477             :                 }
    2478           0 :                 _mem_save_profile_flags_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2479           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.profile_flags, LIBNDR_FLAG_REF_ALLOC);
    2480           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.profile_flags));
    2481           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_profile_flags_0, LIBNDR_FLAG_REF_ALLOC);
    2482           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_veto_type));
    2483           0 :                 if (_ptr_veto_type) {
    2484           0 :                         NDR_PULL_ALLOC(ndr, r->out.veto_type);
    2485             :                 } else {
    2486           0 :                         r->out.veto_type = NULL;
    2487             :                 }
    2488           0 :                 if (r->out.veto_type) {
    2489           0 :                         _mem_save_veto_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2490           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->out.veto_type, 0);
    2491           0 :                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->out.veto_type));
    2492           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_veto_type_0, 0);
    2493             :                 }
    2494           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown5a));
    2495           0 :                 if (_ptr_unknown5a) {
    2496           0 :                         NDR_PULL_ALLOC(ndr, r->out.unknown5a);
    2497             :                 } else {
    2498           0 :                         r->out.unknown5a = NULL;
    2499             :                 }
    2500           0 :                 if (r->out.unknown5a) {
    2501           0 :                         _mem_save_unknown5a_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2502           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->out.unknown5a, 0);
    2503           0 :                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown5a));
    2504           0 :                         if (_ptr_unknown5a) {
    2505           0 :                                 NDR_PULL_ALLOC(ndr, *r->out.unknown5a);
    2506             :                         } else {
    2507           0 :                                 *r->out.unknown5a = NULL;
    2508             :                         }
    2509           0 :                         if (*r->out.unknown5a) {
    2510           0 :                                 _mem_save_unknown5a_1 = NDR_PULL_GET_MEM_CTX(ndr);
    2511           0 :                                 NDR_PULL_SET_MEM_CTX(ndr, *r->out.unknown5a, 0);
    2512           0 :                                 NDR_CHECK(ndr_pull_array_size(ndr, r->out.unknown5a));
    2513           0 :                                 NDR_CHECK(ndr_pull_array_length(ndr, r->out.unknown5a));
    2514           0 :                                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)r->out.unknown5a, &size_unknown5a_2));
    2515           0 :                                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)r->out.unknown5a, &length_unknown5a_2));
    2516           0 :                                 if (length_unknown5a_2 > size_unknown5a_2) {
    2517           0 :                                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %"PRIu32": should exceed array length %"PRIu32"", size_unknown5a_2, length_unknown5a_2);
    2518             :                                 }
    2519           0 :                                 NDR_CHECK(ndr_check_string_terminator(ndr, length_unknown5a_2, sizeof(uint16_t)));
    2520           0 :                                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.unknown5a, length_unknown5a_2, sizeof(uint16_t), CH_UTF16));
    2521           0 :                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown5a_1, 0);
    2522             :                         }
    2523           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown5a_0, 0);
    2524             :                 }
    2525           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    2526             :         }
    2527           0 :         return NDR_ERR_SUCCESS;
    2528             : }
    2529             : 
    2530           0 : _PUBLIC_ void ndr_print_PNP_HwProfFlags(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_HwProfFlags *r)
    2531             : {
    2532           0 :         ndr_print_struct(ndr, name, "PNP_HwProfFlags");
    2533           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2534           0 :         ndr->depth++;
    2535           0 :         if (flags & NDR_SET_VALUES) {
    2536           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2537             :         }
    2538           0 :         if (flags & NDR_IN) {
    2539           0 :                 ndr_print_struct(ndr, "in", "PNP_HwProfFlags");
    2540           0 :                 ndr->depth++;
    2541           0 :                 ndr_print_uint32(ndr, "action", r->in.action);
    2542           0 :                 ndr_print_ptr(ndr, "devicepath", r->in.devicepath);
    2543           0 :                 ndr->depth++;
    2544           0 :                 ndr_print_string(ndr, "devicepath", r->in.devicepath);
    2545           0 :                 ndr->depth--;
    2546           0 :                 ndr_print_uint32(ndr, "config", r->in.config);
    2547           0 :                 ndr_print_ptr(ndr, "profile_flags", r->in.profile_flags);
    2548           0 :                 ndr->depth++;
    2549           0 :                 ndr_print_uint32(ndr, "profile_flags", *r->in.profile_flags);
    2550           0 :                 ndr->depth--;
    2551           0 :                 ndr_print_ptr(ndr, "veto_type", r->in.veto_type);
    2552           0 :                 ndr->depth++;
    2553           0 :                 if (r->in.veto_type) {
    2554           0 :                         ndr_print_uint16(ndr, "veto_type", *r->in.veto_type);
    2555             :                 }
    2556           0 :                 ndr->depth--;
    2557           0 :                 ndr_print_ptr(ndr, "unknown5", r->in.unknown5);
    2558           0 :                 ndr->depth++;
    2559           0 :                 if (r->in.unknown5) {
    2560           0 :                         ndr_print_string(ndr, "unknown5", r->in.unknown5);
    2561             :                 }
    2562           0 :                 ndr->depth--;
    2563           0 :                 ndr_print_uint32(ndr, "name_length", r->in.name_length);
    2564           0 :                 ndr_print_uint32(ndr, "flags", r->in.flags);
    2565           0 :                 ndr->depth--;
    2566             :         }
    2567           0 :         if (flags & NDR_OUT) {
    2568           0 :                 ndr_print_struct(ndr, "out", "PNP_HwProfFlags");
    2569           0 :                 ndr->depth++;
    2570           0 :                 ndr_print_ptr(ndr, "profile_flags", r->out.profile_flags);
    2571           0 :                 ndr->depth++;
    2572           0 :                 ndr_print_uint32(ndr, "profile_flags", *r->out.profile_flags);
    2573           0 :                 ndr->depth--;
    2574           0 :                 ndr_print_ptr(ndr, "veto_type", r->out.veto_type);
    2575           0 :                 ndr->depth++;
    2576           0 :                 if (r->out.veto_type) {
    2577           0 :                         ndr_print_uint16(ndr, "veto_type", *r->out.veto_type);
    2578             :                 }
    2579           0 :                 ndr->depth--;
    2580           0 :                 ndr_print_ptr(ndr, "unknown5a", r->out.unknown5a);
    2581           0 :                 ndr->depth++;
    2582           0 :                 if (r->out.unknown5a) {
    2583           0 :                         ndr_print_ptr(ndr, "unknown5a", *r->out.unknown5a);
    2584           0 :                         ndr->depth++;
    2585           0 :                         if (*r->out.unknown5a) {
    2586           0 :                                 ndr_print_string(ndr, "unknown5a", *r->out.unknown5a);
    2587             :                         }
    2588           0 :                         ndr->depth--;
    2589             :                 }
    2590           0 :                 ndr->depth--;
    2591           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    2592           0 :                 ndr->depth--;
    2593             :         }
    2594           0 :         ndr->depth--;
    2595             : }
    2596             : 
    2597           0 : static enum ndr_err_code ndr_push_PNP_GetHwProfInfo(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_GetHwProfInfo *r)
    2598             : {
    2599           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2600           0 :         if (flags & NDR_IN) {
    2601           0 :                 if (r->in.info == NULL) {
    2602           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2603             :                 }
    2604           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.idx));
    2605           0 :                 NDR_CHECK(ndr_push_PNP_HwProfInfo(ndr, NDR_SCALARS, r->in.info));
    2606           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.size));
    2607           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
    2608             :         }
    2609           0 :         if (flags & NDR_OUT) {
    2610           0 :                 if (r->out.info == NULL) {
    2611           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2612             :                 }
    2613           0 :                 NDR_CHECK(ndr_push_PNP_HwProfInfo(ndr, NDR_SCALARS, r->out.info));
    2614           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    2615             :         }
    2616           0 :         return NDR_ERR_SUCCESS;
    2617             : }
    2618             : 
    2619           0 : static enum ndr_err_code ndr_pull_PNP_GetHwProfInfo(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_GetHwProfInfo *r)
    2620             : {
    2621           0 :         TALLOC_CTX *_mem_save_info_0 = NULL;
    2622           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2623           0 :         if (flags & NDR_IN) {
    2624           0 :                 NDR_ZERO_STRUCT(r->out);
    2625             : 
    2626           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.idx));
    2627           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2628           0 :                         NDR_PULL_ALLOC(ndr, r->in.info);
    2629             :                 }
    2630           0 :                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2631           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
    2632           0 :                 NDR_CHECK(ndr_pull_PNP_HwProfInfo(ndr, NDR_SCALARS, r->in.info));
    2633           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
    2634           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.size));
    2635           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
    2636           0 :                 NDR_PULL_ALLOC(ndr, r->out.info);
    2637           0 :                 *r->out.info = *r->in.info;
    2638             :         }
    2639           0 :         if (flags & NDR_OUT) {
    2640             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2641             :                 if (r->in.info == NULL) {
    2642             :                         NDR_PULL_ALLOC(ndr, r->in.info);
    2643             :                         NDR_ZERO_STRUCTP(r->in.info);
    2644             :                 }
    2645             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2646           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2647           0 :                         NDR_PULL_ALLOC(ndr, r->out.info);
    2648             :                 }
    2649           0 :                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2650           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
    2651           0 :                 NDR_CHECK(ndr_pull_PNP_HwProfInfo(ndr, NDR_SCALARS, r->out.info));
    2652           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
    2653           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    2654             :         }
    2655           0 :         return NDR_ERR_SUCCESS;
    2656             : }
    2657             : 
    2658           0 : _PUBLIC_ void ndr_print_PNP_GetHwProfInfo(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_GetHwProfInfo *r)
    2659             : {
    2660           0 :         ndr_print_struct(ndr, name, "PNP_GetHwProfInfo");
    2661           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2662           0 :         ndr->depth++;
    2663           0 :         if (flags & NDR_SET_VALUES) {
    2664           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2665             :         }
    2666           0 :         if (flags & NDR_IN) {
    2667           0 :                 ndr_print_struct(ndr, "in", "PNP_GetHwProfInfo");
    2668           0 :                 ndr->depth++;
    2669           0 :                 ndr_print_uint32(ndr, "idx", r->in.idx);
    2670           0 :                 ndr_print_ptr(ndr, "info", r->in.info);
    2671           0 :                 ndr->depth++;
    2672           0 :                 ndr_print_PNP_HwProfInfo(ndr, "info", r->in.info);
    2673           0 :                 ndr->depth--;
    2674           0 :                 ndr_print_uint32(ndr, "size", r->in.size);
    2675           0 :                 ndr_print_uint32(ndr, "flags", r->in.flags);
    2676           0 :                 ndr->depth--;
    2677             :         }
    2678           0 :         if (flags & NDR_OUT) {
    2679           0 :                 ndr_print_struct(ndr, "out", "PNP_GetHwProfInfo");
    2680           0 :                 ndr->depth++;
    2681           0 :                 ndr_print_ptr(ndr, "info", r->out.info);
    2682           0 :                 ndr->depth++;
    2683           0 :                 ndr_print_PNP_HwProfInfo(ndr, "info", r->out.info);
    2684           0 :                 ndr->depth--;
    2685           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    2686           0 :                 ndr->depth--;
    2687             :         }
    2688           0 :         ndr->depth--;
    2689             : }
    2690             : 
    2691           0 : static enum ndr_err_code ndr_push_PNP_AddEmptyLogConf(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_AddEmptyLogConf *r)
    2692             : {
    2693           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2694           0 :         if (flags & NDR_IN) {
    2695           0 :         }
    2696           0 :         if (flags & NDR_OUT) {
    2697           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    2698             :         }
    2699           0 :         return NDR_ERR_SUCCESS;
    2700             : }
    2701             : 
    2702           0 : static enum ndr_err_code ndr_pull_PNP_AddEmptyLogConf(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_AddEmptyLogConf *r)
    2703             : {
    2704           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2705           0 :         if (flags & NDR_IN) {
    2706           0 :         }
    2707           0 :         if (flags & NDR_OUT) {
    2708             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2709             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2710           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    2711             :         }
    2712           0 :         return NDR_ERR_SUCCESS;
    2713             : }
    2714             : 
    2715           0 : _PUBLIC_ void ndr_print_PNP_AddEmptyLogConf(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_AddEmptyLogConf *r)
    2716             : {
    2717           0 :         ndr_print_struct(ndr, name, "PNP_AddEmptyLogConf");
    2718           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2719           0 :         ndr->depth++;
    2720           0 :         if (flags & NDR_SET_VALUES) {
    2721           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2722             :         }
    2723           0 :         if (flags & NDR_IN) {
    2724           0 :                 ndr_print_struct(ndr, "in", "PNP_AddEmptyLogConf");
    2725           0 :                 ndr->depth++;
    2726           0 :                 ndr->depth--;
    2727             :         }
    2728           0 :         if (flags & NDR_OUT) {
    2729           0 :                 ndr_print_struct(ndr, "out", "PNP_AddEmptyLogConf");
    2730           0 :                 ndr->depth++;
    2731           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    2732           0 :                 ndr->depth--;
    2733             :         }
    2734           0 :         ndr->depth--;
    2735             : }
    2736             : 
    2737           0 : static enum ndr_err_code ndr_push_PNP_FreeLogConf(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_FreeLogConf *r)
    2738             : {
    2739           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2740           0 :         if (flags & NDR_IN) {
    2741           0 :         }
    2742           0 :         if (flags & NDR_OUT) {
    2743           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    2744             :         }
    2745           0 :         return NDR_ERR_SUCCESS;
    2746             : }
    2747             : 
    2748           0 : static enum ndr_err_code ndr_pull_PNP_FreeLogConf(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_FreeLogConf *r)
    2749             : {
    2750           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2751           0 :         if (flags & NDR_IN) {
    2752           0 :         }
    2753           0 :         if (flags & NDR_OUT) {
    2754             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2755             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2756           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    2757             :         }
    2758           0 :         return NDR_ERR_SUCCESS;
    2759             : }
    2760             : 
    2761           0 : _PUBLIC_ void ndr_print_PNP_FreeLogConf(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_FreeLogConf *r)
    2762             : {
    2763           0 :         ndr_print_struct(ndr, name, "PNP_FreeLogConf");
    2764           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2765           0 :         ndr->depth++;
    2766           0 :         if (flags & NDR_SET_VALUES) {
    2767           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2768             :         }
    2769           0 :         if (flags & NDR_IN) {
    2770           0 :                 ndr_print_struct(ndr, "in", "PNP_FreeLogConf");
    2771           0 :                 ndr->depth++;
    2772           0 :                 ndr->depth--;
    2773             :         }
    2774           0 :         if (flags & NDR_OUT) {
    2775           0 :                 ndr_print_struct(ndr, "out", "PNP_FreeLogConf");
    2776           0 :                 ndr->depth++;
    2777           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    2778           0 :                 ndr->depth--;
    2779             :         }
    2780           0 :         ndr->depth--;
    2781             : }
    2782             : 
    2783           0 : static enum ndr_err_code ndr_push_PNP_GetFirstLogConf(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_GetFirstLogConf *r)
    2784             : {
    2785           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2786           0 :         if (flags & NDR_IN) {
    2787           0 :         }
    2788           0 :         if (flags & NDR_OUT) {
    2789           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    2790             :         }
    2791           0 :         return NDR_ERR_SUCCESS;
    2792             : }
    2793             : 
    2794           0 : static enum ndr_err_code ndr_pull_PNP_GetFirstLogConf(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_GetFirstLogConf *r)
    2795             : {
    2796           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2797           0 :         if (flags & NDR_IN) {
    2798           0 :         }
    2799           0 :         if (flags & NDR_OUT) {
    2800             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2801             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2802           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    2803             :         }
    2804           0 :         return NDR_ERR_SUCCESS;
    2805             : }
    2806             : 
    2807           0 : _PUBLIC_ void ndr_print_PNP_GetFirstLogConf(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_GetFirstLogConf *r)
    2808             : {
    2809           0 :         ndr_print_struct(ndr, name, "PNP_GetFirstLogConf");
    2810           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2811           0 :         ndr->depth++;
    2812           0 :         if (flags & NDR_SET_VALUES) {
    2813           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2814             :         }
    2815           0 :         if (flags & NDR_IN) {
    2816           0 :                 ndr_print_struct(ndr, "in", "PNP_GetFirstLogConf");
    2817           0 :                 ndr->depth++;
    2818           0 :                 ndr->depth--;
    2819             :         }
    2820           0 :         if (flags & NDR_OUT) {
    2821           0 :                 ndr_print_struct(ndr, "out", "PNP_GetFirstLogConf");
    2822           0 :                 ndr->depth++;
    2823           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    2824           0 :                 ndr->depth--;
    2825             :         }
    2826           0 :         ndr->depth--;
    2827             : }
    2828             : 
    2829           0 : static enum ndr_err_code ndr_push_PNP_GetNextLogConf(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_GetNextLogConf *r)
    2830             : {
    2831           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2832           0 :         if (flags & NDR_IN) {
    2833           0 :         }
    2834           0 :         if (flags & NDR_OUT) {
    2835           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    2836             :         }
    2837           0 :         return NDR_ERR_SUCCESS;
    2838             : }
    2839             : 
    2840           0 : static enum ndr_err_code ndr_pull_PNP_GetNextLogConf(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_GetNextLogConf *r)
    2841             : {
    2842           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2843           0 :         if (flags & NDR_IN) {
    2844           0 :         }
    2845           0 :         if (flags & NDR_OUT) {
    2846             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2847             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2848           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    2849             :         }
    2850           0 :         return NDR_ERR_SUCCESS;
    2851             : }
    2852             : 
    2853           0 : _PUBLIC_ void ndr_print_PNP_GetNextLogConf(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_GetNextLogConf *r)
    2854             : {
    2855           0 :         ndr_print_struct(ndr, name, "PNP_GetNextLogConf");
    2856           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2857           0 :         ndr->depth++;
    2858           0 :         if (flags & NDR_SET_VALUES) {
    2859           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2860             :         }
    2861           0 :         if (flags & NDR_IN) {
    2862           0 :                 ndr_print_struct(ndr, "in", "PNP_GetNextLogConf");
    2863           0 :                 ndr->depth++;
    2864           0 :                 ndr->depth--;
    2865             :         }
    2866           0 :         if (flags & NDR_OUT) {
    2867           0 :                 ndr_print_struct(ndr, "out", "PNP_GetNextLogConf");
    2868           0 :                 ndr->depth++;
    2869           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    2870           0 :                 ndr->depth--;
    2871             :         }
    2872           0 :         ndr->depth--;
    2873             : }
    2874             : 
    2875           0 : static enum ndr_err_code ndr_push_PNP_GetLogConfPriority(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_GetLogConfPriority *r)
    2876             : {
    2877           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2878           0 :         if (flags & NDR_IN) {
    2879           0 :         }
    2880           0 :         if (flags & NDR_OUT) {
    2881           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    2882             :         }
    2883           0 :         return NDR_ERR_SUCCESS;
    2884             : }
    2885             : 
    2886           0 : static enum ndr_err_code ndr_pull_PNP_GetLogConfPriority(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_GetLogConfPriority *r)
    2887             : {
    2888           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2889           0 :         if (flags & NDR_IN) {
    2890           0 :         }
    2891           0 :         if (flags & NDR_OUT) {
    2892             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2893             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2894           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    2895             :         }
    2896           0 :         return NDR_ERR_SUCCESS;
    2897             : }
    2898             : 
    2899           0 : _PUBLIC_ void ndr_print_PNP_GetLogConfPriority(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_GetLogConfPriority *r)
    2900             : {
    2901           0 :         ndr_print_struct(ndr, name, "PNP_GetLogConfPriority");
    2902           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2903           0 :         ndr->depth++;
    2904           0 :         if (flags & NDR_SET_VALUES) {
    2905           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2906             :         }
    2907           0 :         if (flags & NDR_IN) {
    2908           0 :                 ndr_print_struct(ndr, "in", "PNP_GetLogConfPriority");
    2909           0 :                 ndr->depth++;
    2910           0 :                 ndr->depth--;
    2911             :         }
    2912           0 :         if (flags & NDR_OUT) {
    2913           0 :                 ndr_print_struct(ndr, "out", "PNP_GetLogConfPriority");
    2914           0 :                 ndr->depth++;
    2915           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    2916           0 :                 ndr->depth--;
    2917             :         }
    2918           0 :         ndr->depth--;
    2919             : }
    2920             : 
    2921           0 : static enum ndr_err_code ndr_push_PNP_AddResDes(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_AddResDes *r)
    2922             : {
    2923           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2924           0 :         if (flags & NDR_IN) {
    2925           0 :         }
    2926           0 :         if (flags & NDR_OUT) {
    2927           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    2928             :         }
    2929           0 :         return NDR_ERR_SUCCESS;
    2930             : }
    2931             : 
    2932           0 : static enum ndr_err_code ndr_pull_PNP_AddResDes(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_AddResDes *r)
    2933             : {
    2934           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2935           0 :         if (flags & NDR_IN) {
    2936           0 :         }
    2937           0 :         if (flags & NDR_OUT) {
    2938             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2939             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2940           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    2941             :         }
    2942           0 :         return NDR_ERR_SUCCESS;
    2943             : }
    2944             : 
    2945           0 : _PUBLIC_ void ndr_print_PNP_AddResDes(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_AddResDes *r)
    2946             : {
    2947           0 :         ndr_print_struct(ndr, name, "PNP_AddResDes");
    2948           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2949           0 :         ndr->depth++;
    2950           0 :         if (flags & NDR_SET_VALUES) {
    2951           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2952             :         }
    2953           0 :         if (flags & NDR_IN) {
    2954           0 :                 ndr_print_struct(ndr, "in", "PNP_AddResDes");
    2955           0 :                 ndr->depth++;
    2956           0 :                 ndr->depth--;
    2957             :         }
    2958           0 :         if (flags & NDR_OUT) {
    2959           0 :                 ndr_print_struct(ndr, "out", "PNP_AddResDes");
    2960           0 :                 ndr->depth++;
    2961           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    2962           0 :                 ndr->depth--;
    2963             :         }
    2964           0 :         ndr->depth--;
    2965             : }
    2966             : 
    2967           0 : static enum ndr_err_code ndr_push_PNP_FreeResDes(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_FreeResDes *r)
    2968             : {
    2969           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2970           0 :         if (flags & NDR_IN) {
    2971           0 :         }
    2972           0 :         if (flags & NDR_OUT) {
    2973           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    2974             :         }
    2975           0 :         return NDR_ERR_SUCCESS;
    2976             : }
    2977             : 
    2978           0 : static enum ndr_err_code ndr_pull_PNP_FreeResDes(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_FreeResDes *r)
    2979             : {
    2980           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2981           0 :         if (flags & NDR_IN) {
    2982           0 :         }
    2983           0 :         if (flags & NDR_OUT) {
    2984             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2985             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2986           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    2987             :         }
    2988           0 :         return NDR_ERR_SUCCESS;
    2989             : }
    2990             : 
    2991           0 : _PUBLIC_ void ndr_print_PNP_FreeResDes(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_FreeResDes *r)
    2992             : {
    2993           0 :         ndr_print_struct(ndr, name, "PNP_FreeResDes");
    2994           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2995           0 :         ndr->depth++;
    2996           0 :         if (flags & NDR_SET_VALUES) {
    2997           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2998             :         }
    2999           0 :         if (flags & NDR_IN) {
    3000           0 :                 ndr_print_struct(ndr, "in", "PNP_FreeResDes");
    3001           0 :                 ndr->depth++;
    3002           0 :                 ndr->depth--;
    3003             :         }
    3004           0 :         if (flags & NDR_OUT) {
    3005           0 :                 ndr_print_struct(ndr, "out", "PNP_FreeResDes");
    3006           0 :                 ndr->depth++;
    3007           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    3008           0 :                 ndr->depth--;
    3009             :         }
    3010           0 :         ndr->depth--;
    3011             : }
    3012             : 
    3013           0 : static enum ndr_err_code ndr_push_PNP_GetNextResDes(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_GetNextResDes *r)
    3014             : {
    3015           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    3016           0 :         if (flags & NDR_IN) {
    3017           0 :         }
    3018           0 :         if (flags & NDR_OUT) {
    3019           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    3020             :         }
    3021           0 :         return NDR_ERR_SUCCESS;
    3022             : }
    3023             : 
    3024           0 : static enum ndr_err_code ndr_pull_PNP_GetNextResDes(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_GetNextResDes *r)
    3025             : {
    3026           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    3027           0 :         if (flags & NDR_IN) {
    3028           0 :         }
    3029           0 :         if (flags & NDR_OUT) {
    3030             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    3031             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    3032           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    3033             :         }
    3034           0 :         return NDR_ERR_SUCCESS;
    3035             : }
    3036             : 
    3037           0 : _PUBLIC_ void ndr_print_PNP_GetNextResDes(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_GetNextResDes *r)
    3038             : {
    3039           0 :         ndr_print_struct(ndr, name, "PNP_GetNextResDes");
    3040           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3041           0 :         ndr->depth++;
    3042           0 :         if (flags & NDR_SET_VALUES) {
    3043           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    3044             :         }
    3045           0 :         if (flags & NDR_IN) {
    3046           0 :                 ndr_print_struct(ndr, "in", "PNP_GetNextResDes");
    3047           0 :                 ndr->depth++;
    3048           0 :                 ndr->depth--;
    3049             :         }
    3050           0 :         if (flags & NDR_OUT) {
    3051           0 :                 ndr_print_struct(ndr, "out", "PNP_GetNextResDes");
    3052           0 :                 ndr->depth++;
    3053           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    3054           0 :                 ndr->depth--;
    3055             :         }
    3056           0 :         ndr->depth--;
    3057             : }
    3058             : 
    3059           0 : static enum ndr_err_code ndr_push_PNP_GetResDesData(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_GetResDesData *r)
    3060             : {
    3061           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    3062           0 :         if (flags & NDR_IN) {
    3063           0 :         }
    3064           0 :         if (flags & NDR_OUT) {
    3065           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    3066             :         }
    3067           0 :         return NDR_ERR_SUCCESS;
    3068             : }
    3069             : 
    3070           0 : static enum ndr_err_code ndr_pull_PNP_GetResDesData(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_GetResDesData *r)
    3071             : {
    3072           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    3073           0 :         if (flags & NDR_IN) {
    3074           0 :         }
    3075           0 :         if (flags & NDR_OUT) {
    3076             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    3077             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    3078           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    3079             :         }
    3080           0 :         return NDR_ERR_SUCCESS;
    3081             : }
    3082             : 
    3083           0 : _PUBLIC_ void ndr_print_PNP_GetResDesData(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_GetResDesData *r)
    3084             : {
    3085           0 :         ndr_print_struct(ndr, name, "PNP_GetResDesData");
    3086           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3087           0 :         ndr->depth++;
    3088           0 :         if (flags & NDR_SET_VALUES) {
    3089           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    3090             :         }
    3091           0 :         if (flags & NDR_IN) {
    3092           0 :                 ndr_print_struct(ndr, "in", "PNP_GetResDesData");
    3093           0 :                 ndr->depth++;
    3094           0 :                 ndr->depth--;
    3095             :         }
    3096           0 :         if (flags & NDR_OUT) {
    3097           0 :                 ndr_print_struct(ndr, "out", "PNP_GetResDesData");
    3098           0 :                 ndr->depth++;
    3099           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    3100           0 :                 ndr->depth--;
    3101             :         }
    3102           0 :         ndr->depth--;
    3103             : }
    3104             : 
    3105           0 : static enum ndr_err_code ndr_push_PNP_GetResDesDataSize(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_GetResDesDataSize *r)
    3106             : {
    3107           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    3108           0 :         if (flags & NDR_IN) {
    3109           0 :         }
    3110           0 :         if (flags & NDR_OUT) {
    3111           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    3112             :         }
    3113           0 :         return NDR_ERR_SUCCESS;
    3114             : }
    3115             : 
    3116           0 : static enum ndr_err_code ndr_pull_PNP_GetResDesDataSize(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_GetResDesDataSize *r)
    3117             : {
    3118           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    3119           0 :         if (flags & NDR_IN) {
    3120           0 :         }
    3121           0 :         if (flags & NDR_OUT) {
    3122             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    3123             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    3124           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    3125             :         }
    3126           0 :         return NDR_ERR_SUCCESS;
    3127             : }
    3128             : 
    3129           0 : _PUBLIC_ void ndr_print_PNP_GetResDesDataSize(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_GetResDesDataSize *r)
    3130             : {
    3131           0 :         ndr_print_struct(ndr, name, "PNP_GetResDesDataSize");
    3132           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3133           0 :         ndr->depth++;
    3134           0 :         if (flags & NDR_SET_VALUES) {
    3135           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    3136             :         }
    3137           0 :         if (flags & NDR_IN) {
    3138           0 :                 ndr_print_struct(ndr, "in", "PNP_GetResDesDataSize");
    3139           0 :                 ndr->depth++;
    3140           0 :                 ndr->depth--;
    3141             :         }
    3142           0 :         if (flags & NDR_OUT) {
    3143           0 :                 ndr_print_struct(ndr, "out", "PNP_GetResDesDataSize");
    3144           0 :                 ndr->depth++;
    3145           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    3146           0 :                 ndr->depth--;
    3147             :         }
    3148           0 :         ndr->depth--;
    3149             : }
    3150             : 
    3151           0 : static enum ndr_err_code ndr_push_PNP_ModifyResDes(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_ModifyResDes *r)
    3152             : {
    3153           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    3154           0 :         if (flags & NDR_IN) {
    3155           0 :         }
    3156           0 :         if (flags & NDR_OUT) {
    3157           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    3158             :         }
    3159           0 :         return NDR_ERR_SUCCESS;
    3160             : }
    3161             : 
    3162           0 : static enum ndr_err_code ndr_pull_PNP_ModifyResDes(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_ModifyResDes *r)
    3163             : {
    3164           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    3165           0 :         if (flags & NDR_IN) {
    3166           0 :         }
    3167           0 :         if (flags & NDR_OUT) {
    3168             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    3169             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    3170           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    3171             :         }
    3172           0 :         return NDR_ERR_SUCCESS;
    3173             : }
    3174             : 
    3175           0 : _PUBLIC_ void ndr_print_PNP_ModifyResDes(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_ModifyResDes *r)
    3176             : {
    3177           0 :         ndr_print_struct(ndr, name, "PNP_ModifyResDes");
    3178           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3179           0 :         ndr->depth++;
    3180           0 :         if (flags & NDR_SET_VALUES) {
    3181           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    3182             :         }
    3183           0 :         if (flags & NDR_IN) {
    3184           0 :                 ndr_print_struct(ndr, "in", "PNP_ModifyResDes");
    3185           0 :                 ndr->depth++;
    3186           0 :                 ndr->depth--;
    3187             :         }
    3188           0 :         if (flags & NDR_OUT) {
    3189           0 :                 ndr_print_struct(ndr, "out", "PNP_ModifyResDes");
    3190           0 :                 ndr->depth++;
    3191           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    3192           0 :                 ndr->depth--;
    3193             :         }
    3194           0 :         ndr->depth--;
    3195             : }
    3196             : 
    3197           0 : static enum ndr_err_code ndr_push_PNP_DetectResourceLimit(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_DetectResourceLimit *r)
    3198             : {
    3199           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    3200           0 :         if (flags & NDR_IN) {
    3201           0 :         }
    3202           0 :         if (flags & NDR_OUT) {
    3203           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    3204             :         }
    3205           0 :         return NDR_ERR_SUCCESS;
    3206             : }
    3207             : 
    3208           0 : static enum ndr_err_code ndr_pull_PNP_DetectResourceLimit(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_DetectResourceLimit *r)
    3209             : {
    3210           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    3211           0 :         if (flags & NDR_IN) {
    3212           0 :         }
    3213           0 :         if (flags & NDR_OUT) {
    3214             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    3215             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    3216           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    3217             :         }
    3218           0 :         return NDR_ERR_SUCCESS;
    3219             : }
    3220             : 
    3221           0 : _PUBLIC_ void ndr_print_PNP_DetectResourceLimit(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_DetectResourceLimit *r)
    3222             : {
    3223           0 :         ndr_print_struct(ndr, name, "PNP_DetectResourceLimit");
    3224           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3225           0 :         ndr->depth++;
    3226           0 :         if (flags & NDR_SET_VALUES) {
    3227           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    3228             :         }
    3229           0 :         if (flags & NDR_IN) {
    3230           0 :                 ndr_print_struct(ndr, "in", "PNP_DetectResourceLimit");
    3231           0 :                 ndr->depth++;
    3232           0 :                 ndr->depth--;
    3233             :         }
    3234           0 :         if (flags & NDR_OUT) {
    3235           0 :                 ndr_print_struct(ndr, "out", "PNP_DetectResourceLimit");
    3236           0 :                 ndr->depth++;
    3237           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    3238           0 :                 ndr->depth--;
    3239             :         }
    3240           0 :         ndr->depth--;
    3241             : }
    3242             : 
    3243           0 : static enum ndr_err_code ndr_push_PNP_QueryResConfList(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_QueryResConfList *r)
    3244             : {
    3245           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    3246           0 :         if (flags & NDR_IN) {
    3247           0 :         }
    3248           0 :         if (flags & NDR_OUT) {
    3249           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    3250             :         }
    3251           0 :         return NDR_ERR_SUCCESS;
    3252             : }
    3253             : 
    3254           0 : static enum ndr_err_code ndr_pull_PNP_QueryResConfList(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_QueryResConfList *r)
    3255             : {
    3256           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    3257           0 :         if (flags & NDR_IN) {
    3258           0 :         }
    3259           0 :         if (flags & NDR_OUT) {
    3260             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    3261             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    3262           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    3263             :         }
    3264           0 :         return NDR_ERR_SUCCESS;
    3265             : }
    3266             : 
    3267           0 : _PUBLIC_ void ndr_print_PNP_QueryResConfList(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_QueryResConfList *r)
    3268             : {
    3269           0 :         ndr_print_struct(ndr, name, "PNP_QueryResConfList");
    3270           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3271           0 :         ndr->depth++;
    3272           0 :         if (flags & NDR_SET_VALUES) {
    3273           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    3274             :         }
    3275           0 :         if (flags & NDR_IN) {
    3276           0 :                 ndr_print_struct(ndr, "in", "PNP_QueryResConfList");
    3277           0 :                 ndr->depth++;
    3278           0 :                 ndr->depth--;
    3279             :         }
    3280           0 :         if (flags & NDR_OUT) {
    3281           0 :                 ndr_print_struct(ndr, "out", "PNP_QueryResConfList");
    3282           0 :                 ndr->depth++;
    3283           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    3284           0 :                 ndr->depth--;
    3285             :         }
    3286           0 :         ndr->depth--;
    3287             : }
    3288             : 
    3289           0 : static enum ndr_err_code ndr_push_PNP_SetHwProf(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_SetHwProf *r)
    3290             : {
    3291           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    3292           0 :         if (flags & NDR_IN) {
    3293           0 :         }
    3294           0 :         if (flags & NDR_OUT) {
    3295           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    3296             :         }
    3297           0 :         return NDR_ERR_SUCCESS;
    3298             : }
    3299             : 
    3300           0 : static enum ndr_err_code ndr_pull_PNP_SetHwProf(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_SetHwProf *r)
    3301             : {
    3302           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    3303           0 :         if (flags & NDR_IN) {
    3304           0 :         }
    3305           0 :         if (flags & NDR_OUT) {
    3306             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    3307             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    3308           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    3309             :         }
    3310           0 :         return NDR_ERR_SUCCESS;
    3311             : }
    3312             : 
    3313           0 : _PUBLIC_ void ndr_print_PNP_SetHwProf(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_SetHwProf *r)
    3314             : {
    3315           0 :         ndr_print_struct(ndr, name, "PNP_SetHwProf");
    3316           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3317           0 :         ndr->depth++;
    3318           0 :         if (flags & NDR_SET_VALUES) {
    3319           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    3320             :         }
    3321           0 :         if (flags & NDR_IN) {
    3322           0 :                 ndr_print_struct(ndr, "in", "PNP_SetHwProf");
    3323           0 :                 ndr->depth++;
    3324           0 :                 ndr->depth--;
    3325             :         }
    3326           0 :         if (flags & NDR_OUT) {
    3327           0 :                 ndr_print_struct(ndr, "out", "PNP_SetHwProf");
    3328           0 :                 ndr->depth++;
    3329           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    3330           0 :                 ndr->depth--;
    3331             :         }
    3332           0 :         ndr->depth--;
    3333             : }
    3334             : 
    3335           0 : static enum ndr_err_code ndr_push_PNP_QueryArbitratorFreeData(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_QueryArbitratorFreeData *r)
    3336             : {
    3337           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    3338           0 :         if (flags & NDR_IN) {
    3339           0 :         }
    3340           0 :         if (flags & NDR_OUT) {
    3341           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    3342             :         }
    3343           0 :         return NDR_ERR_SUCCESS;
    3344             : }
    3345             : 
    3346           0 : static enum ndr_err_code ndr_pull_PNP_QueryArbitratorFreeData(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_QueryArbitratorFreeData *r)
    3347             : {
    3348           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    3349           0 :         if (flags & NDR_IN) {
    3350           0 :         }
    3351           0 :         if (flags & NDR_OUT) {
    3352             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    3353             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    3354           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    3355             :         }
    3356           0 :         return NDR_ERR_SUCCESS;
    3357             : }
    3358             : 
    3359           0 : _PUBLIC_ void ndr_print_PNP_QueryArbitratorFreeData(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_QueryArbitratorFreeData *r)
    3360             : {
    3361           0 :         ndr_print_struct(ndr, name, "PNP_QueryArbitratorFreeData");
    3362           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3363           0 :         ndr->depth++;
    3364           0 :         if (flags & NDR_SET_VALUES) {
    3365           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    3366             :         }
    3367           0 :         if (flags & NDR_IN) {
    3368           0 :                 ndr_print_struct(ndr, "in", "PNP_QueryArbitratorFreeData");
    3369           0 :                 ndr->depth++;
    3370           0 :                 ndr->depth--;
    3371             :         }
    3372           0 :         if (flags & NDR_OUT) {
    3373           0 :                 ndr_print_struct(ndr, "out", "PNP_QueryArbitratorFreeData");
    3374           0 :                 ndr->depth++;
    3375           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    3376           0 :                 ndr->depth--;
    3377             :         }
    3378           0 :         ndr->depth--;
    3379             : }
    3380             : 
    3381           0 : static enum ndr_err_code ndr_push_PNP_QueryArbitratorFreeSize(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_QueryArbitratorFreeSize *r)
    3382             : {
    3383           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    3384           0 :         if (flags & NDR_IN) {
    3385           0 :         }
    3386           0 :         if (flags & NDR_OUT) {
    3387           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    3388             :         }
    3389           0 :         return NDR_ERR_SUCCESS;
    3390             : }
    3391             : 
    3392           0 : static enum ndr_err_code ndr_pull_PNP_QueryArbitratorFreeSize(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_QueryArbitratorFreeSize *r)
    3393             : {
    3394           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    3395           0 :         if (flags & NDR_IN) {
    3396           0 :         }
    3397           0 :         if (flags & NDR_OUT) {
    3398             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    3399             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    3400           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    3401             :         }
    3402           0 :         return NDR_ERR_SUCCESS;
    3403             : }
    3404             : 
    3405           0 : _PUBLIC_ void ndr_print_PNP_QueryArbitratorFreeSize(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_QueryArbitratorFreeSize *r)
    3406             : {
    3407           0 :         ndr_print_struct(ndr, name, "PNP_QueryArbitratorFreeSize");
    3408           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3409           0 :         ndr->depth++;
    3410           0 :         if (flags & NDR_SET_VALUES) {
    3411           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    3412             :         }
    3413           0 :         if (flags & NDR_IN) {
    3414           0 :                 ndr_print_struct(ndr, "in", "PNP_QueryArbitratorFreeSize");
    3415           0 :                 ndr->depth++;
    3416           0 :                 ndr->depth--;
    3417             :         }
    3418           0 :         if (flags & NDR_OUT) {
    3419           0 :                 ndr_print_struct(ndr, "out", "PNP_QueryArbitratorFreeSize");
    3420           0 :                 ndr->depth++;
    3421           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    3422           0 :                 ndr->depth--;
    3423             :         }
    3424           0 :         ndr->depth--;
    3425             : }
    3426             : 
    3427           0 : static enum ndr_err_code ndr_push_PNP_RunDetection(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_RunDetection *r)
    3428             : {
    3429           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    3430           0 :         if (flags & NDR_IN) {
    3431           0 :         }
    3432           0 :         if (flags & NDR_OUT) {
    3433           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    3434             :         }
    3435           0 :         return NDR_ERR_SUCCESS;
    3436             : }
    3437             : 
    3438           0 : static enum ndr_err_code ndr_pull_PNP_RunDetection(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_RunDetection *r)
    3439             : {
    3440           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    3441           0 :         if (flags & NDR_IN) {
    3442           0 :         }
    3443           0 :         if (flags & NDR_OUT) {
    3444             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    3445             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    3446           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    3447             :         }
    3448           0 :         return NDR_ERR_SUCCESS;
    3449             : }
    3450             : 
    3451           0 : _PUBLIC_ void ndr_print_PNP_RunDetection(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_RunDetection *r)
    3452             : {
    3453           0 :         ndr_print_struct(ndr, name, "PNP_RunDetection");
    3454           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3455           0 :         ndr->depth++;
    3456           0 :         if (flags & NDR_SET_VALUES) {
    3457           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    3458             :         }
    3459           0 :         if (flags & NDR_IN) {
    3460           0 :                 ndr_print_struct(ndr, "in", "PNP_RunDetection");
    3461           0 :                 ndr->depth++;
    3462           0 :                 ndr->depth--;
    3463             :         }
    3464           0 :         if (flags & NDR_OUT) {
    3465           0 :                 ndr_print_struct(ndr, "out", "PNP_RunDetection");
    3466           0 :                 ndr->depth++;
    3467           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    3468           0 :                 ndr->depth--;
    3469             :         }
    3470           0 :         ndr->depth--;
    3471             : }
    3472             : 
    3473           0 : static enum ndr_err_code ndr_push_PNP_RegisterNotification(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_RegisterNotification *r)
    3474             : {
    3475           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    3476           0 :         if (flags & NDR_IN) {
    3477           0 :         }
    3478           0 :         if (flags & NDR_OUT) {
    3479           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    3480             :         }
    3481           0 :         return NDR_ERR_SUCCESS;
    3482             : }
    3483             : 
    3484           0 : static enum ndr_err_code ndr_pull_PNP_RegisterNotification(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_RegisterNotification *r)
    3485             : {
    3486           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    3487           0 :         if (flags & NDR_IN) {
    3488           0 :         }
    3489           0 :         if (flags & NDR_OUT) {
    3490             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    3491             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    3492           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    3493             :         }
    3494           0 :         return NDR_ERR_SUCCESS;
    3495             : }
    3496             : 
    3497           0 : _PUBLIC_ void ndr_print_PNP_RegisterNotification(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_RegisterNotification *r)
    3498             : {
    3499           0 :         ndr_print_struct(ndr, name, "PNP_RegisterNotification");
    3500           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3501           0 :         ndr->depth++;
    3502           0 :         if (flags & NDR_SET_VALUES) {
    3503           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    3504             :         }
    3505           0 :         if (flags & NDR_IN) {
    3506           0 :                 ndr_print_struct(ndr, "in", "PNP_RegisterNotification");
    3507           0 :                 ndr->depth++;
    3508           0 :                 ndr->depth--;
    3509             :         }
    3510           0 :         if (flags & NDR_OUT) {
    3511           0 :                 ndr_print_struct(ndr, "out", "PNP_RegisterNotification");
    3512           0 :                 ndr->depth++;
    3513           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    3514           0 :                 ndr->depth--;
    3515             :         }
    3516           0 :         ndr->depth--;
    3517             : }
    3518             : 
    3519           0 : static enum ndr_err_code ndr_push_PNP_UnregisterNotification(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_UnregisterNotification *r)
    3520             : {
    3521           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    3522           0 :         if (flags & NDR_IN) {
    3523           0 :         }
    3524           0 :         if (flags & NDR_OUT) {
    3525           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    3526             :         }
    3527           0 :         return NDR_ERR_SUCCESS;
    3528             : }
    3529             : 
    3530           0 : static enum ndr_err_code ndr_pull_PNP_UnregisterNotification(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_UnregisterNotification *r)
    3531             : {
    3532           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    3533           0 :         if (flags & NDR_IN) {
    3534           0 :         }
    3535           0 :         if (flags & NDR_OUT) {
    3536             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    3537             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    3538           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    3539             :         }
    3540           0 :         return NDR_ERR_SUCCESS;
    3541             : }
    3542             : 
    3543           0 : _PUBLIC_ void ndr_print_PNP_UnregisterNotification(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_UnregisterNotification *r)
    3544             : {
    3545           0 :         ndr_print_struct(ndr, name, "PNP_UnregisterNotification");
    3546           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3547           0 :         ndr->depth++;
    3548           0 :         if (flags & NDR_SET_VALUES) {
    3549           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    3550             :         }
    3551           0 :         if (flags & NDR_IN) {
    3552           0 :                 ndr_print_struct(ndr, "in", "PNP_UnregisterNotification");
    3553           0 :                 ndr->depth++;
    3554           0 :                 ndr->depth--;
    3555             :         }
    3556           0 :         if (flags & NDR_OUT) {
    3557           0 :                 ndr_print_struct(ndr, "out", "PNP_UnregisterNotification");
    3558           0 :                 ndr->depth++;
    3559           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    3560           0 :                 ndr->depth--;
    3561             :         }
    3562           0 :         ndr->depth--;
    3563             : }
    3564             : 
    3565           0 : static enum ndr_err_code ndr_push_PNP_GetCustomDevProp(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_GetCustomDevProp *r)
    3566             : {
    3567           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    3568           0 :         if (flags & NDR_IN) {
    3569           0 :         }
    3570           0 :         if (flags & NDR_OUT) {
    3571           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    3572             :         }
    3573           0 :         return NDR_ERR_SUCCESS;
    3574             : }
    3575             : 
    3576           0 : static enum ndr_err_code ndr_pull_PNP_GetCustomDevProp(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_GetCustomDevProp *r)
    3577             : {
    3578           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    3579           0 :         if (flags & NDR_IN) {
    3580           0 :         }
    3581           0 :         if (flags & NDR_OUT) {
    3582             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    3583             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    3584           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    3585             :         }
    3586           0 :         return NDR_ERR_SUCCESS;
    3587             : }
    3588             : 
    3589           0 : _PUBLIC_ void ndr_print_PNP_GetCustomDevProp(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_GetCustomDevProp *r)
    3590             : {
    3591           0 :         ndr_print_struct(ndr, name, "PNP_GetCustomDevProp");
    3592           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3593           0 :         ndr->depth++;
    3594           0 :         if (flags & NDR_SET_VALUES) {
    3595           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    3596             :         }
    3597           0 :         if (flags & NDR_IN) {
    3598           0 :                 ndr_print_struct(ndr, "in", "PNP_GetCustomDevProp");
    3599           0 :                 ndr->depth++;
    3600           0 :                 ndr->depth--;
    3601             :         }
    3602           0 :         if (flags & NDR_OUT) {
    3603           0 :                 ndr_print_struct(ndr, "out", "PNP_GetCustomDevProp");
    3604           0 :                 ndr->depth++;
    3605           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    3606           0 :                 ndr->depth--;
    3607             :         }
    3608           0 :         ndr->depth--;
    3609             : }
    3610             : 
    3611           0 : static enum ndr_err_code ndr_push_PNP_GetVersionInternal(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_GetVersionInternal *r)
    3612             : {
    3613           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    3614           0 :         if (flags & NDR_IN) {
    3615           0 :         }
    3616           0 :         if (flags & NDR_OUT) {
    3617           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    3618             :         }
    3619           0 :         return NDR_ERR_SUCCESS;
    3620             : }
    3621             : 
    3622           0 : static enum ndr_err_code ndr_pull_PNP_GetVersionInternal(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_GetVersionInternal *r)
    3623             : {
    3624           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    3625           0 :         if (flags & NDR_IN) {
    3626           0 :         }
    3627           0 :         if (flags & NDR_OUT) {
    3628             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    3629             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    3630           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    3631             :         }
    3632           0 :         return NDR_ERR_SUCCESS;
    3633             : }
    3634             : 
    3635           0 : _PUBLIC_ void ndr_print_PNP_GetVersionInternal(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_GetVersionInternal *r)
    3636             : {
    3637           0 :         ndr_print_struct(ndr, name, "PNP_GetVersionInternal");
    3638           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3639           0 :         ndr->depth++;
    3640           0 :         if (flags & NDR_SET_VALUES) {
    3641           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    3642             :         }
    3643           0 :         if (flags & NDR_IN) {
    3644           0 :                 ndr_print_struct(ndr, "in", "PNP_GetVersionInternal");
    3645           0 :                 ndr->depth++;
    3646           0 :                 ndr->depth--;
    3647             :         }
    3648           0 :         if (flags & NDR_OUT) {
    3649           0 :                 ndr_print_struct(ndr, "out", "PNP_GetVersionInternal");
    3650           0 :                 ndr->depth++;
    3651           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    3652           0 :                 ndr->depth--;
    3653             :         }
    3654           0 :         ndr->depth--;
    3655             : }
    3656             : 
    3657           0 : static enum ndr_err_code ndr_push_PNP_GetBlockedDriverInfo(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_GetBlockedDriverInfo *r)
    3658             : {
    3659           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    3660           0 :         if (flags & NDR_IN) {
    3661           0 :         }
    3662           0 :         if (flags & NDR_OUT) {
    3663           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    3664             :         }
    3665           0 :         return NDR_ERR_SUCCESS;
    3666             : }
    3667             : 
    3668           0 : static enum ndr_err_code ndr_pull_PNP_GetBlockedDriverInfo(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_GetBlockedDriverInfo *r)
    3669             : {
    3670           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    3671           0 :         if (flags & NDR_IN) {
    3672           0 :         }
    3673           0 :         if (flags & NDR_OUT) {
    3674             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    3675             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    3676           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    3677             :         }
    3678           0 :         return NDR_ERR_SUCCESS;
    3679             : }
    3680             : 
    3681           0 : _PUBLIC_ void ndr_print_PNP_GetBlockedDriverInfo(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_GetBlockedDriverInfo *r)
    3682             : {
    3683           0 :         ndr_print_struct(ndr, name, "PNP_GetBlockedDriverInfo");
    3684           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3685           0 :         ndr->depth++;
    3686           0 :         if (flags & NDR_SET_VALUES) {
    3687           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    3688             :         }
    3689           0 :         if (flags & NDR_IN) {
    3690           0 :                 ndr_print_struct(ndr, "in", "PNP_GetBlockedDriverInfo");
    3691           0 :                 ndr->depth++;
    3692           0 :                 ndr->depth--;
    3693             :         }
    3694           0 :         if (flags & NDR_OUT) {
    3695           0 :                 ndr_print_struct(ndr, "out", "PNP_GetBlockedDriverInfo");
    3696           0 :                 ndr->depth++;
    3697           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    3698           0 :                 ndr->depth--;
    3699             :         }
    3700           0 :         ndr->depth--;
    3701             : }
    3702             : 
    3703           0 : static enum ndr_err_code ndr_push_PNP_GetServerSideDeviceInstallFlags(struct ndr_push *ndr, ndr_flags_type flags, const struct PNP_GetServerSideDeviceInstallFlags *r)
    3704             : {
    3705           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    3706           0 :         if (flags & NDR_IN) {
    3707           0 :         }
    3708           0 :         if (flags & NDR_OUT) {
    3709           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    3710             :         }
    3711           0 :         return NDR_ERR_SUCCESS;
    3712             : }
    3713             : 
    3714           0 : static enum ndr_err_code ndr_pull_PNP_GetServerSideDeviceInstallFlags(struct ndr_pull *ndr, ndr_flags_type flags, struct PNP_GetServerSideDeviceInstallFlags *r)
    3715             : {
    3716           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    3717           0 :         if (flags & NDR_IN) {
    3718           0 :         }
    3719           0 :         if (flags & NDR_OUT) {
    3720             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    3721             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    3722           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    3723             :         }
    3724           0 :         return NDR_ERR_SUCCESS;
    3725             : }
    3726             : 
    3727           0 : _PUBLIC_ void ndr_print_PNP_GetServerSideDeviceInstallFlags(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct PNP_GetServerSideDeviceInstallFlags *r)
    3728             : {
    3729           0 :         ndr_print_struct(ndr, name, "PNP_GetServerSideDeviceInstallFlags");
    3730           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3731           0 :         ndr->depth++;
    3732           0 :         if (flags & NDR_SET_VALUES) {
    3733           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    3734             :         }
    3735           0 :         if (flags & NDR_IN) {
    3736           0 :                 ndr_print_struct(ndr, "in", "PNP_GetServerSideDeviceInstallFlags");
    3737           0 :                 ndr->depth++;
    3738           0 :                 ndr->depth--;
    3739             :         }
    3740           0 :         if (flags & NDR_OUT) {
    3741           0 :                 ndr_print_struct(ndr, "out", "PNP_GetServerSideDeviceInstallFlags");
    3742           0 :                 ndr->depth++;
    3743           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    3744           0 :                 ndr->depth--;
    3745             :         }
    3746           0 :         ndr->depth--;
    3747             : }
    3748             : 
    3749             : #ifndef SKIP_NDR_TABLE_ntsvcs
    3750             : static const struct ndr_interface_public_struct ntsvcs_public_structs[] = {
    3751             :         { .name = NULL }
    3752             : };
    3753             : 
    3754             : static const struct ndr_interface_call ntsvcs_calls[] = {
    3755             :         {
    3756             :                 "PNP_Disconnect",
    3757             :                 sizeof(struct PNP_Disconnect),
    3758             :                 (ndr_push_flags_fn_t) ndr_push_PNP_Disconnect,
    3759             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_Disconnect,
    3760             :                 (ndr_print_function_t) ndr_print_PNP_Disconnect,
    3761             :                 { 0, NULL },
    3762             :                 { 0, NULL },
    3763             :         },
    3764             :         {
    3765             :                 "PNP_Connect",
    3766             :                 sizeof(struct PNP_Connect),
    3767             :                 (ndr_push_flags_fn_t) ndr_push_PNP_Connect,
    3768             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_Connect,
    3769             :                 (ndr_print_function_t) ndr_print_PNP_Connect,
    3770             :                 { 0, NULL },
    3771             :                 { 0, NULL },
    3772             :         },
    3773             :         {
    3774             :                 "PNP_GetVersion",
    3775             :                 sizeof(struct PNP_GetVersion),
    3776             :                 (ndr_push_flags_fn_t) ndr_push_PNP_GetVersion,
    3777             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_GetVersion,
    3778             :                 (ndr_print_function_t) ndr_print_PNP_GetVersion,
    3779             :                 { 0, NULL },
    3780             :                 { 0, NULL },
    3781             :         },
    3782             :         {
    3783             :                 "PNP_GetGlobalState",
    3784             :                 sizeof(struct PNP_GetGlobalState),
    3785             :                 (ndr_push_flags_fn_t) ndr_push_PNP_GetGlobalState,
    3786             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_GetGlobalState,
    3787             :                 (ndr_print_function_t) ndr_print_PNP_GetGlobalState,
    3788             :                 { 0, NULL },
    3789             :                 { 0, NULL },
    3790             :         },
    3791             :         {
    3792             :                 "PNP_InitDetection",
    3793             :                 sizeof(struct PNP_InitDetection),
    3794             :                 (ndr_push_flags_fn_t) ndr_push_PNP_InitDetection,
    3795             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_InitDetection,
    3796             :                 (ndr_print_function_t) ndr_print_PNP_InitDetection,
    3797             :                 { 0, NULL },
    3798             :                 { 0, NULL },
    3799             :         },
    3800             :         {
    3801             :                 "PNP_ReportLogOn",
    3802             :                 sizeof(struct PNP_ReportLogOn),
    3803             :                 (ndr_push_flags_fn_t) ndr_push_PNP_ReportLogOn,
    3804             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_ReportLogOn,
    3805             :                 (ndr_print_function_t) ndr_print_PNP_ReportLogOn,
    3806             :                 { 0, NULL },
    3807             :                 { 0, NULL },
    3808             :         },
    3809             :         {
    3810             :                 "PNP_ValidateDeviceInstance",
    3811             :                 sizeof(struct PNP_ValidateDeviceInstance),
    3812             :                 (ndr_push_flags_fn_t) ndr_push_PNP_ValidateDeviceInstance,
    3813             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_ValidateDeviceInstance,
    3814             :                 (ndr_print_function_t) ndr_print_PNP_ValidateDeviceInstance,
    3815             :                 { 0, NULL },
    3816             :                 { 0, NULL },
    3817             :         },
    3818             :         {
    3819             :                 "PNP_GetRootDeviceInstance",
    3820             :                 sizeof(struct PNP_GetRootDeviceInstance),
    3821             :                 (ndr_push_flags_fn_t) ndr_push_PNP_GetRootDeviceInstance,
    3822             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_GetRootDeviceInstance,
    3823             :                 (ndr_print_function_t) ndr_print_PNP_GetRootDeviceInstance,
    3824             :                 { 0, NULL },
    3825             :                 { 0, NULL },
    3826             :         },
    3827             :         {
    3828             :                 "PNP_GetRelatedDeviceInstance",
    3829             :                 sizeof(struct PNP_GetRelatedDeviceInstance),
    3830             :                 (ndr_push_flags_fn_t) ndr_push_PNP_GetRelatedDeviceInstance,
    3831             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_GetRelatedDeviceInstance,
    3832             :                 (ndr_print_function_t) ndr_print_PNP_GetRelatedDeviceInstance,
    3833             :                 { 0, NULL },
    3834             :                 { 0, NULL },
    3835             :         },
    3836             :         {
    3837             :                 "PNP_EnumerateSubKeys",
    3838             :                 sizeof(struct PNP_EnumerateSubKeys),
    3839             :                 (ndr_push_flags_fn_t) ndr_push_PNP_EnumerateSubKeys,
    3840             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_EnumerateSubKeys,
    3841             :                 (ndr_print_function_t) ndr_print_PNP_EnumerateSubKeys,
    3842             :                 { 0, NULL },
    3843             :                 { 0, NULL },
    3844             :         },
    3845             :         {
    3846             :                 "PNP_GetDeviceList",
    3847             :                 sizeof(struct PNP_GetDeviceList),
    3848             :                 (ndr_push_flags_fn_t) ndr_push_PNP_GetDeviceList,
    3849             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_GetDeviceList,
    3850             :                 (ndr_print_function_t) ndr_print_PNP_GetDeviceList,
    3851             :                 { 0, NULL },
    3852             :                 { 0, NULL },
    3853             :         },
    3854             :         {
    3855             :                 "PNP_GetDeviceListSize",
    3856             :                 sizeof(struct PNP_GetDeviceListSize),
    3857             :                 (ndr_push_flags_fn_t) ndr_push_PNP_GetDeviceListSize,
    3858             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_GetDeviceListSize,
    3859             :                 (ndr_print_function_t) ndr_print_PNP_GetDeviceListSize,
    3860             :                 { 0, NULL },
    3861             :                 { 0, NULL },
    3862             :         },
    3863             :         {
    3864             :                 "PNP_GetDepth",
    3865             :                 sizeof(struct PNP_GetDepth),
    3866             :                 (ndr_push_flags_fn_t) ndr_push_PNP_GetDepth,
    3867             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_GetDepth,
    3868             :                 (ndr_print_function_t) ndr_print_PNP_GetDepth,
    3869             :                 { 0, NULL },
    3870             :                 { 0, NULL },
    3871             :         },
    3872             :         {
    3873             :                 "PNP_GetDeviceRegProp",
    3874             :                 sizeof(struct PNP_GetDeviceRegProp),
    3875             :                 (ndr_push_flags_fn_t) ndr_push_PNP_GetDeviceRegProp,
    3876             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_GetDeviceRegProp,
    3877             :                 (ndr_print_function_t) ndr_print_PNP_GetDeviceRegProp,
    3878             :                 { 0, NULL },
    3879             :                 { 0, NULL },
    3880             :         },
    3881             :         {
    3882             :                 "PNP_SetDeviceRegProp",
    3883             :                 sizeof(struct PNP_SetDeviceRegProp),
    3884             :                 (ndr_push_flags_fn_t) ndr_push_PNP_SetDeviceRegProp,
    3885             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_SetDeviceRegProp,
    3886             :                 (ndr_print_function_t) ndr_print_PNP_SetDeviceRegProp,
    3887             :                 { 0, NULL },
    3888             :                 { 0, NULL },
    3889             :         },
    3890             :         {
    3891             :                 "PNP_GetClassInstance",
    3892             :                 sizeof(struct PNP_GetClassInstance),
    3893             :                 (ndr_push_flags_fn_t) ndr_push_PNP_GetClassInstance,
    3894             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_GetClassInstance,
    3895             :                 (ndr_print_function_t) ndr_print_PNP_GetClassInstance,
    3896             :                 { 0, NULL },
    3897             :                 { 0, NULL },
    3898             :         },
    3899             :         {
    3900             :                 "PNP_CreateKey",
    3901             :                 sizeof(struct PNP_CreateKey),
    3902             :                 (ndr_push_flags_fn_t) ndr_push_PNP_CreateKey,
    3903             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_CreateKey,
    3904             :                 (ndr_print_function_t) ndr_print_PNP_CreateKey,
    3905             :                 { 0, NULL },
    3906             :                 { 0, NULL },
    3907             :         },
    3908             :         {
    3909             :                 "PNP_DeleteRegistryKey",
    3910             :                 sizeof(struct PNP_DeleteRegistryKey),
    3911             :                 (ndr_push_flags_fn_t) ndr_push_PNP_DeleteRegistryKey,
    3912             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_DeleteRegistryKey,
    3913             :                 (ndr_print_function_t) ndr_print_PNP_DeleteRegistryKey,
    3914             :                 { 0, NULL },
    3915             :                 { 0, NULL },
    3916             :         },
    3917             :         {
    3918             :                 "PNP_GetClassCount",
    3919             :                 sizeof(struct PNP_GetClassCount),
    3920             :                 (ndr_push_flags_fn_t) ndr_push_PNP_GetClassCount,
    3921             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_GetClassCount,
    3922             :                 (ndr_print_function_t) ndr_print_PNP_GetClassCount,
    3923             :                 { 0, NULL },
    3924             :                 { 0, NULL },
    3925             :         },
    3926             :         {
    3927             :                 "PNP_GetClassName",
    3928             :                 sizeof(struct PNP_GetClassName),
    3929             :                 (ndr_push_flags_fn_t) ndr_push_PNP_GetClassName,
    3930             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_GetClassName,
    3931             :                 (ndr_print_function_t) ndr_print_PNP_GetClassName,
    3932             :                 { 0, NULL },
    3933             :                 { 0, NULL },
    3934             :         },
    3935             :         {
    3936             :                 "PNP_DeleteClassKey",
    3937             :                 sizeof(struct PNP_DeleteClassKey),
    3938             :                 (ndr_push_flags_fn_t) ndr_push_PNP_DeleteClassKey,
    3939             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_DeleteClassKey,
    3940             :                 (ndr_print_function_t) ndr_print_PNP_DeleteClassKey,
    3941             :                 { 0, NULL },
    3942             :                 { 0, NULL },
    3943             :         },
    3944             :         {
    3945             :                 "PNP_GetInterfaceDeviceAlias",
    3946             :                 sizeof(struct PNP_GetInterfaceDeviceAlias),
    3947             :                 (ndr_push_flags_fn_t) ndr_push_PNP_GetInterfaceDeviceAlias,
    3948             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_GetInterfaceDeviceAlias,
    3949             :                 (ndr_print_function_t) ndr_print_PNP_GetInterfaceDeviceAlias,
    3950             :                 { 0, NULL },
    3951             :                 { 0, NULL },
    3952             :         },
    3953             :         {
    3954             :                 "PNP_GetInterfaceDeviceList",
    3955             :                 sizeof(struct PNP_GetInterfaceDeviceList),
    3956             :                 (ndr_push_flags_fn_t) ndr_push_PNP_GetInterfaceDeviceList,
    3957             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_GetInterfaceDeviceList,
    3958             :                 (ndr_print_function_t) ndr_print_PNP_GetInterfaceDeviceList,
    3959             :                 { 0, NULL },
    3960             :                 { 0, NULL },
    3961             :         },
    3962             :         {
    3963             :                 "PNP_GetInterfaceDeviceListSize",
    3964             :                 sizeof(struct PNP_GetInterfaceDeviceListSize),
    3965             :                 (ndr_push_flags_fn_t) ndr_push_PNP_GetInterfaceDeviceListSize,
    3966             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_GetInterfaceDeviceListSize,
    3967             :                 (ndr_print_function_t) ndr_print_PNP_GetInterfaceDeviceListSize,
    3968             :                 { 0, NULL },
    3969             :                 { 0, NULL },
    3970             :         },
    3971             :         {
    3972             :                 "PNP_RegisterDeviceClassAssociation",
    3973             :                 sizeof(struct PNP_RegisterDeviceClassAssociation),
    3974             :                 (ndr_push_flags_fn_t) ndr_push_PNP_RegisterDeviceClassAssociation,
    3975             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_RegisterDeviceClassAssociation,
    3976             :                 (ndr_print_function_t) ndr_print_PNP_RegisterDeviceClassAssociation,
    3977             :                 { 0, NULL },
    3978             :                 { 0, NULL },
    3979             :         },
    3980             :         {
    3981             :                 "PNP_UnregisterDeviceClassAssociation",
    3982             :                 sizeof(struct PNP_UnregisterDeviceClassAssociation),
    3983             :                 (ndr_push_flags_fn_t) ndr_push_PNP_UnregisterDeviceClassAssociation,
    3984             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_UnregisterDeviceClassAssociation,
    3985             :                 (ndr_print_function_t) ndr_print_PNP_UnregisterDeviceClassAssociation,
    3986             :                 { 0, NULL },
    3987             :                 { 0, NULL },
    3988             :         },
    3989             :         {
    3990             :                 "PNP_GetClassRegProp",
    3991             :                 sizeof(struct PNP_GetClassRegProp),
    3992             :                 (ndr_push_flags_fn_t) ndr_push_PNP_GetClassRegProp,
    3993             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_GetClassRegProp,
    3994             :                 (ndr_print_function_t) ndr_print_PNP_GetClassRegProp,
    3995             :                 { 0, NULL },
    3996             :                 { 0, NULL },
    3997             :         },
    3998             :         {
    3999             :                 "PNP_SetClassRegProp",
    4000             :                 sizeof(struct PNP_SetClassRegProp),
    4001             :                 (ndr_push_flags_fn_t) ndr_push_PNP_SetClassRegProp,
    4002             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_SetClassRegProp,
    4003             :                 (ndr_print_function_t) ndr_print_PNP_SetClassRegProp,
    4004             :                 { 0, NULL },
    4005             :                 { 0, NULL },
    4006             :         },
    4007             :         {
    4008             :                 "PNP_CreateDevInst",
    4009             :                 sizeof(struct PNP_CreateDevInst),
    4010             :                 (ndr_push_flags_fn_t) ndr_push_PNP_CreateDevInst,
    4011             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_CreateDevInst,
    4012             :                 (ndr_print_function_t) ndr_print_PNP_CreateDevInst,
    4013             :                 { 0, NULL },
    4014             :                 { 0, NULL },
    4015             :         },
    4016             :         {
    4017             :                 "PNP_DeviceInstanceAction",
    4018             :                 sizeof(struct PNP_DeviceInstanceAction),
    4019             :                 (ndr_push_flags_fn_t) ndr_push_PNP_DeviceInstanceAction,
    4020             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_DeviceInstanceAction,
    4021             :                 (ndr_print_function_t) ndr_print_PNP_DeviceInstanceAction,
    4022             :                 { 0, NULL },
    4023             :                 { 0, NULL },
    4024             :         },
    4025             :         {
    4026             :                 "PNP_GetDeviceStatus",
    4027             :                 sizeof(struct PNP_GetDeviceStatus),
    4028             :                 (ndr_push_flags_fn_t) ndr_push_PNP_GetDeviceStatus,
    4029             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_GetDeviceStatus,
    4030             :                 (ndr_print_function_t) ndr_print_PNP_GetDeviceStatus,
    4031             :                 { 0, NULL },
    4032             :                 { 0, NULL },
    4033             :         },
    4034             :         {
    4035             :                 "PNP_SetDeviceProblem",
    4036             :                 sizeof(struct PNP_SetDeviceProblem),
    4037             :                 (ndr_push_flags_fn_t) ndr_push_PNP_SetDeviceProblem,
    4038             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_SetDeviceProblem,
    4039             :                 (ndr_print_function_t) ndr_print_PNP_SetDeviceProblem,
    4040             :                 { 0, NULL },
    4041             :                 { 0, NULL },
    4042             :         },
    4043             :         {
    4044             :                 "PNP_DisableDevInst",
    4045             :                 sizeof(struct PNP_DisableDevInst),
    4046             :                 (ndr_push_flags_fn_t) ndr_push_PNP_DisableDevInst,
    4047             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_DisableDevInst,
    4048             :                 (ndr_print_function_t) ndr_print_PNP_DisableDevInst,
    4049             :                 { 0, NULL },
    4050             :                 { 0, NULL },
    4051             :         },
    4052             :         {
    4053             :                 "PNP_UninstallDevInst",
    4054             :                 sizeof(struct PNP_UninstallDevInst),
    4055             :                 (ndr_push_flags_fn_t) ndr_push_PNP_UninstallDevInst,
    4056             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_UninstallDevInst,
    4057             :                 (ndr_print_function_t) ndr_print_PNP_UninstallDevInst,
    4058             :                 { 0, NULL },
    4059             :                 { 0, NULL },
    4060             :         },
    4061             :         {
    4062             :                 "PNP_AddID",
    4063             :                 sizeof(struct PNP_AddID),
    4064             :                 (ndr_push_flags_fn_t) ndr_push_PNP_AddID,
    4065             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_AddID,
    4066             :                 (ndr_print_function_t) ndr_print_PNP_AddID,
    4067             :                 { 0, NULL },
    4068             :                 { 0, NULL },
    4069             :         },
    4070             :         {
    4071             :                 "PNP_RegisterDriver",
    4072             :                 sizeof(struct PNP_RegisterDriver),
    4073             :                 (ndr_push_flags_fn_t) ndr_push_PNP_RegisterDriver,
    4074             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_RegisterDriver,
    4075             :                 (ndr_print_function_t) ndr_print_PNP_RegisterDriver,
    4076             :                 { 0, NULL },
    4077             :                 { 0, NULL },
    4078             :         },
    4079             :         {
    4080             :                 "PNP_QueryRemove",
    4081             :                 sizeof(struct PNP_QueryRemove),
    4082             :                 (ndr_push_flags_fn_t) ndr_push_PNP_QueryRemove,
    4083             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_QueryRemove,
    4084             :                 (ndr_print_function_t) ndr_print_PNP_QueryRemove,
    4085             :                 { 0, NULL },
    4086             :                 { 0, NULL },
    4087             :         },
    4088             :         {
    4089             :                 "PNP_RequestDeviceEject",
    4090             :                 sizeof(struct PNP_RequestDeviceEject),
    4091             :                 (ndr_push_flags_fn_t) ndr_push_PNP_RequestDeviceEject,
    4092             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_RequestDeviceEject,
    4093             :                 (ndr_print_function_t) ndr_print_PNP_RequestDeviceEject,
    4094             :                 { 0, NULL },
    4095             :                 { 0, NULL },
    4096             :         },
    4097             :         {
    4098             :                 "PNP_IsDockStationPresent",
    4099             :                 sizeof(struct PNP_IsDockStationPresent),
    4100             :                 (ndr_push_flags_fn_t) ndr_push_PNP_IsDockStationPresent,
    4101             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_IsDockStationPresent,
    4102             :                 (ndr_print_function_t) ndr_print_PNP_IsDockStationPresent,
    4103             :                 { 0, NULL },
    4104             :                 { 0, NULL },
    4105             :         },
    4106             :         {
    4107             :                 "PNP_RequestEjectPC",
    4108             :                 sizeof(struct PNP_RequestEjectPC),
    4109             :                 (ndr_push_flags_fn_t) ndr_push_PNP_RequestEjectPC,
    4110             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_RequestEjectPC,
    4111             :                 (ndr_print_function_t) ndr_print_PNP_RequestEjectPC,
    4112             :                 { 0, NULL },
    4113             :                 { 0, NULL },
    4114             :         },
    4115             :         {
    4116             :                 "PNP_HwProfFlags",
    4117             :                 sizeof(struct PNP_HwProfFlags),
    4118             :                 (ndr_push_flags_fn_t) ndr_push_PNP_HwProfFlags,
    4119             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_HwProfFlags,
    4120             :                 (ndr_print_function_t) ndr_print_PNP_HwProfFlags,
    4121             :                 { 0, NULL },
    4122             :                 { 0, NULL },
    4123             :         },
    4124             :         {
    4125             :                 "PNP_GetHwProfInfo",
    4126             :                 sizeof(struct PNP_GetHwProfInfo),
    4127             :                 (ndr_push_flags_fn_t) ndr_push_PNP_GetHwProfInfo,
    4128             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_GetHwProfInfo,
    4129             :                 (ndr_print_function_t) ndr_print_PNP_GetHwProfInfo,
    4130             :                 { 0, NULL },
    4131             :                 { 0, NULL },
    4132             :         },
    4133             :         {
    4134             :                 "PNP_AddEmptyLogConf",
    4135             :                 sizeof(struct PNP_AddEmptyLogConf),
    4136             :                 (ndr_push_flags_fn_t) ndr_push_PNP_AddEmptyLogConf,
    4137             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_AddEmptyLogConf,
    4138             :                 (ndr_print_function_t) ndr_print_PNP_AddEmptyLogConf,
    4139             :                 { 0, NULL },
    4140             :                 { 0, NULL },
    4141             :         },
    4142             :         {
    4143             :                 "PNP_FreeLogConf",
    4144             :                 sizeof(struct PNP_FreeLogConf),
    4145             :                 (ndr_push_flags_fn_t) ndr_push_PNP_FreeLogConf,
    4146             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_FreeLogConf,
    4147             :                 (ndr_print_function_t) ndr_print_PNP_FreeLogConf,
    4148             :                 { 0, NULL },
    4149             :                 { 0, NULL },
    4150             :         },
    4151             :         {
    4152             :                 "PNP_GetFirstLogConf",
    4153             :                 sizeof(struct PNP_GetFirstLogConf),
    4154             :                 (ndr_push_flags_fn_t) ndr_push_PNP_GetFirstLogConf,
    4155             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_GetFirstLogConf,
    4156             :                 (ndr_print_function_t) ndr_print_PNP_GetFirstLogConf,
    4157             :                 { 0, NULL },
    4158             :                 { 0, NULL },
    4159             :         },
    4160             :         {
    4161             :                 "PNP_GetNextLogConf",
    4162             :                 sizeof(struct PNP_GetNextLogConf),
    4163             :                 (ndr_push_flags_fn_t) ndr_push_PNP_GetNextLogConf,
    4164             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_GetNextLogConf,
    4165             :                 (ndr_print_function_t) ndr_print_PNP_GetNextLogConf,
    4166             :                 { 0, NULL },
    4167             :                 { 0, NULL },
    4168             :         },
    4169             :         {
    4170             :                 "PNP_GetLogConfPriority",
    4171             :                 sizeof(struct PNP_GetLogConfPriority),
    4172             :                 (ndr_push_flags_fn_t) ndr_push_PNP_GetLogConfPriority,
    4173             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_GetLogConfPriority,
    4174             :                 (ndr_print_function_t) ndr_print_PNP_GetLogConfPriority,
    4175             :                 { 0, NULL },
    4176             :                 { 0, NULL },
    4177             :         },
    4178             :         {
    4179             :                 "PNP_AddResDes",
    4180             :                 sizeof(struct PNP_AddResDes),
    4181             :                 (ndr_push_flags_fn_t) ndr_push_PNP_AddResDes,
    4182             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_AddResDes,
    4183             :                 (ndr_print_function_t) ndr_print_PNP_AddResDes,
    4184             :                 { 0, NULL },
    4185             :                 { 0, NULL },
    4186             :         },
    4187             :         {
    4188             :                 "PNP_FreeResDes",
    4189             :                 sizeof(struct PNP_FreeResDes),
    4190             :                 (ndr_push_flags_fn_t) ndr_push_PNP_FreeResDes,
    4191             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_FreeResDes,
    4192             :                 (ndr_print_function_t) ndr_print_PNP_FreeResDes,
    4193             :                 { 0, NULL },
    4194             :                 { 0, NULL },
    4195             :         },
    4196             :         {
    4197             :                 "PNP_GetNextResDes",
    4198             :                 sizeof(struct PNP_GetNextResDes),
    4199             :                 (ndr_push_flags_fn_t) ndr_push_PNP_GetNextResDes,
    4200             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_GetNextResDes,
    4201             :                 (ndr_print_function_t) ndr_print_PNP_GetNextResDes,
    4202             :                 { 0, NULL },
    4203             :                 { 0, NULL },
    4204             :         },
    4205             :         {
    4206             :                 "PNP_GetResDesData",
    4207             :                 sizeof(struct PNP_GetResDesData),
    4208             :                 (ndr_push_flags_fn_t) ndr_push_PNP_GetResDesData,
    4209             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_GetResDesData,
    4210             :                 (ndr_print_function_t) ndr_print_PNP_GetResDesData,
    4211             :                 { 0, NULL },
    4212             :                 { 0, NULL },
    4213             :         },
    4214             :         {
    4215             :                 "PNP_GetResDesDataSize",
    4216             :                 sizeof(struct PNP_GetResDesDataSize),
    4217             :                 (ndr_push_flags_fn_t) ndr_push_PNP_GetResDesDataSize,
    4218             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_GetResDesDataSize,
    4219             :                 (ndr_print_function_t) ndr_print_PNP_GetResDesDataSize,
    4220             :                 { 0, NULL },
    4221             :                 { 0, NULL },
    4222             :         },
    4223             :         {
    4224             :                 "PNP_ModifyResDes",
    4225             :                 sizeof(struct PNP_ModifyResDes),
    4226             :                 (ndr_push_flags_fn_t) ndr_push_PNP_ModifyResDes,
    4227             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_ModifyResDes,
    4228             :                 (ndr_print_function_t) ndr_print_PNP_ModifyResDes,
    4229             :                 { 0, NULL },
    4230             :                 { 0, NULL },
    4231             :         },
    4232             :         {
    4233             :                 "PNP_DetectResourceLimit",
    4234             :                 sizeof(struct PNP_DetectResourceLimit),
    4235             :                 (ndr_push_flags_fn_t) ndr_push_PNP_DetectResourceLimit,
    4236             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_DetectResourceLimit,
    4237             :                 (ndr_print_function_t) ndr_print_PNP_DetectResourceLimit,
    4238             :                 { 0, NULL },
    4239             :                 { 0, NULL },
    4240             :         },
    4241             :         {
    4242             :                 "PNP_QueryResConfList",
    4243             :                 sizeof(struct PNP_QueryResConfList),
    4244             :                 (ndr_push_flags_fn_t) ndr_push_PNP_QueryResConfList,
    4245             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_QueryResConfList,
    4246             :                 (ndr_print_function_t) ndr_print_PNP_QueryResConfList,
    4247             :                 { 0, NULL },
    4248             :                 { 0, NULL },
    4249             :         },
    4250             :         {
    4251             :                 "PNP_SetHwProf",
    4252             :                 sizeof(struct PNP_SetHwProf),
    4253             :                 (ndr_push_flags_fn_t) ndr_push_PNP_SetHwProf,
    4254             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_SetHwProf,
    4255             :                 (ndr_print_function_t) ndr_print_PNP_SetHwProf,
    4256             :                 { 0, NULL },
    4257             :                 { 0, NULL },
    4258             :         },
    4259             :         {
    4260             :                 "PNP_QueryArbitratorFreeData",
    4261             :                 sizeof(struct PNP_QueryArbitratorFreeData),
    4262             :                 (ndr_push_flags_fn_t) ndr_push_PNP_QueryArbitratorFreeData,
    4263             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_QueryArbitratorFreeData,
    4264             :                 (ndr_print_function_t) ndr_print_PNP_QueryArbitratorFreeData,
    4265             :                 { 0, NULL },
    4266             :                 { 0, NULL },
    4267             :         },
    4268             :         {
    4269             :                 "PNP_QueryArbitratorFreeSize",
    4270             :                 sizeof(struct PNP_QueryArbitratorFreeSize),
    4271             :                 (ndr_push_flags_fn_t) ndr_push_PNP_QueryArbitratorFreeSize,
    4272             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_QueryArbitratorFreeSize,
    4273             :                 (ndr_print_function_t) ndr_print_PNP_QueryArbitratorFreeSize,
    4274             :                 { 0, NULL },
    4275             :                 { 0, NULL },
    4276             :         },
    4277             :         {
    4278             :                 "PNP_RunDetection",
    4279             :                 sizeof(struct PNP_RunDetection),
    4280             :                 (ndr_push_flags_fn_t) ndr_push_PNP_RunDetection,
    4281             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_RunDetection,
    4282             :                 (ndr_print_function_t) ndr_print_PNP_RunDetection,
    4283             :                 { 0, NULL },
    4284             :                 { 0, NULL },
    4285             :         },
    4286             :         {
    4287             :                 "PNP_RegisterNotification",
    4288             :                 sizeof(struct PNP_RegisterNotification),
    4289             :                 (ndr_push_flags_fn_t) ndr_push_PNP_RegisterNotification,
    4290             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_RegisterNotification,
    4291             :                 (ndr_print_function_t) ndr_print_PNP_RegisterNotification,
    4292             :                 { 0, NULL },
    4293             :                 { 0, NULL },
    4294             :         },
    4295             :         {
    4296             :                 "PNP_UnregisterNotification",
    4297             :                 sizeof(struct PNP_UnregisterNotification),
    4298             :                 (ndr_push_flags_fn_t) ndr_push_PNP_UnregisterNotification,
    4299             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_UnregisterNotification,
    4300             :                 (ndr_print_function_t) ndr_print_PNP_UnregisterNotification,
    4301             :                 { 0, NULL },
    4302             :                 { 0, NULL },
    4303             :         },
    4304             :         {
    4305             :                 "PNP_GetCustomDevProp",
    4306             :                 sizeof(struct PNP_GetCustomDevProp),
    4307             :                 (ndr_push_flags_fn_t) ndr_push_PNP_GetCustomDevProp,
    4308             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_GetCustomDevProp,
    4309             :                 (ndr_print_function_t) ndr_print_PNP_GetCustomDevProp,
    4310             :                 { 0, NULL },
    4311             :                 { 0, NULL },
    4312             :         },
    4313             :         {
    4314             :                 "PNP_GetVersionInternal",
    4315             :                 sizeof(struct PNP_GetVersionInternal),
    4316             :                 (ndr_push_flags_fn_t) ndr_push_PNP_GetVersionInternal,
    4317             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_GetVersionInternal,
    4318             :                 (ndr_print_function_t) ndr_print_PNP_GetVersionInternal,
    4319             :                 { 0, NULL },
    4320             :                 { 0, NULL },
    4321             :         },
    4322             :         {
    4323             :                 "PNP_GetBlockedDriverInfo",
    4324             :                 sizeof(struct PNP_GetBlockedDriverInfo),
    4325             :                 (ndr_push_flags_fn_t) ndr_push_PNP_GetBlockedDriverInfo,
    4326             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_GetBlockedDriverInfo,
    4327             :                 (ndr_print_function_t) ndr_print_PNP_GetBlockedDriverInfo,
    4328             :                 { 0, NULL },
    4329             :                 { 0, NULL },
    4330             :         },
    4331             :         {
    4332             :                 "PNP_GetServerSideDeviceInstallFlags",
    4333             :                 sizeof(struct PNP_GetServerSideDeviceInstallFlags),
    4334             :                 (ndr_push_flags_fn_t) ndr_push_PNP_GetServerSideDeviceInstallFlags,
    4335             :                 (ndr_pull_flags_fn_t) ndr_pull_PNP_GetServerSideDeviceInstallFlags,
    4336             :                 (ndr_print_function_t) ndr_print_PNP_GetServerSideDeviceInstallFlags,
    4337             :                 { 0, NULL },
    4338             :                 { 0, NULL },
    4339             :         },
    4340             :         { .name = NULL }
    4341             : };
    4342             : 
    4343             : static const char * const ntsvcs_endpoint_strings[] = {
    4344             :         "ncacn_np:[\\pipe\\ntsvcs]", 
    4345             :         "ncacn_np:[\\pipe\\plugplay]", 
    4346             : };
    4347             : 
    4348             : static const struct ndr_interface_string_array ntsvcs_endpoints = {
    4349             :         .count  = 2,
    4350             :         .names  = ntsvcs_endpoint_strings
    4351             : };
    4352             : 
    4353             : static const char * const ntsvcs_authservice_strings[] = {
    4354             :         "host", 
    4355             : };
    4356             : 
    4357             : static const struct ndr_interface_string_array ntsvcs_authservices = {
    4358             :         .count  = 1,
    4359             :         .names  = ntsvcs_authservice_strings
    4360             : };
    4361             : 
    4362             : 
    4363             : const struct ndr_interface_table ndr_table_ntsvcs = {
    4364             :         .name           = "ntsvcs",
    4365             :         .syntax_id      = {
    4366             :                 {0x8d9f4e40,0xa03d,0x11ce,{0x8f,0x69},{0x08,0x00,0x3e,0x30,0x05,0x1b}},
    4367             :                 NDR_NTSVCS_VERSION
    4368             :         },
    4369             :         .helpstring     = NDR_NTSVCS_HELPSTRING,
    4370             :         .num_calls      = 65,
    4371             :         .calls          = ntsvcs_calls,
    4372             :         .num_public_structs     = 0,
    4373             :         .public_structs         = ntsvcs_public_structs,
    4374             :         .endpoints      = &ntsvcs_endpoints,
    4375             :         .authservices   = &ntsvcs_authservices
    4376             : };
    4377             : 
    4378             : #endif /* SKIP_NDR_TABLE_ntsvcs */

Generated by: LCOV version 1.14