bin.gen_ndr/default/librpc/gen_ndr/ndr_ntsvcs.c

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