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