bin/default/librpc/gen_ndr/ndr_backupkey.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "bin/default/librpc/gen_ndr/ndr_backupkey.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 #include "librpc/gen_ndr/ndr_security.h"
   8 _PUBLIC_ enum ndr_err_code ndr_push_bkrp_exported_RSA_key_pair(struct ndr_push *ndr, int ndr_flags, const struct bkrp_exported_RSA_key_pair *r)
   9 {
  10         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
  11         if (ndr_flags & NDR_SCALARS) {
  12                 NDR_CHECK(ndr_push_align(ndr, 4));
  13                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
  14                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000494));
  15                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->certificate_len));
  16                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000207));
  17                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x0000A400));
  18                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x32415352));
  19                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000800));
  20                 {
  21                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
  22                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
  23                         {
  24                                 struct ndr_push *_ndr_public_exponent;
  25                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_public_exponent, 0, 4));
  26                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_public_exponent, NDR_SCALARS, r->public_exponent));
  27                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_public_exponent, 0, 4));
  28                         }
  29                         ndr->flags = _flags_save_DATA_BLOB;
  30                 }
  31                 {
  32                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
  33                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
  34                         {
  35                                 struct ndr_push *_ndr_modulus;
  36                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_modulus, 0, 256));
  37                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_modulus, NDR_SCALARS, r->modulus));
  38                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_modulus, 0, 256));
  39                         }
  40                         ndr->flags = _flags_save_DATA_BLOB;
  41                 }
  42                 {
  43                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
  44                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
  45                         {
  46                                 struct ndr_push *_ndr_prime1;
  47                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_prime1, 0, 128));
  48                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_prime1, NDR_SCALARS, r->prime1));
  49                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_prime1, 0, 128));
  50                         }
  51                         ndr->flags = _flags_save_DATA_BLOB;
  52                 }
  53                 {
  54                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
  55                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
  56                         {
  57                                 struct ndr_push *_ndr_prime2;
  58                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_prime2, 0, 128));
  59                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_prime2, NDR_SCALARS, r->prime2));
  60                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_prime2, 0, 128));
  61                         }
  62                         ndr->flags = _flags_save_DATA_BLOB;
  63                 }
  64                 {
  65                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
  66                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
  67                         {
  68                                 struct ndr_push *_ndr_exponent1;
  69                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_exponent1, 0, 128));
  70                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_exponent1, NDR_SCALARS, r->exponent1));
  71                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_exponent1, 0, 128));
  72                         }
  73                         ndr->flags = _flags_save_DATA_BLOB;
  74                 }
  75                 {
  76                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
  77                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
  78                         {
  79                                 struct ndr_push *_ndr_exponent2;
  80                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_exponent2, 0, 128));
  81                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_exponent2, NDR_SCALARS, r->exponent2));
  82                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_exponent2, 0, 128));
  83                         }
  84                         ndr->flags = _flags_save_DATA_BLOB;
  85                 }
  86                 {
  87                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
  88                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
  89                         {
  90                                 struct ndr_push *_ndr_coefficient;
  91                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_coefficient, 0, 128));
  92                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_coefficient, NDR_SCALARS, r->coefficient));
  93                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_coefficient, 0, 128));
  94                         }
  95                         ndr->flags = _flags_save_DATA_BLOB;
  96                 }
  97                 {
  98                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
  99                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 100                         {
 101                                 struct ndr_push *_ndr_private_exponent;
 102                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_private_exponent, 0, 256));
 103                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_private_exponent, NDR_SCALARS, r->private_exponent));
 104                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_private_exponent, 0, 256));
 105                         }
 106                         ndr->flags = _flags_save_DATA_BLOB;
 107                 }
 108                 {
 109                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 110                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 111                         {
 112                                 struct ndr_push *_ndr_cert;
 113                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_cert, 0, r->certificate_len));
 114                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_cert, NDR_SCALARS, r->cert));
 115                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_cert, 0, r->certificate_len));
 116                         }
 117                         ndr->flags = _flags_save_DATA_BLOB;
 118                 }
 119                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 120         }
 121         if (ndr_flags & NDR_BUFFERS) {
 122         }
 123         return NDR_ERR_SUCCESS;
 124 }
 125
 126 _PUBLIC_ enum ndr_err_code ndr_pull_bkrp_exported_RSA_key_pair(struct ndr_pull *ndr, int ndr_flags, struct bkrp_exported_RSA_key_pair *r)
 127 {
 128         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 129         if (ndr_flags & NDR_SCALARS) {
 130                 NDR_CHECK(ndr_pull_align(ndr, 4));
 131                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->header1));
 132                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->header2));
 133                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->certificate_len));
 134                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->magic1));
 135                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->magic2));
 136                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->magic3));
 137                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->magic4));
 138                 {
 139                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 140                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 141                         {
 142                                 struct ndr_pull *_ndr_public_exponent;
 143                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_public_exponent, 0, 4));
 144                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_public_exponent, NDR_SCALARS, &r->public_exponent));
 145                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_public_exponent, 0, 4));
 146                         }
 147                         ndr->flags = _flags_save_DATA_BLOB;
 148                 }
 149                 {
 150                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 151                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 152                         {
 153                                 struct ndr_pull *_ndr_modulus;
 154                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_modulus, 0, 256));
 155                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_modulus, NDR_SCALARS, &r->modulus));
 156                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_modulus, 0, 256));
 157                         }
 158                         ndr->flags = _flags_save_DATA_BLOB;
 159                 }
 160                 {
 161                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 162                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 163                         {
 164                                 struct ndr_pull *_ndr_prime1;
 165                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_prime1, 0, 128));
 166                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_prime1, NDR_SCALARS, &r->prime1));
 167                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_prime1, 0, 128));
 168                         }
 169                         ndr->flags = _flags_save_DATA_BLOB;
 170                 }
 171                 {
 172                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 173                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 174                         {
 175                                 struct ndr_pull *_ndr_prime2;
 176                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_prime2, 0, 128));
 177                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_prime2, NDR_SCALARS, &r->prime2));
 178                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_prime2, 0, 128));
 179                         }
 180                         ndr->flags = _flags_save_DATA_BLOB;
 181                 }
 182                 {
 183                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 184                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 185                         {
 186                                 struct ndr_pull *_ndr_exponent1;
 187                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_exponent1, 0, 128));
 188                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_exponent1, NDR_SCALARS, &r->exponent1));
 189                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_exponent1, 0, 128));
 190                         }
 191                         ndr->flags = _flags_save_DATA_BLOB;
 192                 }
 193                 {
 194                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 195                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 196                         {
 197                                 struct ndr_pull *_ndr_exponent2;
 198                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_exponent2, 0, 128));
 199                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_exponent2, NDR_SCALARS, &r->exponent2));
 200                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_exponent2, 0, 128));
 201                         }
 202                         ndr->flags = _flags_save_DATA_BLOB;
 203                 }
 204                 {
 205                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 206                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 207                         {
 208                                 struct ndr_pull *_ndr_coefficient;
 209                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_coefficient, 0, 128));
 210                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_coefficient, NDR_SCALARS, &r->coefficient));
 211                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_coefficient, 0, 128));
 212                         }
 213                         ndr->flags = _flags_save_DATA_BLOB;
 214                 }
 215                 {
 216                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 217                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 218                         {
 219                                 struct ndr_pull *_ndr_private_exponent;
 220                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_private_exponent, 0, 256));
 221                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_private_exponent, NDR_SCALARS, &r->private_exponent));
 222                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_private_exponent, 0, 256));
 223                         }
 224                         ndr->flags = _flags_save_DATA_BLOB;
 225                 }
 226                 {
 227                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 228                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 229                         {
 230                                 struct ndr_pull *_ndr_cert;
 231                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_cert, 0, r->certificate_len));
 232                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_cert, NDR_SCALARS, &r->cert));
 233                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_cert, 0, r->certificate_len));
 234                         }
 235                         ndr->flags = _flags_save_DATA_BLOB;
 236                 }
 237                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 238         }
 239         if (ndr_flags & NDR_BUFFERS) {
 240         }
 241         return NDR_ERR_SUCCESS;
 242 }
 243
 244 _PUBLIC_ void ndr_print_bkrp_exported_RSA_key_pair(struct ndr_print *ndr, const char *name, const struct bkrp_exported_RSA_key_pair *r)
 245 {
 246         ndr_print_struct(ndr, name, "bkrp_exported_RSA_key_pair");
 247         if (r == NULL) { ndr_print_null(ndr); return; }
 248         ndr->depth++;
 249         ndr_print_uint32(ndr, "header1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->header1);
 250         ndr_print_uint32(ndr, "header2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000494:r->header2);
 251         ndr_print_uint32(ndr, "certificate_len", r->certificate_len);
 252         ndr_print_uint32(ndr, "magic1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000207:r->magic1);
 253         ndr_print_uint32(ndr, "magic2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x0000A400:r->magic2);
 254         ndr_print_uint32(ndr, "magic3", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x32415352:r->magic3);
 255         ndr_print_uint32(ndr, "magic4", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000800:r->magic4);
 256         ndr_print_DATA_BLOB(ndr, "public_exponent", r->public_exponent);
 257         ndr_print_DATA_BLOB(ndr, "modulus", r->modulus);
 258         ndr_print_DATA_BLOB(ndr, "prime1", r->prime1);
 259         ndr_print_DATA_BLOB(ndr, "prime2", r->prime2);
 260         ndr_print_DATA_BLOB(ndr, "exponent1", r->exponent1);
 261         ndr_print_DATA_BLOB(ndr, "exponent2", r->exponent2);
 262         ndr_print_DATA_BLOB(ndr, "coefficient", r->coefficient);
 263         ndr_print_DATA_BLOB(ndr, "private_exponent", r->private_exponent);
 264         ndr_print_DATA_BLOB(ndr, "cert", r->cert);
 265         ndr->depth--;
 266 }
 267
 268 _PUBLIC_ enum ndr_err_code ndr_push_bkrp_dc_serverwrap_key(struct ndr_push *ndr, int ndr_flags, const struct bkrp_dc_serverwrap_key *r)
 269 {
 270         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 271         if (ndr_flags & NDR_SCALARS) {
 272                 NDR_CHECK(ndr_push_align(ndr, 4));
 273                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
 274                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->key, 256));
 275                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 276         }
 277         if (ndr_flags & NDR_BUFFERS) {
 278         }
 279         return NDR_ERR_SUCCESS;
 280 }
 281
 282 _PUBLIC_ enum ndr_err_code ndr_pull_bkrp_dc_serverwrap_key(struct ndr_pull *ndr, int ndr_flags, struct bkrp_dc_serverwrap_key *r)
 283 {
 284         uint32_t size_key_0 = 0;
 285         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 286         if (ndr_flags & NDR_SCALARS) {
 287                 NDR_CHECK(ndr_pull_align(ndr, 4));
 288                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->magic));
 289                 size_key_0 = 256;
 290                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->key, size_key_0));
 291                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 292         }
 293         if (ndr_flags & NDR_BUFFERS) {
 294         }
 295         return NDR_ERR_SUCCESS;
 296 }
 297
 298 _PUBLIC_ void ndr_print_bkrp_dc_serverwrap_key(struct ndr_print *ndr, const char *name, const struct bkrp_dc_serverwrap_key *r)
 299 {
 300         ndr_print_struct(ndr, name, "bkrp_dc_serverwrap_key");
 301         if (r == NULL) { ndr_print_null(ndr); return; }
 302         ndr->depth++;
 303         ndr_print_uint32(ndr, "magic", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->magic);
 304         ndr_print_array_uint8(ndr, "key", r->key, 256);
 305         ndr->depth--;
 306 }
 307
 308 _PUBLIC_ enum ndr_err_code ndr_push_bkrp_client_side_wrapped(struct ndr_push *ndr, int ndr_flags, const struct bkrp_client_side_wrapped *r)
 309 {
 310         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 311         if (ndr_flags & NDR_SCALARS) {
 312                 NDR_CHECK(ndr_push_align(ndr, 4));
 313                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 314                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->encrypted_secret_len));
 315                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->access_check_len));
 316                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
 317                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->encrypted_secret, r->encrypted_secret_len));
 318                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->access_check, r->access_check_len));
 319                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 320         }
 321         if (ndr_flags & NDR_BUFFERS) {
 322         }
 323         return NDR_ERR_SUCCESS;
 324 }
 325
 326 _PUBLIC_ enum ndr_err_code ndr_pull_bkrp_client_side_wrapped(struct ndr_pull *ndr, int ndr_flags, struct bkrp_client_side_wrapped *r)
 327 {
 328         uint32_t size_encrypted_secret_0 = 0;
 329         uint32_t size_access_check_0 = 0;
 330         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 331         if (ndr_flags & NDR_SCALARS) {
 332                 NDR_CHECK(ndr_pull_align(ndr, 4));
 333                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 334                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->encrypted_secret_len));
 335                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->access_check_len));
 336                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
 337                 size_encrypted_secret_0 = r->encrypted_secret_len;
 338                 NDR_PULL_ALLOC_N(ndr, r->encrypted_secret, size_encrypted_secret_0);
 339                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->encrypted_secret, size_encrypted_secret_0));
 340                 size_access_check_0 = r->access_check_len;
 341                 NDR_PULL_ALLOC_N(ndr, r->access_check, size_access_check_0);
 342                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->access_check, size_access_check_0));
 343                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 344         }
 345         if (ndr_flags & NDR_BUFFERS) {
 346         }
 347         return NDR_ERR_SUCCESS;
 348 }
 349
 350 _PUBLIC_ void ndr_print_bkrp_client_side_wrapped(struct ndr_print *ndr, const char *name, const struct bkrp_client_side_wrapped *r)
 351 {
 352         ndr_print_struct(ndr, name, "bkrp_client_side_wrapped");
 353         if (r == NULL) { ndr_print_null(ndr); return; }
 354         ndr->depth++;
 355         ndr_print_uint32(ndr, "version", r->version);
 356         ndr_print_uint32(ndr, "encrypted_secret_len", r->encrypted_secret_len);
 357         ndr_print_uint32(ndr, "access_check_len", r->access_check_len);
 358         ndr_print_GUID(ndr, "guid", &r->guid);
 359         ndr_print_array_uint8(ndr, "encrypted_secret", r->encrypted_secret, r->encrypted_secret_len);
 360         ndr_print_array_uint8(ndr, "access_check", r->access_check, r->access_check_len);
 361         ndr->depth--;
 362 }
 363
 364 _PUBLIC_ size_t ndr_size_bkrp_client_side_wrapped(const struct bkrp_client_side_wrapped *r, int flags)
 365 {
 366         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_bkrp_client_side_wrapped);
 367 }
 368
 369 _PUBLIC_ enum ndr_err_code ndr_push_bkrp_client_side_unwrapped(struct ndr_push *ndr, int ndr_flags, const struct bkrp_client_side_unwrapped *r)
 370 {
 371         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 372         if (ndr_flags & NDR_SCALARS) {
 373                 NDR_CHECK(ndr_push_align(ndr, 4));
 374                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000000));
 375                 {
 376                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 377                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 378                         {
 379                                 struct ndr_push *_ndr_secret;
 380                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secret, 0, -1));
 381                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_secret, NDR_SCALARS, r->secret));
 382                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secret, 0, -1));
 383                         }
 384                         ndr->flags = _flags_save_DATA_BLOB;
 385                 }
 386                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 387         }
 388         if (ndr_flags & NDR_BUFFERS) {
 389         }
 390         return NDR_ERR_SUCCESS;
 391 }
 392
 393 _PUBLIC_ enum ndr_err_code ndr_pull_bkrp_client_side_unwrapped(struct ndr_pull *ndr, int ndr_flags, struct bkrp_client_side_unwrapped *r)
 394 {
 395         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 396         if (ndr_flags & NDR_SCALARS) {
 397                 NDR_CHECK(ndr_pull_align(ndr, 4));
 398                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->magic));
 399                 {
 400                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 401                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 402                         {
 403                                 struct ndr_pull *_ndr_secret;
 404                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secret, 0, -1));
 405                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_secret, NDR_SCALARS, &r->secret));
 406                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secret, 0, -1));
 407                         }
 408                         ndr->flags = _flags_save_DATA_BLOB;
 409                 }
 410                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 411         }
 412         if (ndr_flags & NDR_BUFFERS) {
 413         }
 414         return NDR_ERR_SUCCESS;
 415 }
 416
 417 _PUBLIC_ void ndr_print_bkrp_client_side_unwrapped(struct ndr_print *ndr, const char *name, const struct bkrp_client_side_unwrapped *r)
 418 {
 419         ndr_print_struct(ndr, name, "bkrp_client_side_unwrapped");
 420         if (r == NULL) { ndr_print_null(ndr); return; }
 421         ndr->depth++;
 422         ndr_print_uint32(ndr, "magic", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000000:r->magic);
 423         ndr_print_DATA_BLOB(ndr, "secret", r->secret);
 424         ndr->depth--;
 425 }
 426
 427 _PUBLIC_ enum ndr_err_code ndr_push_bkrp_encrypted_secret_v2(struct ndr_push *ndr, int ndr_flags, const struct bkrp_encrypted_secret_v2 *r)
 428 {
 429         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 430         if (ndr_flags & NDR_SCALARS) {
 431                 NDR_CHECK(ndr_push_align(ndr, 4));
 432                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->secret_len));
 433                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000020));
 434                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->secret, r->secret_len));
 435                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->payload_key, 32));
 436                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 437         }
 438         if (ndr_flags & NDR_BUFFERS) {
 439         }
 440         return NDR_ERR_SUCCESS;
 441 }
 442
 443 _PUBLIC_ enum ndr_err_code ndr_pull_bkrp_encrypted_secret_v2(struct ndr_pull *ndr, int ndr_flags, struct bkrp_encrypted_secret_v2 *r)
 444 {
 445         uint32_t size_secret_0 = 0;
 446         uint32_t size_payload_key_0 = 0;
 447         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 448         if (ndr_flags & NDR_SCALARS) {
 449                 NDR_CHECK(ndr_pull_align(ndr, 4));
 450                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->secret_len));
 451                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->magic));
 452                 size_secret_0 = r->secret_len;
 453                 NDR_PULL_ALLOC_N(ndr, r->secret, size_secret_0);
 454                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->secret, size_secret_0));
 455                 size_payload_key_0 = 32;
 456                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->payload_key, size_payload_key_0));
 457                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 458         }
 459         if (ndr_flags & NDR_BUFFERS) {
 460         }
 461         return NDR_ERR_SUCCESS;
 462 }
 463
 464 _PUBLIC_ void ndr_print_bkrp_encrypted_secret_v2(struct ndr_print *ndr, const char *name, const struct bkrp_encrypted_secret_v2 *r)
 465 {
 466         ndr_print_struct(ndr, name, "bkrp_encrypted_secret_v2");
 467         if (r == NULL) { ndr_print_null(ndr); return; }
 468         ndr->depth++;
 469         ndr_print_uint32(ndr, "secret_len", r->secret_len);
 470         ndr_print_uint32(ndr, "magic", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000020:r->magic);
 471         ndr_print_array_uint8(ndr, "secret", r->secret, r->secret_len);
 472         ndr_print_array_uint8(ndr, "payload_key", r->payload_key, 32);
 473         ndr->depth--;
 474 }
 475
 476 _PUBLIC_ enum ndr_err_code ndr_push_bkrp_encrypted_secret_v3(struct ndr_push *ndr, int ndr_flags, const struct bkrp_encrypted_secret_v3 *r)
 477 {
 478         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 479         if (ndr_flags & NDR_SCALARS) {
 480                 NDR_CHECK(ndr_push_align(ndr, 4));
 481                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->secret_len));
 482                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000030));
 483                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00006610));
 484                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x0000800e));
 485                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->secret, r->secret_len));
 486                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->payload_key, 48));
 487                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 488         }
 489         if (ndr_flags & NDR_BUFFERS) {
 490         }
 491         return NDR_ERR_SUCCESS;
 492 }
 493
 494 _PUBLIC_ enum ndr_err_code ndr_pull_bkrp_encrypted_secret_v3(struct ndr_pull *ndr, int ndr_flags, struct bkrp_encrypted_secret_v3 *r)
 495 {
 496         uint32_t size_secret_0 = 0;
 497         uint32_t size_payload_key_0 = 0;
 498         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 499         if (ndr_flags & NDR_SCALARS) {
 500                 NDR_CHECK(ndr_pull_align(ndr, 4));
 501                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->secret_len));
 502                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->magic1));
 503                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->magic2));
 504                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->magic3));
 505                 size_secret_0 = r->secret_len;
 506                 NDR_PULL_ALLOC_N(ndr, r->secret, size_secret_0);
 507                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->secret, size_secret_0));
 508                 size_payload_key_0 = 48;
 509                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->payload_key, size_payload_key_0));
 510                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 511         }
 512         if (ndr_flags & NDR_BUFFERS) {
 513         }
 514         return NDR_ERR_SUCCESS;
 515 }
 516
 517 _PUBLIC_ void ndr_print_bkrp_encrypted_secret_v3(struct ndr_print *ndr, const char *name, const struct bkrp_encrypted_secret_v3 *r)
 518 {
 519         ndr_print_struct(ndr, name, "bkrp_encrypted_secret_v3");
 520         if (r == NULL) { ndr_print_null(ndr); return; }
 521         ndr->depth++;
 522         ndr_print_uint32(ndr, "secret_len", r->secret_len);
 523         ndr_print_uint32(ndr, "magic1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000030:r->magic1);
 524         ndr_print_uint32(ndr, "magic2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00006610:r->magic2);
 525         ndr_print_uint32(ndr, "magic3", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x0000800e:r->magic3);
 526         ndr_print_array_uint8(ndr, "secret", r->secret, r->secret_len);
 527         ndr_print_array_uint8(ndr, "payload_key", r->payload_key, 48);
 528         ndr->depth--;
 529 }
 530
 531 _PUBLIC_ void ndr_print_bkrp_access_check_v2(struct ndr_print *ndr, const char *name, const struct bkrp_access_check_v2 *r)
 532 {
 533         ndr_print_struct(ndr, name, "bkrp_access_check_v2");
 534         if (r == NULL) { ndr_print_null(ndr); return; }
 535         ndr->depth++;
 536         ndr_print_uint32(ndr, "magic", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->magic);
 537         ndr_print_uint32(ndr, "nonce_len", r->nonce_len);
 538         ndr_print_array_uint8(ndr, "nonce", r->nonce, r->nonce_len);
 539         ndr_print_dom_sid(ndr, "sid", &r->sid);
 540         ndr_print_array_uint8(ndr, "hash", r->hash, 20);
 541         ndr->depth--;
 542 }
 543
 544 _PUBLIC_ void ndr_print_bkrp_access_check_v3(struct ndr_print *ndr, const char *name, const struct bkrp_access_check_v3 *r)
 545 {
 546         ndr_print_struct(ndr, name, "bkrp_access_check_v3");
 547         if (r == NULL) { ndr_print_null(ndr); return; }
 548         ndr->depth++;
 549         ndr_print_uint32(ndr, "magic", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->magic);
 550         ndr_print_uint32(ndr, "nonce_len", r->nonce_len);
 551         ndr_print_array_uint8(ndr, "nonce", r->nonce, r->nonce_len);
 552         ndr_print_dom_sid(ndr, "sid", &r->sid);
 553         ndr_print_array_uint8(ndr, "hash", r->hash, 64);
 554         ndr->depth--;
 555 }
 556
 557 _PUBLIC_ enum ndr_err_code ndr_push_bkrp_data_in_blob(struct ndr_push *ndr, int ndr_flags, const union bkrp_data_in_blob *r)
 558 {
 559         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 560         if (ndr_flags & NDR_SCALARS) {
 561                 uint32_t level = ndr_push_get_switch_value(ndr, r);
 562                 NDR_CHECK(ndr_push_union_align(ndr, 4));
 563                 switch (level) {
 564                         case BACKUPKEY_RESTORE_GUID_INTEGER: {
 565                                 NDR_CHECK(ndr_push_bkrp_client_side_wrapped(ndr, NDR_SCALARS, &r->restore_req));
 566                         break; }
 567
 568                         case BACKUPKEY_RETRIEVE_BACKUP_KEY_GUID_INTEGER: {
 569                                 NDR_CHECK(ndr_push_bkrp_client_side_wrapped(ndr, NDR_SCALARS, &r->cert_req));
 570                         break; }
 571
 572                         default:
 573                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 574                 }
 575         }
 576         if (ndr_flags & NDR_BUFFERS) {
 577                 uint32_t level = ndr_push_get_switch_value(ndr, r);
 578                 switch (level) {
 579                         case BACKUPKEY_RESTORE_GUID_INTEGER:
 580                         break;
 581
 582                         case BACKUPKEY_RETRIEVE_BACKUP_KEY_GUID_INTEGER:
 583                         break;
 584
 585                         default:
 586                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 587                 }
 588         }
 589         return NDR_ERR_SUCCESS;
 590 }
 591
 592 _PUBLIC_ enum ndr_err_code ndr_pull_bkrp_data_in_blob(struct ndr_pull *ndr, int ndr_flags, union bkrp_data_in_blob *r)
 593 {
 594         uint32_t level;
 595         level = ndr_pull_get_switch_value(ndr, r);
 596         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 597         if (ndr_flags & NDR_SCALARS) {
 598                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
 599                 switch (level) {
 600                         case BACKUPKEY_RESTORE_GUID_INTEGER: {
 601                                 NDR_CHECK(ndr_pull_bkrp_client_side_wrapped(ndr, NDR_SCALARS, &r->restore_req));
 602                         break; }
 603
 604                         case BACKUPKEY_RETRIEVE_BACKUP_KEY_GUID_INTEGER: {
 605                                 NDR_CHECK(ndr_pull_bkrp_client_side_wrapped(ndr, NDR_SCALARS, &r->cert_req));
 606                         break; }
 607
 608                         default:
 609                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 610                 }
 611         }
 612         if (ndr_flags & NDR_BUFFERS) {
 613                 switch (level) {
 614                         case BACKUPKEY_RESTORE_GUID_INTEGER:
 615                         break;
 616
 617                         case BACKUPKEY_RETRIEVE_BACKUP_KEY_GUID_INTEGER:
 618                         break;
 619
 620                         default:
 621                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 622                 }
 623         }
 624         return NDR_ERR_SUCCESS;
 625 }
 626
 627 _PUBLIC_ void ndr_print_bkrp_data_in_blob(struct ndr_print *ndr, const char *name, const union bkrp_data_in_blob *r)
 628 {
 629         uint32_t level;
 630         level = ndr_print_get_switch_value(ndr, r);
 631         ndr_print_union(ndr, name, level, "bkrp_data_in_blob");
 632         switch (level) {
 633                 case BACKUPKEY_RESTORE_GUID_INTEGER:
 634                         ndr_print_bkrp_client_side_wrapped(ndr, "restore_req", &r->restore_req);
 635                 break;
 636
 637                 case BACKUPKEY_RETRIEVE_BACKUP_KEY_GUID_INTEGER:
 638                         ndr_print_bkrp_client_side_wrapped(ndr, "cert_req", &r->cert_req);
 639                 break;
 640
 641                 default:
 642                         ndr_print_bad_level(ndr, name, level);
 643         }
 644 }
 645
 646 _PUBLIC_ enum ndr_err_code ndr_push_bkrp_BackupKey(struct ndr_push *ndr, int flags, const struct bkrp_BackupKey *r)
 647 {
 648         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
 649         if (flags & NDR_IN) {
 650                 if (r->in.guidActionAgent == NULL) {
 651                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 652                 }
 653                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->in.guidActionAgent));
 654                 if (r->in.data_in == NULL) {
 655                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 656                 }
 657                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_in_len));
 658                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.data_in, r->in.data_in_len));
 659                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_in_len));
 660                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.param));
 661         }
 662         if (flags & NDR_OUT) {
 663                 if (r->out.data_out == NULL) {
 664                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 665                 }
 666                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.data_out));
 667                 if (*r->out.data_out) {
 668                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.data_out_len));
 669                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, *r->out.data_out, *r->out.data_out_len));
 670                 }
 671                 if (r->out.data_out_len == NULL) {
 672                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 673                 }
 674                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_out_len));
 675                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 676         }
 677         return NDR_ERR_SUCCESS;
 678 }
 679
 680 _PUBLIC_ enum ndr_err_code ndr_pull_bkrp_BackupKey(struct ndr_pull *ndr, int flags, struct bkrp_BackupKey *r)
 681 {
 682         uint32_t size_data_in_1 = 0;
 683         uint32_t _ptr_data_out;
 684         uint32_t size_data_out_2 = 0;
 685         TALLOC_CTX *_mem_save_guidActionAgent_0;
 686         TALLOC_CTX *_mem_save_data_out_0;
 687         TALLOC_CTX *_mem_save_data_out_1;
 688         TALLOC_CTX *_mem_save_data_out_len_0;
 689         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
 690         if (flags & NDR_IN) {
 691                 ZERO_STRUCT(r->out);
 692
 693                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 694                         NDR_PULL_ALLOC(ndr, r->in.guidActionAgent);
 695                 }
 696                 _mem_save_guidActionAgent_0 = NDR_PULL_GET_MEM_CTX(ndr);
 697                 NDR_PULL_SET_MEM_CTX(ndr, r->in.guidActionAgent, LIBNDR_FLAG_REF_ALLOC);
 698                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->in.guidActionAgent));
 699                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guidActionAgent_0, LIBNDR_FLAG_REF_ALLOC);
 700                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_in));
 701                 size_data_in_1 = ndr_get_array_size(ndr, &r->in.data_in);
 702                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 703                         NDR_PULL_ALLOC_N(ndr, r->in.data_in, size_data_in_1);
 704                 }
 705                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.data_in, size_data_in_1));
 706                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_in_len));
 707                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.param));
 708                 NDR_PULL_ALLOC(ndr, r->out.data_out);
 709                 ZERO_STRUCTP(r->out.data_out);
 710                 NDR_PULL_ALLOC(ndr, r->out.data_out_len);
 711                 ZERO_STRUCTP(r->out.data_out_len);
 712                 if (r->in.data_in) {
 713                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.data_in, r->in.data_in_len));
 714                 }
 715         }
 716         if (flags & NDR_OUT) {
 717                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 718                         NDR_PULL_ALLOC(ndr, r->out.data_out);
 719                 }
 720                 _mem_save_data_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
 721                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_out, LIBNDR_FLAG_REF_ALLOC);
 722                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_out));
 723                 if (_ptr_data_out) {
 724                         NDR_PULL_ALLOC(ndr, *r->out.data_out);
 725                 } else {
 726                         *r->out.data_out = NULL;
 727                 }
 728                 if (*r->out.data_out) {
 729                         _mem_save_data_out_1 = NDR_PULL_GET_MEM_CTX(ndr);
 730                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.data_out, 0);
 731                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.data_out));
 732                         size_data_out_2 = ndr_get_array_size(ndr, r->out.data_out);
 733                         NDR_PULL_ALLOC_N(ndr, *r->out.data_out, size_data_out_2);
 734                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, *r->out.data_out, size_data_out_2));
 735                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_out_1, 0);
 736                 }
 737                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_out_0, LIBNDR_FLAG_REF_ALLOC);
 738                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 739                         NDR_PULL_ALLOC(ndr, r->out.data_out_len);
 740                 }
 741                 _mem_save_data_out_len_0 = NDR_PULL_GET_MEM_CTX(ndr);
 742                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_out_len, LIBNDR_FLAG_REF_ALLOC);
 743                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_out_len));
 744                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_out_len_0, LIBNDR_FLAG_REF_ALLOC);
 745                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 746                 if (*r->out.data_out) {
 747                         NDR_CHECK(ndr_check_array_size(ndr, (void*)r->out.data_out, *r->out.data_out_len));
 748                 }
 749         }
 750         return NDR_ERR_SUCCESS;
 751 }
 752
 753 static const struct ndr_interface_call backupkey_calls[] = {
 754         {
 755                 "bkrp_BackupKey",
 756                 sizeof(struct bkrp_BackupKey),
 757                 (ndr_push_flags_fn_t) ndr_push_bkrp_BackupKey,
 758                 (ndr_pull_flags_fn_t) ndr_pull_bkrp_BackupKey,
 759                 (ndr_print_function_t) ndr_print_bkrp_BackupKey,
 760                 { 0, NULL },
 761                 { 0, NULL },
 762         },
 763         { NULL, 0, NULL, NULL, NULL }
 764 };
 765
 766 static const char * const backupkey_endpoint_strings[] = {
 767         "ncacn_np:[\\pipe\\protected_storage]",
 768         "ncacn_np:[\\pipe\\ntsvcs]",
 769         "ncacn_ip_tcp:",
 770 };
 771
 772 static const struct ndr_interface_string_array backupkey_endpoints = {
 773         .count  = 3,
 774         .names  = backupkey_endpoint_strings
 775 };
 776
 777 static const char * const backupkey_authservice_strings[] = {
 778         "host",
 779 };
 780
 781 static const struct ndr_interface_string_array backupkey_authservices = {
 782         .count  = 1,
 783         .names  = backupkey_authservice_strings
 784 };
 785
 786
 787 const struct ndr_interface_table ndr_table_backupkey = {
 788         .name           = "backupkey",
 789         .syntax_id      = {
 790                 {0x3dde7c30,0x165d,0x11d1,{0xab,0x8f},{0x00,0x80,0x5f,0x14,0xdb,0x40}},
 791                 NDR_BACKUPKEY_VERSION
 792         },
 793         .helpstring     = NDR_BACKUPKEY_HELPSTRING,
 794         .num_calls      = 1,
 795         .calls          = backupkey_calls,
 796         .endpoints      = &backupkey_endpoints,
 797         .authservices   = &backupkey_authservices
 798 };
 799