librpc/gen_ndr/ndr_schannel.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_schannel.h"
   5
   6 #include "librpc/gen_ndr/ndr_netlogon.h"
   7 #include "librpc/gen_ndr/ndr_nbt.h"
   8 _PUBLIC_ enum ndr_err_code ndr_push_netlogon_creds_CredentialState(struct ndr_push *ndr, int ndr_flags, const struct netlogon_creds_CredentialState *r)
   9 {
  10         {
  11                 uint32_t _flags_save_STRUCT = ndr->flags;
  12                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
  13                 if (ndr_flags & NDR_SCALARS) {
  14                         NDR_CHECK(ndr_push_align(ndr, 5));
  15                         NDR_CHECK(ndr_push_netr_NegotiateFlags(ndr, NDR_SCALARS, r->negotiate_flags));
  16                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->session_key, 16));
  17                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sequence));
  18                         NDR_CHECK(ndr_push_netr_Credential(ndr, NDR_SCALARS, &r->seed));
  19                         NDR_CHECK(ndr_push_netr_Credential(ndr, NDR_SCALARS, &r->client));
  20                         NDR_CHECK(ndr_push_netr_Credential(ndr, NDR_SCALARS, &r->server));
  21                         NDR_CHECK(ndr_push_netr_SchannelType(ndr, NDR_SCALARS, r->secure_channel_type));
  22                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_name, CH_UTF8)));
  23                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
  24                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_name, CH_UTF8)));
  25                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_name, ndr_charset_length(r->computer_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
  26                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->account_name, CH_UTF8)));
  27                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
  28                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->account_name, CH_UTF8)));
  29                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->account_name, ndr_charset_length(r->account_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
  30                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
  31                 }
  32                 if (ndr_flags & NDR_BUFFERS) {
  33                         if (r->sid) {
  34                                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->sid));
  35                         }
  36                 }
  37                 ndr->flags = _flags_save_STRUCT;
  38         }
  39         return NDR_ERR_SUCCESS;
  40 }
  41
  42 _PUBLIC_ enum ndr_err_code ndr_pull_netlogon_creds_CredentialState(struct ndr_pull *ndr, int ndr_flags, struct netlogon_creds_CredentialState *r)
  43 {
  44         uint32_t _ptr_sid;
  45         TALLOC_CTX *_mem_save_sid_0;
  46         {
  47                 uint32_t _flags_save_STRUCT = ndr->flags;
  48                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
  49                 if (ndr_flags & NDR_SCALARS) {
  50                         NDR_CHECK(ndr_pull_align(ndr, 5));
  51                         NDR_CHECK(ndr_pull_netr_NegotiateFlags(ndr, NDR_SCALARS, &r->negotiate_flags));
  52                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->session_key, 16));
  53                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sequence));
  54                         NDR_CHECK(ndr_pull_netr_Credential(ndr, NDR_SCALARS, &r->seed));
  55                         NDR_CHECK(ndr_pull_netr_Credential(ndr, NDR_SCALARS, &r->client));
  56                         NDR_CHECK(ndr_pull_netr_Credential(ndr, NDR_SCALARS, &r->server));
  57                         NDR_CHECK(ndr_pull_netr_SchannelType(ndr, NDR_SCALARS, &r->secure_channel_type));
  58                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_name));
  59                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_name));
  60                         if (ndr_get_array_length(ndr, &r->computer_name) > ndr_get_array_size(ndr, &r->computer_name)) {
  61                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->computer_name), ndr_get_array_length(ndr, &r->computer_name));
  62                         }
  63                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_name), sizeof(uint8_t)));
  64                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_name, ndr_get_array_length(ndr, &r->computer_name), sizeof(uint8_t), CH_UTF8));
  65                         NDR_CHECK(ndr_pull_array_size(ndr, &r->account_name));
  66                         NDR_CHECK(ndr_pull_array_length(ndr, &r->account_name));
  67                         if (ndr_get_array_length(ndr, &r->account_name) > ndr_get_array_size(ndr, &r->account_name)) {
  68                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->account_name), ndr_get_array_length(ndr, &r->account_name));
  69                         }
  70                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->account_name), sizeof(uint8_t)));
  71                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->account_name, ndr_get_array_length(ndr, &r->account_name), sizeof(uint8_t), CH_UTF8));
  72                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
  73                         if (_ptr_sid) {
  74                                 NDR_PULL_ALLOC(ndr, r->sid);
  75                         } else {
  76                                 r->sid = NULL;
  77                         }
  78                 }
  79                 if (ndr_flags & NDR_BUFFERS) {
  80                         if (r->sid) {
  81                                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
  82                                 NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
  83                                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->sid));
  84                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
  85                         }
  86                 }
  87                 ndr->flags = _flags_save_STRUCT;
  88         }
  89         return NDR_ERR_SUCCESS;
  90 }
  91
  92 _PUBLIC_ void ndr_print_netlogon_creds_CredentialState(struct ndr_print *ndr, const char *name, const struct netlogon_creds_CredentialState *r)
  93 {
  94         ndr_print_struct(ndr, name, "netlogon_creds_CredentialState");
  95         {
  96                 uint32_t _flags_save_STRUCT = ndr->flags;
  97                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
  98                 ndr->depth++;
  99                 ndr_print_netr_NegotiateFlags(ndr, "negotiate_flags", r->negotiate_flags);
 100                 ndr_print_array_uint8(ndr, "session_key", r->session_key, 16);
 101                 ndr_print_uint32(ndr, "sequence", r->sequence);
 102                 ndr_print_netr_Credential(ndr, "seed", &r->seed);
 103                 ndr_print_netr_Credential(ndr, "client", &r->client);
 104                 ndr_print_netr_Credential(ndr, "server", &r->server);
 105                 ndr_print_netr_SchannelType(ndr, "secure_channel_type", r->secure_channel_type);
 106                 ndr_print_string(ndr, "computer_name", r->computer_name);
 107                 ndr_print_string(ndr, "account_name", r->account_name);
 108                 ndr_print_ptr(ndr, "sid", r->sid);
 109                 ndr->depth++;
 110                 if (r->sid) {
 111                         ndr_print_dom_sid(ndr, "sid", r->sid);
 112                 }
 113                 ndr->depth--;
 114                 ndr->depth--;
 115                 ndr->flags = _flags_save_STRUCT;
 116         }
 117 }
 118
 119 static enum ndr_err_code ndr_push_NL_AUTH_MESSAGE_TYPE(struct ndr_push *ndr, int ndr_flags, enum NL_AUTH_MESSAGE_TYPE r)
 120 {
 121         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 122         return NDR_ERR_SUCCESS;
 123 }
 124
 125 static enum ndr_err_code ndr_pull_NL_AUTH_MESSAGE_TYPE(struct ndr_pull *ndr, int ndr_flags, enum NL_AUTH_MESSAGE_TYPE *r)
 126 {
 127         uint32_t v;
 128         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 129         *r = v;
 130         return NDR_ERR_SUCCESS;
 131 }
 132
 133 _PUBLIC_ void ndr_print_NL_AUTH_MESSAGE_TYPE(struct ndr_print *ndr, const char *name, enum NL_AUTH_MESSAGE_TYPE r)
 134 {
 135         const char *val = NULL;
 136
 137         switch (r) {
 138                 case NL_NEGOTIATE_REQUEST: val = "NL_NEGOTIATE_REQUEST"; break;
 139                 case NL_NEGOTIATE_RESPONSE: val = "NL_NEGOTIATE_RESPONSE"; break;
 140         }
 141         ndr_print_enum(ndr, name, "ENUM", val, r);
 142 }
 143
 144 static enum ndr_err_code ndr_push_NL_AUTH_MESSAGE_FLAGS(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 145 {
 146         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 147         return NDR_ERR_SUCCESS;
 148 }
 149
 150 static enum ndr_err_code ndr_pull_NL_AUTH_MESSAGE_FLAGS(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 151 {
 152         uint32_t v;
 153         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 154         *r = v;
 155         return NDR_ERR_SUCCESS;
 156 }
 157
 158 _PUBLIC_ void ndr_print_NL_AUTH_MESSAGE_FLAGS(struct ndr_print *ndr, const char *name, uint32_t r)
 159 {
 160         ndr_print_uint32(ndr, name, r);
 161         ndr->depth++;
 162         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NL_FLAG_OEM_NETBIOS_DOMAIN_NAME", NL_FLAG_OEM_NETBIOS_DOMAIN_NAME, r);
 163         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NL_FLAG_OEM_NETBIOS_COMPUTER_NAME", NL_FLAG_OEM_NETBIOS_COMPUTER_NAME, r);
 164         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NL_FLAG_UTF8_DNS_DOMAIN_NAME", NL_FLAG_UTF8_DNS_DOMAIN_NAME, r);
 165         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NL_FLAG_UTF8_DNS_HOST_NAME", NL_FLAG_UTF8_DNS_HOST_NAME, r);
 166         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NL_FLAG_UTF8_NETBIOS_COMPUTER_NAME", NL_FLAG_UTF8_NETBIOS_COMPUTER_NAME, r);
 167         ndr->depth--;
 168 }
 169
 170 _PUBLIC_ enum ndr_err_code ndr_push_NL_AUTH_MESSAGE_BUFFER(struct ndr_push *ndr, int ndr_flags, const union NL_AUTH_MESSAGE_BUFFER *r)
 171 {
 172         if (ndr_flags & NDR_SCALARS) {
 173                 int level = ndr_push_get_switch_value(ndr, r);
 174                 NDR_CHECK(ndr_push_union_align(ndr, 4));
 175                 switch (level) {
 176                         case NL_FLAG_OEM_NETBIOS_DOMAIN_NAME: {
 177                                 {
 178                                         uint32_t _flags_save_string = ndr->flags;
 179                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 180                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->a));
 181                                         ndr->flags = _flags_save_string;
 182                                 }
 183                         break; }
 184
 185                         case NL_FLAG_OEM_NETBIOS_COMPUTER_NAME: {
 186                                 {
 187                                         uint32_t _flags_save_string = ndr->flags;
 188                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 189                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->a));
 190                                         ndr->flags = _flags_save_string;
 191                                 }
 192                         break; }
 193
 194                         case NL_FLAG_UTF8_DNS_DOMAIN_NAME: {
 195                                 NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->u));
 196                         break; }
 197
 198                         case NL_FLAG_UTF8_DNS_HOST_NAME: {
 199                                 NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->u));
 200                         break; }
 201
 202                         case NL_FLAG_UTF8_NETBIOS_COMPUTER_NAME: {
 203                                 NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->u));
 204                         break; }
 205
 206                         default: {
 207                         break; }
 208
 209                 }
 210         }
 211         if (ndr_flags & NDR_BUFFERS) {
 212                 int level = ndr_push_get_switch_value(ndr, r);
 213                 switch (level) {
 214                         case NL_FLAG_OEM_NETBIOS_DOMAIN_NAME:
 215                         break;
 216
 217                         case NL_FLAG_OEM_NETBIOS_COMPUTER_NAME:
 218                         break;
 219
 220                         case NL_FLAG_UTF8_DNS_DOMAIN_NAME:
 221                         break;
 222
 223                         case NL_FLAG_UTF8_DNS_HOST_NAME:
 224                         break;
 225
 226                         case NL_FLAG_UTF8_NETBIOS_COMPUTER_NAME:
 227                         break;
 228
 229                         default:
 230                         break;
 231
 232                 }
 233         }
 234         return NDR_ERR_SUCCESS;
 235 }
 236
 237 _PUBLIC_ enum ndr_err_code ndr_pull_NL_AUTH_MESSAGE_BUFFER(struct ndr_pull *ndr, int ndr_flags, union NL_AUTH_MESSAGE_BUFFER *r)
 238 {
 239         int level;
 240         level = ndr_pull_get_switch_value(ndr, r);
 241         if (ndr_flags & NDR_SCALARS) {
 242                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
 243                 switch (level) {
 244                         case NL_FLAG_OEM_NETBIOS_DOMAIN_NAME: {
 245                                 {
 246                                         uint32_t _flags_save_string = ndr->flags;
 247                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 248                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->a));
 249                                         ndr->flags = _flags_save_string;
 250                                 }
 251                         break; }
 252
 253                         case NL_FLAG_OEM_NETBIOS_COMPUTER_NAME: {
 254                                 {
 255                                         uint32_t _flags_save_string = ndr->flags;
 256                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 257                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->a));
 258                                         ndr->flags = _flags_save_string;
 259                                 }
 260                         break; }
 261
 262                         case NL_FLAG_UTF8_DNS_DOMAIN_NAME: {
 263                                 NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->u));
 264                         break; }
 265
 266                         case NL_FLAG_UTF8_DNS_HOST_NAME: {
 267                                 NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->u));
 268                         break; }
 269
 270                         case NL_FLAG_UTF8_NETBIOS_COMPUTER_NAME: {
 271                                 NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->u));
 272                         break; }
 273
 274                         default: {
 275                         break; }
 276
 277                 }
 278         }
 279         if (ndr_flags & NDR_BUFFERS) {
 280                 switch (level) {
 281                         case NL_FLAG_OEM_NETBIOS_DOMAIN_NAME:
 282                         break;
 283
 284                         case NL_FLAG_OEM_NETBIOS_COMPUTER_NAME:
 285                         break;
 286
 287                         case NL_FLAG_UTF8_DNS_DOMAIN_NAME:
 288                         break;
 289
 290                         case NL_FLAG_UTF8_DNS_HOST_NAME:
 291                         break;
 292
 293                         case NL_FLAG_UTF8_NETBIOS_COMPUTER_NAME:
 294                         break;
 295
 296                         default:
 297                         break;
 298
 299                 }
 300         }
 301         return NDR_ERR_SUCCESS;
 302 }
 303
 304 _PUBLIC_ enum ndr_err_code ndr_push_NL_AUTH_MESSAGE_BUFFER_REPLY(struct ndr_push *ndr, int ndr_flags, const union NL_AUTH_MESSAGE_BUFFER_REPLY *r)
 305 {
 306         if (ndr_flags & NDR_SCALARS) {
 307                 int level = ndr_push_get_switch_value(ndr, r);
 308                 NDR_CHECK(ndr_push_union_align(ndr, 4));
 309                 switch (level) {
 310                         case NL_NEGOTIATE_RESPONSE: {
 311                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dummy));
 312                         break; }
 313
 314                         default: {
 315                         break; }
 316
 317                 }
 318         }
 319         if (ndr_flags & NDR_BUFFERS) {
 320                 int level = ndr_push_get_switch_value(ndr, r);
 321                 switch (level) {
 322                         case NL_NEGOTIATE_RESPONSE:
 323                         break;
 324
 325                         default:
 326                         break;
 327
 328                 }
 329         }
 330         return NDR_ERR_SUCCESS;
 331 }
 332
 333 _PUBLIC_ enum ndr_err_code ndr_pull_NL_AUTH_MESSAGE_BUFFER_REPLY(struct ndr_pull *ndr, int ndr_flags, union NL_AUTH_MESSAGE_BUFFER_REPLY *r)
 334 {
 335         int level;
 336         level = ndr_pull_get_switch_value(ndr, r);
 337         if (ndr_flags & NDR_SCALARS) {
 338                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
 339                 switch (level) {
 340                         case NL_NEGOTIATE_RESPONSE: {
 341                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dummy));
 342                         break; }
 343
 344                         default: {
 345                         break; }
 346
 347                 }
 348         }
 349         if (ndr_flags & NDR_BUFFERS) {
 350                 switch (level) {
 351                         case NL_NEGOTIATE_RESPONSE:
 352                         break;
 353
 354                         default:
 355                         break;
 356
 357                 }
 358         }
 359         return NDR_ERR_SUCCESS;
 360 }
 361
 362 _PUBLIC_ enum ndr_err_code ndr_push_NL_AUTH_MESSAGE(struct ndr_push *ndr, int ndr_flags, const struct NL_AUTH_MESSAGE *r)
 363 {
 364         {
 365                 uint32_t _flags_save_STRUCT = ndr->flags;
 366                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 367                 if (ndr_flags & NDR_SCALARS) {
 368                         NDR_CHECK(ndr_push_align(ndr, 4));
 369                         NDR_CHECK(ndr_push_NL_AUTH_MESSAGE_TYPE(ndr, NDR_SCALARS, r->MessageType));
 370                         NDR_CHECK(ndr_push_NL_AUTH_MESSAGE_FLAGS(ndr, NDR_SCALARS, r->Flags));
 371                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->oem_netbios_domain, r->Flags & NL_FLAG_OEM_NETBIOS_DOMAIN_NAME));
 372                         NDR_CHECK(ndr_push_NL_AUTH_MESSAGE_BUFFER(ndr, NDR_SCALARS, &r->oem_netbios_domain));
 373                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->oem_netbios_computer, r->Flags & NL_FLAG_OEM_NETBIOS_COMPUTER_NAME));
 374                         NDR_CHECK(ndr_push_NL_AUTH_MESSAGE_BUFFER(ndr, NDR_SCALARS, &r->oem_netbios_computer));
 375                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->utf8_dns_domain, r->Flags & NL_FLAG_UTF8_DNS_DOMAIN_NAME));
 376                         NDR_CHECK(ndr_push_NL_AUTH_MESSAGE_BUFFER(ndr, NDR_SCALARS, &r->utf8_dns_domain));
 377                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->utf8_dns_host, r->Flags & NL_FLAG_UTF8_DNS_HOST_NAME));
 378                         NDR_CHECK(ndr_push_NL_AUTH_MESSAGE_BUFFER(ndr, NDR_SCALARS, &r->utf8_dns_host));
 379                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->utf8_netbios_computer, r->Flags & NL_FLAG_UTF8_NETBIOS_COMPUTER_NAME));
 380                         NDR_CHECK(ndr_push_NL_AUTH_MESSAGE_BUFFER(ndr, NDR_SCALARS, &r->utf8_netbios_computer));
 381                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->Buffer, r->MessageType & NL_NEGOTIATE_RESPONSE));
 382                         NDR_CHECK(ndr_push_NL_AUTH_MESSAGE_BUFFER_REPLY(ndr, NDR_SCALARS, &r->Buffer));
 383                 }
 384                 if (ndr_flags & NDR_BUFFERS) {
 385                         NDR_CHECK(ndr_push_NL_AUTH_MESSAGE_BUFFER(ndr, NDR_BUFFERS, &r->oem_netbios_domain));
 386                         NDR_CHECK(ndr_push_NL_AUTH_MESSAGE_BUFFER(ndr, NDR_BUFFERS, &r->oem_netbios_computer));
 387                         NDR_CHECK(ndr_push_NL_AUTH_MESSAGE_BUFFER(ndr, NDR_BUFFERS, &r->utf8_dns_domain));
 388                         NDR_CHECK(ndr_push_NL_AUTH_MESSAGE_BUFFER(ndr, NDR_BUFFERS, &r->utf8_dns_host));
 389                         NDR_CHECK(ndr_push_NL_AUTH_MESSAGE_BUFFER(ndr, NDR_BUFFERS, &r->utf8_netbios_computer));
 390                         NDR_CHECK(ndr_push_NL_AUTH_MESSAGE_BUFFER_REPLY(ndr, NDR_BUFFERS, &r->Buffer));
 391                 }
 392                 ndr->flags = _flags_save_STRUCT;
 393         }
 394         return NDR_ERR_SUCCESS;
 395 }
 396
 397 _PUBLIC_ enum ndr_err_code ndr_pull_NL_AUTH_MESSAGE(struct ndr_pull *ndr, int ndr_flags, struct NL_AUTH_MESSAGE *r)
 398 {
 399         {
 400                 uint32_t _flags_save_STRUCT = ndr->flags;
 401                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 402                 if (ndr_flags & NDR_SCALARS) {
 403                         NDR_CHECK(ndr_pull_align(ndr, 4));
 404                         NDR_CHECK(ndr_pull_NL_AUTH_MESSAGE_TYPE(ndr, NDR_SCALARS, &r->MessageType));
 405                         NDR_CHECK(ndr_pull_NL_AUTH_MESSAGE_FLAGS(ndr, NDR_SCALARS, &r->Flags));
 406                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->oem_netbios_domain, r->Flags & NL_FLAG_OEM_NETBIOS_DOMAIN_NAME));
 407                         NDR_CHECK(ndr_pull_NL_AUTH_MESSAGE_BUFFER(ndr, NDR_SCALARS, &r->oem_netbios_domain));
 408                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->oem_netbios_computer, r->Flags & NL_FLAG_OEM_NETBIOS_COMPUTER_NAME));
 409                         NDR_CHECK(ndr_pull_NL_AUTH_MESSAGE_BUFFER(ndr, NDR_SCALARS, &r->oem_netbios_computer));
 410                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->utf8_dns_domain, r->Flags & NL_FLAG_UTF8_DNS_DOMAIN_NAME));
 411                         NDR_CHECK(ndr_pull_NL_AUTH_MESSAGE_BUFFER(ndr, NDR_SCALARS, &r->utf8_dns_domain));
 412                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->utf8_dns_host, r->Flags & NL_FLAG_UTF8_DNS_HOST_NAME));
 413                         NDR_CHECK(ndr_pull_NL_AUTH_MESSAGE_BUFFER(ndr, NDR_SCALARS, &r->utf8_dns_host));
 414                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->utf8_netbios_computer, r->Flags & NL_FLAG_UTF8_NETBIOS_COMPUTER_NAME));
 415                         NDR_CHECK(ndr_pull_NL_AUTH_MESSAGE_BUFFER(ndr, NDR_SCALARS, &r->utf8_netbios_computer));
 416                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->Buffer, r->MessageType & NL_NEGOTIATE_RESPONSE));
 417                         NDR_CHECK(ndr_pull_NL_AUTH_MESSAGE_BUFFER_REPLY(ndr, NDR_SCALARS, &r->Buffer));
 418                 }
 419                 if (ndr_flags & NDR_BUFFERS) {
 420                         NDR_CHECK(ndr_pull_NL_AUTH_MESSAGE_BUFFER(ndr, NDR_BUFFERS, &r->oem_netbios_domain));
 421                         NDR_CHECK(ndr_pull_NL_AUTH_MESSAGE_BUFFER(ndr, NDR_BUFFERS, &r->oem_netbios_computer));
 422                         NDR_CHECK(ndr_pull_NL_AUTH_MESSAGE_BUFFER(ndr, NDR_BUFFERS, &r->utf8_dns_domain));
 423                         NDR_CHECK(ndr_pull_NL_AUTH_MESSAGE_BUFFER(ndr, NDR_BUFFERS, &r->utf8_dns_host));
 424                         NDR_CHECK(ndr_pull_NL_AUTH_MESSAGE_BUFFER(ndr, NDR_BUFFERS, &r->utf8_netbios_computer));
 425                         NDR_CHECK(ndr_pull_NL_AUTH_MESSAGE_BUFFER_REPLY(ndr, NDR_BUFFERS, &r->Buffer));
 426                 }
 427                 ndr->flags = _flags_save_STRUCT;
 428         }
 429         return NDR_ERR_SUCCESS;
 430 }
 431
 432 _PUBLIC_ void ndr_print_NL_AUTH_MESSAGE(struct ndr_print *ndr, const char *name, const struct NL_AUTH_MESSAGE *r)
 433 {
 434         ndr_print_struct(ndr, name, "NL_AUTH_MESSAGE");
 435         {
 436                 uint32_t _flags_save_STRUCT = ndr->flags;
 437                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 438                 ndr->depth++;
 439                 ndr_print_NL_AUTH_MESSAGE_TYPE(ndr, "MessageType", r->MessageType);
 440                 ndr_print_NL_AUTH_MESSAGE_FLAGS(ndr, "Flags", r->Flags);
 441                 ndr_print_set_switch_value(ndr, &r->oem_netbios_domain, r->Flags & NL_FLAG_OEM_NETBIOS_DOMAIN_NAME);
 442                 ndr_print_NL_AUTH_MESSAGE_BUFFER(ndr, "oem_netbios_domain", &r->oem_netbios_domain);
 443                 ndr_print_set_switch_value(ndr, &r->oem_netbios_computer, r->Flags & NL_FLAG_OEM_NETBIOS_COMPUTER_NAME);
 444                 ndr_print_NL_AUTH_MESSAGE_BUFFER(ndr, "oem_netbios_computer", &r->oem_netbios_computer);
 445                 ndr_print_set_switch_value(ndr, &r->utf8_dns_domain, r->Flags & NL_FLAG_UTF8_DNS_DOMAIN_NAME);
 446                 ndr_print_NL_AUTH_MESSAGE_BUFFER(ndr, "utf8_dns_domain", &r->utf8_dns_domain);
 447                 ndr_print_set_switch_value(ndr, &r->utf8_dns_host, r->Flags & NL_FLAG_UTF8_DNS_HOST_NAME);
 448                 ndr_print_NL_AUTH_MESSAGE_BUFFER(ndr, "utf8_dns_host", &r->utf8_dns_host);
 449                 ndr_print_set_switch_value(ndr, &r->utf8_netbios_computer, r->Flags & NL_FLAG_UTF8_NETBIOS_COMPUTER_NAME);
 450                 ndr_print_NL_AUTH_MESSAGE_BUFFER(ndr, "utf8_netbios_computer", &r->utf8_netbios_computer);
 451                 ndr_print_set_switch_value(ndr, &r->Buffer, r->MessageType & NL_NEGOTIATE_RESPONSE);
 452                 ndr_print_NL_AUTH_MESSAGE_BUFFER_REPLY(ndr, "Buffer", &r->Buffer);
 453                 ndr->depth--;
 454                 ndr->flags = _flags_save_STRUCT;
 455         }
 456 }
 457
 458 static enum ndr_err_code ndr_push_NL_SIGNATURE_ALGORITHM(struct ndr_push *ndr, int ndr_flags, enum NL_SIGNATURE_ALGORITHM r)
 459 {
 460         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 461         return NDR_ERR_SUCCESS;
 462 }
 463
 464 static enum ndr_err_code ndr_pull_NL_SIGNATURE_ALGORITHM(struct ndr_pull *ndr, int ndr_flags, enum NL_SIGNATURE_ALGORITHM *r)
 465 {
 466         uint16_t v;
 467         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 468         *r = v;
 469         return NDR_ERR_SUCCESS;
 470 }
 471
 472 _PUBLIC_ void ndr_print_NL_SIGNATURE_ALGORITHM(struct ndr_print *ndr, const char *name, enum NL_SIGNATURE_ALGORITHM r)
 473 {
 474         const char *val = NULL;
 475
 476         switch (r) {
 477                 case NL_SIGN_HMAC_SHA256: val = "NL_SIGN_HMAC_SHA256"; break;
 478                 case NL_SIGN_HMAC_MD5: val = "NL_SIGN_HMAC_MD5"; break;
 479         }
 480         ndr_print_enum(ndr, name, "ENUM", val, r);
 481 }
 482
 483 static enum ndr_err_code ndr_push_NL_SEAL_ALGORITHM(struct ndr_push *ndr, int ndr_flags, enum NL_SEAL_ALGORITHM r)
 484 {
 485         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 486         return NDR_ERR_SUCCESS;
 487 }
 488
 489 static enum ndr_err_code ndr_pull_NL_SEAL_ALGORITHM(struct ndr_pull *ndr, int ndr_flags, enum NL_SEAL_ALGORITHM *r)
 490 {
 491         uint16_t v;
 492         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 493         *r = v;
 494         return NDR_ERR_SUCCESS;
 495 }
 496
 497 _PUBLIC_ void ndr_print_NL_SEAL_ALGORITHM(struct ndr_print *ndr, const char *name, enum NL_SEAL_ALGORITHM r)
 498 {
 499         const char *val = NULL;
 500
 501         switch (r) {
 502                 case NL_SEAL_AES128: val = "NL_SEAL_AES128"; break;
 503                 case NL_SEAL_RC4: val = "NL_SEAL_RC4"; break;
 504                 case NL_SEAL_NONE: val = "NL_SEAL_NONE"; break;
 505         }
 506         ndr_print_enum(ndr, name, "ENUM", val, r);
 507 }
 508
 509 _PUBLIC_ enum ndr_err_code ndr_push_NL_AUTH_SIGNATURE(struct ndr_push *ndr, int ndr_flags, const struct NL_AUTH_SIGNATURE *r)
 510 {
 511         {
 512                 uint32_t _flags_save_STRUCT = ndr->flags;
 513                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 514                 if (ndr_flags & NDR_SCALARS) {
 515                         NDR_CHECK(ndr_push_align(ndr, 2));
 516                         NDR_CHECK(ndr_push_NL_SIGNATURE_ALGORITHM(ndr, NDR_SCALARS, NL_SIGN_HMAC_MD5));
 517                         NDR_CHECK(ndr_push_NL_SEAL_ALGORITHM(ndr, NDR_SCALARS, r->SealAlgorithm));
 518                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->Pad));
 519                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->Flags));
 520                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->SequenceNumber, 8));
 521                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Checksum, 8));
 522                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Confounder, 8));
 523                 }
 524                 if (ndr_flags & NDR_BUFFERS) {
 525                 }
 526                 ndr->flags = _flags_save_STRUCT;
 527         }
 528         return NDR_ERR_SUCCESS;
 529 }
 530
 531 _PUBLIC_ enum ndr_err_code ndr_pull_NL_AUTH_SIGNATURE(struct ndr_pull *ndr, int ndr_flags, struct NL_AUTH_SIGNATURE *r)
 532 {
 533         {
 534                 uint32_t _flags_save_STRUCT = ndr->flags;
 535                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 536                 if (ndr_flags & NDR_SCALARS) {
 537                         NDR_CHECK(ndr_pull_align(ndr, 2));
 538                         NDR_CHECK(ndr_pull_NL_SIGNATURE_ALGORITHM(ndr, NDR_SCALARS, &r->SignatureAlgorithm));
 539                         NDR_CHECK(ndr_pull_NL_SEAL_ALGORITHM(ndr, NDR_SCALARS, &r->SealAlgorithm));
 540                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->Pad));
 541                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->Flags));
 542                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->SequenceNumber, 8));
 543                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Checksum, 8));
 544                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Confounder, 8));
 545                 }
 546                 if (ndr_flags & NDR_BUFFERS) {
 547                 }
 548                 ndr->flags = _flags_save_STRUCT;
 549         }
 550         return NDR_ERR_SUCCESS;
 551 }
 552
 553 _PUBLIC_ void ndr_print_NL_AUTH_SIGNATURE(struct ndr_print *ndr, const char *name, const struct NL_AUTH_SIGNATURE *r)
 554 {
 555         ndr_print_struct(ndr, name, "NL_AUTH_SIGNATURE");
 556         {
 557                 uint32_t _flags_save_STRUCT = ndr->flags;
 558                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 559                 ndr->depth++;
 560                 ndr_print_NL_SIGNATURE_ALGORITHM(ndr, "SignatureAlgorithm", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?NL_SIGN_HMAC_MD5:r->SignatureAlgorithm);
 561                 ndr_print_NL_SEAL_ALGORITHM(ndr, "SealAlgorithm", r->SealAlgorithm);
 562                 ndr_print_uint16(ndr, "Pad", r->Pad);
 563                 ndr_print_uint16(ndr, "Flags", r->Flags);
 564                 ndr_print_array_uint8(ndr, "SequenceNumber", r->SequenceNumber, 8);
 565                 ndr_print_array_uint8(ndr, "Checksum", r->Checksum, 8);
 566                 ndr_print_array_uint8(ndr, "Confounder", r->Confounder, 8);
 567                 ndr->depth--;
 568                 ndr->flags = _flags_save_STRUCT;
 569         }
 570 }
 571
 572 _PUBLIC_ enum ndr_err_code ndr_push_NL_AUTH_SHA2_SIGNATURE(struct ndr_push *ndr, int ndr_flags, const struct NL_AUTH_SHA2_SIGNATURE *r)
 573 {
 574         {
 575                 uint32_t _flags_save_STRUCT = ndr->flags;
 576                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 577                 if (ndr_flags & NDR_SCALARS) {
 578                         NDR_CHECK(ndr_push_align(ndr, 2));
 579                         NDR_CHECK(ndr_push_NL_SIGNATURE_ALGORITHM(ndr, NDR_SCALARS, NL_SIGN_HMAC_SHA256));
 580                         NDR_CHECK(ndr_push_NL_SEAL_ALGORITHM(ndr, NDR_SCALARS, r->SealAlgorithm));
 581                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->Pad));
 582                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->Flags));
 583                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->SequenceNumber, 8));
 584                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Checksum, 32));
 585                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Confounder, 8));
 586                 }
 587                 if (ndr_flags & NDR_BUFFERS) {
 588                 }
 589                 ndr->flags = _flags_save_STRUCT;
 590         }
 591         return NDR_ERR_SUCCESS;
 592 }
 593
 594 _PUBLIC_ enum ndr_err_code ndr_pull_NL_AUTH_SHA2_SIGNATURE(struct ndr_pull *ndr, int ndr_flags, struct NL_AUTH_SHA2_SIGNATURE *r)
 595 {
 596         {
 597                 uint32_t _flags_save_STRUCT = ndr->flags;
 598                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 599                 if (ndr_flags & NDR_SCALARS) {
 600                         NDR_CHECK(ndr_pull_align(ndr, 2));
 601                         NDR_CHECK(ndr_pull_NL_SIGNATURE_ALGORITHM(ndr, NDR_SCALARS, &r->SignatureAlgorithm));
 602                         NDR_CHECK(ndr_pull_NL_SEAL_ALGORITHM(ndr, NDR_SCALARS, &r->SealAlgorithm));
 603                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->Pad));
 604                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->Flags));
 605                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->SequenceNumber, 8));
 606                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Checksum, 32));
 607                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Confounder, 8));
 608                 }
 609                 if (ndr_flags & NDR_BUFFERS) {
 610                 }
 611                 ndr->flags = _flags_save_STRUCT;
 612         }
 613         return NDR_ERR_SUCCESS;
 614 }
 615
 616 _PUBLIC_ void ndr_print_NL_AUTH_SHA2_SIGNATURE(struct ndr_print *ndr, const char *name, const struct NL_AUTH_SHA2_SIGNATURE *r)
 617 {
 618         ndr_print_struct(ndr, name, "NL_AUTH_SHA2_SIGNATURE");
 619         {
 620                 uint32_t _flags_save_STRUCT = ndr->flags;
 621                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 622                 ndr->depth++;
 623                 ndr_print_NL_SIGNATURE_ALGORITHM(ndr, "SignatureAlgorithm", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?NL_SIGN_HMAC_SHA256:r->SignatureAlgorithm);
 624                 ndr_print_NL_SEAL_ALGORITHM(ndr, "SealAlgorithm", r->SealAlgorithm);
 625                 ndr_print_uint16(ndr, "Pad", r->Pad);
 626                 ndr_print_uint16(ndr, "Flags", r->Flags);
 627                 ndr_print_array_uint8(ndr, "SequenceNumber", r->SequenceNumber, 8);
 628                 ndr_print_array_uint8(ndr, "Checksum", r->Checksum, 32);
 629                 ndr_print_array_uint8(ndr, "Confounder", r->Confounder, 8);
 630                 ndr->depth--;
 631                 ndr->flags = _flags_save_STRUCT;
 632         }
 633 }
 634