librpc/gen_ndr/ndr_ntlmssp.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_ntlmssp.h"
   5
   6 static enum ndr_err_code ndr_push_ntlmssp_MessageType(struct ndr_push *ndr, int ndr_flags, enum ntlmssp_MessageType r)
   7 {
   8         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
   9         return NDR_ERR_SUCCESS;
  10 }
  11
  12 static enum ndr_err_code ndr_pull_ntlmssp_MessageType(struct ndr_pull *ndr, int ndr_flags, enum ntlmssp_MessageType *r)
  13 {
  14         uint32_t v;
  15         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
  16         *r = v;
  17         return NDR_ERR_SUCCESS;
  18 }
  19
  20 _PUBLIC_ void ndr_print_ntlmssp_MessageType(struct ndr_print *ndr, const char *name, enum ntlmssp_MessageType r)
  21 {
  22         const char *val = NULL;
  23
  24         switch (r) {
  25                 case NtLmNegotiate: val = "NtLmNegotiate"; break;
  26                 case NtLmChallenge: val = "NtLmChallenge"; break;
  27                 case NtLmAuthenticate: val = "NtLmAuthenticate"; break;
  28         }
  29         ndr_print_enum(ndr, name, "ENUM", val, r);
  30 }
  31
  32 static enum ndr_err_code ndr_push_NEGOTIATE(struct ndr_push *ndr, int ndr_flags, uint32_t r)
  33 {
  34         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  35         return NDR_ERR_SUCCESS;
  36 }
  37
  38 static enum ndr_err_code ndr_pull_NEGOTIATE(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
  39 {
  40         uint32_t v;
  41         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  42         *r = v;
  43         return NDR_ERR_SUCCESS;
  44 }
  45
  46 _PUBLIC_ void ndr_print_NEGOTIATE(struct ndr_print *ndr, const char *name, uint32_t r)
  47 {
  48         ndr_print_uint32(ndr, name, r);
  49         ndr->depth++;
  50         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NTLMSSP_NEGOTIATE_UNICODE", NTLMSSP_NEGOTIATE_UNICODE, r);
  51         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NTLMSSP_NEGOTIATE_OEM", NTLMSSP_NEGOTIATE_OEM, r);
  52         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NTLMSSP_REQUEST_TARGET", NTLMSSP_REQUEST_TARGET, r);
  53         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NTLMSSP_NEGOTIATE_SIGN", NTLMSSP_NEGOTIATE_SIGN, r);
  54         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NTLMSSP_NEGOTIATE_SEAL", NTLMSSP_NEGOTIATE_SEAL, r);
  55         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NTLMSSP_NEGOTIATE_DATAGRAM", NTLMSSP_NEGOTIATE_DATAGRAM, r);
  56         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NTLMSSP_NEGOTIATE_LM_KEY", NTLMSSP_NEGOTIATE_LM_KEY, r);
  57         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NTLMSSP_NEGOTIATE_NETWARE", NTLMSSP_NEGOTIATE_NETWARE, r);
  58         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NTLMSSP_NEGOTIATE_NTLM", NTLMSSP_NEGOTIATE_NTLM, r);
  59         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NTLMSSP_NEGOTIATE_NT_ONLY", NTLMSSP_NEGOTIATE_NT_ONLY, r);
  60         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NTLMSSP_ANONYMOUS", NTLMSSP_ANONYMOUS, r);
  61         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NTLMSSP_NEGOTIATE_OEM_DOMAIN_SUPPLIED", NTLMSSP_NEGOTIATE_OEM_DOMAIN_SUPPLIED, r);
  62         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NTLMSSP_NEGOTIATE_OEM_WORKSTATION_SUPPLIED", NTLMSSP_NEGOTIATE_OEM_WORKSTATION_SUPPLIED, r);
  63         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NTLMSSP_NEGOTIATE_THIS_IS_LOCAL_CALL", NTLMSSP_NEGOTIATE_THIS_IS_LOCAL_CALL, r);
  64         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NTLMSSP_NEGOTIATE_ALWAYS_SIGN", NTLMSSP_NEGOTIATE_ALWAYS_SIGN, r);
  65         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NTLMSSP_TARGET_TYPE_DOMAIN", NTLMSSP_TARGET_TYPE_DOMAIN, r);
  66         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NTLMSSP_TARGET_TYPE_SERVER", NTLMSSP_TARGET_TYPE_SERVER, r);
  67         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NTLMSSP_TARGET_TYPE_SHARE", NTLMSSP_TARGET_TYPE_SHARE, r);
  68         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NTLMSSP_NEGOTIATE_EXTENDED_SESSIONSECURITY", NTLMSSP_NEGOTIATE_EXTENDED_SESSIONSECURITY, r);
  69         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NTLMSSP_NEGOTIATE_IDENTIFY", NTLMSSP_NEGOTIATE_IDENTIFY, r);
  70         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NTLMSSP_REQUEST_NON_NT_SESSION_KEY", NTLMSSP_REQUEST_NON_NT_SESSION_KEY, r);
  71         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NTLMSSP_NEGOTIATE_TARGET_INFO", NTLMSSP_NEGOTIATE_TARGET_INFO, r);
  72         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NTLMSSP_NEGOTIATE_VERSION", NTLMSSP_NEGOTIATE_VERSION, r);
  73         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NTLMSSP_NEGOTIATE_128", NTLMSSP_NEGOTIATE_128, r);
  74         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NTLMSSP_NEGOTIATE_KEY_EXCH", NTLMSSP_NEGOTIATE_KEY_EXCH, r);
  75         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NTLMSSP_NEGOTIATE_56", NTLMSSP_NEGOTIATE_56, r);
  76         ndr->depth--;
  77 }
  78
  79 static enum ndr_err_code ndr_push_ntlmssp_WindowsMajorVersion(struct ndr_push *ndr, int ndr_flags, enum ntlmssp_WindowsMajorVersion r)
  80 {
  81         NDR_CHECK(ndr_push_enum_uint8(ndr, NDR_SCALARS, r));
  82         return NDR_ERR_SUCCESS;
  83 }
  84
  85 static enum ndr_err_code ndr_pull_ntlmssp_WindowsMajorVersion(struct ndr_pull *ndr, int ndr_flags, enum ntlmssp_WindowsMajorVersion *r)
  86 {
  87         uint8_t v;
  88         NDR_CHECK(ndr_pull_enum_uint8(ndr, NDR_SCALARS, &v));
  89         *r = v;
  90         return NDR_ERR_SUCCESS;
  91 }
  92
  93 _PUBLIC_ void ndr_print_ntlmssp_WindowsMajorVersion(struct ndr_print *ndr, const char *name, enum ntlmssp_WindowsMajorVersion r)
  94 {
  95         const char *val = NULL;
  96
  97         switch (r) {
  98                 case NTLMSSP_WINDOWS_MAJOR_VERSION_5: val = "NTLMSSP_WINDOWS_MAJOR_VERSION_5"; break;
  99                 case NTLMSSP_WINDOWS_MAJOR_VERSION_6: val = "NTLMSSP_WINDOWS_MAJOR_VERSION_6"; break;
 100         }
 101         ndr_print_enum(ndr, name, "ENUM", val, r);
 102 }
 103
 104 static enum ndr_err_code ndr_push_ntlmssp_WindowsMinorVersion(struct ndr_push *ndr, int ndr_flags, enum ntlmssp_WindowsMinorVersion r)
 105 {
 106         NDR_CHECK(ndr_push_enum_uint8(ndr, NDR_SCALARS, r));
 107         return NDR_ERR_SUCCESS;
 108 }
 109
 110 static enum ndr_err_code ndr_pull_ntlmssp_WindowsMinorVersion(struct ndr_pull *ndr, int ndr_flags, enum ntlmssp_WindowsMinorVersion *r)
 111 {
 112         uint8_t v;
 113         NDR_CHECK(ndr_pull_enum_uint8(ndr, NDR_SCALARS, &v));
 114         *r = v;
 115         return NDR_ERR_SUCCESS;
 116 }
 117
 118 _PUBLIC_ void ndr_print_ntlmssp_WindowsMinorVersion(struct ndr_print *ndr, const char *name, enum ntlmssp_WindowsMinorVersion r)
 119 {
 120         const char *val = NULL;
 121
 122         switch (r) {
 123                 case NTLMSSP_WINDOWS_MINOR_VERSION_0: val = "NTLMSSP_WINDOWS_MINOR_VERSION_0"; break;
 124                 case NTLMSSP_WINDOWS_MINOR_VERSION_1: val = "NTLMSSP_WINDOWS_MINOR_VERSION_1"; break;
 125                 case NTLMSSP_WINDOWS_MINOR_VERSION_2: val = "NTLMSSP_WINDOWS_MINOR_VERSION_2"; break;
 126         }
 127         ndr_print_enum(ndr, name, "ENUM", val, r);
 128 }
 129
 130 static enum ndr_err_code ndr_push_ntlmssp_NTLMRevisionCurrent(struct ndr_push *ndr, int ndr_flags, enum ntlmssp_NTLMRevisionCurrent r)
 131 {
 132         NDR_CHECK(ndr_push_enum_uint8(ndr, NDR_SCALARS, r));
 133         return NDR_ERR_SUCCESS;
 134 }
 135
 136 static enum ndr_err_code ndr_pull_ntlmssp_NTLMRevisionCurrent(struct ndr_pull *ndr, int ndr_flags, enum ntlmssp_NTLMRevisionCurrent *r)
 137 {
 138         uint8_t v;
 139         NDR_CHECK(ndr_pull_enum_uint8(ndr, NDR_SCALARS, &v));
 140         *r = v;
 141         return NDR_ERR_SUCCESS;
 142 }
 143
 144 _PUBLIC_ void ndr_print_ntlmssp_NTLMRevisionCurrent(struct ndr_print *ndr, const char *name, enum ntlmssp_NTLMRevisionCurrent r)
 145 {
 146         const char *val = NULL;
 147
 148         switch (r) {
 149                 case NTLMSSP_REVISION_W2K3_RC1: val = "NTLMSSP_REVISION_W2K3_RC1"; break;
 150                 case NTLMSSP_REVISION_W2K3: val = "NTLMSSP_REVISION_W2K3"; break;
 151         }
 152         ndr_print_enum(ndr, name, "ENUM", val, r);
 153 }
 154
 155 static enum ndr_err_code ndr_push_VERSION(struct ndr_push *ndr, int ndr_flags, const struct VERSION *r)
 156 {
 157         if (ndr_flags & NDR_SCALARS) {
 158                 NDR_CHECK(ndr_push_align(ndr, 2));
 159                 NDR_CHECK(ndr_push_ntlmssp_WindowsMajorVersion(ndr, NDR_SCALARS, r->ProductMajorVersion));
 160                 NDR_CHECK(ndr_push_ntlmssp_WindowsMinorVersion(ndr, NDR_SCALARS, r->ProductMinorVersion));
 161                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ProductBuild));
 162                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Reserved, 3));
 163                 NDR_CHECK(ndr_push_ntlmssp_NTLMRevisionCurrent(ndr, NDR_SCALARS, r->NTLMRevisionCurrent));
 164         }
 165         if (ndr_flags & NDR_BUFFERS) {
 166         }
 167         return NDR_ERR_SUCCESS;
 168 }
 169
 170 static enum ndr_err_code ndr_pull_VERSION(struct ndr_pull *ndr, int ndr_flags, struct VERSION *r)
 171 {
 172         if (ndr_flags & NDR_SCALARS) {
 173                 NDR_CHECK(ndr_pull_align(ndr, 2));
 174                 NDR_CHECK(ndr_pull_ntlmssp_WindowsMajorVersion(ndr, NDR_SCALARS, &r->ProductMajorVersion));
 175                 NDR_CHECK(ndr_pull_ntlmssp_WindowsMinorVersion(ndr, NDR_SCALARS, &r->ProductMinorVersion));
 176                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ProductBuild));
 177                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Reserved, 3));
 178                 NDR_CHECK(ndr_pull_ntlmssp_NTLMRevisionCurrent(ndr, NDR_SCALARS, &r->NTLMRevisionCurrent));
 179         }
 180         if (ndr_flags & NDR_BUFFERS) {
 181         }
 182         return NDR_ERR_SUCCESS;
 183 }
 184
 185 _PUBLIC_ void ndr_print_VERSION(struct ndr_print *ndr, const char *name, const struct VERSION *r)
 186 {
 187         ndr_print_struct(ndr, name, "VERSION");
 188         ndr->depth++;
 189         ndr_print_ntlmssp_WindowsMajorVersion(ndr, "ProductMajorVersion", r->ProductMajorVersion);
 190         ndr_print_ntlmssp_WindowsMinorVersion(ndr, "ProductMinorVersion", r->ProductMinorVersion);
 191         ndr_print_uint16(ndr, "ProductBuild", r->ProductBuild);
 192         ndr_print_array_uint8(ndr, "Reserved", r->Reserved, 3);
 193         ndr_print_ntlmssp_NTLMRevisionCurrent(ndr, "NTLMRevisionCurrent", r->NTLMRevisionCurrent);
 194         ndr->depth--;
 195 }
 196
 197 static enum ndr_err_code ndr_push_ntlmssp_Version(struct ndr_push *ndr, int ndr_flags, const union ntlmssp_Version *r)
 198 {
 199         if (ndr_flags & NDR_SCALARS) {
 200                 int level = ndr_push_get_switch_value(ndr, r);
 201                 switch (level) {
 202                         case NTLMSSP_NEGOTIATE_VERSION: {
 203                                 NDR_CHECK(ndr_push_VERSION(ndr, NDR_SCALARS, &r->version));
 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 NTLMSSP_NEGOTIATE_VERSION:
 215                         break;
 216
 217                         default:
 218                         break;
 219
 220                 }
 221         }
 222         return NDR_ERR_SUCCESS;
 223 }
 224
 225 static enum ndr_err_code ndr_pull_ntlmssp_Version(struct ndr_pull *ndr, int ndr_flags, union ntlmssp_Version *r)
 226 {
 227         int level;
 228         level = ndr_pull_get_switch_value(ndr, r);
 229         if (ndr_flags & NDR_SCALARS) {
 230                 switch (level) {
 231                         case NTLMSSP_NEGOTIATE_VERSION: {
 232                                 NDR_CHECK(ndr_pull_VERSION(ndr, NDR_SCALARS, &r->version));
 233                         break; }
 234
 235                         default: {
 236                         break; }
 237
 238                 }
 239         }
 240         if (ndr_flags & NDR_BUFFERS) {
 241                 switch (level) {
 242                         case NTLMSSP_NEGOTIATE_VERSION:
 243                         break;
 244
 245                         default:
 246                         break;
 247
 248                 }
 249         }
 250         return NDR_ERR_SUCCESS;
 251 }
 252
 253 _PUBLIC_ enum ndr_err_code ndr_push_NEGOTIATE_MESSAGE(struct ndr_push *ndr, int ndr_flags, const struct NEGOTIATE_MESSAGE *r)
 254 {
 255         if (ndr_flags & NDR_SCALARS) {
 256                 NDR_CHECK(ndr_push_align(ndr, 5));
 257                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, "NTLMSSP", 8, sizeof(uint8_t), CH_DOS));
 258                 NDR_CHECK(ndr_push_ntlmssp_MessageType(ndr, NDR_SCALARS, NtLmNegotiate));
 259                 NDR_CHECK(ndr_push_NEGOTIATE(ndr, NDR_SCALARS, r->NegotiateFlags));
 260                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen(r->DomainName)));
 261                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen(r->DomainName)));
 262                 {
 263                         uint32_t _flags_save_string = ndr->flags;
 264                         ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(NTLMSSP_NEGOTIATE_OEM));
 265                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->DomainName));
 266                         ndr->flags = _flags_save_string;
 267                 }
 268                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen(r->Workstation)));
 269                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen(r->Workstation)));
 270                 {
 271                         uint32_t _flags_save_string = ndr->flags;
 272                         ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(NTLMSSP_NEGOTIATE_OEM));
 273                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->Workstation));
 274                         ndr->flags = _flags_save_string;
 275                 }
 276                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->Version, r->NegotiateFlags & NTLMSSP_NEGOTIATE_VERSION));
 277                 NDR_CHECK(ndr_push_ntlmssp_Version(ndr, NDR_SCALARS, &r->Version));
 278         }
 279         if (ndr_flags & NDR_BUFFERS) {
 280                 {
 281                         uint32_t _flags_save_string = ndr->flags;
 282                         ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(NTLMSSP_NEGOTIATE_OEM));
 283                         if (r->DomainName) {
 284                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->DomainName));
 285                                 {
 286                                         struct ndr_push *_ndr_DomainName;
 287                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_DomainName, 0, strlen(r->DomainName)));
 288                                         NDR_CHECK(ndr_push_string(_ndr_DomainName, NDR_SCALARS, r->DomainName));
 289                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_DomainName, 0, strlen(r->DomainName)));
 290                                 }
 291                         }
 292                         ndr->flags = _flags_save_string;
 293                 }
 294                 {
 295                         uint32_t _flags_save_string = ndr->flags;
 296                         ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(NTLMSSP_NEGOTIATE_OEM));
 297                         if (r->Workstation) {
 298                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->Workstation));
 299                                 {
 300                                         struct ndr_push *_ndr_Workstation;
 301                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_Workstation, 0, strlen(r->Workstation)));
 302                                         NDR_CHECK(ndr_push_string(_ndr_Workstation, NDR_SCALARS, r->Workstation));
 303                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_Workstation, 0, strlen(r->Workstation)));
 304                                 }
 305                         }
 306                         ndr->flags = _flags_save_string;
 307                 }
 308                 NDR_CHECK(ndr_push_ntlmssp_Version(ndr, NDR_BUFFERS, &r->Version));
 309         }
 310         return NDR_ERR_SUCCESS;
 311 }
 312
 313 _PUBLIC_ enum ndr_err_code ndr_pull_NEGOTIATE_MESSAGE(struct ndr_pull *ndr, int ndr_flags, struct NEGOTIATE_MESSAGE *r)
 314 {
 315         uint32_t _ptr_DomainName;
 316         TALLOC_CTX *_mem_save_DomainName_0;
 317         uint32_t _ptr_Workstation;
 318         TALLOC_CTX *_mem_save_Workstation_0;
 319         if (ndr_flags & NDR_SCALARS) {
 320                 NDR_CHECK(ndr_pull_align(ndr, 5));
 321                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->Signature, 8, sizeof(uint8_t), CH_DOS));
 322                 NDR_CHECK(ndr_pull_ntlmssp_MessageType(ndr, NDR_SCALARS, &r->MessageType));
 323                 NDR_CHECK(ndr_pull_NEGOTIATE(ndr, NDR_SCALARS, &r->NegotiateFlags));
 324                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->DomainNameLen));
 325                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->DomainNameMaxLen));
 326                 {
 327                         uint32_t _flags_save_string = ndr->flags;
 328                         ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(NTLMSSP_NEGOTIATE_OEM));
 329                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_DomainName));
 330                         if (_ptr_DomainName) {
 331                                 NDR_PULL_ALLOC(ndr, r->DomainName);
 332                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->DomainName, _ptr_DomainName));
 333                         } else {
 334                                 r->DomainName = NULL;
 335                         }
 336                         ndr->flags = _flags_save_string;
 337                 }
 338                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->WorkstationLen));
 339                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->WorkstationMaxLen));
 340                 {
 341                         uint32_t _flags_save_string = ndr->flags;
 342                         ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(NTLMSSP_NEGOTIATE_OEM));
 343                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Workstation));
 344                         if (_ptr_Workstation) {
 345                                 NDR_PULL_ALLOC(ndr, r->Workstation);
 346                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->Workstation, _ptr_Workstation));
 347                         } else {
 348                                 r->Workstation = NULL;
 349                         }
 350                         ndr->flags = _flags_save_string;
 351                 }
 352                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->Version, r->NegotiateFlags & NTLMSSP_NEGOTIATE_VERSION));
 353                 NDR_CHECK(ndr_pull_ntlmssp_Version(ndr, NDR_SCALARS, &r->Version));
 354         }
 355         if (ndr_flags & NDR_BUFFERS) {
 356                 {
 357                         uint32_t _flags_save_string = ndr->flags;
 358                         ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(NTLMSSP_NEGOTIATE_OEM));
 359                         if (r->DomainName) {
 360                                 uint32_t _relative_save_offset;
 361                                 _relative_save_offset = ndr->offset;
 362                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->DomainName));
 363                                 _mem_save_DomainName_0 = NDR_PULL_GET_MEM_CTX(ndr);
 364                                 NDR_PULL_SET_MEM_CTX(ndr, r->DomainName, 0);
 365                                 {
 366                                         struct ndr_pull *_ndr_DomainName;
 367                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_DomainName, 0, r->DomainNameLen));
 368                                         NDR_CHECK(ndr_pull_string(_ndr_DomainName, NDR_SCALARS, &r->DomainName));
 369                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_DomainName, 0, r->DomainNameLen));
 370                                 }
 371                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_DomainName_0, 0);
 372                                 ndr->offset = _relative_save_offset;
 373                         }
 374                         ndr->flags = _flags_save_string;
 375                 }
 376                 {
 377                         uint32_t _flags_save_string = ndr->flags;
 378                         ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(NTLMSSP_NEGOTIATE_OEM));
 379                         if (r->Workstation) {
 380                                 uint32_t _relative_save_offset;
 381                                 _relative_save_offset = ndr->offset;
 382                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->Workstation));
 383                                 _mem_save_Workstation_0 = NDR_PULL_GET_MEM_CTX(ndr);
 384                                 NDR_PULL_SET_MEM_CTX(ndr, r->Workstation, 0);
 385                                 {
 386                                         struct ndr_pull *_ndr_Workstation;
 387                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_Workstation, 0, r->WorkstationLen));
 388                                         NDR_CHECK(ndr_pull_string(_ndr_Workstation, NDR_SCALARS, &r->Workstation));
 389                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_Workstation, 0, r->WorkstationLen));
 390                                 }
 391                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Workstation_0, 0);
 392                                 ndr->offset = _relative_save_offset;
 393                         }
 394                         ndr->flags = _flags_save_string;
 395                 }
 396                 NDR_CHECK(ndr_pull_ntlmssp_Version(ndr, NDR_BUFFERS, &r->Version));
 397         }
 398         return NDR_ERR_SUCCESS;
 399 }
 400
 401 _PUBLIC_ void ndr_print_NEGOTIATE_MESSAGE(struct ndr_print *ndr, const char *name, const struct NEGOTIATE_MESSAGE *r)
 402 {
 403         ndr_print_struct(ndr, name, "NEGOTIATE_MESSAGE");
 404         ndr->depth++;
 405         ndr_print_string(ndr, "Signature", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?"NTLMSSP":r->Signature);
 406         ndr_print_ntlmssp_MessageType(ndr, "MessageType", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?NtLmNegotiate:r->MessageType);
 407         ndr_print_NEGOTIATE(ndr, "NegotiateFlags", r->NegotiateFlags);
 408         ndr_print_uint16(ndr, "DomainNameLen", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen(r->DomainName):r->DomainNameLen);
 409         ndr_print_uint16(ndr, "DomainNameMaxLen", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->DomainNameLen:r->DomainNameMaxLen);
 410         ndr_print_ptr(ndr, "DomainName", r->DomainName);
 411         ndr->depth++;
 412         if (r->DomainName) {
 413                 ndr_print_string(ndr, "DomainName", r->DomainName);
 414         }
 415         ndr->depth--;
 416         ndr_print_uint16(ndr, "WorkstationLen", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen(r->Workstation):r->WorkstationLen);
 417         ndr_print_uint16(ndr, "WorkstationMaxLen", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->WorkstationLen:r->WorkstationMaxLen);
 418         ndr_print_ptr(ndr, "Workstation", r->Workstation);
 419         ndr->depth++;
 420         if (r->Workstation) {
 421                 ndr_print_string(ndr, "Workstation", r->Workstation);
 422         }
 423         ndr->depth--;
 424         ndr_print_set_switch_value(ndr, &r->Version, r->NegotiateFlags & NTLMSSP_NEGOTIATE_VERSION);
 425         ndr_print_ntlmssp_Version(ndr, "Version", &r->Version);
 426         ndr->depth--;
 427 }
 428
 429 static enum ndr_err_code ndr_push_ntlmssp_AvId(struct ndr_push *ndr, int ndr_flags, enum ntlmssp_AvId r)
 430 {
 431         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 432         return NDR_ERR_SUCCESS;
 433 }
 434
 435 static enum ndr_err_code ndr_pull_ntlmssp_AvId(struct ndr_pull *ndr, int ndr_flags, enum ntlmssp_AvId *r)
 436 {
 437         uint16_t v;
 438         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 439         *r = v;
 440         return NDR_ERR_SUCCESS;
 441 }
 442
 443 _PUBLIC_ void ndr_print_ntlmssp_AvId(struct ndr_print *ndr, const char *name, enum ntlmssp_AvId r)
 444 {
 445         const char *val = NULL;
 446
 447         switch (r) {
 448                 case MsvAvEOL: val = "MsvAvEOL"; break;
 449                 case MsvAvNbComputerName: val = "MsvAvNbComputerName"; break;
 450                 case MsvAvNbDomainName: val = "MsvAvNbDomainName"; break;
 451                 case MsvAvDnsComputerName: val = "MsvAvDnsComputerName"; break;
 452                 case MsvAvDnsDomainName: val = "MsvAvDnsDomainName"; break;
 453                 case MsvAvDnsTreeName: val = "MsvAvDnsTreeName"; break;
 454                 case MsvAvFlags: val = "MsvAvFlags"; break;
 455                 case MsvAvTimestamp: val = "MsvAvTimestamp"; break;
 456                 case MsAvRestrictions: val = "MsAvRestrictions"; break;
 457                 case MsvAvTargetName: val = "MsvAvTargetName"; break;
 458                 case MsvChannelBindings: val = "MsvChannelBindings"; break;
 459         }
 460         ndr_print_enum(ndr, name, "ENUM", val, r);
 461 }
 462
 463 static enum ndr_err_code ndr_push_Restriction_Encoding(struct ndr_push *ndr, int ndr_flags, const struct Restriction_Encoding *r)
 464 {
 465         if (ndr_flags & NDR_SCALARS) {
 466                 NDR_CHECK(ndr_push_align(ndr, 4));
 467                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Size));
 468                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 469                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->IntegrityLevel));
 470                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->SubjectIntegrityLevel));
 471                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->MachineId, 32));
 472         }
 473         if (ndr_flags & NDR_BUFFERS) {
 474         }
 475         return NDR_ERR_SUCCESS;
 476 }
 477
 478 static enum ndr_err_code ndr_pull_Restriction_Encoding(struct ndr_pull *ndr, int ndr_flags, struct Restriction_Encoding *r)
 479 {
 480         if (ndr_flags & NDR_SCALARS) {
 481                 NDR_CHECK(ndr_pull_align(ndr, 4));
 482                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Size));
 483                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Z4));
 484                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->IntegrityLevel));
 485                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->SubjectIntegrityLevel));
 486                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->MachineId, 32));
 487         }
 488         if (ndr_flags & NDR_BUFFERS) {
 489         }
 490         return NDR_ERR_SUCCESS;
 491 }
 492
 493 _PUBLIC_ void ndr_print_Restriction_Encoding(struct ndr_print *ndr, const char *name, const struct Restriction_Encoding *r)
 494 {
 495         ndr_print_struct(ndr, name, "Restriction_Encoding");
 496         ndr->depth++;
 497         ndr_print_uint32(ndr, "Size", r->Size);
 498         ndr_print_uint32(ndr, "Z4", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->Z4);
 499         ndr_print_uint32(ndr, "IntegrityLevel", r->IntegrityLevel);
 500         ndr_print_uint32(ndr, "SubjectIntegrityLevel", r->SubjectIntegrityLevel);
 501         ndr_print_array_uint8(ndr, "MachineId", r->MachineId, 32);
 502         ndr->depth--;
 503 }
 504
 505 static enum ndr_err_code ndr_push_ntlmssp_AvFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 506 {
 507         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 508         return NDR_ERR_SUCCESS;
 509 }
 510
 511 static enum ndr_err_code ndr_pull_ntlmssp_AvFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 512 {
 513         uint32_t v;
 514         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 515         *r = v;
 516         return NDR_ERR_SUCCESS;
 517 }
 518
 519 _PUBLIC_ void ndr_print_ntlmssp_AvFlags(struct ndr_print *ndr, const char *name, uint32_t r)
 520 {
 521         ndr_print_uint32(ndr, name, r);
 522         ndr->depth++;
 523         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NTLMSSP_AVFLAG_CONSTRAINTED_ACCOUNT", NTLMSSP_AVFLAG_CONSTRAINTED_ACCOUNT, r);
 524         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NTLMSSP_AVFLAG_MIC_IN_AUTHENTICATE_MESSAGE", NTLMSSP_AVFLAG_MIC_IN_AUTHENTICATE_MESSAGE, r);
 525         ndr->depth--;
 526 }
 527
 528 static enum ndr_err_code ndr_push_ntlmssp_AvValue(struct ndr_push *ndr, int ndr_flags, const union ntlmssp_AvValue *r)
 529 {
 530         {
 531                 uint32_t _flags_save_UNION = ndr->flags;
 532                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 533                 if (ndr_flags & NDR_SCALARS) {
 534                         int level = ndr_push_get_switch_value(ndr, r);
 535                         switch (level) {
 536                                 case MsvAvEOL: {
 537                                 break; }
 538
 539                                 case MsvAvNbComputerName: {
 540                                         {
 541                                                 uint32_t _flags_save_string = ndr->flags;
 542                                                 ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(NTLMSSP_NEGOTIATE_UNICODE));
 543                                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->AvNbComputerName));
 544                                                 ndr->flags = _flags_save_string;
 545                                         }
 546                                 break; }
 547
 548                                 case MsvAvNbDomainName: {
 549                                         {
 550                                                 uint32_t _flags_save_string = ndr->flags;
 551                                                 ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(NTLMSSP_NEGOTIATE_UNICODE));
 552                                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->AvNbDomainName));
 553                                                 ndr->flags = _flags_save_string;
 554                                         }
 555                                 break; }
 556
 557                                 case MsvAvDnsComputerName: {
 558                                         {
 559                                                 uint32_t _flags_save_string = ndr->flags;
 560                                                 ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(NTLMSSP_NEGOTIATE_UNICODE));
 561                                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->AvDnsComputerName));
 562                                                 ndr->flags = _flags_save_string;
 563                                         }
 564                                 break; }
 565
 566                                 case MsvAvDnsDomainName: {
 567                                         {
 568                                                 uint32_t _flags_save_string = ndr->flags;
 569                                                 ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(NTLMSSP_NEGOTIATE_UNICODE));
 570                                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->AvDnsDomainName));
 571                                                 ndr->flags = _flags_save_string;
 572                                         }
 573                                 break; }
 574
 575                                 case MsvAvDnsTreeName: {
 576                                         {
 577                                                 uint32_t _flags_save_string = ndr->flags;
 578                                                 ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(NTLMSSP_NEGOTIATE_UNICODE));
 579                                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->AvDnsTreeName));
 580                                                 ndr->flags = _flags_save_string;
 581                                         }
 582                                 break; }
 583
 584                                 case MsvAvFlags: {
 585                                         NDR_CHECK(ndr_push_ntlmssp_AvFlags(ndr, NDR_SCALARS, r->AvFlags));
 586                                 break; }
 587
 588                                 case MsvAvTimestamp: {
 589                                         NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->AvTimestamp));
 590                                 break; }
 591
 592                                 case MsAvRestrictions: {
 593                                         NDR_CHECK(ndr_push_Restriction_Encoding(ndr, NDR_SCALARS, &r->AvRestrictions));
 594                                 break; }
 595
 596                                 case MsvAvTargetName: {
 597                                         {
 598                                                 uint32_t _flags_save_string = ndr->flags;
 599                                                 ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(NTLMSSP_NEGOTIATE_UNICODE));
 600                                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->AvTargetName));
 601                                                 ndr->flags = _flags_save_string;
 602                                         }
 603                                 break; }
 604
 605                                 case MsvChannelBindings: {
 606                                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->ChannelBindings, 16));
 607                                 break; }
 608
 609                                 default: {
 610                                         {
 611                                                 uint32_t _flags_save_DATA_BLOB = ndr->flags;
 612                                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 613                                                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->blob));
 614                                                 ndr->flags = _flags_save_DATA_BLOB;
 615                                         }
 616                                 break; }
 617
 618                         }
 619                 }
 620                 if (ndr_flags & NDR_BUFFERS) {
 621                         int level = ndr_push_get_switch_value(ndr, r);
 622                         switch (level) {
 623                                 case MsvAvEOL:
 624                                 break;
 625
 626                                 case MsvAvNbComputerName:
 627                                 break;
 628
 629                                 case MsvAvNbDomainName:
 630                                 break;
 631
 632                                 case MsvAvDnsComputerName:
 633                                 break;
 634
 635                                 case MsvAvDnsDomainName:
 636                                 break;
 637
 638                                 case MsvAvDnsTreeName:
 639                                 break;
 640
 641                                 case MsvAvFlags:
 642                                 break;
 643
 644                                 case MsvAvTimestamp:
 645                                 break;
 646
 647                                 case MsAvRestrictions:
 648                                 break;
 649
 650                                 case MsvAvTargetName:
 651                                 break;
 652
 653                                 case MsvChannelBindings:
 654                                 break;
 655
 656                                 default:
 657                                 break;
 658
 659                         }
 660                 }
 661                 ndr->flags = _flags_save_UNION;
 662         }
 663         return NDR_ERR_SUCCESS;
 664 }
 665
 666 static enum ndr_err_code ndr_pull_ntlmssp_AvValue(struct ndr_pull *ndr, int ndr_flags, union ntlmssp_AvValue *r)
 667 {
 668         int level;
 669         {
 670                 uint32_t _flags_save_UNION = ndr->flags;
 671                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 672                 level = ndr_pull_get_switch_value(ndr, r);
 673                 if (ndr_flags & NDR_SCALARS) {
 674                         switch (level) {
 675                                 case MsvAvEOL: {
 676                                 break; }
 677
 678                                 case MsvAvNbComputerName: {
 679                                         {
 680                                                 uint32_t _flags_save_string = ndr->flags;
 681                                                 ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(NTLMSSP_NEGOTIATE_UNICODE));
 682                                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->AvNbComputerName));
 683                                                 ndr->flags = _flags_save_string;
 684                                         }
 685                                 break; }
 686
 687                                 case MsvAvNbDomainName: {
 688                                         {
 689                                                 uint32_t _flags_save_string = ndr->flags;
 690                                                 ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(NTLMSSP_NEGOTIATE_UNICODE));
 691                                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->AvNbDomainName));
 692                                                 ndr->flags = _flags_save_string;
 693                                         }
 694                                 break; }
 695
 696                                 case MsvAvDnsComputerName: {
 697                                         {
 698                                                 uint32_t _flags_save_string = ndr->flags;
 699                                                 ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(NTLMSSP_NEGOTIATE_UNICODE));
 700                                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->AvDnsComputerName));
 701                                                 ndr->flags = _flags_save_string;
 702                                         }
 703                                 break; }
 704
 705                                 case MsvAvDnsDomainName: {
 706                                         {
 707                                                 uint32_t _flags_save_string = ndr->flags;
 708                                                 ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(NTLMSSP_NEGOTIATE_UNICODE));
 709                                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->AvDnsDomainName));
 710                                                 ndr->flags = _flags_save_string;
 711                                         }
 712                                 break; }
 713
 714                                 case MsvAvDnsTreeName: {
 715                                         {
 716                                                 uint32_t _flags_save_string = ndr->flags;
 717                                                 ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(NTLMSSP_NEGOTIATE_UNICODE));
 718                                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->AvDnsTreeName));
 719                                                 ndr->flags = _flags_save_string;
 720                                         }
 721                                 break; }
 722
 723                                 case MsvAvFlags: {
 724                                         NDR_CHECK(ndr_pull_ntlmssp_AvFlags(ndr, NDR_SCALARS, &r->AvFlags));
 725                                 break; }
 726
 727                                 case MsvAvTimestamp: {
 728                                         NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->AvTimestamp));
 729                                 break; }
 730
 731                                 case MsAvRestrictions: {
 732                                         NDR_CHECK(ndr_pull_Restriction_Encoding(ndr, NDR_SCALARS, &r->AvRestrictions));
 733                                 break; }
 734
 735                                 case MsvAvTargetName: {
 736                                         {
 737                                                 uint32_t _flags_save_string = ndr->flags;
 738                                                 ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(NTLMSSP_NEGOTIATE_UNICODE));
 739                                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->AvTargetName));
 740                                                 ndr->flags = _flags_save_string;
 741                                         }
 742                                 break; }
 743
 744                                 case MsvChannelBindings: {
 745                                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->ChannelBindings, 16));
 746                                 break; }
 747
 748                                 default: {
 749                                         {
 750                                                 uint32_t _flags_save_DATA_BLOB = ndr->flags;
 751                                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 752                                                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->blob));
 753                                                 ndr->flags = _flags_save_DATA_BLOB;
 754                                         }
 755                                 break; }
 756
 757                         }
 758                 }
 759                 if (ndr_flags & NDR_BUFFERS) {
 760                         switch (level) {
 761                                 case MsvAvEOL:
 762                                 break;
 763
 764                                 case MsvAvNbComputerName:
 765                                 break;
 766
 767                                 case MsvAvNbDomainName:
 768                                 break;
 769
 770                                 case MsvAvDnsComputerName:
 771                                 break;
 772
 773                                 case MsvAvDnsDomainName:
 774                                 break;
 775
 776                                 case MsvAvDnsTreeName:
 777                                 break;
 778
 779                                 case MsvAvFlags:
 780                                 break;
 781
 782                                 case MsvAvTimestamp:
 783                                 break;
 784
 785                                 case MsAvRestrictions:
 786                                 break;
 787
 788                                 case MsvAvTargetName:
 789                                 break;
 790
 791                                 case MsvChannelBindings:
 792                                 break;
 793
 794                                 default:
 795                                 break;
 796
 797                         }
 798                 }
 799                 ndr->flags = _flags_save_UNION;
 800         }
 801         return NDR_ERR_SUCCESS;
 802 }
 803
 804 _PUBLIC_ void ndr_print_ntlmssp_AvValue(struct ndr_print *ndr, const char *name, const union ntlmssp_AvValue *r)
 805 {
 806         int level;
 807         {
 808                 uint32_t _flags_save_UNION = ndr->flags;
 809                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 810                 level = ndr_print_get_switch_value(ndr, r);
 811                 ndr_print_union(ndr, name, level, "ntlmssp_AvValue");
 812                 switch (level) {
 813                         case MsvAvEOL:
 814                         break;
 815
 816                         case MsvAvNbComputerName:
 817                                 ndr_print_string(ndr, "AvNbComputerName", r->AvNbComputerName);
 818                         break;
 819
 820                         case MsvAvNbDomainName:
 821                                 ndr_print_string(ndr, "AvNbDomainName", r->AvNbDomainName);
 822                         break;
 823
 824                         case MsvAvDnsComputerName:
 825                                 ndr_print_string(ndr, "AvDnsComputerName", r->AvDnsComputerName);
 826                         break;
 827
 828                         case MsvAvDnsDomainName:
 829                                 ndr_print_string(ndr, "AvDnsDomainName", r->AvDnsDomainName);
 830                         break;
 831
 832                         case MsvAvDnsTreeName:
 833                                 ndr_print_string(ndr, "AvDnsTreeName", r->AvDnsTreeName);
 834                         break;
 835
 836                         case MsvAvFlags:
 837                                 ndr_print_ntlmssp_AvFlags(ndr, "AvFlags", r->AvFlags);
 838                         break;
 839
 840                         case MsvAvTimestamp:
 841                                 ndr_print_NTTIME(ndr, "AvTimestamp", r->AvTimestamp);
 842                         break;
 843
 844                         case MsAvRestrictions:
 845                                 ndr_print_Restriction_Encoding(ndr, "AvRestrictions", &r->AvRestrictions);
 846                         break;
 847
 848                         case MsvAvTargetName:
 849                                 ndr_print_string(ndr, "AvTargetName", r->AvTargetName);
 850                         break;
 851
 852                         case MsvChannelBindings:
 853                                 ndr_print_array_uint8(ndr, "ChannelBindings", r->ChannelBindings, 16);
 854                         break;
 855
 856                         default:
 857                                 ndr_print_DATA_BLOB(ndr, "blob", r->blob);
 858                         break;
 859
 860                 }
 861                 ndr->flags = _flags_save_UNION;
 862         }
 863 }
 864
 865 static size_t ndr_size_ntlmssp_AvValue(const union ntlmssp_AvValue *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
 866 {
 867         flags |= LIBNDR_FLAG_NOALIGN;
 868         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_ntlmssp_AvValue, ic);
 869 }
 870
 871 _PUBLIC_ enum ndr_err_code ndr_push_AV_PAIR(struct ndr_push *ndr, int ndr_flags, const struct AV_PAIR *r)
 872 {
 873         {
 874                 uint32_t _flags_save_STRUCT = ndr->flags;
 875                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 876                 if (ndr_flags & NDR_SCALARS) {
 877                         NDR_CHECK(ndr_push_align(ndr, 4));
 878                         NDR_CHECK(ndr_push_ntlmssp_AvId(ndr, NDR_SCALARS, r->AvId));
 879                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, ndr_size_ntlmssp_AvValue(&r->Value, r->AvId, ndr->iconv_convenience, 0)));
 880                         {
 881                                 struct ndr_push *_ndr_Value;
 882                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_Value, 0, ndr_size_ntlmssp_AvValue(&r->Value, r->AvId, ndr->iconv_convenience, 0)));
 883                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_Value, &r->Value, r->AvId));
 884                                 NDR_CHECK(ndr_push_ntlmssp_AvValue(_ndr_Value, NDR_SCALARS|NDR_BUFFERS, &r->Value));
 885                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_Value, 0, ndr_size_ntlmssp_AvValue(&r->Value, r->AvId, ndr->iconv_convenience, 0)));
 886                         }
 887                 }
 888                 if (ndr_flags & NDR_BUFFERS) {
 889                 }
 890                 ndr->flags = _flags_save_STRUCT;
 891         }
 892         return NDR_ERR_SUCCESS;
 893 }
 894
 895 _PUBLIC_ enum ndr_err_code ndr_pull_AV_PAIR(struct ndr_pull *ndr, int ndr_flags, struct AV_PAIR *r)
 896 {
 897         {
 898                 uint32_t _flags_save_STRUCT = ndr->flags;
 899                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 900                 if (ndr_flags & NDR_SCALARS) {
 901                         NDR_CHECK(ndr_pull_align(ndr, 4));
 902                         NDR_CHECK(ndr_pull_ntlmssp_AvId(ndr, NDR_SCALARS, &r->AvId));
 903                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->AvLen));
 904                         {
 905                                 struct ndr_pull *_ndr_Value;
 906                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_Value, 0, r->AvLen));
 907                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_Value, &r->Value, r->AvId));
 908                                 NDR_CHECK(ndr_pull_ntlmssp_AvValue(_ndr_Value, NDR_SCALARS|NDR_BUFFERS, &r->Value));
 909                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_Value, 0, r->AvLen));
 910                         }
 911                 }
 912                 if (ndr_flags & NDR_BUFFERS) {
 913                 }
 914                 ndr->flags = _flags_save_STRUCT;
 915         }
 916         return NDR_ERR_SUCCESS;
 917 }
 918
 919 _PUBLIC_ void ndr_print_AV_PAIR(struct ndr_print *ndr, const char *name, const struct AV_PAIR *r)
 920 {
 921         ndr_print_struct(ndr, name, "AV_PAIR");
 922         {
 923                 uint32_t _flags_save_STRUCT = ndr->flags;
 924                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 925                 ndr->depth++;
 926                 ndr_print_ntlmssp_AvId(ndr, "AvId", r->AvId);
 927                 ndr_print_uint16(ndr, "AvLen", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_ntlmssp_AvValue(&r->Value, r->AvId, ndr->iconv_convenience, 0):r->AvLen);
 928                 ndr_print_set_switch_value(ndr, &r->Value, r->AvId);
 929                 ndr_print_ntlmssp_AvValue(ndr, "Value", &r->Value);
 930                 ndr->depth--;
 931                 ndr->flags = _flags_save_STRUCT;
 932         }
 933 }
 934
 935 _PUBLIC_ void ndr_print_AV_PAIR_LIST(struct ndr_print *ndr, const char *name, const struct AV_PAIR_LIST *r)
 936 {
 937         uint32_t cntr_pair_0;
 938         ndr_print_struct(ndr, name, "AV_PAIR_LIST");
 939         {
 940                 uint32_t _flags_save_STRUCT = ndr->flags;
 941                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 942                 ndr->depth++;
 943                 ndr_print_uint32(ndr, "count", r->count);
 944                 ndr->print(ndr, "%s: ARRAY(%d)", "pair", (int)r->count);
 945                 ndr->depth++;
 946                 for (cntr_pair_0=0;cntr_pair_0<r->count;cntr_pair_0++) {
 947                         char *idx_0=NULL;
 948                         if (asprintf(&idx_0, "[%d]", cntr_pair_0) != -1) {
 949                                 ndr_print_AV_PAIR(ndr, "pair", &r->pair[cntr_pair_0]);
 950                                 free(idx_0);
 951                         }
 952                 }
 953                 ndr->depth--;
 954                 ndr->depth--;
 955                 ndr->flags = _flags_save_STRUCT;
 956         }
 957 }
 958
 959 static size_t ndr_size_AV_PAIR_LIST(const struct AV_PAIR_LIST *r, struct smb_iconv_convenience *ic, int flags)
 960 {
 961         flags |= LIBNDR_FLAG_NOALIGN;
 962         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_AV_PAIR_LIST, ic);
 963 }
 964
 965 _PUBLIC_ enum ndr_err_code ndr_push_CHALLENGE_MESSAGE(struct ndr_push *ndr, int ndr_flags, const struct CHALLENGE_MESSAGE *r)
 966 {
 967         {
 968                 uint32_t _flags_save_STRUCT = ndr->flags;
 969                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 970                 if (ndr_flags & NDR_SCALARS) {
 971                         NDR_CHECK(ndr_push_align(ndr, 5));
 972                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, "NTLMSSP", 8, sizeof(uint8_t), CH_DOS));
 973                         NDR_CHECK(ndr_push_ntlmssp_MessageType(ndr, NDR_SCALARS, NtLmChallenge));
 974                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, ndr_ntlmssp_string_length(r->NegotiateFlags, r->TargetName)));
 975                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, ndr_ntlmssp_string_length(r->NegotiateFlags, r->TargetName)));
 976                         {
 977                                 uint32_t _flags_save_string = ndr->flags;
 978                                 ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(r->NegotiateFlags));
 979                                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->TargetName));
 980                                 ndr->flags = _flags_save_string;
 981                         }
 982                         NDR_CHECK(ndr_push_NEGOTIATE(ndr, NDR_SCALARS, r->NegotiateFlags));
 983                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->ServerChallenge, 8));
 984                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Reserved, 8));
 985                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, ndr_size_AV_PAIR_LIST(r->TargetInfo, ndr->iconv_convenience, ndr->flags)));
 986                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, ndr_size_AV_PAIR_LIST(r->TargetInfo, ndr->iconv_convenience, ndr->flags)));
 987                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->TargetInfo));
 988                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->Version, r->NegotiateFlags & NTLMSSP_NEGOTIATE_VERSION));
 989                         NDR_CHECK(ndr_push_ntlmssp_Version(ndr, NDR_SCALARS, &r->Version));
 990                 }
 991                 if (ndr_flags & NDR_BUFFERS) {
 992                         {
 993                                 uint32_t _flags_save_string = ndr->flags;
 994                                 ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(r->NegotiateFlags));
 995                                 if (r->TargetName) {
 996                                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->TargetName));
 997                                         {
 998                                                 struct ndr_push *_ndr_TargetName;
 999                                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_TargetName, 0, ndr_ntlmssp_string_length(r->NegotiateFlags, r->TargetName)));
1000                                                 NDR_CHECK(ndr_push_string(_ndr_TargetName, NDR_SCALARS, r->TargetName));
1001                                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_TargetName, 0, ndr_ntlmssp_string_length(r->NegotiateFlags, r->TargetName)));
1002                                         }
1003                                 }
1004                                 ndr->flags = _flags_save_string;
1005                         }
1006                         if (r->TargetInfo) {
1007                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->TargetInfo));
1008                                 {
1009                                         struct ndr_push *_ndr_TargetInfo;
1010                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_TargetInfo, 0, ndr_size_AV_PAIR_LIST(r->TargetInfo, ndr->iconv_convenience, ndr->flags)));
1011                                         NDR_CHECK(ndr_push_AV_PAIR_LIST(_ndr_TargetInfo, NDR_SCALARS|NDR_BUFFERS, r->TargetInfo));
1012                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_TargetInfo, 0, ndr_size_AV_PAIR_LIST(r->TargetInfo, ndr->iconv_convenience, ndr->flags)));
1013                                 }
1014                         }
1015                         NDR_CHECK(ndr_push_ntlmssp_Version(ndr, NDR_BUFFERS, &r->Version));
1016                 }
1017                 ndr->flags = _flags_save_STRUCT;
1018         }
1019         return NDR_ERR_SUCCESS;
1020 }
1021
1022 _PUBLIC_ enum ndr_err_code ndr_pull_CHALLENGE_MESSAGE(struct ndr_pull *ndr, int ndr_flags, struct CHALLENGE_MESSAGE *r)
1023 {
1024         uint32_t _ptr_TargetName;
1025         TALLOC_CTX *_mem_save_TargetName_0;
1026         uint32_t _ptr_TargetInfo;
1027         TALLOC_CTX *_mem_save_TargetInfo_0;
1028         {
1029                 uint32_t _flags_save_STRUCT = ndr->flags;
1030                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1031                 if (ndr_flags & NDR_SCALARS) {
1032                         NDR_CHECK(ndr_pull_align(ndr, 5));
1033                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->Signature, 8, sizeof(uint8_t), CH_DOS));
1034                         NDR_CHECK(ndr_pull_ntlmssp_MessageType(ndr, NDR_SCALARS, &r->MessageType));
1035                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->TargetNameLen));
1036                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->TargetNameMaxLen));
1037                         {
1038                                 uint32_t _flags_save_string = ndr->flags;
1039                                 ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(r->NegotiateFlags));
1040                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_TargetName));
1041                                 if (_ptr_TargetName) {
1042                                         NDR_PULL_ALLOC(ndr, r->TargetName);
1043                                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->TargetName, _ptr_TargetName));
1044                                 } else {
1045                                         r->TargetName = NULL;
1046                                 }
1047                                 ndr->flags = _flags_save_string;
1048                         }
1049                         NDR_CHECK(ndr_pull_NEGOTIATE(ndr, NDR_SCALARS, &r->NegotiateFlags));
1050                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->ServerChallenge, 8));
1051                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Reserved, 8));
1052                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->TargetInfoLen));
1053                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->TargetNameInfoMaxLen));
1054                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_TargetInfo));
1055                         if (_ptr_TargetInfo) {
1056                                 NDR_PULL_ALLOC(ndr, r->TargetInfo);
1057                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->TargetInfo, _ptr_TargetInfo));
1058                         } else {
1059                                 r->TargetInfo = NULL;
1060                         }
1061                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->Version, r->NegotiateFlags & NTLMSSP_NEGOTIATE_VERSION));
1062                         NDR_CHECK(ndr_pull_ntlmssp_Version(ndr, NDR_SCALARS, &r->Version));
1063                 }
1064                 if (ndr_flags & NDR_BUFFERS) {
1065                         {
1066                                 uint32_t _flags_save_string = ndr->flags;
1067                                 ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(r->NegotiateFlags));
1068                                 if (r->TargetName) {
1069                                         uint32_t _relative_save_offset;
1070                                         _relative_save_offset = ndr->offset;
1071                                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->TargetName));
1072                                         _mem_save_TargetName_0 = NDR_PULL_GET_MEM_CTX(ndr);
1073                                         NDR_PULL_SET_MEM_CTX(ndr, r->TargetName, 0);
1074                                         {
1075                                                 struct ndr_pull *_ndr_TargetName;
1076                                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_TargetName, 0, r->TargetNameLen));
1077                                                 NDR_CHECK(ndr_pull_string(_ndr_TargetName, NDR_SCALARS, &r->TargetName));
1078                                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_TargetName, 0, r->TargetNameLen));
1079                                         }
1080                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_TargetName_0, 0);
1081                                         ndr->offset = _relative_save_offset;
1082                                 }
1083                                 ndr->flags = _flags_save_string;
1084                         }
1085                         if (r->TargetInfo) {
1086                                 uint32_t _relative_save_offset;
1087                                 _relative_save_offset = ndr->offset;
1088                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->TargetInfo));
1089                                 _mem_save_TargetInfo_0 = NDR_PULL_GET_MEM_CTX(ndr);
1090                                 NDR_PULL_SET_MEM_CTX(ndr, r->TargetInfo, 0);
1091                                 {
1092                                         struct ndr_pull *_ndr_TargetInfo;
1093                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_TargetInfo, 0, r->TargetInfoLen));
1094                                         NDR_CHECK(ndr_pull_AV_PAIR_LIST(_ndr_TargetInfo, NDR_SCALARS|NDR_BUFFERS, r->TargetInfo));
1095                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_TargetInfo, 0, r->TargetInfoLen));
1096                                 }
1097                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_TargetInfo_0, 0);
1098                                 ndr->offset = _relative_save_offset;
1099                         }
1100                         NDR_CHECK(ndr_pull_ntlmssp_Version(ndr, NDR_BUFFERS, &r->Version));
1101                 }
1102                 ndr->flags = _flags_save_STRUCT;
1103         }
1104         return NDR_ERR_SUCCESS;
1105 }
1106
1107 _PUBLIC_ void ndr_print_CHALLENGE_MESSAGE(struct ndr_print *ndr, const char *name, const struct CHALLENGE_MESSAGE *r)
1108 {
1109         ndr_print_struct(ndr, name, "CHALLENGE_MESSAGE");
1110         {
1111                 uint32_t _flags_save_STRUCT = ndr->flags;
1112                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1113                 ndr->depth++;
1114                 ndr_print_string(ndr, "Signature", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?"NTLMSSP":r->Signature);
1115                 ndr_print_ntlmssp_MessageType(ndr, "MessageType", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?NtLmChallenge:r->MessageType);
1116                 ndr_print_uint16(ndr, "TargetNameLen", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_ntlmssp_string_length(r->NegotiateFlags, r->TargetName):r->TargetNameLen);
1117                 ndr_print_uint16(ndr, "TargetNameMaxLen", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->TargetNameLen:r->TargetNameMaxLen);
1118                 ndr_print_ptr(ndr, "TargetName", r->TargetName);
1119                 ndr->depth++;
1120                 if (r->TargetName) {
1121                         ndr_print_string(ndr, "TargetName", r->TargetName);
1122                 }
1123                 ndr->depth--;
1124                 ndr_print_NEGOTIATE(ndr, "NegotiateFlags", r->NegotiateFlags);
1125                 ndr_print_array_uint8(ndr, "ServerChallenge", r->ServerChallenge, 8);
1126                 ndr_print_array_uint8(ndr, "Reserved", r->Reserved, 8);
1127                 ndr_print_uint16(ndr, "TargetInfoLen", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_AV_PAIR_LIST(r->TargetInfo, ndr->iconv_convenience, ndr->flags):r->TargetInfoLen);
1128                 ndr_print_uint16(ndr, "TargetNameInfoMaxLen", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->TargetInfoLen:r->TargetNameInfoMaxLen);
1129                 ndr_print_ptr(ndr, "TargetInfo", r->TargetInfo);
1130                 ndr->depth++;
1131                 if (r->TargetInfo) {
1132                         ndr_print_AV_PAIR_LIST(ndr, "TargetInfo", r->TargetInfo);
1133                 }
1134                 ndr->depth--;
1135                 ndr_print_set_switch_value(ndr, &r->Version, r->NegotiateFlags & NTLMSSP_NEGOTIATE_VERSION);
1136                 ndr_print_ntlmssp_Version(ndr, "Version", &r->Version);
1137                 ndr->depth--;
1138                 ndr->flags = _flags_save_STRUCT;
1139         }
1140 }
1141
1142 _PUBLIC_ enum ndr_err_code ndr_push_LM_RESPONSE(struct ndr_push *ndr, int ndr_flags, const struct LM_RESPONSE *r)
1143 {
1144         {
1145                 uint32_t _flags_save_STRUCT = ndr->flags;
1146                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1147                 if (ndr_flags & NDR_SCALARS) {
1148                         NDR_CHECK(ndr_push_align(ndr, 1));
1149                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Response, 24));
1150                 }
1151                 if (ndr_flags & NDR_BUFFERS) {
1152                 }
1153                 ndr->flags = _flags_save_STRUCT;
1154         }
1155         return NDR_ERR_SUCCESS;
1156 }
1157
1158 _PUBLIC_ enum ndr_err_code ndr_pull_LM_RESPONSE(struct ndr_pull *ndr, int ndr_flags, struct LM_RESPONSE *r)
1159 {
1160         {
1161                 uint32_t _flags_save_STRUCT = ndr->flags;
1162                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1163                 if (ndr_flags & NDR_SCALARS) {
1164                         NDR_CHECK(ndr_pull_align(ndr, 1));
1165                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Response, 24));
1166                 }
1167                 if (ndr_flags & NDR_BUFFERS) {
1168                 }
1169                 ndr->flags = _flags_save_STRUCT;
1170         }
1171         return NDR_ERR_SUCCESS;
1172 }
1173
1174 _PUBLIC_ void ndr_print_LM_RESPONSE(struct ndr_print *ndr, const char *name, const struct LM_RESPONSE *r)
1175 {
1176         ndr_print_struct(ndr, name, "LM_RESPONSE");
1177         {
1178                 uint32_t _flags_save_STRUCT = ndr->flags;
1179                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1180                 ndr->depth++;
1181                 ndr_print_array_uint8(ndr, "Response", r->Response, 24);
1182                 ndr->depth--;
1183                 ndr->flags = _flags_save_STRUCT;
1184         }
1185 }
1186
1187 _PUBLIC_ enum ndr_err_code ndr_push_LMv2_RESPONSE(struct ndr_push *ndr, int ndr_flags, const struct LMv2_RESPONSE *r)
1188 {
1189         {
1190                 uint32_t _flags_save_STRUCT = ndr->flags;
1191                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1192                 if (ndr_flags & NDR_SCALARS) {
1193                         NDR_CHECK(ndr_push_align(ndr, 1));
1194                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Response, 16));
1195                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->ChallengeFromClient, 8));
1196                 }
1197                 if (ndr_flags & NDR_BUFFERS) {
1198                 }
1199                 ndr->flags = _flags_save_STRUCT;
1200         }
1201         return NDR_ERR_SUCCESS;
1202 }
1203
1204 _PUBLIC_ enum ndr_err_code ndr_pull_LMv2_RESPONSE(struct ndr_pull *ndr, int ndr_flags, struct LMv2_RESPONSE *r)
1205 {
1206         {
1207                 uint32_t _flags_save_STRUCT = ndr->flags;
1208                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1209                 if (ndr_flags & NDR_SCALARS) {
1210                         NDR_CHECK(ndr_pull_align(ndr, 1));
1211                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Response, 16));
1212                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->ChallengeFromClient, 8));
1213                 }
1214                 if (ndr_flags & NDR_BUFFERS) {
1215                 }
1216                 ndr->flags = _flags_save_STRUCT;
1217         }
1218         return NDR_ERR_SUCCESS;
1219 }
1220
1221 _PUBLIC_ void ndr_print_LMv2_RESPONSE(struct ndr_print *ndr, const char *name, const struct LMv2_RESPONSE *r)
1222 {
1223         ndr_print_struct(ndr, name, "LMv2_RESPONSE");
1224         {
1225                 uint32_t _flags_save_STRUCT = ndr->flags;
1226                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1227                 ndr->depth++;
1228                 ndr_print_array_uint8(ndr, "Response", r->Response, 16);
1229                 ndr_print_array_uint8(ndr, "ChallengeFromClient", r->ChallengeFromClient, 8);
1230                 ndr->depth--;
1231                 ndr->flags = _flags_save_STRUCT;
1232         }
1233 }
1234
1235 static enum ndr_err_code ndr_push_ntlmssp_LM_RESPONSE(struct ndr_push *ndr, int ndr_flags, const union ntlmssp_LM_RESPONSE *r)
1236 {
1237         if (ndr_flags & NDR_SCALARS) {
1238                 int level = ndr_push_get_switch_value(ndr, r);
1239                 switch (level) {
1240                         case 24: {
1241                                 NDR_CHECK(ndr_push_LM_RESPONSE(ndr, NDR_SCALARS, &r->v1));
1242                         break; }
1243
1244                         default: {
1245                         break; }
1246
1247                 }
1248         }
1249         if (ndr_flags & NDR_BUFFERS) {
1250                 int level = ndr_push_get_switch_value(ndr, r);
1251                 switch (level) {
1252                         case 24:
1253                         break;
1254
1255                         default:
1256                         break;
1257
1258                 }
1259         }
1260         return NDR_ERR_SUCCESS;
1261 }
1262
1263 static enum ndr_err_code ndr_pull_ntlmssp_LM_RESPONSE(struct ndr_pull *ndr, int ndr_flags, union ntlmssp_LM_RESPONSE *r)
1264 {
1265         int level;
1266         level = ndr_pull_get_switch_value(ndr, r);
1267         if (ndr_flags & NDR_SCALARS) {
1268                 switch (level) {
1269                         case 24: {
1270                                 NDR_CHECK(ndr_pull_LM_RESPONSE(ndr, NDR_SCALARS, &r->v1));
1271                         break; }
1272
1273                         default: {
1274                         break; }
1275
1276                 }
1277         }
1278         if (ndr_flags & NDR_BUFFERS) {
1279                 switch (level) {
1280                         case 24:
1281                         break;
1282
1283                         default:
1284                         break;
1285
1286                 }
1287         }
1288         return NDR_ERR_SUCCESS;
1289 }
1290
1291 _PUBLIC_ void ndr_print_ntlmssp_LM_RESPONSE(struct ndr_print *ndr, const char *name, const union ntlmssp_LM_RESPONSE *r)
1292 {
1293         int level;
1294         level = ndr_print_get_switch_value(ndr, r);
1295         ndr_print_union(ndr, name, level, "ntlmssp_LM_RESPONSE");
1296         switch (level) {
1297                 case 24:
1298                         ndr_print_LM_RESPONSE(ndr, "v1", &r->v1);
1299                 break;
1300
1301                 default:
1302                 break;
1303
1304         }
1305 }
1306
1307 _PUBLIC_ enum ndr_err_code ndr_push_NTLM_RESPONSE(struct ndr_push *ndr, int ndr_flags, const struct NTLM_RESPONSE *r)
1308 {
1309         {
1310                 uint32_t _flags_save_STRUCT = ndr->flags;
1311                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1312                 if (ndr_flags & NDR_SCALARS) {
1313                         NDR_CHECK(ndr_push_align(ndr, 1));
1314                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Response, 24));
1315                 }
1316                 if (ndr_flags & NDR_BUFFERS) {
1317                 }
1318                 ndr->flags = _flags_save_STRUCT;
1319         }
1320         return NDR_ERR_SUCCESS;
1321 }
1322
1323 _PUBLIC_ enum ndr_err_code ndr_pull_NTLM_RESPONSE(struct ndr_pull *ndr, int ndr_flags, struct NTLM_RESPONSE *r)
1324 {
1325         {
1326                 uint32_t _flags_save_STRUCT = ndr->flags;
1327                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1328                 if (ndr_flags & NDR_SCALARS) {
1329                         NDR_CHECK(ndr_pull_align(ndr, 1));
1330                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Response, 24));
1331                 }
1332                 if (ndr_flags & NDR_BUFFERS) {
1333                 }
1334                 ndr->flags = _flags_save_STRUCT;
1335         }
1336         return NDR_ERR_SUCCESS;
1337 }
1338
1339 _PUBLIC_ void ndr_print_NTLM_RESPONSE(struct ndr_print *ndr, const char *name, const struct NTLM_RESPONSE *r)
1340 {
1341         ndr_print_struct(ndr, name, "NTLM_RESPONSE");
1342         {
1343                 uint32_t _flags_save_STRUCT = ndr->flags;
1344                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1345                 ndr->depth++;
1346                 ndr_print_array_uint8(ndr, "Response", r->Response, 24);
1347                 ndr->depth--;
1348                 ndr->flags = _flags_save_STRUCT;
1349         }
1350 }
1351
1352 static enum ndr_err_code ndr_push_NTLMv2_CLIENT_CHALLENGE(struct ndr_push *ndr, int ndr_flags, const struct NTLMv2_CLIENT_CHALLENGE *r)
1353 {
1354         {
1355                 uint32_t _flags_save_STRUCT = ndr->flags;
1356                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1357                 if (ndr_flags & NDR_SCALARS) {
1358                         NDR_CHECK(ndr_push_align(ndr, 4));
1359                         NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, 1));
1360                         NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, 1));
1361                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->Reserved1));
1362                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Reserved2));
1363                         NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->TimeStamp));
1364                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->ChallengeFromClient, 8));
1365                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Reserved3));
1366                         {
1367                                 uint32_t _flags_save_AV_PAIR_LIST = ndr->flags;
1368                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1369                                 {
1370                                         struct ndr_push *_ndr_AvPairs;
1371                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_AvPairs, 0, -1));
1372                                         NDR_CHECK(ndr_push_AV_PAIR_LIST(_ndr_AvPairs, NDR_SCALARS|NDR_BUFFERS, &r->AvPairs));
1373                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_AvPairs, 0, -1));
1374                                 }
1375                                 ndr->flags = _flags_save_AV_PAIR_LIST;
1376                         }
1377                 }
1378                 if (ndr_flags & NDR_BUFFERS) {
1379                         {
1380                                 uint32_t _flags_save_AV_PAIR_LIST = ndr->flags;
1381                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1382                                 ndr->flags = _flags_save_AV_PAIR_LIST;
1383                         }
1384                 }
1385                 ndr->flags = _flags_save_STRUCT;
1386         }
1387         return NDR_ERR_SUCCESS;
1388 }
1389
1390 static enum ndr_err_code ndr_pull_NTLMv2_CLIENT_CHALLENGE(struct ndr_pull *ndr, int ndr_flags, struct NTLMv2_CLIENT_CHALLENGE *r)
1391 {
1392         {
1393                 uint32_t _flags_save_STRUCT = ndr->flags;
1394                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1395                 if (ndr_flags & NDR_SCALARS) {
1396                         NDR_CHECK(ndr_pull_align(ndr, 4));
1397                         NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->RespType));
1398                         NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->HiRespType));
1399                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->Reserved1));
1400                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Reserved2));
1401                         NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->TimeStamp));
1402                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->ChallengeFromClient, 8));
1403                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Reserved3));
1404                         {
1405                                 uint32_t _flags_save_AV_PAIR_LIST = ndr->flags;
1406                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1407                                 {
1408                                         struct ndr_pull *_ndr_AvPairs;
1409                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_AvPairs, 0, -1));
1410                                         NDR_CHECK(ndr_pull_AV_PAIR_LIST(_ndr_AvPairs, NDR_SCALARS|NDR_BUFFERS, &r->AvPairs));
1411                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_AvPairs, 0, -1));
1412                                 }
1413                                 ndr->flags = _flags_save_AV_PAIR_LIST;
1414                         }
1415                 }
1416                 if (ndr_flags & NDR_BUFFERS) {
1417                         {
1418                                 uint32_t _flags_save_AV_PAIR_LIST = ndr->flags;
1419                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1420                                 ndr->flags = _flags_save_AV_PAIR_LIST;
1421                         }
1422                 }
1423                 ndr->flags = _flags_save_STRUCT;
1424         }
1425         return NDR_ERR_SUCCESS;
1426 }
1427
1428 _PUBLIC_ void ndr_print_NTLMv2_CLIENT_CHALLENGE(struct ndr_print *ndr, const char *name, const struct NTLMv2_CLIENT_CHALLENGE *r)
1429 {
1430         ndr_print_struct(ndr, name, "NTLMv2_CLIENT_CHALLENGE");
1431         {
1432                 uint32_t _flags_save_STRUCT = ndr->flags;
1433                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1434                 ndr->depth++;
1435                 ndr_print_uint8(ndr, "RespType", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->RespType);
1436                 ndr_print_uint8(ndr, "HiRespType", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->HiRespType);
1437                 ndr_print_uint16(ndr, "Reserved1", r->Reserved1);
1438                 ndr_print_uint32(ndr, "Reserved2", r->Reserved2);
1439                 ndr_print_NTTIME(ndr, "TimeStamp", r->TimeStamp);
1440                 ndr_print_array_uint8(ndr, "ChallengeFromClient", r->ChallengeFromClient, 8);
1441                 ndr_print_uint32(ndr, "Reserved3", r->Reserved3);
1442                 ndr_print_AV_PAIR_LIST(ndr, "AvPairs", &r->AvPairs);
1443                 ndr->depth--;
1444                 ndr->flags = _flags_save_STRUCT;
1445         }
1446 }
1447
1448 _PUBLIC_ enum ndr_err_code ndr_push_NTLMv2_RESPONSE(struct ndr_push *ndr, int ndr_flags, const struct NTLMv2_RESPONSE *r)
1449 {
1450         {
1451                 uint32_t _flags_save_STRUCT = ndr->flags;
1452                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1453                 if (ndr_flags & NDR_SCALARS) {
1454                         NDR_CHECK(ndr_push_align(ndr, 4));
1455                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Response, 16));
1456                         NDR_CHECK(ndr_push_NTLMv2_CLIENT_CHALLENGE(ndr, NDR_SCALARS, &r->Challenge));
1457                 }
1458                 if (ndr_flags & NDR_BUFFERS) {
1459                         NDR_CHECK(ndr_push_NTLMv2_CLIENT_CHALLENGE(ndr, NDR_BUFFERS, &r->Challenge));
1460                 }
1461                 ndr->flags = _flags_save_STRUCT;
1462         }
1463         return NDR_ERR_SUCCESS;
1464 }
1465
1466 _PUBLIC_ enum ndr_err_code ndr_pull_NTLMv2_RESPONSE(struct ndr_pull *ndr, int ndr_flags, struct NTLMv2_RESPONSE *r)
1467 {
1468         {
1469                 uint32_t _flags_save_STRUCT = ndr->flags;
1470                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1471                 if (ndr_flags & NDR_SCALARS) {
1472                         NDR_CHECK(ndr_pull_align(ndr, 4));
1473                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Response, 16));
1474                         NDR_CHECK(ndr_pull_NTLMv2_CLIENT_CHALLENGE(ndr, NDR_SCALARS, &r->Challenge));
1475                 }
1476                 if (ndr_flags & NDR_BUFFERS) {
1477                         NDR_CHECK(ndr_pull_NTLMv2_CLIENT_CHALLENGE(ndr, NDR_BUFFERS, &r->Challenge));
1478                 }
1479                 ndr->flags = _flags_save_STRUCT;
1480         }
1481         return NDR_ERR_SUCCESS;
1482 }
1483
1484 _PUBLIC_ void ndr_print_NTLMv2_RESPONSE(struct ndr_print *ndr, const char *name, const struct NTLMv2_RESPONSE *r)
1485 {
1486         ndr_print_struct(ndr, name, "NTLMv2_RESPONSE");
1487         {
1488                 uint32_t _flags_save_STRUCT = ndr->flags;
1489                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1490                 ndr->depth++;
1491                 ndr_print_array_uint8(ndr, "Response", r->Response, 16);
1492                 ndr_print_NTLMv2_CLIENT_CHALLENGE(ndr, "Challenge", &r->Challenge);
1493                 ndr->depth--;
1494                 ndr->flags = _flags_save_STRUCT;
1495         }
1496 }
1497
1498 _PUBLIC_ enum ndr_err_code ndr_push_ntlmssp_NTLM_RESPONSE(struct ndr_push *ndr, int ndr_flags, const union ntlmssp_NTLM_RESPONSE *r)
1499 {
1500         if (ndr_flags & NDR_SCALARS) {
1501                 int level = ndr_push_get_switch_value(ndr, r);
1502                 switch (level) {
1503                         case 0: {
1504                         break; }
1505
1506                         case 0x18: {
1507                                 NDR_CHECK(ndr_push_NTLM_RESPONSE(ndr, NDR_SCALARS, &r->v1));
1508                         break; }
1509
1510                         default: {
1511                                 NDR_CHECK(ndr_push_NTLMv2_RESPONSE(ndr, NDR_SCALARS, &r->v2));
1512                         break; }
1513
1514                 }
1515         }
1516         if (ndr_flags & NDR_BUFFERS) {
1517                 int level = ndr_push_get_switch_value(ndr, r);
1518                 switch (level) {
1519                         case 0:
1520                         break;
1521
1522                         case 0x18:
1523                         break;
1524
1525                         default:
1526                                 NDR_CHECK(ndr_push_NTLMv2_RESPONSE(ndr, NDR_BUFFERS, &r->v2));
1527                         break;
1528
1529                 }
1530         }
1531         return NDR_ERR_SUCCESS;
1532 }
1533
1534 _PUBLIC_ enum ndr_err_code ndr_pull_ntlmssp_NTLM_RESPONSE(struct ndr_pull *ndr, int ndr_flags, union ntlmssp_NTLM_RESPONSE *r)
1535 {
1536         int level;
1537         level = ndr_pull_get_switch_value(ndr, r);
1538         if (ndr_flags & NDR_SCALARS) {
1539                 switch (level) {
1540                         case 0: {
1541                         break; }
1542
1543                         case 0x18: {
1544                                 NDR_CHECK(ndr_pull_NTLM_RESPONSE(ndr, NDR_SCALARS, &r->v1));
1545                         break; }
1546
1547                         default: {
1548                                 NDR_CHECK(ndr_pull_NTLMv2_RESPONSE(ndr, NDR_SCALARS, &r->v2));
1549                         break; }
1550
1551                 }
1552         }
1553         if (ndr_flags & NDR_BUFFERS) {
1554                 switch (level) {
1555                         case 0:
1556                         break;
1557
1558                         case 0x18:
1559                         break;
1560
1561                         default:
1562                                 NDR_CHECK(ndr_pull_NTLMv2_RESPONSE(ndr, NDR_BUFFERS, &r->v2));
1563                         break;
1564
1565                 }
1566         }
1567         return NDR_ERR_SUCCESS;
1568 }
1569
1570 _PUBLIC_ void ndr_print_ntlmssp_NTLM_RESPONSE(struct ndr_print *ndr, const char *name, const union ntlmssp_NTLM_RESPONSE *r)
1571 {
1572         int level;
1573         level = ndr_print_get_switch_value(ndr, r);
1574         ndr_print_union(ndr, name, level, "ntlmssp_NTLM_RESPONSE");
1575         switch (level) {
1576                 case 0:
1577                 break;
1578
1579                 case 0x18:
1580                         ndr_print_NTLM_RESPONSE(ndr, "v1", &r->v1);
1581                 break;
1582
1583                 default:
1584                         ndr_print_NTLMv2_RESPONSE(ndr, "v2", &r->v2);
1585                 break;
1586
1587         }
1588 }
1589
1590 _PUBLIC_ enum ndr_err_code ndr_push_AUTHENTICATE_MESSAGE(struct ndr_push *ndr, int ndr_flags, const struct AUTHENTICATE_MESSAGE *r)
1591 {
1592         {
1593                 uint32_t _flags_save_STRUCT = ndr->flags;
1594                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1595                 if (ndr_flags & NDR_SCALARS) {
1596                         NDR_CHECK(ndr_push_align(ndr, 5));
1597                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, "NTLMSSP", 8, sizeof(uint8_t), CH_DOS));
1598                         NDR_CHECK(ndr_push_ntlmssp_MessageType(ndr, NDR_SCALARS, NtLmAuthenticate));
1599                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->LmChallengeResponseLen));
1600                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->LmChallengeResponseLen));
1601                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->LmChallengeResponse));
1602                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->NtChallengeResponseLen));
1603                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->NtChallengeResponseLen));
1604                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->NtChallengeResponse));
1605                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, ndr_ntlmssp_string_length(r->NegotiateFlags, r->DomainName)));
1606                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, ndr_ntlmssp_string_length(r->NegotiateFlags, r->DomainName)));
1607                         {
1608                                 uint32_t _flags_save_string = ndr->flags;
1609                                 ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(r->NegotiateFlags));
1610                                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->DomainName));
1611                                 ndr->flags = _flags_save_string;
1612                         }
1613                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, ndr_ntlmssp_string_length(r->NegotiateFlags, r->UserName)));
1614                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, ndr_ntlmssp_string_length(r->NegotiateFlags, r->UserName)));
1615                         {
1616                                 uint32_t _flags_save_string = ndr->flags;
1617                                 ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(r->NegotiateFlags));
1618                                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->UserName));
1619                                 ndr->flags = _flags_save_string;
1620                         }
1621                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, ndr_ntlmssp_string_length(r->NegotiateFlags, r->Workstation)));
1622                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, ndr_ntlmssp_string_length(r->NegotiateFlags, r->Workstation)));
1623                         {
1624                                 uint32_t _flags_save_string = ndr->flags;
1625                                 ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(r->NegotiateFlags));
1626                                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->Workstation));
1627                                 ndr->flags = _flags_save_string;
1628                         }
1629                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->EncryptedRandomSessionKey->length));
1630                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->EncryptedRandomSessionKey->length));
1631                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->EncryptedRandomSessionKey));
1632                         NDR_CHECK(ndr_push_NEGOTIATE(ndr, NDR_SCALARS, r->NegotiateFlags));
1633                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->Version, r->NegotiateFlags & NTLMSSP_NEGOTIATE_VERSION));
1634                         NDR_CHECK(ndr_push_ntlmssp_Version(ndr, NDR_SCALARS, &r->Version));
1635                 }
1636                 if (ndr_flags & NDR_BUFFERS) {
1637                         if (r->LmChallengeResponse) {
1638                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->LmChallengeResponse));
1639                                 {
1640                                         struct ndr_push *_ndr_LmChallengeResponse;
1641                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_LmChallengeResponse, 0, r->LmChallengeResponseLen));
1642                                         NDR_CHECK(ndr_push_set_switch_value(_ndr_LmChallengeResponse, r->LmChallengeResponse, r->LmChallengeResponseLen));
1643                                         NDR_CHECK(ndr_push_ntlmssp_LM_RESPONSE(_ndr_LmChallengeResponse, NDR_SCALARS|NDR_BUFFERS, r->LmChallengeResponse));
1644                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_LmChallengeResponse, 0, r->LmChallengeResponseLen));
1645                                 }
1646                         }
1647                         if (r->NtChallengeResponse) {
1648                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->NtChallengeResponse));
1649                                 {
1650                                         struct ndr_push *_ndr_NtChallengeResponse;
1651                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_NtChallengeResponse, 0, r->NtChallengeResponseLen));
1652                                         NDR_CHECK(ndr_push_set_switch_value(_ndr_NtChallengeResponse, r->NtChallengeResponse, r->NtChallengeResponseLen));
1653                                         NDR_CHECK(ndr_push_ntlmssp_NTLM_RESPONSE(_ndr_NtChallengeResponse, NDR_SCALARS|NDR_BUFFERS, r->NtChallengeResponse));
1654                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_NtChallengeResponse, 0, r->NtChallengeResponseLen));
1655                                 }
1656                         }
1657                         {
1658                                 uint32_t _flags_save_string = ndr->flags;
1659                                 ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(r->NegotiateFlags));
1660                                 if (r->DomainName) {
1661                                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->DomainName));
1662                                         {
1663                                                 struct ndr_push *_ndr_DomainName;
1664                                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_DomainName, 0, ndr_ntlmssp_string_length(r->NegotiateFlags, r->DomainName)));
1665                                                 NDR_CHECK(ndr_push_string(_ndr_DomainName, NDR_SCALARS, r->DomainName));
1666                                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_DomainName, 0, ndr_ntlmssp_string_length(r->NegotiateFlags, r->DomainName)));
1667                                         }
1668                                 }
1669                                 ndr->flags = _flags_save_string;
1670                         }
1671                         {
1672                                 uint32_t _flags_save_string = ndr->flags;
1673                                 ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(r->NegotiateFlags));
1674                                 if (r->UserName) {
1675                                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->UserName));
1676                                         {
1677                                                 struct ndr_push *_ndr_UserName;
1678                                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_UserName, 0, ndr_ntlmssp_string_length(r->NegotiateFlags, r->UserName)));
1679                                                 NDR_CHECK(ndr_push_string(_ndr_UserName, NDR_SCALARS, r->UserName));
1680                                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_UserName, 0, ndr_ntlmssp_string_length(r->NegotiateFlags, r->UserName)));
1681                                         }
1682                                 }
1683                                 ndr->flags = _flags_save_string;
1684                         }
1685                         {
1686                                 uint32_t _flags_save_string = ndr->flags;
1687                                 ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(r->NegotiateFlags));
1688                                 if (r->Workstation) {
1689                                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->Workstation));
1690                                         {
1691                                                 struct ndr_push *_ndr_Workstation;
1692                                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_Workstation, 0, ndr_ntlmssp_string_length(r->NegotiateFlags, r->Workstation)));
1693                                                 NDR_CHECK(ndr_push_string(_ndr_Workstation, NDR_SCALARS, r->Workstation));
1694                                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_Workstation, 0, ndr_ntlmssp_string_length(r->NegotiateFlags, r->Workstation)));
1695                                         }
1696                                 }
1697                                 ndr->flags = _flags_save_string;
1698                         }
1699                         if (r->EncryptedRandomSessionKey) {
1700                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->EncryptedRandomSessionKey));
1701                                 {
1702                                         struct ndr_push *_ndr_EncryptedRandomSessionKey;
1703                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_EncryptedRandomSessionKey, 0, r->EncryptedRandomSessionKey->length));
1704                                         NDR_CHECK(ndr_push_DATA_BLOB(_ndr_EncryptedRandomSessionKey, NDR_SCALARS, *r->EncryptedRandomSessionKey));
1705                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_EncryptedRandomSessionKey, 0, r->EncryptedRandomSessionKey->length));
1706                                 }
1707                         }
1708                         NDR_CHECK(ndr_push_ntlmssp_Version(ndr, NDR_BUFFERS, &r->Version));
1709                 }
1710                 ndr->flags = _flags_save_STRUCT;
1711         }
1712         return NDR_ERR_SUCCESS;
1713 }
1714
1715 _PUBLIC_ enum ndr_err_code ndr_pull_AUTHENTICATE_MESSAGE(struct ndr_pull *ndr, int ndr_flags, struct AUTHENTICATE_MESSAGE *r)
1716 {
1717         uint32_t _ptr_LmChallengeResponse;
1718         TALLOC_CTX *_mem_save_LmChallengeResponse_0;
1719         uint32_t _ptr_NtChallengeResponse;
1720         TALLOC_CTX *_mem_save_NtChallengeResponse_0;
1721         uint32_t _ptr_DomainName;
1722         TALLOC_CTX *_mem_save_DomainName_0;
1723         uint32_t _ptr_UserName;
1724         TALLOC_CTX *_mem_save_UserName_0;
1725         uint32_t _ptr_Workstation;
1726         TALLOC_CTX *_mem_save_Workstation_0;
1727         uint32_t _ptr_EncryptedRandomSessionKey;
1728         TALLOC_CTX *_mem_save_EncryptedRandomSessionKey_0;
1729         {
1730                 uint32_t _flags_save_STRUCT = ndr->flags;
1731                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1732                 if (ndr_flags & NDR_SCALARS) {
1733                         NDR_CHECK(ndr_pull_align(ndr, 5));
1734                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->Signature, 8, sizeof(uint8_t), CH_DOS));
1735                         NDR_CHECK(ndr_pull_ntlmssp_MessageType(ndr, NDR_SCALARS, &r->MessageType));
1736                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->LmChallengeResponseLen));
1737                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->LmChallengeResponseMaxLen));
1738                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_LmChallengeResponse));
1739                         if (_ptr_LmChallengeResponse) {
1740                                 NDR_PULL_ALLOC(ndr, r->LmChallengeResponse);
1741                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->LmChallengeResponse, _ptr_LmChallengeResponse));
1742                         } else {
1743                                 r->LmChallengeResponse = NULL;
1744                         }
1745                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->NtChallengeResponseLen));
1746                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->NtChallengeResponseMaxLen));
1747                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_NtChallengeResponse));
1748                         if (_ptr_NtChallengeResponse) {
1749                                 NDR_PULL_ALLOC(ndr, r->NtChallengeResponse);
1750                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->NtChallengeResponse, _ptr_NtChallengeResponse));
1751                         } else {
1752                                 r->NtChallengeResponse = NULL;
1753                         }
1754                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->DomainNameLen));
1755                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->DomainNameMaxLen));
1756                         {
1757                                 uint32_t _flags_save_string = ndr->flags;
1758                                 ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(r->NegotiateFlags));
1759                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_DomainName));
1760                                 if (_ptr_DomainName) {
1761                                         NDR_PULL_ALLOC(ndr, r->DomainName);
1762                                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->DomainName, _ptr_DomainName));
1763                                 } else {
1764                                         r->DomainName = NULL;
1765                                 }
1766                                 ndr->flags = _flags_save_string;
1767                         }
1768                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->UserNameLen));
1769                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->UserNameMaxLen));
1770                         {
1771                                 uint32_t _flags_save_string = ndr->flags;
1772                                 ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(r->NegotiateFlags));
1773                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_UserName));
1774                                 if (_ptr_UserName) {
1775                                         NDR_PULL_ALLOC(ndr, r->UserName);
1776                                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->UserName, _ptr_UserName));
1777                                 } else {
1778                                         r->UserName = NULL;
1779                                 }
1780                                 ndr->flags = _flags_save_string;
1781                         }
1782                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->WorkstationLen));
1783                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->WorkstationMaxLen));
1784                         {
1785                                 uint32_t _flags_save_string = ndr->flags;
1786                                 ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(r->NegotiateFlags));
1787                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Workstation));
1788                                 if (_ptr_Workstation) {
1789                                         NDR_PULL_ALLOC(ndr, r->Workstation);
1790                                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->Workstation, _ptr_Workstation));
1791                                 } else {
1792                                         r->Workstation = NULL;
1793                                 }
1794                                 ndr->flags = _flags_save_string;
1795                         }
1796                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->EncryptedRandomSessionKeyLen));
1797                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->EncryptedRandomSessionKeyMaxLen));
1798                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedRandomSessionKey));
1799                         if (_ptr_EncryptedRandomSessionKey) {
1800                                 NDR_PULL_ALLOC(ndr, r->EncryptedRandomSessionKey);
1801                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->EncryptedRandomSessionKey, _ptr_EncryptedRandomSessionKey));
1802                         } else {
1803                                 r->EncryptedRandomSessionKey = NULL;
1804                         }
1805                         NDR_CHECK(ndr_pull_NEGOTIATE(ndr, NDR_SCALARS, &r->NegotiateFlags));
1806                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->Version, r->NegotiateFlags & NTLMSSP_NEGOTIATE_VERSION));
1807                         NDR_CHECK(ndr_pull_ntlmssp_Version(ndr, NDR_SCALARS, &r->Version));
1808                 }
1809                 if (ndr_flags & NDR_BUFFERS) {
1810                         if (r->LmChallengeResponse) {
1811                                 uint32_t _relative_save_offset;
1812                                 _relative_save_offset = ndr->offset;
1813                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->LmChallengeResponse));
1814                                 _mem_save_LmChallengeResponse_0 = NDR_PULL_GET_MEM_CTX(ndr);
1815                                 NDR_PULL_SET_MEM_CTX(ndr, r->LmChallengeResponse, 0);
1816                                 {
1817                                         struct ndr_pull *_ndr_LmChallengeResponse;
1818                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_LmChallengeResponse, 0, r->LmChallengeResponseLen));
1819                                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_LmChallengeResponse, r->LmChallengeResponse, r->LmChallengeResponseLen));
1820                                         NDR_CHECK(ndr_pull_ntlmssp_LM_RESPONSE(_ndr_LmChallengeResponse, NDR_SCALARS|NDR_BUFFERS, r->LmChallengeResponse));
1821                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_LmChallengeResponse, 0, r->LmChallengeResponseLen));
1822                                 }
1823                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_LmChallengeResponse_0, 0);
1824                                 ndr->offset = _relative_save_offset;
1825                         }
1826                         if (r->NtChallengeResponse) {
1827                                 uint32_t _relative_save_offset;
1828                                 _relative_save_offset = ndr->offset;
1829                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->NtChallengeResponse));
1830                                 _mem_save_NtChallengeResponse_0 = NDR_PULL_GET_MEM_CTX(ndr);
1831                                 NDR_PULL_SET_MEM_CTX(ndr, r->NtChallengeResponse, 0);
1832                                 {
1833                                         struct ndr_pull *_ndr_NtChallengeResponse;
1834                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_NtChallengeResponse, 0, r->NtChallengeResponseMaxLen));
1835                                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_NtChallengeResponse, r->NtChallengeResponse, r->NtChallengeResponseLen));
1836                                         NDR_CHECK(ndr_pull_ntlmssp_NTLM_RESPONSE(_ndr_NtChallengeResponse, NDR_SCALARS|NDR_BUFFERS, r->NtChallengeResponse));
1837                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_NtChallengeResponse, 0, r->NtChallengeResponseMaxLen));
1838                                 }
1839                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_NtChallengeResponse_0, 0);
1840                                 ndr->offset = _relative_save_offset;
1841                         }
1842                         {
1843                                 uint32_t _flags_save_string = ndr->flags;
1844                                 ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(r->NegotiateFlags));
1845                                 if (r->DomainName) {
1846                                         uint32_t _relative_save_offset;
1847                                         _relative_save_offset = ndr->offset;
1848                                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->DomainName));
1849                                         _mem_save_DomainName_0 = NDR_PULL_GET_MEM_CTX(ndr);
1850                                         NDR_PULL_SET_MEM_CTX(ndr, r->DomainName, 0);
1851                                         {
1852                                                 struct ndr_pull *_ndr_DomainName;
1853                                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_DomainName, 0, r->DomainNameLen));
1854                                                 NDR_CHECK(ndr_pull_string(_ndr_DomainName, NDR_SCALARS, &r->DomainName));
1855                                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_DomainName, 0, r->DomainNameLen));
1856                                         }
1857                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_DomainName_0, 0);
1858                                         ndr->offset = _relative_save_offset;
1859                                 }
1860                                 ndr->flags = _flags_save_string;
1861                         }
1862                         {
1863                                 uint32_t _flags_save_string = ndr->flags;
1864                                 ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(r->NegotiateFlags));
1865                                 if (r->UserName) {
1866                                         uint32_t _relative_save_offset;
1867                                         _relative_save_offset = ndr->offset;
1868                                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->UserName));
1869                                         _mem_save_UserName_0 = NDR_PULL_GET_MEM_CTX(ndr);
1870                                         NDR_PULL_SET_MEM_CTX(ndr, r->UserName, 0);
1871                                         {
1872                                                 struct ndr_pull *_ndr_UserName;
1873                                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_UserName, 0, r->UserNameLen));
1874                                                 NDR_CHECK(ndr_pull_string(_ndr_UserName, NDR_SCALARS, &r->UserName));
1875                                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_UserName, 0, r->UserNameLen));
1876                                         }
1877                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_UserName_0, 0);
1878                                         ndr->offset = _relative_save_offset;
1879                                 }
1880                                 ndr->flags = _flags_save_string;
1881                         }
1882                         {
1883                                 uint32_t _flags_save_string = ndr->flags;
1884                                 ndr_set_flags(&ndr->flags, ndr_ntlmssp_negotiated_string_flags(r->NegotiateFlags));
1885                                 if (r->Workstation) {
1886                                         uint32_t _relative_save_offset;
1887                                         _relative_save_offset = ndr->offset;
1888                                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->Workstation));
1889                                         _mem_save_Workstation_0 = NDR_PULL_GET_MEM_CTX(ndr);
1890                                         NDR_PULL_SET_MEM_CTX(ndr, r->Workstation, 0);
1891                                         {
1892                                                 struct ndr_pull *_ndr_Workstation;
1893                                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_Workstation, 0, r->WorkstationLen));
1894                                                 NDR_CHECK(ndr_pull_string(_ndr_Workstation, NDR_SCALARS, &r->Workstation));
1895                                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_Workstation, 0, r->WorkstationLen));
1896                                         }
1897                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Workstation_0, 0);
1898                                         ndr->offset = _relative_save_offset;
1899                                 }
1900                                 ndr->flags = _flags_save_string;
1901                         }
1902                         if (r->EncryptedRandomSessionKey) {
1903                                 uint32_t _relative_save_offset;
1904                                 _relative_save_offset = ndr->offset;
1905                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->EncryptedRandomSessionKey));
1906                                 _mem_save_EncryptedRandomSessionKey_0 = NDR_PULL_GET_MEM_CTX(ndr);
1907                                 NDR_PULL_SET_MEM_CTX(ndr, r->EncryptedRandomSessionKey, 0);
1908                                 {
1909                                         struct ndr_pull *_ndr_EncryptedRandomSessionKey;
1910                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_EncryptedRandomSessionKey, 0, r->EncryptedRandomSessionKeyLen));
1911                                         NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_EncryptedRandomSessionKey, NDR_SCALARS, r->EncryptedRandomSessionKey));
1912                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_EncryptedRandomSessionKey, 0, r->EncryptedRandomSessionKeyLen));
1913                                 }
1914                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedRandomSessionKey_0, 0);
1915                                 ndr->offset = _relative_save_offset;
1916                         }
1917                         NDR_CHECK(ndr_pull_ntlmssp_Version(ndr, NDR_BUFFERS, &r->Version));
1918                 }
1919                 ndr->flags = _flags_save_STRUCT;
1920         }
1921         return NDR_ERR_SUCCESS;
1922 }
1923
1924 _PUBLIC_ void ndr_print_AUTHENTICATE_MESSAGE(struct ndr_print *ndr, const char *name, const struct AUTHENTICATE_MESSAGE *r)
1925 {
1926         ndr_print_struct(ndr, name, "AUTHENTICATE_MESSAGE");
1927         {
1928                 uint32_t _flags_save_STRUCT = ndr->flags;
1929                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1930                 ndr->depth++;
1931                 ndr_print_string(ndr, "Signature", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?"NTLMSSP":r->Signature);
1932                 ndr_print_ntlmssp_MessageType(ndr, "MessageType", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?NtLmAuthenticate:r->MessageType);
1933                 ndr_print_uint16(ndr, "LmChallengeResponseLen", r->LmChallengeResponseLen);
1934                 ndr_print_uint16(ndr, "LmChallengeResponseMaxLen", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->LmChallengeResponseLen:r->LmChallengeResponseMaxLen);
1935                 ndr_print_ptr(ndr, "LmChallengeResponse", r->LmChallengeResponse);
1936                 ndr->depth++;
1937                 if (r->LmChallengeResponse) {
1938                         ndr_print_set_switch_value(ndr, r->LmChallengeResponse, r->LmChallengeResponseLen);
1939                         ndr_print_ntlmssp_LM_RESPONSE(ndr, "LmChallengeResponse", r->LmChallengeResponse);
1940                 }
1941                 ndr->depth--;
1942                 ndr_print_uint16(ndr, "NtChallengeResponseLen", r->NtChallengeResponseLen);
1943                 ndr_print_uint16(ndr, "NtChallengeResponseMaxLen", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->NtChallengeResponseLen:r->NtChallengeResponseMaxLen);
1944                 ndr_print_ptr(ndr, "NtChallengeResponse", r->NtChallengeResponse);
1945                 ndr->depth++;
1946                 if (r->NtChallengeResponse) {
1947                         ndr_print_set_switch_value(ndr, r->NtChallengeResponse, r->NtChallengeResponseLen);
1948                         ndr_print_ntlmssp_NTLM_RESPONSE(ndr, "NtChallengeResponse", r->NtChallengeResponse);
1949                 }
1950                 ndr->depth--;
1951                 ndr_print_uint16(ndr, "DomainNameLen", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_ntlmssp_string_length(r->NegotiateFlags, r->DomainName):r->DomainNameLen);
1952                 ndr_print_uint16(ndr, "DomainNameMaxLen", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->DomainNameLen:r->DomainNameMaxLen);
1953                 ndr_print_ptr(ndr, "DomainName", r->DomainName);
1954                 ndr->depth++;
1955                 if (r->DomainName) {
1956                         ndr_print_string(ndr, "DomainName", r->DomainName);
1957                 }
1958                 ndr->depth--;
1959                 ndr_print_uint16(ndr, "UserNameLen", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_ntlmssp_string_length(r->NegotiateFlags, r->UserName):r->UserNameLen);
1960                 ndr_print_uint16(ndr, "UserNameMaxLen", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->UserNameLen:r->UserNameMaxLen);
1961                 ndr_print_ptr(ndr, "UserName", r->UserName);
1962                 ndr->depth++;
1963                 if (r->UserName) {
1964                         ndr_print_string(ndr, "UserName", r->UserName);
1965                 }
1966                 ndr->depth--;
1967                 ndr_print_uint16(ndr, "WorkstationLen", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_ntlmssp_string_length(r->NegotiateFlags, r->Workstation):r->WorkstationLen);
1968                 ndr_print_uint16(ndr, "WorkstationMaxLen", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->WorkstationLen:r->WorkstationMaxLen);
1969                 ndr_print_ptr(ndr, "Workstation", r->Workstation);
1970                 ndr->depth++;
1971                 if (r->Workstation) {
1972                         ndr_print_string(ndr, "Workstation", r->Workstation);
1973                 }
1974                 ndr->depth--;
1975                 ndr_print_uint16(ndr, "EncryptedRandomSessionKeyLen", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->EncryptedRandomSessionKey->length:r->EncryptedRandomSessionKeyLen);
1976                 ndr_print_uint16(ndr, "EncryptedRandomSessionKeyMaxLen", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->EncryptedRandomSessionKeyLen:r->EncryptedRandomSessionKeyMaxLen);
1977                 ndr_print_ptr(ndr, "EncryptedRandomSessionKey", r->EncryptedRandomSessionKey);
1978                 ndr->depth++;
1979                 if (r->EncryptedRandomSessionKey) {
1980                         ndr_print_DATA_BLOB(ndr, "EncryptedRandomSessionKey", *r->EncryptedRandomSessionKey);
1981                 }
1982                 ndr->depth--;
1983                 ndr_print_NEGOTIATE(ndr, "NegotiateFlags", r->NegotiateFlags);
1984                 ndr_print_set_switch_value(ndr, &r->Version, r->NegotiateFlags & NTLMSSP_NEGOTIATE_VERSION);
1985                 ndr_print_ntlmssp_Version(ndr, "Version", &r->Version);
1986                 ndr->depth--;
1987                 ndr->flags = _flags_save_STRUCT;
1988         }
1989 }
1990
1991 _PUBLIC_ enum ndr_err_code ndr_push_NTLMSSP_MESSAGE_SIGNATURE(struct ndr_push *ndr, int ndr_flags, const struct NTLMSSP_MESSAGE_SIGNATURE *r)
1992 {
1993         if (ndr_flags & NDR_SCALARS) {
1994                 NDR_CHECK(ndr_push_align(ndr, 4));
1995                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, NTLMSSP_SIGN_VERSION));
1996                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->RandomPad));
1997                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Checksum));
1998                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->SeqNum));
1999         }
2000         if (ndr_flags & NDR_BUFFERS) {
2001         }
2002         return NDR_ERR_SUCCESS;
2003 }
2004
2005 _PUBLIC_ enum ndr_err_code ndr_pull_NTLMSSP_MESSAGE_SIGNATURE(struct ndr_pull *ndr, int ndr_flags, struct NTLMSSP_MESSAGE_SIGNATURE *r)
2006 {
2007         if (ndr_flags & NDR_SCALARS) {
2008                 NDR_CHECK(ndr_pull_align(ndr, 4));
2009                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Version));
2010                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->RandomPad));
2011                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Checksum));
2012                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->SeqNum));
2013         }
2014         if (ndr_flags & NDR_BUFFERS) {
2015         }
2016         return NDR_ERR_SUCCESS;
2017 }
2018
2019 _PUBLIC_ void ndr_print_NTLMSSP_MESSAGE_SIGNATURE(struct ndr_print *ndr, const char *name, const struct NTLMSSP_MESSAGE_SIGNATURE *r)
2020 {
2021         ndr_print_struct(ndr, name, "NTLMSSP_MESSAGE_SIGNATURE");
2022         ndr->depth++;
2023         ndr_print_uint32(ndr, "Version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?NTLMSSP_SIGN_VERSION:r->Version);
2024         ndr_print_uint32(ndr, "RandomPad", r->RandomPad);
2025         ndr_print_uint32(ndr, "Checksum", r->Checksum);
2026         ndr_print_uint32(ndr, "SeqNum", r->SeqNum);
2027         ndr->depth--;
2028 }
2029
2030 _PUBLIC_ enum ndr_err_code ndr_push_NTLMSSP_MESSAGE_SIGNATURE_NTLMv2(struct ndr_push *ndr, int ndr_flags, const struct NTLMSSP_MESSAGE_SIGNATURE_NTLMv2 *r)
2031 {
2032         {
2033                 uint32_t _flags_save_STRUCT = ndr->flags;
2034                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2035                 if (ndr_flags & NDR_SCALARS) {
2036                         NDR_CHECK(ndr_push_align(ndr, 4));
2037                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, NTLMSSP_SIGN_VERSION));
2038                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Checksum, 8));
2039                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->SeqNum));
2040                 }
2041                 if (ndr_flags & NDR_BUFFERS) {
2042                 }
2043                 ndr->flags = _flags_save_STRUCT;
2044         }
2045         return NDR_ERR_SUCCESS;
2046 }
2047
2048 _PUBLIC_ enum ndr_err_code ndr_pull_NTLMSSP_MESSAGE_SIGNATURE_NTLMv2(struct ndr_pull *ndr, int ndr_flags, struct NTLMSSP_MESSAGE_SIGNATURE_NTLMv2 *r)
2049 {
2050         {
2051                 uint32_t _flags_save_STRUCT = ndr->flags;
2052                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2053                 if (ndr_flags & NDR_SCALARS) {
2054                         NDR_CHECK(ndr_pull_align(ndr, 4));
2055                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Version));
2056                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Checksum, 8));
2057                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->SeqNum));
2058                 }
2059                 if (ndr_flags & NDR_BUFFERS) {
2060                 }
2061                 ndr->flags = _flags_save_STRUCT;
2062         }
2063         return NDR_ERR_SUCCESS;
2064 }
2065
2066 _PUBLIC_ void ndr_print_NTLMSSP_MESSAGE_SIGNATURE_NTLMv2(struct ndr_print *ndr, const char *name, const struct NTLMSSP_MESSAGE_SIGNATURE_NTLMv2 *r)
2067 {
2068         ndr_print_struct(ndr, name, "NTLMSSP_MESSAGE_SIGNATURE_NTLMv2");
2069         {
2070                 uint32_t _flags_save_STRUCT = ndr->flags;
2071                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2072                 ndr->depth++;
2073                 ndr_print_uint32(ndr, "Version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?NTLMSSP_SIGN_VERSION:r->Version);
2074                 ndr_print_array_uint8(ndr, "Checksum", r->Checksum, 8);
2075                 ndr_print_uint32(ndr, "SeqNum", r->SeqNum);
2076                 ndr->depth--;
2077                 ndr->flags = _flags_save_STRUCT;
2078         }
2079 }
2080
2081 static enum ndr_err_code ndr_push_decode_NEGOTIATE_MESSAGE(struct ndr_push *ndr, int flags, const struct decode_NEGOTIATE_MESSAGE *r)
2082 {
2083         if (flags & NDR_IN) {
2084                 NDR_CHECK(ndr_push_NEGOTIATE_MESSAGE(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.negotiate));
2085         }
2086         if (flags & NDR_OUT) {
2087         }
2088         return NDR_ERR_SUCCESS;
2089 }
2090
2091 static enum ndr_err_code ndr_pull_decode_NEGOTIATE_MESSAGE(struct ndr_pull *ndr, int flags, struct decode_NEGOTIATE_MESSAGE *r)
2092 {
2093         if (flags & NDR_IN) {
2094                 NDR_CHECK(ndr_pull_NEGOTIATE_MESSAGE(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.negotiate));
2095         }
2096         if (flags & NDR_OUT) {
2097         }
2098         return NDR_ERR_SUCCESS;
2099 }
2100
2101 _PUBLIC_ void ndr_print_decode_NEGOTIATE_MESSAGE(struct ndr_print *ndr, const char *name, int flags, const struct decode_NEGOTIATE_MESSAGE *r)
2102 {
2103         ndr_print_struct(ndr, name, "decode_NEGOTIATE_MESSAGE");
2104         ndr->depth++;
2105         if (flags & NDR_SET_VALUES) {
2106                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2107         }
2108         if (flags & NDR_IN) {
2109                 ndr_print_struct(ndr, "in", "decode_NEGOTIATE_MESSAGE");
2110                 ndr->depth++;
2111                 ndr_print_NEGOTIATE_MESSAGE(ndr, "negotiate", &r->in.negotiate);
2112                 ndr->depth--;
2113         }
2114         if (flags & NDR_OUT) {
2115                 ndr_print_struct(ndr, "out", "decode_NEGOTIATE_MESSAGE");
2116                 ndr->depth++;
2117                 ndr->depth--;
2118         }
2119         ndr->depth--;
2120 }
2121
2122 static enum ndr_err_code ndr_push_decode_CHALLENGE_MESSAGE(struct ndr_push *ndr, int flags, const struct decode_CHALLENGE_MESSAGE *r)
2123 {
2124         if (flags & NDR_IN) {
2125                 NDR_CHECK(ndr_push_CHALLENGE_MESSAGE(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.challenge));
2126         }
2127         if (flags & NDR_OUT) {
2128         }
2129         return NDR_ERR_SUCCESS;
2130 }
2131
2132 static enum ndr_err_code ndr_pull_decode_CHALLENGE_MESSAGE(struct ndr_pull *ndr, int flags, struct decode_CHALLENGE_MESSAGE *r)
2133 {
2134         if (flags & NDR_IN) {
2135                 NDR_CHECK(ndr_pull_CHALLENGE_MESSAGE(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.challenge));
2136         }
2137         if (flags & NDR_OUT) {
2138         }
2139         return NDR_ERR_SUCCESS;
2140 }
2141
2142 _PUBLIC_ void ndr_print_decode_CHALLENGE_MESSAGE(struct ndr_print *ndr, const char *name, int flags, const struct decode_CHALLENGE_MESSAGE *r)
2143 {
2144         ndr_print_struct(ndr, name, "decode_CHALLENGE_MESSAGE");
2145         ndr->depth++;
2146         if (flags & NDR_SET_VALUES) {
2147                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2148         }
2149         if (flags & NDR_IN) {
2150                 ndr_print_struct(ndr, "in", "decode_CHALLENGE_MESSAGE");
2151                 ndr->depth++;
2152                 ndr_print_CHALLENGE_MESSAGE(ndr, "challenge", &r->in.challenge);
2153                 ndr->depth--;
2154         }
2155         if (flags & NDR_OUT) {
2156                 ndr_print_struct(ndr, "out", "decode_CHALLENGE_MESSAGE");
2157                 ndr->depth++;
2158                 ndr->depth--;
2159         }
2160         ndr->depth--;
2161 }
2162
2163 static enum ndr_err_code ndr_push_decode_AUTHENTICATE_MESSAGE(struct ndr_push *ndr, int flags, const struct decode_AUTHENTICATE_MESSAGE *r)
2164 {
2165         if (flags & NDR_IN) {
2166                 NDR_CHECK(ndr_push_AUTHENTICATE_MESSAGE(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.authenticate));
2167         }
2168         if (flags & NDR_OUT) {
2169         }
2170         return NDR_ERR_SUCCESS;
2171 }
2172
2173 static enum ndr_err_code ndr_pull_decode_AUTHENTICATE_MESSAGE(struct ndr_pull *ndr, int flags, struct decode_AUTHENTICATE_MESSAGE *r)
2174 {
2175         if (flags & NDR_IN) {
2176                 NDR_CHECK(ndr_pull_AUTHENTICATE_MESSAGE(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.authenticate));
2177         }
2178         if (flags & NDR_OUT) {
2179         }
2180         return NDR_ERR_SUCCESS;
2181 }
2182
2183 _PUBLIC_ void ndr_print_decode_AUTHENTICATE_MESSAGE(struct ndr_print *ndr, const char *name, int flags, const struct decode_AUTHENTICATE_MESSAGE *r)
2184 {
2185         ndr_print_struct(ndr, name, "decode_AUTHENTICATE_MESSAGE");
2186         ndr->depth++;
2187         if (flags & NDR_SET_VALUES) {
2188                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2189         }
2190         if (flags & NDR_IN) {
2191                 ndr_print_struct(ndr, "in", "decode_AUTHENTICATE_MESSAGE");
2192                 ndr->depth++;
2193                 ndr_print_AUTHENTICATE_MESSAGE(ndr, "authenticate", &r->in.authenticate);
2194                 ndr->depth--;
2195         }
2196         if (flags & NDR_OUT) {
2197                 ndr_print_struct(ndr, "out", "decode_AUTHENTICATE_MESSAGE");
2198                 ndr->depth++;
2199                 ndr->depth--;
2200         }
2201         ndr->depth--;
2202 }
2203
2204 static enum ndr_err_code ndr_push_decode_NTLMv2_CLIENT_CHALLENGE(struct ndr_push *ndr, int flags, const struct decode_NTLMv2_CLIENT_CHALLENGE *r)
2205 {
2206         if (flags & NDR_IN) {
2207                 NDR_CHECK(ndr_push_NTLMv2_CLIENT_CHALLENGE(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.challenge));
2208         }
2209         if (flags & NDR_OUT) {
2210         }
2211         return NDR_ERR_SUCCESS;
2212 }
2213
2214 static enum ndr_err_code ndr_pull_decode_NTLMv2_CLIENT_CHALLENGE(struct ndr_pull *ndr, int flags, struct decode_NTLMv2_CLIENT_CHALLENGE *r)
2215 {
2216         if (flags & NDR_IN) {
2217                 NDR_CHECK(ndr_pull_NTLMv2_CLIENT_CHALLENGE(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.challenge));
2218         }
2219         if (flags & NDR_OUT) {
2220         }
2221         return NDR_ERR_SUCCESS;
2222 }
2223
2224 _PUBLIC_ void ndr_print_decode_NTLMv2_CLIENT_CHALLENGE(struct ndr_print *ndr, const char *name, int flags, const struct decode_NTLMv2_CLIENT_CHALLENGE *r)
2225 {
2226         ndr_print_struct(ndr, name, "decode_NTLMv2_CLIENT_CHALLENGE");
2227         ndr->depth++;
2228         if (flags & NDR_SET_VALUES) {
2229                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2230         }
2231         if (flags & NDR_IN) {
2232                 ndr_print_struct(ndr, "in", "decode_NTLMv2_CLIENT_CHALLENGE");
2233                 ndr->depth++;
2234                 ndr_print_NTLMv2_CLIENT_CHALLENGE(ndr, "challenge", &r->in.challenge);
2235                 ndr->depth--;
2236         }
2237         if (flags & NDR_OUT) {
2238                 ndr_print_struct(ndr, "out", "decode_NTLMv2_CLIENT_CHALLENGE");
2239                 ndr->depth++;
2240                 ndr->depth--;
2241         }
2242         ndr->depth--;
2243 }
2244
2245 static const struct ndr_interface_call ntlmssp_calls[] = {
2246         {
2247                 "decode_NEGOTIATE_MESSAGE",
2248                 sizeof(struct decode_NEGOTIATE_MESSAGE),
2249                 (ndr_push_flags_fn_t) ndr_push_decode_NEGOTIATE_MESSAGE,
2250                 (ndr_pull_flags_fn_t) ndr_pull_decode_NEGOTIATE_MESSAGE,
2251                 (ndr_print_function_t) ndr_print_decode_NEGOTIATE_MESSAGE,
2252                 false,
2253         },
2254         {
2255                 "decode_CHALLENGE_MESSAGE",
2256                 sizeof(struct decode_CHALLENGE_MESSAGE),
2257                 (ndr_push_flags_fn_t) ndr_push_decode_CHALLENGE_MESSAGE,
2258                 (ndr_pull_flags_fn_t) ndr_pull_decode_CHALLENGE_MESSAGE,
2259                 (ndr_print_function_t) ndr_print_decode_CHALLENGE_MESSAGE,
2260                 false,
2261         },
2262         {
2263                 "decode_AUTHENTICATE_MESSAGE",
2264                 sizeof(struct decode_AUTHENTICATE_MESSAGE),
2265                 (ndr_push_flags_fn_t) ndr_push_decode_AUTHENTICATE_MESSAGE,
2266                 (ndr_pull_flags_fn_t) ndr_pull_decode_AUTHENTICATE_MESSAGE,
2267                 (ndr_print_function_t) ndr_print_decode_AUTHENTICATE_MESSAGE,
2268                 false,
2269         },
2270         {
2271                 "decode_NTLMv2_CLIENT_CHALLENGE",
2272                 sizeof(struct decode_NTLMv2_CLIENT_CHALLENGE),
2273                 (ndr_push_flags_fn_t) ndr_push_decode_NTLMv2_CLIENT_CHALLENGE,
2274                 (ndr_pull_flags_fn_t) ndr_pull_decode_NTLMv2_CLIENT_CHALLENGE,
2275                 (ndr_print_function_t) ndr_print_decode_NTLMv2_CLIENT_CHALLENGE,
2276                 false,
2277         },
2278         { NULL, 0, NULL, NULL, NULL, false }
2279 };
2280
2281 static const char * const ntlmssp_endpoint_strings[] = {
2282         "ncacn_np:[\\pipe\\ntlmssp]",
2283 };
2284
2285 static const struct ndr_interface_string_array ntlmssp_endpoints = {
2286         .count  = 1,
2287         .names  = ntlmssp_endpoint_strings
2288 };
2289
2290 static const char * const ntlmssp_authservice_strings[] = {
2291         "host",
2292 };
2293
2294 static const struct ndr_interface_string_array ntlmssp_authservices = {
2295         .count  = 1,
2296         .names  = ntlmssp_authservice_strings
2297 };
2298
2299
2300 const struct ndr_interface_table ndr_table_ntlmssp = {
2301         .name           = "ntlmssp",
2302         .syntax_id      = {
2303                 {0x6e746c6d,0x7373,0x700a,{0x00,0x00},{0x00,0x00,0x00,0x00}},
2304                 NDR_NTLMSSP_VERSION
2305         },
2306         .helpstring     = NDR_NTLMSSP_HELPSTRING,
2307         .num_calls      = 4,
2308         .calls          = ntlmssp_calls,
2309         .endpoints      = &ntlmssp_endpoints,
2310         .authservices   = &ntlmssp_authservices
2311 };
2312