source/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, 4));
 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, 4));
 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 static size_t ndr_size_PAC_LOGON_INFO(const struct PAC_LOGON_INFO *r, int flags)
 165 {
 166         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_PAC_LOGON_INFO);
 167 }
 168
 169 static enum ndr_err_code ndr_push_PAC_UNKNOWN_12(struct ndr_push *ndr, int ndr_flags, const struct PAC_UNKNOWN_12 *r)
 170 {
 171         if (ndr_flags & NDR_SCALARS) {
 172                 NDR_CHECK(ndr_push_align(ndr, 4));
 173                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->upn_name)));
 174                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown1));
 175                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->domain_name)));
 176                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown2));
 177                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown3));
 178                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown4));
 179                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown5));
 180                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->upn_name, 2 * strlen_m(r->upn_name) + 2, sizeof(uint8_t), CH_UTF16));
 181                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, 2 * strlen_m(r->domain_name) + 2, sizeof(uint8_t), CH_UTF16));
 182                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown6));
 183         }
 184         if (ndr_flags & NDR_BUFFERS) {
 185         }
 186         return NDR_ERR_SUCCESS;
 187 }
 188
 189 static enum ndr_err_code ndr_pull_PAC_UNKNOWN_12(struct ndr_pull *ndr, int ndr_flags, struct PAC_UNKNOWN_12 *r)
 190 {
 191         if (ndr_flags & NDR_SCALARS) {
 192                 NDR_CHECK(ndr_pull_align(ndr, 4));
 193                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->upn_size));
 194                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown1));
 195                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->domain_size));
 196                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown2));
 197                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown3));
 198                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown4));
 199                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown5));
 200                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->upn_name, r->upn_size + 2, sizeof(uint8_t), CH_UTF16));
 201                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, r->domain_size + 2, sizeof(uint8_t), CH_UTF16));
 202                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown6));
 203         }
 204         if (ndr_flags & NDR_BUFFERS) {
 205         }
 206         return NDR_ERR_SUCCESS;
 207 }
 208
 209 _PUBLIC_ void ndr_print_PAC_UNKNOWN_12(struct ndr_print *ndr, const char *name, const struct PAC_UNKNOWN_12 *r)
 210 {
 211         ndr_print_struct(ndr, name, "PAC_UNKNOWN_12");
 212         ndr->depth++;
 213         ndr_print_uint16(ndr, "upn_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m(r->upn_name):r->upn_size);
 214         ndr_print_uint16(ndr, "unknown1", r->unknown1);
 215         ndr_print_uint16(ndr, "domain_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m(r->domain_name):r->domain_size);
 216         ndr_print_uint16(ndr, "unknown2", r->unknown2);
 217         ndr_print_uint16(ndr, "unknown3", r->unknown3);
 218         ndr_print_uint16(ndr, "unknown4", r->unknown4);
 219         ndr_print_uint32(ndr, "unknown5", r->unknown5);
 220         ndr_print_string(ndr, "upn_name", r->upn_name);
 221         ndr_print_string(ndr, "domain_name", r->domain_name);
 222         ndr_print_uint32(ndr, "unknown6", r->unknown6);
 223         ndr->depth--;
 224 }
 225
 226 _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)
 227 {
 228         if (ndr_flags & NDR_SCALARS) {
 229                 NDR_CHECK(ndr_push_align(ndr, 4));
 230                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00081001));
 231                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0xCCCCCCCC));
 232                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, NDR_ROUND(ndr_size_PAC_LOGON_INFO(r->info, ndr->flags) + 4, 8)));
 233                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000000));
 234                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
 235         }
 236         if (ndr_flags & NDR_BUFFERS) {
 237                 if (r->info) {
 238                         NDR_CHECK(ndr_push_PAC_LOGON_INFO(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
 239                 }
 240         }
 241         return NDR_ERR_SUCCESS;
 242 }
 243
 244 _PUBLIC_ enum ndr_err_code ndr_pull_PAC_LOGON_INFO_CTR(struct ndr_pull *ndr, int ndr_flags, struct PAC_LOGON_INFO_CTR *r)
 245 {
 246         uint32_t _ptr_info;
 247         TALLOC_CTX *_mem_save_info_0;
 248         if (ndr_flags & NDR_SCALARS) {
 249                 NDR_CHECK(ndr_pull_align(ndr, 4));
 250                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
 251                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
 252                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
 253                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
 254                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
 255                 if (_ptr_info) {
 256                         NDR_PULL_ALLOC(ndr, r->info);
 257                 } else {
 258                         r->info = NULL;
 259                 }
 260         }
 261         if (ndr_flags & NDR_BUFFERS) {
 262                 if (r->info) {
 263                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 264                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
 265                         NDR_CHECK(ndr_pull_PAC_LOGON_INFO(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
 266                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
 267                 }
 268         }
 269         return NDR_ERR_SUCCESS;
 270 }
 271
 272 _PUBLIC_ void ndr_print_PAC_LOGON_INFO_CTR(struct ndr_print *ndr, const char *name, const struct PAC_LOGON_INFO_CTR *r)
 273 {
 274         ndr_print_struct(ndr, name, "PAC_LOGON_INFO_CTR");
 275         ndr->depth++;
 276         ndr_print_uint32(ndr, "unknown1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00081001:r->unknown1);
 277         ndr_print_uint32(ndr, "unknown2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0xCCCCCCCC:r->unknown2);
 278         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?NDR_ROUND(ndr_size_PAC_LOGON_INFO(r->info, ndr->flags) + 4, 8):r->_ndr_size);
 279         ndr_print_uint32(ndr, "unknown3", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000000:r->unknown3);
 280         ndr_print_ptr(ndr, "info", r->info);
 281         ndr->depth++;
 282         if (r->info) {
 283                 ndr_print_PAC_LOGON_INFO(ndr, "info", r->info);
 284         }
 285         ndr->depth--;
 286         ndr->depth--;
 287 }
 288
 289 _PUBLIC_ enum ndr_err_code ndr_push_PAC_TYPE(struct ndr_push *ndr, int ndr_flags, enum PAC_TYPE r)
 290 {
 291         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 292         return NDR_ERR_SUCCESS;
 293 }
 294
 295 _PUBLIC_ enum ndr_err_code ndr_pull_PAC_TYPE(struct ndr_pull *ndr, int ndr_flags, enum PAC_TYPE *r)
 296 {
 297         uint32_t v;
 298         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 299         *r = v;
 300         return NDR_ERR_SUCCESS;
 301 }
 302
 303 _PUBLIC_ void ndr_print_PAC_TYPE(struct ndr_print *ndr, const char *name, enum PAC_TYPE r)
 304 {
 305         const char *val = NULL;
 306
 307         switch (r) {
 308                 case PAC_TYPE_LOGON_INFO: val = "PAC_TYPE_LOGON_INFO"; break;
 309                 case PAC_TYPE_SRV_CHECKSUM: val = "PAC_TYPE_SRV_CHECKSUM"; break;
 310                 case PAC_TYPE_KDC_CHECKSUM: val = "PAC_TYPE_KDC_CHECKSUM"; break;
 311                 case PAC_TYPE_LOGON_NAME: val = "PAC_TYPE_LOGON_NAME"; break;
 312                 case PAC_TYPE_CONSTRAINED_DELEGATION: val = "PAC_TYPE_CONSTRAINED_DELEGATION"; break;
 313                 case PAC_TYPE_UNKNOWN_12: val = "PAC_TYPE_UNKNOWN_12"; break;
 314         }
 315         ndr_print_enum(ndr, name, "ENUM", val, r);
 316 }
 317
 318 _PUBLIC_ enum ndr_err_code ndr_push_PAC_INFO(struct ndr_push *ndr, int ndr_flags, const union PAC_INFO *r)
 319 {
 320         if (ndr_flags & NDR_SCALARS) {
 321                 int level = ndr_push_get_switch_value(ndr, r);
 322                 switch (level) {
 323                         case PAC_TYPE_LOGON_INFO: {
 324                                 NDR_CHECK(ndr_push_PAC_LOGON_INFO_CTR(ndr, NDR_SCALARS, &r->logon_info));
 325                         break; }
 326
 327                         case PAC_TYPE_SRV_CHECKSUM: {
 328                                 NDR_CHECK(ndr_push_PAC_SIGNATURE_DATA(ndr, NDR_SCALARS, &r->srv_cksum));
 329                         break; }
 330
 331                         case PAC_TYPE_KDC_CHECKSUM: {
 332                                 NDR_CHECK(ndr_push_PAC_SIGNATURE_DATA(ndr, NDR_SCALARS, &r->kdc_cksum));
 333                         break; }
 334
 335                         case PAC_TYPE_LOGON_NAME: {
 336                                 NDR_CHECK(ndr_push_PAC_LOGON_NAME(ndr, NDR_SCALARS, &r->logon_name));
 337                         break; }
 338
 339                         case PAC_TYPE_UNKNOWN_12: {
 340                                 NDR_CHECK(ndr_push_PAC_UNKNOWN_12(ndr, NDR_SCALARS, &r->unknown));
 341                         break; }
 342
 343                         default:
 344                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 345                 }
 346         }
 347         if (ndr_flags & NDR_BUFFERS) {
 348                 int level = ndr_push_get_switch_value(ndr, r);
 349                 switch (level) {
 350                         case PAC_TYPE_LOGON_INFO:
 351                                 NDR_CHECK(ndr_push_PAC_LOGON_INFO_CTR(ndr, NDR_BUFFERS, &r->logon_info));
 352                         break;
 353
 354                         case PAC_TYPE_SRV_CHECKSUM:
 355                         break;
 356
 357                         case PAC_TYPE_KDC_CHECKSUM:
 358                         break;
 359
 360                         case PAC_TYPE_LOGON_NAME:
 361                         break;
 362
 363                         case PAC_TYPE_UNKNOWN_12:
 364                         break;
 365
 366                         default:
 367                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 368                 }
 369         }
 370         return NDR_ERR_SUCCESS;
 371 }
 372
 373 _PUBLIC_ enum ndr_err_code ndr_pull_PAC_INFO(struct ndr_pull *ndr, int ndr_flags, union PAC_INFO *r)
 374 {
 375         int level;
 376         level = ndr_pull_get_switch_value(ndr, r);
 377         if (ndr_flags & NDR_SCALARS) {
 378                 switch (level) {
 379                         case PAC_TYPE_LOGON_INFO: {
 380                                 NDR_CHECK(ndr_pull_PAC_LOGON_INFO_CTR(ndr, NDR_SCALARS, &r->logon_info));
 381                         break; }
 382
 383                         case PAC_TYPE_SRV_CHECKSUM: {
 384                                 NDR_CHECK(ndr_pull_PAC_SIGNATURE_DATA(ndr, NDR_SCALARS, &r->srv_cksum));
 385                         break; }
 386
 387                         case PAC_TYPE_KDC_CHECKSUM: {
 388                                 NDR_CHECK(ndr_pull_PAC_SIGNATURE_DATA(ndr, NDR_SCALARS, &r->kdc_cksum));
 389                         break; }
 390
 391                         case PAC_TYPE_LOGON_NAME: {
 392                                 NDR_CHECK(ndr_pull_PAC_LOGON_NAME(ndr, NDR_SCALARS, &r->logon_name));
 393                         break; }
 394
 395                         case PAC_TYPE_UNKNOWN_12: {
 396                                 NDR_CHECK(ndr_pull_PAC_UNKNOWN_12(ndr, NDR_SCALARS, &r->unknown));
 397                         break; }
 398
 399                         default:
 400                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 401                 }
 402         }
 403         if (ndr_flags & NDR_BUFFERS) {
 404                 switch (level) {
 405                         case PAC_TYPE_LOGON_INFO:
 406                                 NDR_CHECK(ndr_pull_PAC_LOGON_INFO_CTR(ndr, NDR_BUFFERS, &r->logon_info));
 407                         break;
 408
 409                         case PAC_TYPE_SRV_CHECKSUM:
 410                         break;
 411
 412                         case PAC_TYPE_KDC_CHECKSUM:
 413                         break;
 414
 415                         case PAC_TYPE_LOGON_NAME:
 416                         break;
 417
 418                         case PAC_TYPE_UNKNOWN_12:
 419                         break;
 420
 421                         default:
 422                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 423                 }
 424         }
 425         return NDR_ERR_SUCCESS;
 426 }
 427
 428 _PUBLIC_ void ndr_print_PAC_INFO(struct ndr_print *ndr, const char *name, const union PAC_INFO *r)
 429 {
 430         int level;
 431         level = ndr_print_get_switch_value(ndr, r);
 432         ndr_print_union(ndr, name, level, "PAC_INFO");
 433         switch (level) {
 434                 case PAC_TYPE_LOGON_INFO:
 435                         ndr_print_PAC_LOGON_INFO_CTR(ndr, "logon_info", &r->logon_info);
 436                 break;
 437
 438                 case PAC_TYPE_SRV_CHECKSUM:
 439                         ndr_print_PAC_SIGNATURE_DATA(ndr, "srv_cksum", &r->srv_cksum);
 440                 break;
 441
 442                 case PAC_TYPE_KDC_CHECKSUM:
 443                         ndr_print_PAC_SIGNATURE_DATA(ndr, "kdc_cksum", &r->kdc_cksum);
 444                 break;
 445
 446                 case PAC_TYPE_LOGON_NAME:
 447                         ndr_print_PAC_LOGON_NAME(ndr, "logon_name", &r->logon_name);
 448                 break;
 449
 450                 case PAC_TYPE_UNKNOWN_12:
 451                         ndr_print_PAC_UNKNOWN_12(ndr, "unknown", &r->unknown);
 452                 break;
 453
 454                 default:
 455                         ndr_print_bad_level(ndr, name, level);
 456         }
 457 }
 458
 459 _PUBLIC_ size_t ndr_size_PAC_INFO(const union PAC_INFO *r, uint32_t level, int flags)
 460 {
 461         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_PAC_INFO);
 462 }
 463
 464 _PUBLIC_ enum ndr_err_code ndr_push_PAC_DATA(struct ndr_push *ndr, int ndr_flags, const struct PAC_DATA *r)
 465 {
 466         uint32_t cntr_buffers_0;
 467         if (ndr_flags & NDR_SCALARS) {
 468                 NDR_CHECK(ndr_push_align(ndr, 4));
 469                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_buffers));
 470                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 471                 for (cntr_buffers_0 = 0; cntr_buffers_0 < r->num_buffers; cntr_buffers_0++) {
 472                         NDR_CHECK(ndr_push_PAC_BUFFER(ndr, NDR_SCALARS, &r->buffers[cntr_buffers_0]));
 473                 }
 474         }
 475         if (ndr_flags & NDR_BUFFERS) {
 476                 for (cntr_buffers_0 = 0; cntr_buffers_0 < r->num_buffers; cntr_buffers_0++) {
 477                         NDR_CHECK(ndr_push_PAC_BUFFER(ndr, NDR_BUFFERS, &r->buffers[cntr_buffers_0]));
 478                 }
 479         }
 480         return NDR_ERR_SUCCESS;
 481 }
 482
 483 _PUBLIC_ enum ndr_err_code ndr_pull_PAC_DATA(struct ndr_pull *ndr, int ndr_flags, struct PAC_DATA *r)
 484 {
 485         uint32_t cntr_buffers_0;
 486         TALLOC_CTX *_mem_save_buffers_0;
 487         if (ndr_flags & NDR_SCALARS) {
 488                 NDR_CHECK(ndr_pull_align(ndr, 4));
 489                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_buffers));
 490                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 491                 NDR_PULL_ALLOC_N(ndr, r->buffers, r->num_buffers);
 492                 _mem_save_buffers_0 = NDR_PULL_GET_MEM_CTX(ndr);
 493                 NDR_PULL_SET_MEM_CTX(ndr, r->buffers, 0);
 494                 for (cntr_buffers_0 = 0; cntr_buffers_0 < r->num_buffers; cntr_buffers_0++) {
 495                         NDR_CHECK(ndr_pull_PAC_BUFFER(ndr, NDR_SCALARS, &r->buffers[cntr_buffers_0]));
 496                 }
 497                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffers_0, 0);
 498         }
 499         if (ndr_flags & NDR_BUFFERS) {
 500                 _mem_save_buffers_0 = NDR_PULL_GET_MEM_CTX(ndr);
 501                 NDR_PULL_SET_MEM_CTX(ndr, r->buffers, 0);
 502                 for (cntr_buffers_0 = 0; cntr_buffers_0 < r->num_buffers; cntr_buffers_0++) {
 503                         NDR_CHECK(ndr_pull_PAC_BUFFER(ndr, NDR_BUFFERS, &r->buffers[cntr_buffers_0]));
 504                 }
 505                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffers_0, 0);
 506         }
 507         return NDR_ERR_SUCCESS;
 508 }
 509
 510 _PUBLIC_ void ndr_print_PAC_DATA(struct ndr_print *ndr, const char *name, const struct PAC_DATA *r)
 511 {
 512         uint32_t cntr_buffers_0;
 513         ndr_print_struct(ndr, name, "PAC_DATA");
 514         ndr->depth++;
 515         ndr_print_uint32(ndr, "num_buffers", r->num_buffers);
 516         ndr_print_uint32(ndr, "version", r->version);
 517         ndr->print(ndr, "%s: ARRAY(%d)", "buffers", r->num_buffers);
 518         ndr->depth++;
 519         for (cntr_buffers_0=0;cntr_buffers_0<r->num_buffers;cntr_buffers_0++) {
 520                 char *idx_0=NULL;
 521                 if (asprintf(&idx_0, "[%d]", cntr_buffers_0) != -1) {
 522                         ndr_print_PAC_BUFFER(ndr, "buffers", &r->buffers[cntr_buffers_0]);
 523                         free(idx_0);
 524                 }
 525         }
 526         ndr->depth--;
 527         ndr->depth--;
 528 }
 529
 530 static enum ndr_err_code ndr_push_DATA_BLOB_REM(struct ndr_push *ndr, int ndr_flags, const struct DATA_BLOB_REM *r)
 531 {
 532         if (ndr_flags & NDR_SCALARS) {
 533                 NDR_CHECK(ndr_push_align(ndr, 4));
 534                 {
 535                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 537                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->remaining));
 538                         ndr->flags = _flags_save_DATA_BLOB;
 539                 }
 540         }
 541         if (ndr_flags & NDR_BUFFERS) {
 542         }
 543         return NDR_ERR_SUCCESS;
 544 }
 545
 546 static enum ndr_err_code ndr_pull_DATA_BLOB_REM(struct ndr_pull *ndr, int ndr_flags, struct DATA_BLOB_REM *r)
 547 {
 548         if (ndr_flags & NDR_SCALARS) {
 549                 NDR_CHECK(ndr_pull_align(ndr, 4));
 550                 {
 551                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 552                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 553                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->remaining));
 554                         ndr->flags = _flags_save_DATA_BLOB;
 555                 }
 556         }
 557         if (ndr_flags & NDR_BUFFERS) {
 558         }
 559         return NDR_ERR_SUCCESS;
 560 }
 561
 562 _PUBLIC_ void ndr_print_DATA_BLOB_REM(struct ndr_print *ndr, const char *name, const struct DATA_BLOB_REM *r)
 563 {
 564         ndr_print_struct(ndr, name, "DATA_BLOB_REM");
 565         ndr->depth++;
 566         ndr_print_DATA_BLOB(ndr, "remaining", r->remaining);
 567         ndr->depth--;
 568 }
 569
 570 _PUBLIC_ enum ndr_err_code ndr_push_PAC_BUFFER_RAW(struct ndr_push *ndr, int ndr_flags, const struct PAC_BUFFER_RAW *r)
 571 {
 572         if (ndr_flags & NDR_SCALARS) {
 573                 NDR_CHECK(ndr_push_align(ndr, 4));
 574                 NDR_CHECK(ndr_push_PAC_TYPE(ndr, NDR_SCALARS, r->type));
 575                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ndr_size));
 576                 {
 577                         uint32_t _flags_save_DATA_BLOB_REM = ndr->flags;
 578                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
 579                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->info));
 580                         ndr->flags = _flags_save_DATA_BLOB_REM;
 581                 }
 582                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 583         }
 584         if (ndr_flags & NDR_BUFFERS) {
 585                 {
 586                         uint32_t _flags_save_DATA_BLOB_REM = ndr->flags;
 587                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
 588                         if (r->info) {
 589                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->info));
 590                                 {
 591                                         struct ndr_push *_ndr_info;
 592                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 0, NDR_ROUND(r->ndr_size, 8)));
 593                                         NDR_CHECK(ndr_push_DATA_BLOB_REM(_ndr_info, NDR_SCALARS, r->info));
 594                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 0, NDR_ROUND(r->ndr_size, 8)));
 595                                 }
 596                         }
 597                         ndr->flags = _flags_save_DATA_BLOB_REM;
 598                 }
 599         }
 600         return NDR_ERR_SUCCESS;
 601 }
 602
 603 _PUBLIC_ enum ndr_err_code ndr_pull_PAC_BUFFER_RAW(struct ndr_pull *ndr, int ndr_flags, struct PAC_BUFFER_RAW *r)
 604 {
 605         uint32_t _ptr_info;
 606         TALLOC_CTX *_mem_save_info_0;
 607         if (ndr_flags & NDR_SCALARS) {
 608                 NDR_CHECK(ndr_pull_align(ndr, 4));
 609                 NDR_CHECK(ndr_pull_PAC_TYPE(ndr, NDR_SCALARS, &r->type));
 610                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ndr_size));
 611                 {
 612                         uint32_t _flags_save_DATA_BLOB_REM = ndr->flags;
 613                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
 614                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
 615                         if (_ptr_info) {
 616                                 NDR_PULL_ALLOC(ndr, r->info);
 617                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->info, _ptr_info));
 618                         } else {
 619                                 r->info = NULL;
 620                         }
 621                         ndr->flags = _flags_save_DATA_BLOB_REM;
 622                 }
 623                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_pad));
 624         }
 625         if (ndr_flags & NDR_BUFFERS) {
 626                 {
 627                         uint32_t _flags_save_DATA_BLOB_REM = ndr->flags;
 628                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
 629                         if (r->info) {
 630                                 uint32_t _relative_save_offset;
 631                                 _relative_save_offset = ndr->offset;
 632                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->info));
 633                                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 634                                 NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
 635                                 {
 636                                         struct ndr_pull *_ndr_info;
 637                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 0, NDR_ROUND(r->ndr_size, 8)));
 638                                         NDR_CHECK(ndr_pull_DATA_BLOB_REM(_ndr_info, NDR_SCALARS, r->info));
 639                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 0, NDR_ROUND(r->ndr_size, 8)));
 640                                 }
 641                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
 642                                 ndr->offset = _relative_save_offset;
 643                         }
 644                         ndr->flags = _flags_save_DATA_BLOB_REM;
 645                 }
 646         }
 647         return NDR_ERR_SUCCESS;
 648 }
 649
 650 _PUBLIC_ void ndr_print_PAC_BUFFER_RAW(struct ndr_print *ndr, const char *name, const struct PAC_BUFFER_RAW *r)
 651 {
 652         ndr_print_struct(ndr, name, "PAC_BUFFER_RAW");
 653         ndr->depth++;
 654         ndr_print_PAC_TYPE(ndr, "type", r->type);
 655         ndr_print_uint32(ndr, "ndr_size", r->ndr_size);
 656         ndr_print_ptr(ndr, "info", r->info);
 657         ndr->depth++;
 658         if (r->info) {
 659                 ndr_print_DATA_BLOB_REM(ndr, "info", r->info);
 660         }
 661         ndr->depth--;
 662         ndr_print_uint32(ndr, "_pad", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->_pad);
 663         ndr->depth--;
 664 }
 665
 666 _PUBLIC_ enum ndr_err_code ndr_push_PAC_DATA_RAW(struct ndr_push *ndr, int ndr_flags, const struct PAC_DATA_RAW *r)
 667 {
 668         uint32_t cntr_buffers_0;
 669         if (ndr_flags & NDR_SCALARS) {
 670                 NDR_CHECK(ndr_push_align(ndr, 4));
 671                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_buffers));
 672                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 673                 for (cntr_buffers_0 = 0; cntr_buffers_0 < r->num_buffers; cntr_buffers_0++) {
 674                         NDR_CHECK(ndr_push_PAC_BUFFER_RAW(ndr, NDR_SCALARS, &r->buffers[cntr_buffers_0]));
 675                 }
 676         }
 677         if (ndr_flags & NDR_BUFFERS) {
 678                 for (cntr_buffers_0 = 0; cntr_buffers_0 < r->num_buffers; cntr_buffers_0++) {
 679                         NDR_CHECK(ndr_push_PAC_BUFFER_RAW(ndr, NDR_BUFFERS, &r->buffers[cntr_buffers_0]));
 680                 }
 681         }
 682         return NDR_ERR_SUCCESS;
 683 }
 684
 685 _PUBLIC_ enum ndr_err_code ndr_pull_PAC_DATA_RAW(struct ndr_pull *ndr, int ndr_flags, struct PAC_DATA_RAW *r)
 686 {
 687         uint32_t cntr_buffers_0;
 688         TALLOC_CTX *_mem_save_buffers_0;
 689         if (ndr_flags & NDR_SCALARS) {
 690                 NDR_CHECK(ndr_pull_align(ndr, 4));
 691                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_buffers));
 692                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 693                 NDR_PULL_ALLOC_N(ndr, r->buffers, r->num_buffers);
 694                 _mem_save_buffers_0 = NDR_PULL_GET_MEM_CTX(ndr);
 695                 NDR_PULL_SET_MEM_CTX(ndr, r->buffers, 0);
 696                 for (cntr_buffers_0 = 0; cntr_buffers_0 < r->num_buffers; cntr_buffers_0++) {
 697                         NDR_CHECK(ndr_pull_PAC_BUFFER_RAW(ndr, NDR_SCALARS, &r->buffers[cntr_buffers_0]));
 698                 }
 699                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffers_0, 0);
 700         }
 701         if (ndr_flags & NDR_BUFFERS) {
 702                 _mem_save_buffers_0 = NDR_PULL_GET_MEM_CTX(ndr);
 703                 NDR_PULL_SET_MEM_CTX(ndr, r->buffers, 0);
 704                 for (cntr_buffers_0 = 0; cntr_buffers_0 < r->num_buffers; cntr_buffers_0++) {
 705                         NDR_CHECK(ndr_pull_PAC_BUFFER_RAW(ndr, NDR_BUFFERS, &r->buffers[cntr_buffers_0]));
 706                 }
 707                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffers_0, 0);
 708         }
 709         return NDR_ERR_SUCCESS;
 710 }
 711
 712 _PUBLIC_ void ndr_print_PAC_DATA_RAW(struct ndr_print *ndr, const char *name, const struct PAC_DATA_RAW *r)
 713 {
 714         uint32_t cntr_buffers_0;
 715         ndr_print_struct(ndr, name, "PAC_DATA_RAW");
 716         ndr->depth++;
 717         ndr_print_uint32(ndr, "num_buffers", r->num_buffers);
 718         ndr_print_uint32(ndr, "version", r->version);
 719         ndr->print(ndr, "%s: ARRAY(%d)", "buffers", r->num_buffers);
 720         ndr->depth++;
 721         for (cntr_buffers_0=0;cntr_buffers_0<r->num_buffers;cntr_buffers_0++) {
 722                 char *idx_0=NULL;
 723                 if (asprintf(&idx_0, "[%d]", cntr_buffers_0) != -1) {
 724                         ndr_print_PAC_BUFFER_RAW(ndr, "buffers", &r->buffers[cntr_buffers_0]);
 725                         free(idx_0);
 726                 }
 727         }
 728         ndr->depth--;
 729         ndr->depth--;
 730 }
 731
 732 _PUBLIC_ enum ndr_err_code ndr_push_netsamlogoncache_entry(struct ndr_push *ndr, int ndr_flags, const struct netsamlogoncache_entry *r)
 733 {
 734         if (ndr_flags & NDR_SCALARS) {
 735                 NDR_CHECK(ndr_push_align(ndr, 4));
 736                 NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, r->timestamp));
 737                 NDR_CHECK(ndr_push_netr_SamInfo3(ndr, NDR_SCALARS, &r->info3));
 738         }
 739         if (ndr_flags & NDR_BUFFERS) {
 740                 NDR_CHECK(ndr_push_netr_SamInfo3(ndr, NDR_BUFFERS, &r->info3));
 741         }
 742         return NDR_ERR_SUCCESS;
 743 }
 744
 745 _PUBLIC_ enum ndr_err_code ndr_pull_netsamlogoncache_entry(struct ndr_pull *ndr, int ndr_flags, struct netsamlogoncache_entry *r)
 746 {
 747         if (ndr_flags & NDR_SCALARS) {
 748                 NDR_CHECK(ndr_pull_align(ndr, 4));
 749                 NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, &r->timestamp));
 750                 NDR_CHECK(ndr_pull_netr_SamInfo3(ndr, NDR_SCALARS, &r->info3));
 751         }
 752         if (ndr_flags & NDR_BUFFERS) {
 753                 NDR_CHECK(ndr_pull_netr_SamInfo3(ndr, NDR_BUFFERS, &r->info3));
 754         }
 755         return NDR_ERR_SUCCESS;
 756 }
 757
 758 _PUBLIC_ void ndr_print_netsamlogoncache_entry(struct ndr_print *ndr, const char *name, const struct netsamlogoncache_entry *r)
 759 {
 760         ndr_print_struct(ndr, name, "netsamlogoncache_entry");
 761         ndr->depth++;
 762         ndr_print_time_t(ndr, "timestamp", r->timestamp);
 763         ndr_print_netr_SamInfo3(ndr, "info3", &r->info3);
 764         ndr->depth--;
 765 }
 766
 767 static enum ndr_err_code ndr_push_decode_pac(struct ndr_push *ndr, int flags, const struct decode_pac *r)
 768 {
 769         if (flags & NDR_IN) {
 770                 NDR_CHECK(ndr_push_PAC_DATA(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.pac));
 771         }
 772         if (flags & NDR_OUT) {
 773         }
 774         return NDR_ERR_SUCCESS;
 775 }
 776
 777 static enum ndr_err_code ndr_pull_decode_pac(struct ndr_pull *ndr, int flags, struct decode_pac *r)
 778 {
 779         if (flags & NDR_IN) {
 780                 NDR_CHECK(ndr_pull_PAC_DATA(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.pac));
 781         }
 782         if (flags & NDR_OUT) {
 783         }
 784         return NDR_ERR_SUCCESS;
 785 }
 786
 787 _PUBLIC_ void ndr_print_decode_pac(struct ndr_print *ndr, const char *name, int flags, const struct decode_pac *r)
 788 {
 789         ndr_print_struct(ndr, name, "decode_pac");
 790         ndr->depth++;
 791         if (flags & NDR_SET_VALUES) {
 792                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 793         }
 794         if (flags & NDR_IN) {
 795                 ndr_print_struct(ndr, "in", "decode_pac");
 796                 ndr->depth++;
 797                 ndr_print_PAC_DATA(ndr, "pac", &r->in.pac);
 798                 ndr->depth--;
 799         }
 800         if (flags & NDR_OUT) {
 801                 ndr_print_struct(ndr, "out", "decode_pac");
 802                 ndr->depth++;
 803                 ndr->depth--;
 804         }
 805         ndr->depth--;
 806 }
 807
 808 static enum ndr_err_code ndr_push_decode_pac_raw(struct ndr_push *ndr, int flags, const struct decode_pac_raw *r)
 809 {
 810         if (flags & NDR_IN) {
 811                 NDR_CHECK(ndr_push_PAC_DATA_RAW(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.pac));
 812         }
 813         if (flags & NDR_OUT) {
 814         }
 815         return NDR_ERR_SUCCESS;
 816 }
 817
 818 static enum ndr_err_code ndr_pull_decode_pac_raw(struct ndr_pull *ndr, int flags, struct decode_pac_raw *r)
 819 {
 820         if (flags & NDR_IN) {
 821                 NDR_CHECK(ndr_pull_PAC_DATA_RAW(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.pac));
 822         }
 823         if (flags & NDR_OUT) {
 824         }
 825         return NDR_ERR_SUCCESS;
 826 }
 827
 828 _PUBLIC_ void ndr_print_decode_pac_raw(struct ndr_print *ndr, const char *name, int flags, const struct decode_pac_raw *r)
 829 {
 830         ndr_print_struct(ndr, name, "decode_pac_raw");
 831         ndr->depth++;
 832         if (flags & NDR_SET_VALUES) {
 833                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 834         }
 835         if (flags & NDR_IN) {
 836                 ndr_print_struct(ndr, "in", "decode_pac_raw");
 837                 ndr->depth++;
 838                 ndr_print_PAC_DATA_RAW(ndr, "pac", &r->in.pac);
 839                 ndr->depth--;
 840         }
 841         if (flags & NDR_OUT) {
 842                 ndr_print_struct(ndr, "out", "decode_pac_raw");
 843                 ndr->depth++;
 844                 ndr->depth--;
 845         }
 846         ndr->depth--;
 847 }
 848
 849 static enum ndr_err_code ndr_push_decode_login_info(struct ndr_push *ndr, int flags, const struct decode_login_info *r)
 850 {
 851         if (flags & NDR_IN) {
 852                 NDR_CHECK(ndr_push_PAC_LOGON_INFO(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.logon_info));
 853         }
 854         if (flags & NDR_OUT) {
 855         }
 856         return NDR_ERR_SUCCESS;
 857 }
 858
 859 static enum ndr_err_code ndr_pull_decode_login_info(struct ndr_pull *ndr, int flags, struct decode_login_info *r)
 860 {
 861         if (flags & NDR_IN) {
 862                 NDR_CHECK(ndr_pull_PAC_LOGON_INFO(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.logon_info));
 863         }
 864         if (flags & NDR_OUT) {
 865         }
 866         return NDR_ERR_SUCCESS;
 867 }
 868
 869 _PUBLIC_ void ndr_print_decode_login_info(struct ndr_print *ndr, const char *name, int flags, const struct decode_login_info *r)
 870 {
 871         ndr_print_struct(ndr, name, "decode_login_info");
 872         ndr->depth++;
 873         if (flags & NDR_SET_VALUES) {
 874                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 875         }
 876         if (flags & NDR_IN) {
 877                 ndr_print_struct(ndr, "in", "decode_login_info");
 878                 ndr->depth++;
 879                 ndr_print_PAC_LOGON_INFO(ndr, "logon_info", &r->in.logon_info);
 880                 ndr->depth--;
 881         }
 882         if (flags & NDR_OUT) {
 883                 ndr_print_struct(ndr, "out", "decode_login_info");
 884                 ndr->depth++;
 885                 ndr->depth--;
 886         }
 887         ndr->depth--;
 888 }
 889
 890 static const struct ndr_interface_call krb5pac_calls[] = {
 891         {
 892                 "decode_pac",
 893                 sizeof(struct decode_pac),
 894                 (ndr_push_flags_fn_t) ndr_push_decode_pac,
 895                 (ndr_pull_flags_fn_t) ndr_pull_decode_pac,
 896                 (ndr_print_function_t) ndr_print_decode_pac,
 897                 false,
 898         },
 899         {
 900                 "decode_pac_raw",
 901                 sizeof(struct decode_pac_raw),
 902                 (ndr_push_flags_fn_t) ndr_push_decode_pac_raw,
 903                 (ndr_pull_flags_fn_t) ndr_pull_decode_pac_raw,
 904                 (ndr_print_function_t) ndr_print_decode_pac_raw,
 905                 false,
 906         },
 907         {
 908                 "decode_login_info",
 909                 sizeof(struct decode_login_info),
 910                 (ndr_push_flags_fn_t) ndr_push_decode_login_info,
 911                 (ndr_pull_flags_fn_t) ndr_pull_decode_login_info,
 912                 (ndr_print_function_t) ndr_print_decode_login_info,
 913                 false,
 914         },
 915         { NULL, 0, NULL, NULL, NULL, false }
 916 };
 917
 918 static const char * const krb5pac_endpoint_strings[] = {
 919         "ncacn_np:[\\pipe\\krb5pac]",
 920 };
 921
 922 static const struct ndr_interface_string_array krb5pac_endpoints = {
 923         .count  = 1,
 924         .names  = krb5pac_endpoint_strings
 925 };
 926
 927 static const char * const krb5pac_authservice_strings[] = {
 928         "host",
 929 };
 930
 931 static const struct ndr_interface_string_array krb5pac_authservices = {
 932         .count  = 1,
 933         .names  = krb5pac_authservice_strings
 934 };
 935
 936
 937 const struct ndr_interface_table ndr_table_krb5pac = {
 938         .name           = "krb5pac",
 939         .syntax_id      = {
 940                 {0x12345778,0x1234,0xabcd,{0x00,0x00},{0x00,0x00,0x00,0x00}},
 941                 NDR_KRB5PAC_VERSION
 942         },
 943         .helpstring     = NDR_KRB5PAC_HELPSTRING,
 944         .num_calls      = 3,
 945         .calls          = krb5pac_calls,
 946         .endpoints      = &krb5pac_endpoints,
 947         .authservices   = &krb5pac_authservices
 948 };
 949