librpc/gen_ndr/ndr_ntsvcs.c

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