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