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