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