librpc/gen_ndr/ndr_krb5pac.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_krb5pac.h"
   5
   6 #include "librpc/gen_ndr/ndr_security.h"
   7 #include "librpc/gen_ndr/ndr_netlogon.h"
   8 #include "librpc/gen_ndr/ndr_samr.h"
   9 static enum ndr_err_code ndr_push_PAC_LOGON_NAME(struct ndr_push *ndr, int ndr_flags, const struct PAC_LOGON_NAME *r)
  10 {
  11         if (ndr_flags & NDR_SCALARS) {
  12                 NDR_CHECK(ndr_push_align(ndr, 4));
  13                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->logon_time));
  14                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->account_name)));
  15                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->account_name, 2 * strlen_m(r->account_name), sizeof(uint8_t), CH_UTF16));
  16         }
  17         if (ndr_flags & NDR_BUFFERS) {
  18         }
  19         return NDR_ERR_SUCCESS;
  20 }
  21
  22 static enum ndr_err_code ndr_pull_PAC_LOGON_NAME(struct ndr_pull *ndr, int ndr_flags, struct PAC_LOGON_NAME *r)
  23 {
  24         if (ndr_flags & NDR_SCALARS) {
  25                 NDR_CHECK(ndr_pull_align(ndr, 4));
  26                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->logon_time));
  27                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
  28                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->account_name, r->size, sizeof(uint8_t), CH_UTF16));
  29         }
  30         if (ndr_flags & NDR_BUFFERS) {
  31         }
  32         return NDR_ERR_SUCCESS;
  33 }
  34
  35 _PUBLIC_ void ndr_print_PAC_LOGON_NAME(struct ndr_print *ndr, const char *name, const struct PAC_LOGON_NAME *r)
  36 {
  37         ndr_print_struct(ndr, name, "PAC_LOGON_NAME");
  38         ndr->depth++;
  39         ndr_print_NTTIME(ndr, "logon_time", r->logon_time);
  40         ndr_print_uint16(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m(r->account_name):r->size);
  41         ndr_print_string(ndr, "account_name", r->account_name);
  42         ndr->depth--;
  43 }
  44
  45 _PUBLIC_ enum ndr_err_code ndr_push_PAC_SIGNATURE_DATA(struct ndr_push *ndr, int ndr_flags, const struct PAC_SIGNATURE_DATA *r)
  46 {
  47         {
  48                 uint32_t _flags_save_STRUCT = ndr->flags;
  49                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
  50                 if (ndr_flags & NDR_SCALARS) {
  51                         NDR_CHECK(ndr_push_align(ndr, 4));
  52                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->type));
  53                         {
  54                                 uint32_t _flags_save_DATA_BLOB = ndr->flags;
  55                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
  56                                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->signature));
  57                                 ndr->flags = _flags_save_DATA_BLOB;
  58                         }
  59                 }
  60                 if (ndr_flags & NDR_BUFFERS) {
  61                 }
  62                 ndr->flags = _flags_save_STRUCT;
  63         }
  64         return NDR_ERR_SUCCESS;
  65 }
  66
  67 _PUBLIC_ enum ndr_err_code ndr_pull_PAC_SIGNATURE_DATA(struct ndr_pull *ndr, int ndr_flags, struct PAC_SIGNATURE_DATA *r)
  68 {
  69         {
  70                 uint32_t _flags_save_STRUCT = ndr->flags;
  71                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
  72                 if (ndr_flags & NDR_SCALARS) {
  73                         NDR_CHECK(ndr_pull_align(ndr, 4));
  74                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->type));
  75                         {
  76                                 uint32_t _flags_save_DATA_BLOB = ndr->flags;
  77                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
  78                                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->signature));
  79                                 ndr->flags = _flags_save_DATA_BLOB;
  80                         }
  81                 }
  82                 if (ndr_flags & NDR_BUFFERS) {
  83                 }
  84                 ndr->flags = _flags_save_STRUCT;
  85         }
  86         return NDR_ERR_SUCCESS;
  87 }
  88
  89 _PUBLIC_ void ndr_print_PAC_SIGNATURE_DATA(struct ndr_print *ndr, const char *name, const struct PAC_SIGNATURE_DATA *r)
  90 {
  91         ndr_print_struct(ndr, name, "PAC_SIGNATURE_DATA");
  92         {
  93                 uint32_t _flags_save_STRUCT = ndr->flags;
  94                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
  95                 ndr->depth++;
  96                 ndr_print_uint32(ndr, "type", r->type);
  97                 ndr_print_DATA_BLOB(ndr, "signature", r->signature);
  98                 ndr->depth--;
  99                 ndr->flags = _flags_save_STRUCT;
 100         }
 101 }
 102
 103 static enum ndr_err_code ndr_push_PAC_LOGON_INFO(struct ndr_push *ndr, int ndr_flags, const struct PAC_LOGON_INFO *r)
 104 {
 105         if (ndr_flags & NDR_SCALARS) {
 106                 NDR_CHECK(ndr_push_align(ndr, 5));
 107                 NDR_CHECK(ndr_push_netr_SamInfo3(ndr, NDR_SCALARS, &r->info3));
 108                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->res_group_dom_sid));
 109                 NDR_CHECK(ndr_push_samr_RidWithAttributeArray(ndr, NDR_SCALARS, &r->res_groups));
 110         }
 111         if (ndr_flags & NDR_BUFFERS) {
 112                 NDR_CHECK(ndr_push_netr_SamInfo3(ndr, NDR_BUFFERS, &r->info3));
 113                 if (r->res_group_dom_sid) {
 114                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->res_group_dom_sid));
 115                 }
 116                 NDR_CHECK(ndr_push_samr_RidWithAttributeArray(ndr, NDR_BUFFERS, &r->res_groups));
 117         }
 118         return NDR_ERR_SUCCESS;
 119 }
 120
 121 static enum ndr_err_code ndr_pull_PAC_LOGON_INFO(struct ndr_pull *ndr, int ndr_flags, struct PAC_LOGON_INFO *r)
 122 {
 123         uint32_t _ptr_res_group_dom_sid;
 124         TALLOC_CTX *_mem_save_res_group_dom_sid_0;
 125         if (ndr_flags & NDR_SCALARS) {
 126                 NDR_CHECK(ndr_pull_align(ndr, 5));
 127                 NDR_CHECK(ndr_pull_netr_SamInfo3(ndr, NDR_SCALARS, &r->info3));
 128                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_res_group_dom_sid));
 129                 if (_ptr_res_group_dom_sid) {
 130                         NDR_PULL_ALLOC(ndr, r->res_group_dom_sid);
 131                 } else {
 132                         r->res_group_dom_sid = NULL;
 133                 }
 134                 NDR_CHECK(ndr_pull_samr_RidWithAttributeArray(ndr, NDR_SCALARS, &r->res_groups));
 135         }
 136         if (ndr_flags & NDR_BUFFERS) {
 137                 NDR_CHECK(ndr_pull_netr_SamInfo3(ndr, NDR_BUFFERS, &r->info3));
 138                 if (r->res_group_dom_sid) {
 139                         _mem_save_res_group_dom_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 140                         NDR_PULL_SET_MEM_CTX(ndr, r->res_group_dom_sid, 0);
 141                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->res_group_dom_sid));
 142                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_group_dom_sid_0, 0);
 143                 }
 144                 NDR_CHECK(ndr_pull_samr_RidWithAttributeArray(ndr, NDR_BUFFERS, &r->res_groups));
 145         }
 146         return NDR_ERR_SUCCESS;
 147 }
 148
 149 _PUBLIC_ void ndr_print_PAC_LOGON_INFO(struct ndr_print *ndr, const char *name, const struct PAC_LOGON_INFO *r)
 150 {
 151         ndr_print_struct(ndr, name, "PAC_LOGON_INFO");
 152         ndr->depth++;
 153         ndr_print_netr_SamInfo3(ndr, "info3", &r->info3);
 154         ndr_print_ptr(ndr, "res_group_dom_sid", r->res_group_dom_sid);
 155         ndr->depth++;
 156         if (r->res_group_dom_sid) {
 157                 ndr_print_dom_sid2(ndr, "res_group_dom_sid", r->res_group_dom_sid);
 158         }
 159         ndr->depth--;
 160         ndr_print_samr_RidWithAttributeArray(ndr, "res_groups", &r->res_groups);
 161         ndr->depth--;
 162 }
 163
 164 _PUBLIC_ enum ndr_err_code ndr_push_PAC_LOGON_INFO_CTR(struct ndr_push *ndr, int ndr_flags, const struct PAC_LOGON_INFO_CTR *r)
 165 {
 166         if (ndr_flags & NDR_SCALARS) {
 167                 NDR_CHECK(ndr_push_align(ndr, 5));
 168                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
 169         }
 170         if (ndr_flags & NDR_BUFFERS) {
 171                 if (r->info) {
 172                         NDR_CHECK(ndr_push_PAC_LOGON_INFO(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
 173                 }
 174         }
 175         return NDR_ERR_SUCCESS;
 176 }
 177
 178 _PUBLIC_ enum ndr_err_code ndr_pull_PAC_LOGON_INFO_CTR(struct ndr_pull *ndr, int ndr_flags, struct PAC_LOGON_INFO_CTR *r)
 179 {
 180         uint32_t _ptr_info;
 181         TALLOC_CTX *_mem_save_info_0;
 182         if (ndr_flags & NDR_SCALARS) {
 183                 NDR_CHECK(ndr_pull_align(ndr, 5));
 184                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
 185                 if (_ptr_info) {
 186                         NDR_PULL_ALLOC(ndr, r->info);
 187                 } else {
 188                         r->info = NULL;
 189                 }
 190         }
 191         if (ndr_flags & NDR_BUFFERS) {
 192                 if (r->info) {
 193                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 194                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
 195                         NDR_CHECK(ndr_pull_PAC_LOGON_INFO(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
 196                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
 197                 }
 198         }
 199         return NDR_ERR_SUCCESS;
 200 }
 201
 202 _PUBLIC_ void ndr_print_PAC_LOGON_INFO_CTR(struct ndr_print *ndr, const char *name, const struct PAC_LOGON_INFO_CTR *r)
 203 {
 204         ndr_print_struct(ndr, name, "PAC_LOGON_INFO_CTR");
 205         ndr->depth++;
 206         ndr_print_ptr(ndr, "info", r->info);
 207         ndr->depth++;
 208         if (r->info) {
 209                 ndr_print_PAC_LOGON_INFO(ndr, "info", r->info);
 210         }
 211         ndr->depth--;
 212         ndr->depth--;
 213 }
 214
 215 _PUBLIC_ enum ndr_err_code ndr_push_PAC_TYPE(struct ndr_push *ndr, int ndr_flags, enum PAC_TYPE r)
 216 {
 217         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 218         return NDR_ERR_SUCCESS;
 219 }
 220
 221 _PUBLIC_ enum ndr_err_code ndr_pull_PAC_TYPE(struct ndr_pull *ndr, int ndr_flags, enum PAC_TYPE *r)
 222 {
 223         uint32_t v;
 224         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 225         *r = v;
 226         return NDR_ERR_SUCCESS;
 227 }
 228
 229 _PUBLIC_ void ndr_print_PAC_TYPE(struct ndr_print *ndr, const char *name, enum PAC_TYPE r)
 230 {
 231         const char *val = NULL;
 232
 233         switch (r) {
 234                 case PAC_TYPE_LOGON_INFO: val = "PAC_TYPE_LOGON_INFO"; break;
 235                 case PAC_TYPE_SRV_CHECKSUM: val = "PAC_TYPE_SRV_CHECKSUM"; break;
 236                 case PAC_TYPE_KDC_CHECKSUM: val = "PAC_TYPE_KDC_CHECKSUM"; break;
 237                 case PAC_TYPE_LOGON_NAME: val = "PAC_TYPE_LOGON_NAME"; break;
 238                 case PAC_TYPE_CONSTRAINED_DELEGATION: val = "PAC_TYPE_CONSTRAINED_DELEGATION"; break;
 239                 case PAC_TYPE_UNKNOWN_12: val = "PAC_TYPE_UNKNOWN_12"; break;
 240         }
 241         ndr_print_enum(ndr, name, "ENUM", val, r);
 242 }
 243
 244 static enum ndr_err_code ndr_push_DATA_BLOB_REM(struct ndr_push *ndr, int ndr_flags, const struct DATA_BLOB_REM *r)
 245 {
 246         if (ndr_flags & NDR_SCALARS) {
 247                 NDR_CHECK(ndr_push_align(ndr, 4));
 248                 {
 249                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 250                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 251                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->remaining));
 252                         ndr->flags = _flags_save_DATA_BLOB;
 253                 }
 254         }
 255         if (ndr_flags & NDR_BUFFERS) {
 256         }
 257         return NDR_ERR_SUCCESS;
 258 }
 259
 260 static enum ndr_err_code ndr_pull_DATA_BLOB_REM(struct ndr_pull *ndr, int ndr_flags, struct DATA_BLOB_REM *r)
 261 {
 262         if (ndr_flags & NDR_SCALARS) {
 263                 NDR_CHECK(ndr_pull_align(ndr, 4));
 264                 {
 265                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 266                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 267                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->remaining));
 268                         ndr->flags = _flags_save_DATA_BLOB;
 269                 }
 270         }
 271         if (ndr_flags & NDR_BUFFERS) {
 272         }
 273         return NDR_ERR_SUCCESS;
 274 }
 275
 276 _PUBLIC_ void ndr_print_DATA_BLOB_REM(struct ndr_print *ndr, const char *name, const struct DATA_BLOB_REM *r)
 277 {
 278         ndr_print_struct(ndr, name, "DATA_BLOB_REM");
 279         ndr->depth++;
 280         ndr_print_DATA_BLOB(ndr, "remaining", r->remaining);
 281         ndr->depth--;
 282 }
 283
 284 _PUBLIC_ enum ndr_err_code ndr_push_PAC_INFO(struct ndr_push *ndr, int ndr_flags, const union PAC_INFO *r)
 285 {
 286         if (ndr_flags & NDR_SCALARS) {
 287                 int level = ndr_push_get_switch_value(ndr, r);
 288                 NDR_CHECK(ndr_push_union_align(ndr, 4));
 289                 switch (level) {
 290                         case PAC_TYPE_LOGON_INFO: {
 291                                 {
 292                                         struct ndr_push *_ndr_logon_info;
 293                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_logon_info, 0xFFFFFC01, -1));
 294                                         NDR_CHECK(ndr_push_PAC_LOGON_INFO_CTR(_ndr_logon_info, NDR_SCALARS|NDR_BUFFERS, &r->logon_info));
 295                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_logon_info, 0xFFFFFC01, -1));
 296                                 }
 297                         break; }
 298
 299                         case PAC_TYPE_SRV_CHECKSUM: {
 300                                 NDR_CHECK(ndr_push_PAC_SIGNATURE_DATA(ndr, NDR_SCALARS, &r->srv_cksum));
 301                         break; }
 302
 303                         case PAC_TYPE_KDC_CHECKSUM: {
 304                                 NDR_CHECK(ndr_push_PAC_SIGNATURE_DATA(ndr, NDR_SCALARS, &r->kdc_cksum));
 305                         break; }
 306
 307                         case PAC_TYPE_LOGON_NAME: {
 308                                 NDR_CHECK(ndr_push_PAC_LOGON_NAME(ndr, NDR_SCALARS, &r->logon_name));
 309                         break; }
 310
 311                         default: {
 312                                 {
 313                                         struct ndr_push *_ndr_unknown;
 314                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_unknown, 0, -1));
 315                                         NDR_CHECK(ndr_push_DATA_BLOB_REM(_ndr_unknown, NDR_SCALARS, &r->unknown));
 316                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_unknown, 0, -1));
 317                                 }
 318                         break; }
 319
 320                 }
 321         }
 322         if (ndr_flags & NDR_BUFFERS) {
 323                 int level = ndr_push_get_switch_value(ndr, r);
 324                 switch (level) {
 325                         case PAC_TYPE_LOGON_INFO:
 326                         break;
 327
 328                         case PAC_TYPE_SRV_CHECKSUM:
 329                         break;
 330
 331                         case PAC_TYPE_KDC_CHECKSUM:
 332                         break;
 333
 334                         case PAC_TYPE_LOGON_NAME:
 335                         break;
 336
 337                         default:
 338                         break;
 339
 340                 }
 341         }
 342         return NDR_ERR_SUCCESS;
 343 }
 344
 345 _PUBLIC_ enum ndr_err_code ndr_pull_PAC_INFO(struct ndr_pull *ndr, int ndr_flags, union PAC_INFO *r)
 346 {
 347         int level;
 348         level = ndr_pull_get_switch_value(ndr, r);
 349         if (ndr_flags & NDR_SCALARS) {
 350                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
 351                 switch (level) {
 352                         case PAC_TYPE_LOGON_INFO: {
 353                                 {
 354                                         struct ndr_pull *_ndr_logon_info;
 355                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_logon_info, 0xFFFFFC01, -1));
 356                                         NDR_CHECK(ndr_pull_PAC_LOGON_INFO_CTR(_ndr_logon_info, NDR_SCALARS|NDR_BUFFERS, &r->logon_info));
 357                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_logon_info, 0xFFFFFC01, -1));
 358                                 }
 359                         break; }
 360
 361                         case PAC_TYPE_SRV_CHECKSUM: {
 362                                 NDR_CHECK(ndr_pull_PAC_SIGNATURE_DATA(ndr, NDR_SCALARS, &r->srv_cksum));
 363                         break; }
 364
 365                         case PAC_TYPE_KDC_CHECKSUM: {
 366                                 NDR_CHECK(ndr_pull_PAC_SIGNATURE_DATA(ndr, NDR_SCALARS, &r->kdc_cksum));
 367                         break; }
 368
 369                         case PAC_TYPE_LOGON_NAME: {
 370                                 NDR_CHECK(ndr_pull_PAC_LOGON_NAME(ndr, NDR_SCALARS, &r->logon_name));
 371                         break; }
 372
 373                         default: {
 374                                 {
 375                                         struct ndr_pull *_ndr_unknown;
 376                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_unknown, 0, -1));
 377                                         NDR_CHECK(ndr_pull_DATA_BLOB_REM(_ndr_unknown, NDR_SCALARS, &r->unknown));
 378                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_unknown, 0, -1));
 379                                 }
 380                         break; }
 381
 382                 }
 383         }
 384         if (ndr_flags & NDR_BUFFERS) {
 385                 switch (level) {
 386                         case PAC_TYPE_LOGON_INFO:
 387                         break;
 388
 389                         case PAC_TYPE_SRV_CHECKSUM:
 390                         break;
 391
 392                         case PAC_TYPE_KDC_CHECKSUM:
 393                         break;
 394
 395                         case PAC_TYPE_LOGON_NAME:
 396                         break;
 397
 398                         default:
 399                         break;
 400
 401                 }
 402         }
 403         return NDR_ERR_SUCCESS;
 404 }
 405
 406 _PUBLIC_ void ndr_print_PAC_INFO(struct ndr_print *ndr, const char *name, const union PAC_INFO *r)
 407 {
 408         int level;
 409         level = ndr_print_get_switch_value(ndr, r);
 410         ndr_print_union(ndr, name, level, "PAC_INFO");
 411         switch (level) {
 412                 case PAC_TYPE_LOGON_INFO:
 413                         ndr_print_PAC_LOGON_INFO_CTR(ndr, "logon_info", &r->logon_info);
 414                 break;
 415
 416                 case PAC_TYPE_SRV_CHECKSUM:
 417                         ndr_print_PAC_SIGNATURE_DATA(ndr, "srv_cksum", &r->srv_cksum);
 418                 break;
 419
 420                 case PAC_TYPE_KDC_CHECKSUM:
 421                         ndr_print_PAC_SIGNATURE_DATA(ndr, "kdc_cksum", &r->kdc_cksum);
 422                 break;
 423
 424                 case PAC_TYPE_LOGON_NAME:
 425                         ndr_print_PAC_LOGON_NAME(ndr, "logon_name", &r->logon_name);
 426                 break;
 427
 428                 default:
 429                         ndr_print_DATA_BLOB_REM(ndr, "unknown", &r->unknown);
 430                 break;
 431
 432         }
 433 }
 434
 435 _PUBLIC_ size_t ndr_size_PAC_INFO(const union PAC_INFO *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
 436 {
 437         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_PAC_INFO, ic);
 438 }
 439
 440 _PUBLIC_ enum ndr_err_code ndr_push_PAC_DATA(struct ndr_push *ndr, int ndr_flags, const struct PAC_DATA *r)
 441 {
 442         uint32_t cntr_buffers_0;
 443         if (ndr_flags & NDR_SCALARS) {
 444                 NDR_CHECK(ndr_push_align(ndr, 5));
 445                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_buffers));
 446                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 447                 for (cntr_buffers_0 = 0; cntr_buffers_0 < r->num_buffers; cntr_buffers_0++) {
 448                         NDR_CHECK(ndr_push_PAC_BUFFER(ndr, NDR_SCALARS, &r->buffers[cntr_buffers_0]));
 449                 }
 450         }
 451         if (ndr_flags & NDR_BUFFERS) {
 452                 for (cntr_buffers_0 = 0; cntr_buffers_0 < r->num_buffers; cntr_buffers_0++) {
 453                         NDR_CHECK(ndr_push_PAC_BUFFER(ndr, NDR_BUFFERS, &r->buffers[cntr_buffers_0]));
 454                 }
 455         }
 456         return NDR_ERR_SUCCESS;
 457 }
 458
 459 _PUBLIC_ enum ndr_err_code ndr_pull_PAC_DATA(struct ndr_pull *ndr, int ndr_flags, struct PAC_DATA *r)
 460 {
 461         uint32_t cntr_buffers_0;
 462         TALLOC_CTX *_mem_save_buffers_0;
 463         if (ndr_flags & NDR_SCALARS) {
 464                 NDR_CHECK(ndr_pull_align(ndr, 5));
 465                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_buffers));
 466                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 467                 NDR_PULL_ALLOC_N(ndr, r->buffers, r->num_buffers);
 468                 _mem_save_buffers_0 = NDR_PULL_GET_MEM_CTX(ndr);
 469                 NDR_PULL_SET_MEM_CTX(ndr, r->buffers, 0);
 470                 for (cntr_buffers_0 = 0; cntr_buffers_0 < r->num_buffers; cntr_buffers_0++) {
 471                         NDR_CHECK(ndr_pull_PAC_BUFFER(ndr, NDR_SCALARS, &r->buffers[cntr_buffers_0]));
 472                 }
 473                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffers_0, 0);
 474         }
 475         if (ndr_flags & NDR_BUFFERS) {
 476                 _mem_save_buffers_0 = NDR_PULL_GET_MEM_CTX(ndr);
 477                 NDR_PULL_SET_MEM_CTX(ndr, r->buffers, 0);
 478                 for (cntr_buffers_0 = 0; cntr_buffers_0 < r->num_buffers; cntr_buffers_0++) {
 479                         NDR_CHECK(ndr_pull_PAC_BUFFER(ndr, NDR_BUFFERS, &r->buffers[cntr_buffers_0]));
 480                 }
 481                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffers_0, 0);
 482         }
 483         return NDR_ERR_SUCCESS;
 484 }
 485
 486 _PUBLIC_ void ndr_print_PAC_DATA(struct ndr_print *ndr, const char *name, const struct PAC_DATA *r)
 487 {
 488         uint32_t cntr_buffers_0;
 489         ndr_print_struct(ndr, name, "PAC_DATA");
 490         ndr->depth++;
 491         ndr_print_uint32(ndr, "num_buffers", r->num_buffers);
 492         ndr_print_uint32(ndr, "version", r->version);
 493         ndr->print(ndr, "%s: ARRAY(%d)", "buffers", (int)r->num_buffers);
 494         ndr->depth++;
 495         for (cntr_buffers_0=0;cntr_buffers_0<r->num_buffers;cntr_buffers_0++) {
 496                 char *idx_0=NULL;
 497                 if (asprintf(&idx_0, "[%d]", cntr_buffers_0) != -1) {
 498                         ndr_print_PAC_BUFFER(ndr, "buffers", &r->buffers[cntr_buffers_0]);
 499                         free(idx_0);
 500                 }
 501         }
 502         ndr->depth--;
 503         ndr->depth--;
 504 }
 505
 506 _PUBLIC_ enum ndr_err_code ndr_push_PAC_BUFFER_RAW(struct ndr_push *ndr, int ndr_flags, const struct PAC_BUFFER_RAW *r)
 507 {
 508         if (ndr_flags & NDR_SCALARS) {
 509                 NDR_CHECK(ndr_push_align(ndr, 5));
 510                 NDR_CHECK(ndr_push_PAC_TYPE(ndr, NDR_SCALARS, r->type));
 511                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ndr_size));
 512                 {
 513                         uint32_t _flags_save_DATA_BLOB_REM = ndr->flags;
 514                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
 515                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->info));
 516                         ndr->flags = _flags_save_DATA_BLOB_REM;
 517                 }
 518                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 519         }
 520         if (ndr_flags & NDR_BUFFERS) {
 521                 {
 522                         uint32_t _flags_save_DATA_BLOB_REM = ndr->flags;
 523                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
 524                         if (r->info) {
 525                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->info));
 526                                 {
 527                                         struct ndr_push *_ndr_info;
 528                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 0, NDR_ROUND(r->ndr_size, 8)));
 529                                         NDR_CHECK(ndr_push_DATA_BLOB_REM(_ndr_info, NDR_SCALARS, r->info));
 530                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 0, NDR_ROUND(r->ndr_size, 8)));
 531                                 }
 532                         }
 533                         ndr->flags = _flags_save_DATA_BLOB_REM;
 534                 }
 535         }
 536         return NDR_ERR_SUCCESS;
 537 }
 538
 539 _PUBLIC_ enum ndr_err_code ndr_pull_PAC_BUFFER_RAW(struct ndr_pull *ndr, int ndr_flags, struct PAC_BUFFER_RAW *r)
 540 {
 541         uint32_t _ptr_info;
 542         TALLOC_CTX *_mem_save_info_0;
 543         if (ndr_flags & NDR_SCALARS) {
 544                 NDR_CHECK(ndr_pull_align(ndr, 5));
 545                 NDR_CHECK(ndr_pull_PAC_TYPE(ndr, NDR_SCALARS, &r->type));
 546                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ndr_size));
 547                 {
 548                         uint32_t _flags_save_DATA_BLOB_REM = ndr->flags;
 549                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
 550                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
 551                         if (_ptr_info) {
 552                                 NDR_PULL_ALLOC(ndr, r->info);
 553                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->info, _ptr_info));
 554                         } else {
 555                                 r->info = NULL;
 556                         }
 557                         ndr->flags = _flags_save_DATA_BLOB_REM;
 558                 }
 559                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_pad));
 560         }
 561         if (ndr_flags & NDR_BUFFERS) {
 562                 {
 563                         uint32_t _flags_save_DATA_BLOB_REM = ndr->flags;
 564                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
 565                         if (r->info) {
 566                                 uint32_t _relative_save_offset;
 567                                 _relative_save_offset = ndr->offset;
 568                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->info));
 569                                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 570                                 NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
 571                                 {
 572                                         struct ndr_pull *_ndr_info;
 573                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 0, NDR_ROUND(r->ndr_size, 8)));
 574                                         NDR_CHECK(ndr_pull_DATA_BLOB_REM(_ndr_info, NDR_SCALARS, r->info));
 575                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 0, NDR_ROUND(r->ndr_size, 8)));
 576                                 }
 577                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
 578                                 ndr->offset = _relative_save_offset;
 579                         }
 580                         ndr->flags = _flags_save_DATA_BLOB_REM;
 581                 }
 582         }
 583         return NDR_ERR_SUCCESS;
 584 }
 585
 586 _PUBLIC_ void ndr_print_PAC_BUFFER_RAW(struct ndr_print *ndr, const char *name, const struct PAC_BUFFER_RAW *r)
 587 {
 588         ndr_print_struct(ndr, name, "PAC_BUFFER_RAW");
 589         ndr->depth++;
 590         ndr_print_PAC_TYPE(ndr, "type", r->type);
 591         ndr_print_uint32(ndr, "ndr_size", r->ndr_size);
 592         ndr_print_ptr(ndr, "info", r->info);
 593         ndr->depth++;
 594         if (r->info) {
 595                 ndr_print_DATA_BLOB_REM(ndr, "info", r->info);
 596         }
 597         ndr->depth--;
 598         ndr_print_uint32(ndr, "_pad", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->_pad);
 599         ndr->depth--;
 600 }
 601
 602 _PUBLIC_ enum ndr_err_code ndr_push_PAC_DATA_RAW(struct ndr_push *ndr, int ndr_flags, const struct PAC_DATA_RAW *r)
 603 {
 604         uint32_t cntr_buffers_0;
 605         if (ndr_flags & NDR_SCALARS) {
 606                 NDR_CHECK(ndr_push_align(ndr, 5));
 607                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_buffers));
 608                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 609                 for (cntr_buffers_0 = 0; cntr_buffers_0 < r->num_buffers; cntr_buffers_0++) {
 610                         NDR_CHECK(ndr_push_PAC_BUFFER_RAW(ndr, NDR_SCALARS, &r->buffers[cntr_buffers_0]));
 611                 }
 612         }
 613         if (ndr_flags & NDR_BUFFERS) {
 614                 for (cntr_buffers_0 = 0; cntr_buffers_0 < r->num_buffers; cntr_buffers_0++) {
 615                         NDR_CHECK(ndr_push_PAC_BUFFER_RAW(ndr, NDR_BUFFERS, &r->buffers[cntr_buffers_0]));
 616                 }
 617         }
 618         return NDR_ERR_SUCCESS;
 619 }
 620
 621 _PUBLIC_ enum ndr_err_code ndr_pull_PAC_DATA_RAW(struct ndr_pull *ndr, int ndr_flags, struct PAC_DATA_RAW *r)
 622 {
 623         uint32_t cntr_buffers_0;
 624         TALLOC_CTX *_mem_save_buffers_0;
 625         if (ndr_flags & NDR_SCALARS) {
 626                 NDR_CHECK(ndr_pull_align(ndr, 5));
 627                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_buffers));
 628                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 629                 NDR_PULL_ALLOC_N(ndr, r->buffers, r->num_buffers);
 630                 _mem_save_buffers_0 = NDR_PULL_GET_MEM_CTX(ndr);
 631                 NDR_PULL_SET_MEM_CTX(ndr, r->buffers, 0);
 632                 for (cntr_buffers_0 = 0; cntr_buffers_0 < r->num_buffers; cntr_buffers_0++) {
 633                         NDR_CHECK(ndr_pull_PAC_BUFFER_RAW(ndr, NDR_SCALARS, &r->buffers[cntr_buffers_0]));
 634                 }
 635                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffers_0, 0);
 636         }
 637         if (ndr_flags & NDR_BUFFERS) {
 638                 _mem_save_buffers_0 = NDR_PULL_GET_MEM_CTX(ndr);
 639                 NDR_PULL_SET_MEM_CTX(ndr, r->buffers, 0);
 640                 for (cntr_buffers_0 = 0; cntr_buffers_0 < r->num_buffers; cntr_buffers_0++) {
 641                         NDR_CHECK(ndr_pull_PAC_BUFFER_RAW(ndr, NDR_BUFFERS, &r->buffers[cntr_buffers_0]));
 642                 }
 643                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffers_0, 0);
 644         }
 645         return NDR_ERR_SUCCESS;
 646 }
 647
 648 _PUBLIC_ void ndr_print_PAC_DATA_RAW(struct ndr_print *ndr, const char *name, const struct PAC_DATA_RAW *r)
 649 {
 650         uint32_t cntr_buffers_0;
 651         ndr_print_struct(ndr, name, "PAC_DATA_RAW");
 652         ndr->depth++;
 653         ndr_print_uint32(ndr, "num_buffers", r->num_buffers);
 654         ndr_print_uint32(ndr, "version", r->version);
 655         ndr->print(ndr, "%s: ARRAY(%d)", "buffers", (int)r->num_buffers);
 656         ndr->depth++;
 657         for (cntr_buffers_0=0;cntr_buffers_0<r->num_buffers;cntr_buffers_0++) {
 658                 char *idx_0=NULL;
 659                 if (asprintf(&idx_0, "[%d]", cntr_buffers_0) != -1) {
 660                         ndr_print_PAC_BUFFER_RAW(ndr, "buffers", &r->buffers[cntr_buffers_0]);
 661                         free(idx_0);
 662                 }
 663         }
 664         ndr->depth--;
 665         ndr->depth--;
 666 }
 667
 668 _PUBLIC_ enum ndr_err_code ndr_push_PAC_Validate(struct ndr_push *ndr, int ndr_flags, const struct PAC_Validate *r)
 669 {
 670         if (ndr_flags & NDR_SCALARS) {
 671                 NDR_CHECK(ndr_push_align(ndr, 4));
 672                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, NETLOGON_GENERIC_KRB5_PAC_VALIDATE));
 673                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ChecksumLength));
 674                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->SignatureType));
 675                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->SignatureLength));
 676                 {
 677                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 678                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 679                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->ChecksumAndSignature));
 680                         ndr->flags = _flags_save_DATA_BLOB;
 681                 }
 682         }
 683         if (ndr_flags & NDR_BUFFERS) {
 684         }
 685         return NDR_ERR_SUCCESS;
 686 }
 687
 688 _PUBLIC_ enum ndr_err_code ndr_pull_PAC_Validate(struct ndr_pull *ndr, int ndr_flags, struct PAC_Validate *r)
 689 {
 690         if (ndr_flags & NDR_SCALARS) {
 691                 NDR_CHECK(ndr_pull_align(ndr, 4));
 692                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->MessageType));
 693                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ChecksumLength));
 694                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->SignatureType));
 695                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->SignatureLength));
 696                 {
 697                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 698                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 699                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->ChecksumAndSignature));
 700                         ndr->flags = _flags_save_DATA_BLOB;
 701                 }
 702         }
 703         if (ndr_flags & NDR_BUFFERS) {
 704         }
 705         return NDR_ERR_SUCCESS;
 706 }
 707
 708 _PUBLIC_ void ndr_print_PAC_Validate(struct ndr_print *ndr, const char *name, const struct PAC_Validate *r)
 709 {
 710         ndr_print_struct(ndr, name, "PAC_Validate");
 711         ndr->depth++;
 712         ndr_print_uint32(ndr, "MessageType", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?NETLOGON_GENERIC_KRB5_PAC_VALIDATE:r->MessageType);
 713         ndr_print_uint32(ndr, "ChecksumLength", r->ChecksumLength);
 714         ndr_print_int32(ndr, "SignatureType", r->SignatureType);
 715         ndr_print_uint32(ndr, "SignatureLength", r->SignatureLength);
 716         ndr_print_DATA_BLOB(ndr, "ChecksumAndSignature", r->ChecksumAndSignature);
 717         ndr->depth--;
 718 }
 719
 720 _PUBLIC_ enum ndr_err_code ndr_push_netsamlogoncache_entry(struct ndr_push *ndr, int ndr_flags, const struct netsamlogoncache_entry *r)
 721 {
 722         if (ndr_flags & NDR_SCALARS) {
 723                 NDR_CHECK(ndr_push_align(ndr, 5));
 724                 NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, r->timestamp));
 725                 NDR_CHECK(ndr_push_netr_SamInfo3(ndr, NDR_SCALARS, &r->info3));
 726         }
 727         if (ndr_flags & NDR_BUFFERS) {
 728                 NDR_CHECK(ndr_push_netr_SamInfo3(ndr, NDR_BUFFERS, &r->info3));
 729         }
 730         return NDR_ERR_SUCCESS;
 731 }
 732
 733 _PUBLIC_ enum ndr_err_code ndr_pull_netsamlogoncache_entry(struct ndr_pull *ndr, int ndr_flags, struct netsamlogoncache_entry *r)
 734 {
 735         if (ndr_flags & NDR_SCALARS) {
 736                 NDR_CHECK(ndr_pull_align(ndr, 5));
 737                 NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, &r->timestamp));
 738                 NDR_CHECK(ndr_pull_netr_SamInfo3(ndr, NDR_SCALARS, &r->info3));
 739         }
 740         if (ndr_flags & NDR_BUFFERS) {
 741                 NDR_CHECK(ndr_pull_netr_SamInfo3(ndr, NDR_BUFFERS, &r->info3));
 742         }
 743         return NDR_ERR_SUCCESS;
 744 }
 745
 746 _PUBLIC_ void ndr_print_netsamlogoncache_entry(struct ndr_print *ndr, const char *name, const struct netsamlogoncache_entry *r)
 747 {
 748         ndr_print_struct(ndr, name, "netsamlogoncache_entry");
 749         ndr->depth++;
 750         ndr_print_time_t(ndr, "timestamp", r->timestamp);
 751         ndr_print_netr_SamInfo3(ndr, "info3", &r->info3);
 752         ndr->depth--;
 753 }
 754
 755 static enum ndr_err_code ndr_push_decode_pac(struct ndr_push *ndr, int flags, const struct decode_pac *r)
 756 {
 757         if (flags & NDR_IN) {
 758                 NDR_CHECK(ndr_push_PAC_DATA(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.pac));
 759         }
 760         if (flags & NDR_OUT) {
 761         }
 762         return NDR_ERR_SUCCESS;
 763 }
 764
 765 static enum ndr_err_code ndr_pull_decode_pac(struct ndr_pull *ndr, int flags, struct decode_pac *r)
 766 {
 767         if (flags & NDR_IN) {
 768                 NDR_CHECK(ndr_pull_PAC_DATA(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.pac));
 769         }
 770         if (flags & NDR_OUT) {
 771         }
 772         return NDR_ERR_SUCCESS;
 773 }
 774
 775 _PUBLIC_ void ndr_print_decode_pac(struct ndr_print *ndr, const char *name, int flags, const struct decode_pac *r)
 776 {
 777         ndr_print_struct(ndr, name, "decode_pac");
 778         ndr->depth++;
 779         if (flags & NDR_SET_VALUES) {
 780                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 781         }
 782         if (flags & NDR_IN) {
 783                 ndr_print_struct(ndr, "in", "decode_pac");
 784                 ndr->depth++;
 785                 ndr_print_PAC_DATA(ndr, "pac", &r->in.pac);
 786                 ndr->depth--;
 787         }
 788         if (flags & NDR_OUT) {
 789                 ndr_print_struct(ndr, "out", "decode_pac");
 790                 ndr->depth++;
 791                 ndr->depth--;
 792         }
 793         ndr->depth--;
 794 }
 795
 796 static enum ndr_err_code ndr_push_decode_pac_raw(struct ndr_push *ndr, int flags, const struct decode_pac_raw *r)
 797 {
 798         if (flags & NDR_IN) {
 799                 NDR_CHECK(ndr_push_PAC_DATA_RAW(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.pac));
 800         }
 801         if (flags & NDR_OUT) {
 802         }
 803         return NDR_ERR_SUCCESS;
 804 }
 805
 806 static enum ndr_err_code ndr_pull_decode_pac_raw(struct ndr_pull *ndr, int flags, struct decode_pac_raw *r)
 807 {
 808         if (flags & NDR_IN) {
 809                 NDR_CHECK(ndr_pull_PAC_DATA_RAW(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.pac));
 810         }
 811         if (flags & NDR_OUT) {
 812         }
 813         return NDR_ERR_SUCCESS;
 814 }
 815
 816 _PUBLIC_ void ndr_print_decode_pac_raw(struct ndr_print *ndr, const char *name, int flags, const struct decode_pac_raw *r)
 817 {
 818         ndr_print_struct(ndr, name, "decode_pac_raw");
 819         ndr->depth++;
 820         if (flags & NDR_SET_VALUES) {
 821                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 822         }
 823         if (flags & NDR_IN) {
 824                 ndr_print_struct(ndr, "in", "decode_pac_raw");
 825                 ndr->depth++;
 826                 ndr_print_PAC_DATA_RAW(ndr, "pac", &r->in.pac);
 827                 ndr->depth--;
 828         }
 829         if (flags & NDR_OUT) {
 830                 ndr_print_struct(ndr, "out", "decode_pac_raw");
 831                 ndr->depth++;
 832                 ndr->depth--;
 833         }
 834         ndr->depth--;
 835 }
 836
 837 static enum ndr_err_code ndr_push_decode_login_info(struct ndr_push *ndr, int flags, const struct decode_login_info *r)
 838 {
 839         if (flags & NDR_IN) {
 840                 NDR_CHECK(ndr_push_PAC_LOGON_INFO(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.logon_info));
 841         }
 842         if (flags & NDR_OUT) {
 843         }
 844         return NDR_ERR_SUCCESS;
 845 }
 846
 847 static enum ndr_err_code ndr_pull_decode_login_info(struct ndr_pull *ndr, int flags, struct decode_login_info *r)
 848 {
 849         if (flags & NDR_IN) {
 850                 NDR_CHECK(ndr_pull_PAC_LOGON_INFO(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.logon_info));
 851         }
 852         if (flags & NDR_OUT) {
 853         }
 854         return NDR_ERR_SUCCESS;
 855 }
 856
 857 _PUBLIC_ void ndr_print_decode_login_info(struct ndr_print *ndr, const char *name, int flags, const struct decode_login_info *r)
 858 {
 859         ndr_print_struct(ndr, name, "decode_login_info");
 860         ndr->depth++;
 861         if (flags & NDR_SET_VALUES) {
 862                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 863         }
 864         if (flags & NDR_IN) {
 865                 ndr_print_struct(ndr, "in", "decode_login_info");
 866                 ndr->depth++;
 867                 ndr_print_PAC_LOGON_INFO(ndr, "logon_info", &r->in.logon_info);
 868                 ndr->depth--;
 869         }
 870         if (flags & NDR_OUT) {
 871                 ndr_print_struct(ndr, "out", "decode_login_info");
 872                 ndr->depth++;
 873                 ndr->depth--;
 874         }
 875         ndr->depth--;
 876 }
 877
 878 static enum ndr_err_code ndr_push_decode_pac_validate(struct ndr_push *ndr, int flags, const struct decode_pac_validate *r)
 879 {
 880         if (flags & NDR_IN) {
 881                 NDR_CHECK(ndr_push_PAC_Validate(ndr, NDR_SCALARS, &r->in.pac_validate));
 882         }
 883         if (flags & NDR_OUT) {
 884         }
 885         return NDR_ERR_SUCCESS;
 886 }
 887
 888 static enum ndr_err_code ndr_pull_decode_pac_validate(struct ndr_pull *ndr, int flags, struct decode_pac_validate *r)
 889 {
 890         if (flags & NDR_IN) {
 891                 NDR_CHECK(ndr_pull_PAC_Validate(ndr, NDR_SCALARS, &r->in.pac_validate));
 892         }
 893         if (flags & NDR_OUT) {
 894         }
 895         return NDR_ERR_SUCCESS;
 896 }
 897
 898 _PUBLIC_ void ndr_print_decode_pac_validate(struct ndr_print *ndr, const char *name, int flags, const struct decode_pac_validate *r)
 899 {
 900         ndr_print_struct(ndr, name, "decode_pac_validate");
 901         ndr->depth++;
 902         if (flags & NDR_SET_VALUES) {
 903                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 904         }
 905         if (flags & NDR_IN) {
 906                 ndr_print_struct(ndr, "in", "decode_pac_validate");
 907                 ndr->depth++;
 908                 ndr_print_PAC_Validate(ndr, "pac_validate", &r->in.pac_validate);
 909                 ndr->depth--;
 910         }
 911         if (flags & NDR_OUT) {
 912                 ndr_print_struct(ndr, "out", "decode_pac_validate");
 913                 ndr->depth++;
 914                 ndr->depth--;
 915         }
 916         ndr->depth--;
 917 }
 918
 919 static const struct ndr_interface_call krb5pac_calls[] = {
 920         {
 921                 "decode_pac",
 922                 sizeof(struct decode_pac),
 923                 (ndr_push_flags_fn_t) ndr_push_decode_pac,
 924                 (ndr_pull_flags_fn_t) ndr_pull_decode_pac,
 925                 (ndr_print_function_t) ndr_print_decode_pac,
 926                 false,
 927         },
 928         {
 929                 "decode_pac_raw",
 930                 sizeof(struct decode_pac_raw),
 931                 (ndr_push_flags_fn_t) ndr_push_decode_pac_raw,
 932                 (ndr_pull_flags_fn_t) ndr_pull_decode_pac_raw,
 933                 (ndr_print_function_t) ndr_print_decode_pac_raw,
 934                 false,
 935         },
 936         {
 937                 "decode_login_info",
 938                 sizeof(struct decode_login_info),
 939                 (ndr_push_flags_fn_t) ndr_push_decode_login_info,
 940                 (ndr_pull_flags_fn_t) ndr_pull_decode_login_info,
 941                 (ndr_print_function_t) ndr_print_decode_login_info,
 942                 false,
 943         },
 944         {
 945                 "decode_pac_validate",
 946                 sizeof(struct decode_pac_validate),
 947                 (ndr_push_flags_fn_t) ndr_push_decode_pac_validate,
 948                 (ndr_pull_flags_fn_t) ndr_pull_decode_pac_validate,
 949                 (ndr_print_function_t) ndr_print_decode_pac_validate,
 950                 false,
 951         },
 952         { NULL, 0, NULL, NULL, NULL, false }
 953 };
 954
 955 static const char * const krb5pac_endpoint_strings[] = {
 956         "ncacn_np:[\\pipe\\krb5pac]",
 957 };
 958
 959 static const struct ndr_interface_string_array krb5pac_endpoints = {
 960         .count  = 1,
 961         .names  = krb5pac_endpoint_strings
 962 };
 963
 964 static const char * const krb5pac_authservice_strings[] = {
 965         "host",
 966 };
 967
 968 static const struct ndr_interface_string_array krb5pac_authservices = {
 969         .count  = 1,
 970         .names  = krb5pac_authservice_strings
 971 };
 972
 973
 974 const struct ndr_interface_table ndr_table_krb5pac = {
 975         .name           = "krb5pac",
 976         .syntax_id      = {
 977                 {0x12345778,0x1234,0xabcd,{0x00,0x00},{0x00,0x00,0x00,0x00}},
 978                 NDR_KRB5PAC_VERSION
 979         },
 980         .helpstring     = NDR_KRB5PAC_HELPSTRING,
 981         .num_calls      = 4,
 982         .calls          = krb5pac_calls,
 983         .endpoints      = &krb5pac_endpoints,
 984         .authservices   = &krb5pac_authservices
 985 };
 986