librpc/gen_ndr/ndr_ntsvcs.c

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