librpc/gen_ndr/ndr_ntsvcs.c

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