librpc/gen_ndr/ndr_ntsvcs.c

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