bin.gen_ndr/default/librpc/gen_ndr/ndr_auth.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "bin/default/librpc/gen_ndr/ndr_auth.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 #include "librpc/gen_ndr/ndr_security.h"
   8 #include "librpc/gen_ndr/ndr_lsa.h"
   9 #include "librpc/gen_ndr/ndr_krb5pac.h"
  10 _PUBLIC_ enum ndr_err_code ndr_push_auth_method(struct ndr_push *ndr, int ndr_flags, enum auth_method r)
  11 {
  12         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
  13         return NDR_ERR_SUCCESS;
  14 }
  15
  16 _PUBLIC_ enum ndr_err_code ndr_pull_auth_method(struct ndr_pull *ndr, int ndr_flags, enum auth_method *r)
  17 {
  18         uint16_t v;
  19         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
  20         *r = v;
  21         return NDR_ERR_SUCCESS;
  22 }
  23
  24 _PUBLIC_ void ndr_print_auth_method(struct ndr_print *ndr, const char *name, enum auth_method r)
  25 {
  26         const char *val = NULL;
  27
  28         switch (r) {
  29                 case SEC_AUTH_METHOD_UNAUTHENTICATED: val = "SEC_AUTH_METHOD_UNAUTHENTICATED"; break;
  30                 case SEC_AUTH_METHOD_NTLM: val = "SEC_AUTH_METHOD_NTLM"; break;
  31                 case SEC_AUTH_METHOD_KERBEROS: val = "SEC_AUTH_METHOD_KERBEROS"; break;
  32         }
  33         ndr_print_enum(ndr, name, "ENUM", val, r);
  34 }
  35
  36 _PUBLIC_ enum ndr_err_code ndr_push_auth_user_info(struct ndr_push *ndr, int ndr_flags, const struct auth_user_info *r)
  37 {
  38         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
  39         if (ndr_flags & NDR_SCALARS) {
  40                 NDR_CHECK(ndr_push_align(ndr, 5));
  41                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->account_name));
  42                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
  43                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->full_name));
  44                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->logon_script));
  45                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->profile_path));
  46                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->home_directory));
  47                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->home_drive));
  48                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->logon_server));
  49                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logon));
  50                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logoff));
  51                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->acct_expiry));
  52                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_password_change));
  53                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->allow_password_change));
  54                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_password_change));
  55                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logon_count));
  56                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->bad_password_count));
  57                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->acct_flags));
  58                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->authenticated));
  59                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
  60         }
  61         if (ndr_flags & NDR_BUFFERS) {
  62                 if (r->account_name) {
  63                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->account_name, CH_UTF8)));
  64                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
  65                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->account_name, CH_UTF8)));
  66                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->account_name, ndr_charset_length(r->account_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
  67                 }
  68                 if (r->domain_name) {
  69                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF8)));
  70                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
  71                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF8)));
  72                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
  73                 }
  74                 if (r->full_name) {
  75                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->full_name, CH_UTF8)));
  76                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
  77                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->full_name, CH_UTF8)));
  78                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->full_name, ndr_charset_length(r->full_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
  79                 }
  80                 if (r->logon_script) {
  81                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->logon_script, CH_UTF8)));
  82                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
  83                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->logon_script, CH_UTF8)));
  84                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->logon_script, ndr_charset_length(r->logon_script, CH_UTF8), sizeof(uint8_t), CH_UTF8));
  85                 }
  86                 if (r->profile_path) {
  87                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->profile_path, CH_UTF8)));
  88                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
  89                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->profile_path, CH_UTF8)));
  90                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->profile_path, ndr_charset_length(r->profile_path, CH_UTF8), sizeof(uint8_t), CH_UTF8));
  91                 }
  92                 if (r->home_directory) {
  93                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->home_directory, CH_UTF8)));
  94                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
  95                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->home_directory, CH_UTF8)));
  96                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->home_directory, ndr_charset_length(r->home_directory, CH_UTF8), sizeof(uint8_t), CH_UTF8));
  97                 }
  98                 if (r->home_drive) {
  99                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->home_drive, CH_UTF8)));
 100                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 101                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->home_drive, CH_UTF8)));
 102                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->home_drive, ndr_charset_length(r->home_drive, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 103                 }
 104                 if (r->logon_server) {
 105                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->logon_server, CH_UTF8)));
 106                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 107                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->logon_server, CH_UTF8)));
 108                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->logon_server, ndr_charset_length(r->logon_server, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 109                 }
 110         }
 111         return NDR_ERR_SUCCESS;
 112 }
 113
 114 _PUBLIC_ enum ndr_err_code ndr_pull_auth_user_info(struct ndr_pull *ndr, int ndr_flags, struct auth_user_info *r)
 115 {
 116         uint32_t _ptr_account_name;
 117         uint32_t size_account_name_1 = 0;
 118         uint32_t length_account_name_1 = 0;
 119         TALLOC_CTX *_mem_save_account_name_0;
 120         uint32_t _ptr_domain_name;
 121         uint32_t size_domain_name_1 = 0;
 122         uint32_t length_domain_name_1 = 0;
 123         TALLOC_CTX *_mem_save_domain_name_0;
 124         uint32_t _ptr_full_name;
 125         uint32_t size_full_name_1 = 0;
 126         uint32_t length_full_name_1 = 0;
 127         TALLOC_CTX *_mem_save_full_name_0;
 128         uint32_t _ptr_logon_script;
 129         uint32_t size_logon_script_1 = 0;
 130         uint32_t length_logon_script_1 = 0;
 131         TALLOC_CTX *_mem_save_logon_script_0;
 132         uint32_t _ptr_profile_path;
 133         uint32_t size_profile_path_1 = 0;
 134         uint32_t length_profile_path_1 = 0;
 135         TALLOC_CTX *_mem_save_profile_path_0;
 136         uint32_t _ptr_home_directory;
 137         uint32_t size_home_directory_1 = 0;
 138         uint32_t length_home_directory_1 = 0;
 139         TALLOC_CTX *_mem_save_home_directory_0;
 140         uint32_t _ptr_home_drive;
 141         uint32_t size_home_drive_1 = 0;
 142         uint32_t length_home_drive_1 = 0;
 143         TALLOC_CTX *_mem_save_home_drive_0;
 144         uint32_t _ptr_logon_server;
 145         uint32_t size_logon_server_1 = 0;
 146         uint32_t length_logon_server_1 = 0;
 147         TALLOC_CTX *_mem_save_logon_server_0;
 148         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 149         if (ndr_flags & NDR_SCALARS) {
 150                 NDR_CHECK(ndr_pull_align(ndr, 5));
 151                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account_name));
 152                 if (_ptr_account_name) {
 153                         NDR_PULL_ALLOC(ndr, r->account_name);
 154                 } else {
 155                         r->account_name = NULL;
 156                 }
 157                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
 158                 if (_ptr_domain_name) {
 159                         NDR_PULL_ALLOC(ndr, r->domain_name);
 160                 } else {
 161                         r->domain_name = NULL;
 162                 }
 163                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_full_name));
 164                 if (_ptr_full_name) {
 165                         NDR_PULL_ALLOC(ndr, r->full_name);
 166                 } else {
 167                         r->full_name = NULL;
 168                 }
 169                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_logon_script));
 170                 if (_ptr_logon_script) {
 171                         NDR_PULL_ALLOC(ndr, r->logon_script);
 172                 } else {
 173                         r->logon_script = NULL;
 174                 }
 175                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_profile_path));
 176                 if (_ptr_profile_path) {
 177                         NDR_PULL_ALLOC(ndr, r->profile_path);
 178                 } else {
 179                         r->profile_path = NULL;
 180                 }
 181                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_home_directory));
 182                 if (_ptr_home_directory) {
 183                         NDR_PULL_ALLOC(ndr, r->home_directory);
 184                 } else {
 185                         r->home_directory = NULL;
 186                 }
 187                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_home_drive));
 188                 if (_ptr_home_drive) {
 189                         NDR_PULL_ALLOC(ndr, r->home_drive);
 190                 } else {
 191                         r->home_drive = NULL;
 192                 }
 193                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_logon_server));
 194                 if (_ptr_logon_server) {
 195                         NDR_PULL_ALLOC(ndr, r->logon_server);
 196                 } else {
 197                         r->logon_server = NULL;
 198                 }
 199                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logon));
 200                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logoff));
 201                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->acct_expiry));
 202                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_password_change));
 203                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->allow_password_change));
 204                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_password_change));
 205                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logon_count));
 206                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->bad_password_count));
 207                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->acct_flags));
 208                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->authenticated));
 209                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 210         }
 211         if (ndr_flags & NDR_BUFFERS) {
 212                 if (r->account_name) {
 213                         _mem_save_account_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 214                         NDR_PULL_SET_MEM_CTX(ndr, r->account_name, 0);
 215                         NDR_CHECK(ndr_pull_array_size(ndr, &r->account_name));
 216                         NDR_CHECK(ndr_pull_array_length(ndr, &r->account_name));
 217                         size_account_name_1 = ndr_get_array_size(ndr, &r->account_name);
 218                         length_account_name_1 = ndr_get_array_length(ndr, &r->account_name);
 219                         if (length_account_name_1 > size_account_name_1) {
 220                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_account_name_1, length_account_name_1);
 221                         }
 222                         NDR_CHECK(ndr_check_string_terminator(ndr, length_account_name_1, sizeof(uint8_t)));
 223                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->account_name, length_account_name_1, sizeof(uint8_t), CH_UTF8));
 224                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_0, 0);
 225                 }
 226                 if (r->domain_name) {
 227                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 228                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
 229                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
 230                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
 231                         size_domain_name_1 = ndr_get_array_size(ndr, &r->domain_name);
 232                         length_domain_name_1 = ndr_get_array_length(ndr, &r->domain_name);
 233                         if (length_domain_name_1 > size_domain_name_1) {
 234                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_domain_name_1, length_domain_name_1);
 235                         }
 236                         NDR_CHECK(ndr_check_string_terminator(ndr, length_domain_name_1, sizeof(uint8_t)));
 237                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, length_domain_name_1, sizeof(uint8_t), CH_UTF8));
 238                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
 239                 }
 240                 if (r->full_name) {
 241                         _mem_save_full_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 242                         NDR_PULL_SET_MEM_CTX(ndr, r->full_name, 0);
 243                         NDR_CHECK(ndr_pull_array_size(ndr, &r->full_name));
 244                         NDR_CHECK(ndr_pull_array_length(ndr, &r->full_name));
 245                         size_full_name_1 = ndr_get_array_size(ndr, &r->full_name);
 246                         length_full_name_1 = ndr_get_array_length(ndr, &r->full_name);
 247                         if (length_full_name_1 > size_full_name_1) {
 248                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_full_name_1, length_full_name_1);
 249                         }
 250                         NDR_CHECK(ndr_check_string_terminator(ndr, length_full_name_1, sizeof(uint8_t)));
 251                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->full_name, length_full_name_1, sizeof(uint8_t), CH_UTF8));
 252                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_full_name_0, 0);
 253                 }
 254                 if (r->logon_script) {
 255                         _mem_save_logon_script_0 = NDR_PULL_GET_MEM_CTX(ndr);
 256                         NDR_PULL_SET_MEM_CTX(ndr, r->logon_script, 0);
 257                         NDR_CHECK(ndr_pull_array_size(ndr, &r->logon_script));
 258                         NDR_CHECK(ndr_pull_array_length(ndr, &r->logon_script));
 259                         size_logon_script_1 = ndr_get_array_size(ndr, &r->logon_script);
 260                         length_logon_script_1 = ndr_get_array_length(ndr, &r->logon_script);
 261                         if (length_logon_script_1 > size_logon_script_1) {
 262                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_logon_script_1, length_logon_script_1);
 263                         }
 264                         NDR_CHECK(ndr_check_string_terminator(ndr, length_logon_script_1, sizeof(uint8_t)));
 265                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->logon_script, length_logon_script_1, sizeof(uint8_t), CH_UTF8));
 266                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_logon_script_0, 0);
 267                 }
 268                 if (r->profile_path) {
 269                         _mem_save_profile_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
 270                         NDR_PULL_SET_MEM_CTX(ndr, r->profile_path, 0);
 271                         NDR_CHECK(ndr_pull_array_size(ndr, &r->profile_path));
 272                         NDR_CHECK(ndr_pull_array_length(ndr, &r->profile_path));
 273                         size_profile_path_1 = ndr_get_array_size(ndr, &r->profile_path);
 274                         length_profile_path_1 = ndr_get_array_length(ndr, &r->profile_path);
 275                         if (length_profile_path_1 > size_profile_path_1) {
 276                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_profile_path_1, length_profile_path_1);
 277                         }
 278                         NDR_CHECK(ndr_check_string_terminator(ndr, length_profile_path_1, sizeof(uint8_t)));
 279                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->profile_path, length_profile_path_1, sizeof(uint8_t), CH_UTF8));
 280                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_profile_path_0, 0);
 281                 }
 282                 if (r->home_directory) {
 283                         _mem_save_home_directory_0 = NDR_PULL_GET_MEM_CTX(ndr);
 284                         NDR_PULL_SET_MEM_CTX(ndr, r->home_directory, 0);
 285                         NDR_CHECK(ndr_pull_array_size(ndr, &r->home_directory));
 286                         NDR_CHECK(ndr_pull_array_length(ndr, &r->home_directory));
 287                         size_home_directory_1 = ndr_get_array_size(ndr, &r->home_directory);
 288                         length_home_directory_1 = ndr_get_array_length(ndr, &r->home_directory);
 289                         if (length_home_directory_1 > size_home_directory_1) {
 290                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_home_directory_1, length_home_directory_1);
 291                         }
 292                         NDR_CHECK(ndr_check_string_terminator(ndr, length_home_directory_1, sizeof(uint8_t)));
 293                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->home_directory, length_home_directory_1, sizeof(uint8_t), CH_UTF8));
 294                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_home_directory_0, 0);
 295                 }
 296                 if (r->home_drive) {
 297                         _mem_save_home_drive_0 = NDR_PULL_GET_MEM_CTX(ndr);
 298                         NDR_PULL_SET_MEM_CTX(ndr, r->home_drive, 0);
 299                         NDR_CHECK(ndr_pull_array_size(ndr, &r->home_drive));
 300                         NDR_CHECK(ndr_pull_array_length(ndr, &r->home_drive));
 301                         size_home_drive_1 = ndr_get_array_size(ndr, &r->home_drive);
 302                         length_home_drive_1 = ndr_get_array_length(ndr, &r->home_drive);
 303                         if (length_home_drive_1 > size_home_drive_1) {
 304                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_home_drive_1, length_home_drive_1);
 305                         }
 306                         NDR_CHECK(ndr_check_string_terminator(ndr, length_home_drive_1, sizeof(uint8_t)));
 307                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->home_drive, length_home_drive_1, sizeof(uint8_t), CH_UTF8));
 308                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_home_drive_0, 0);
 309                 }
 310                 if (r->logon_server) {
 311                         _mem_save_logon_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
 312                         NDR_PULL_SET_MEM_CTX(ndr, r->logon_server, 0);
 313                         NDR_CHECK(ndr_pull_array_size(ndr, &r->logon_server));
 314                         NDR_CHECK(ndr_pull_array_length(ndr, &r->logon_server));
 315                         size_logon_server_1 = ndr_get_array_size(ndr, &r->logon_server);
 316                         length_logon_server_1 = ndr_get_array_length(ndr, &r->logon_server);
 317                         if (length_logon_server_1 > size_logon_server_1) {
 318                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_logon_server_1, length_logon_server_1);
 319                         }
 320                         NDR_CHECK(ndr_check_string_terminator(ndr, length_logon_server_1, sizeof(uint8_t)));
 321                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->logon_server, length_logon_server_1, sizeof(uint8_t), CH_UTF8));
 322                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_logon_server_0, 0);
 323                 }
 324         }
 325         return NDR_ERR_SUCCESS;
 326 }
 327
 328 _PUBLIC_ void ndr_print_auth_user_info(struct ndr_print *ndr, const char *name, const struct auth_user_info *r)
 329 {
 330         ndr_print_struct(ndr, name, "auth_user_info");
 331         if (r == NULL) { ndr_print_null(ndr); return; }
 332         ndr->depth++;
 333         ndr_print_ptr(ndr, "account_name", r->account_name);
 334         ndr->depth++;
 335         if (r->account_name) {
 336                 ndr_print_string(ndr, "account_name", r->account_name);
 337         }
 338         ndr->depth--;
 339         ndr_print_ptr(ndr, "domain_name", r->domain_name);
 340         ndr->depth++;
 341         if (r->domain_name) {
 342                 ndr_print_string(ndr, "domain_name", r->domain_name);
 343         }
 344         ndr->depth--;
 345         ndr_print_ptr(ndr, "full_name", r->full_name);
 346         ndr->depth++;
 347         if (r->full_name) {
 348                 ndr_print_string(ndr, "full_name", r->full_name);
 349         }
 350         ndr->depth--;
 351         ndr_print_ptr(ndr, "logon_script", r->logon_script);
 352         ndr->depth++;
 353         if (r->logon_script) {
 354                 ndr_print_string(ndr, "logon_script", r->logon_script);
 355         }
 356         ndr->depth--;
 357         ndr_print_ptr(ndr, "profile_path", r->profile_path);
 358         ndr->depth++;
 359         if (r->profile_path) {
 360                 ndr_print_string(ndr, "profile_path", r->profile_path);
 361         }
 362         ndr->depth--;
 363         ndr_print_ptr(ndr, "home_directory", r->home_directory);
 364         ndr->depth++;
 365         if (r->home_directory) {
 366                 ndr_print_string(ndr, "home_directory", r->home_directory);
 367         }
 368         ndr->depth--;
 369         ndr_print_ptr(ndr, "home_drive", r->home_drive);
 370         ndr->depth++;
 371         if (r->home_drive) {
 372                 ndr_print_string(ndr, "home_drive", r->home_drive);
 373         }
 374         ndr->depth--;
 375         ndr_print_ptr(ndr, "logon_server", r->logon_server);
 376         ndr->depth++;
 377         if (r->logon_server) {
 378                 ndr_print_string(ndr, "logon_server", r->logon_server);
 379         }
 380         ndr->depth--;
 381         ndr_print_NTTIME(ndr, "last_logon", r->last_logon);
 382         ndr_print_NTTIME(ndr, "last_logoff", r->last_logoff);
 383         ndr_print_NTTIME(ndr, "acct_expiry", r->acct_expiry);
 384         ndr_print_NTTIME(ndr, "last_password_change", r->last_password_change);
 385         ndr_print_NTTIME(ndr, "allow_password_change", r->allow_password_change);
 386         ndr_print_NTTIME(ndr, "force_password_change", r->force_password_change);
 387         ndr_print_uint16(ndr, "logon_count", r->logon_count);
 388         ndr_print_uint16(ndr, "bad_password_count", r->bad_password_count);
 389         ndr_print_uint32(ndr, "acct_flags", r->acct_flags);
 390         ndr_print_uint8(ndr, "authenticated", r->authenticated);
 391         ndr->depth--;
 392 }
 393
 394 _PUBLIC_ enum ndr_err_code ndr_push_auth_user_info_torture(struct ndr_push *ndr, int ndr_flags, const struct auth_user_info_torture *r)
 395 {
 396         uint32_t cntr_dc_sids_0;
 397         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 398         if (ndr_flags & NDR_SCALARS) {
 399                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_dc_sids));
 400                 NDR_CHECK(ndr_push_align(ndr, 4));
 401                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_dc_sids));
 402                 for (cntr_dc_sids_0 = 0; cntr_dc_sids_0 < r->num_dc_sids; cntr_dc_sids_0++) {
 403                         NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, &r->dc_sids[cntr_dc_sids_0]));
 404                 }
 405                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 406         }
 407         if (ndr_flags & NDR_BUFFERS) {
 408         }
 409         return NDR_ERR_SUCCESS;
 410 }
 411
 412 _PUBLIC_ enum ndr_err_code ndr_pull_auth_user_info_torture(struct ndr_pull *ndr, int ndr_flags, struct auth_user_info_torture *r)
 413 {
 414         uint32_t size_dc_sids_0 = 0;
 415         uint32_t cntr_dc_sids_0;
 416         TALLOC_CTX *_mem_save_dc_sids_0;
 417         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 418         if (ndr_flags & NDR_SCALARS) {
 419                 NDR_CHECK(ndr_pull_array_size(ndr, &r->dc_sids));
 420                 NDR_CHECK(ndr_pull_align(ndr, 4));
 421                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_dc_sids));
 422                 size_dc_sids_0 = ndr_get_array_size(ndr, &r->dc_sids);
 423                 NDR_PULL_ALLOC_N(ndr, r->dc_sids, size_dc_sids_0);
 424                 _mem_save_dc_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 425                 NDR_PULL_SET_MEM_CTX(ndr, r->dc_sids, 0);
 426                 for (cntr_dc_sids_0 = 0; cntr_dc_sids_0 < size_dc_sids_0; cntr_dc_sids_0++) {
 427                         NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, &r->dc_sids[cntr_dc_sids_0]));
 428                 }
 429                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dc_sids_0, 0);
 430                 if (r->dc_sids) {
 431                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->dc_sids, r->num_dc_sids));
 432                 }
 433                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 434         }
 435         if (ndr_flags & NDR_BUFFERS) {
 436         }
 437         return NDR_ERR_SUCCESS;
 438 }
 439
 440 _PUBLIC_ void ndr_print_auth_user_info_torture(struct ndr_print *ndr, const char *name, const struct auth_user_info_torture *r)
 441 {
 442         uint32_t cntr_dc_sids_0;
 443         ndr_print_struct(ndr, name, "auth_user_info_torture");
 444         if (r == NULL) { ndr_print_null(ndr); return; }
 445         ndr->depth++;
 446         ndr_print_uint32(ndr, "num_dc_sids", r->num_dc_sids);
 447         ndr->print(ndr, "%s: ARRAY(%d)", "dc_sids", (int)r->num_dc_sids);
 448         ndr->depth++;
 449         for (cntr_dc_sids_0=0;cntr_dc_sids_0<r->num_dc_sids;cntr_dc_sids_0++) {
 450                 ndr_print_dom_sid(ndr, "dc_sids", &r->dc_sids[cntr_dc_sids_0]);
 451         }
 452         ndr->depth--;
 453         ndr->depth--;
 454 }
 455
 456 _PUBLIC_ enum ndr_err_code ndr_push_auth_user_info_unix(struct ndr_push *ndr, int ndr_flags, const struct auth_user_info_unix *r)
 457 {
 458         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 459         if (ndr_flags & NDR_SCALARS) {
 460                 NDR_CHECK(ndr_push_align(ndr, 5));
 461                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->unix_name));
 462                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sanitized_username));
 463                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 464         }
 465         if (ndr_flags & NDR_BUFFERS) {
 466                 if (r->unix_name) {
 467                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->unix_name, CH_UTF8)));
 468                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 469                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->unix_name, CH_UTF8)));
 470                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->unix_name, ndr_charset_length(r->unix_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 471                 }
 472                 if (r->sanitized_username) {
 473                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sanitized_username, CH_UTF8)));
 474                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 475                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sanitized_username, CH_UTF8)));
 476                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sanitized_username, ndr_charset_length(r->sanitized_username, CH_UTF8), sizeof(uint8_t), CH_UTF8));
 477                 }
 478         }
 479         return NDR_ERR_SUCCESS;
 480 }
 481
 482 _PUBLIC_ enum ndr_err_code ndr_pull_auth_user_info_unix(struct ndr_pull *ndr, int ndr_flags, struct auth_user_info_unix *r)
 483 {
 484         uint32_t _ptr_unix_name;
 485         uint32_t size_unix_name_1 = 0;
 486         uint32_t length_unix_name_1 = 0;
 487         TALLOC_CTX *_mem_save_unix_name_0;
 488         uint32_t _ptr_sanitized_username;
 489         uint32_t size_sanitized_username_1 = 0;
 490         uint32_t length_sanitized_username_1 = 0;
 491         TALLOC_CTX *_mem_save_sanitized_username_0;
 492         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 493         if (ndr_flags & NDR_SCALARS) {
 494                 NDR_CHECK(ndr_pull_align(ndr, 5));
 495                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unix_name));
 496                 if (_ptr_unix_name) {
 497                         NDR_PULL_ALLOC(ndr, r->unix_name);
 498                 } else {
 499                         r->unix_name = NULL;
 500                 }
 501                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sanitized_username));
 502                 if (_ptr_sanitized_username) {
 503                         NDR_PULL_ALLOC(ndr, r->sanitized_username);
 504                 } else {
 505                         r->sanitized_username = NULL;
 506                 }
 507                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 508         }
 509         if (ndr_flags & NDR_BUFFERS) {
 510                 if (r->unix_name) {
 511                         _mem_save_unix_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 512                         NDR_PULL_SET_MEM_CTX(ndr, r->unix_name, 0);
 513                         NDR_CHECK(ndr_pull_array_size(ndr, &r->unix_name));
 514                         NDR_CHECK(ndr_pull_array_length(ndr, &r->unix_name));
 515                         size_unix_name_1 = ndr_get_array_size(ndr, &r->unix_name);
 516                         length_unix_name_1 = ndr_get_array_length(ndr, &r->unix_name);
 517                         if (length_unix_name_1 > size_unix_name_1) {
 518                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_unix_name_1, length_unix_name_1);
 519                         }
 520                         NDR_CHECK(ndr_check_string_terminator(ndr, length_unix_name_1, sizeof(uint8_t)));
 521                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->unix_name, length_unix_name_1, sizeof(uint8_t), CH_UTF8));
 522                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unix_name_0, 0);
 523                 }
 524                 if (r->sanitized_username) {
 525                         _mem_save_sanitized_username_0 = NDR_PULL_GET_MEM_CTX(ndr);
 526                         NDR_PULL_SET_MEM_CTX(ndr, r->sanitized_username, 0);
 527                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sanitized_username));
 528                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sanitized_username));
 529                         size_sanitized_username_1 = ndr_get_array_size(ndr, &r->sanitized_username);
 530                         length_sanitized_username_1 = ndr_get_array_length(ndr, &r->sanitized_username);
 531                         if (length_sanitized_username_1 > size_sanitized_username_1) {
 532                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_sanitized_username_1, length_sanitized_username_1);
 533                         }
 534                         NDR_CHECK(ndr_check_string_terminator(ndr, length_sanitized_username_1, sizeof(uint8_t)));
 535                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sanitized_username, length_sanitized_username_1, sizeof(uint8_t), CH_UTF8));
 536                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sanitized_username_0, 0);
 537                 }
 538         }
 539         return NDR_ERR_SUCCESS;
 540 }
 541
 542 _PUBLIC_ void ndr_print_auth_user_info_unix(struct ndr_print *ndr, const char *name, const struct auth_user_info_unix *r)
 543 {
 544         ndr_print_struct(ndr, name, "auth_user_info_unix");
 545         if (r == NULL) { ndr_print_null(ndr); return; }
 546         ndr->depth++;
 547         ndr_print_ptr(ndr, "unix_name", r->unix_name);
 548         ndr->depth++;
 549         if (r->unix_name) {
 550                 ndr_print_string(ndr, "unix_name", r->unix_name);
 551         }
 552         ndr->depth--;
 553         ndr_print_ptr(ndr, "sanitized_username", r->sanitized_username);
 554         ndr->depth++;
 555         if (r->sanitized_username) {
 556                 ndr_print_string(ndr, "sanitized_username", r->sanitized_username);
 557         }
 558         ndr->depth--;
 559         ndr->depth--;
 560 }
 561
 562 _PUBLIC_ enum ndr_err_code ndr_push_auth_user_info_dc(struct ndr_push *ndr, int ndr_flags, const struct auth_user_info_dc *r)
 563 {
 564         uint32_t cntr_sids_0;
 565         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 566         if (ndr_flags & NDR_SCALARS) {
 567                 NDR_CHECK(ndr_push_align(ndr, 5));
 568                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
 569                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_sids));
 570                 for (cntr_sids_0 = 0; cntr_sids_0 < r->num_sids; cntr_sids_0++) {
 571                         NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, &r->sids[cntr_sids_0]));
 572                 }
 573                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
 574                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->user_session_key));
 575                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->lm_session_key));
 576                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 577         }
 578         if (ndr_flags & NDR_BUFFERS) {
 579                 if (r->info) {
 580                         NDR_CHECK(ndr_push_auth_user_info(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
 581                 }
 582         }
 583         return NDR_ERR_SUCCESS;
 584 }
 585
 586 _PUBLIC_ enum ndr_err_code ndr_pull_auth_user_info_dc(struct ndr_pull *ndr, int ndr_flags, struct auth_user_info_dc *r)
 587 {
 588         uint32_t size_sids_0 = 0;
 589         uint32_t cntr_sids_0;
 590         TALLOC_CTX *_mem_save_sids_0;
 591         uint32_t _ptr_info;
 592         TALLOC_CTX *_mem_save_info_0;
 593         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 594         if (ndr_flags & NDR_SCALARS) {
 595                 NDR_CHECK(ndr_pull_align(ndr, 5));
 596                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_sids));
 597                 NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
 598                 size_sids_0 = ndr_get_array_size(ndr, &r->sids);
 599                 NDR_PULL_ALLOC_N(ndr, r->sids, size_sids_0);
 600                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 601                 NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
 602                 for (cntr_sids_0 = 0; cntr_sids_0 < size_sids_0; cntr_sids_0++) {
 603                         NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, &r->sids[cntr_sids_0]));
 604                 }
 605                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
 606                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
 607                 if (_ptr_info) {
 608                         NDR_PULL_ALLOC(ndr, r->info);
 609                 } else {
 610                         r->info = NULL;
 611                 }
 612                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->user_session_key));
 613                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->lm_session_key));
 614                 if (r->sids) {
 615                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->num_sids));
 616                 }
 617                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 618         }
 619         if (ndr_flags & NDR_BUFFERS) {
 620                 if (r->info) {
 621                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 622                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
 623                         NDR_CHECK(ndr_pull_auth_user_info(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
 624                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
 625                 }
 626         }
 627         return NDR_ERR_SUCCESS;
 628 }
 629
 630 _PUBLIC_ void ndr_print_auth_user_info_dc(struct ndr_print *ndr, const char *name, const struct auth_user_info_dc *r)
 631 {
 632         uint32_t cntr_sids_0;
 633         ndr_print_struct(ndr, name, "auth_user_info_dc");
 634         if (r == NULL) { ndr_print_null(ndr); return; }
 635         ndr->depth++;
 636         ndr_print_uint32(ndr, "num_sids", r->num_sids);
 637         ndr->print(ndr, "%s: ARRAY(%d)", "sids", (int)r->num_sids);
 638         ndr->depth++;
 639         for (cntr_sids_0=0;cntr_sids_0<r->num_sids;cntr_sids_0++) {
 640                 ndr_print_dom_sid(ndr, "sids", &r->sids[cntr_sids_0]);
 641         }
 642         ndr->depth--;
 643         ndr_print_ptr(ndr, "info", r->info);
 644         ndr->depth++;
 645         if (r->info) {
 646                 ndr_print_auth_user_info(ndr, "info", r->info);
 647         }
 648         ndr->depth--;
 649         ndr->depth--;
 650 }
 651
 652 _PUBLIC_ enum ndr_err_code ndr_push_auth_session_info(struct ndr_push *ndr, int ndr_flags, const struct auth_session_info *r)
 653 {
 654         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 655         if (ndr_flags & NDR_SCALARS) {
 656                 NDR_CHECK(ndr_push_align(ndr, 5));
 657                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->security_token));
 658                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->unix_token));
 659                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
 660                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->unix_info));
 661                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 662                 /* [ignore] 'torture' */
 663                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->session_key));
 664                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 665                 /* [ignore] 'credentials' */
 666                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 667         }
 668         if (ndr_flags & NDR_BUFFERS) {
 669                 if (r->security_token) {
 670                         NDR_CHECK(ndr_push_security_token(ndr, NDR_SCALARS, r->security_token));
 671                 }
 672                 if (r->unix_token) {
 673                         NDR_CHECK(ndr_push_security_unix_token(ndr, NDR_SCALARS, r->unix_token));
 674                 }
 675                 if (r->info) {
 676                         NDR_CHECK(ndr_push_auth_user_info(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
 677                 }
 678                 if (r->unix_info) {
 679                         NDR_CHECK(ndr_push_auth_user_info_unix(ndr, NDR_SCALARS|NDR_BUFFERS, r->unix_info));
 680                 }
 681                 /* [ignore] 'torture' */
 682                 /* [ignore] 'credentials' */
 683         }
 684         return NDR_ERR_SUCCESS;
 685 }
 686
 687 _PUBLIC_ enum ndr_err_code ndr_pull_auth_session_info(struct ndr_pull *ndr, int ndr_flags, struct auth_session_info *r)
 688 {
 689         uint32_t _ptr_security_token;
 690         TALLOC_CTX *_mem_save_security_token_0;
 691         uint32_t _ptr_unix_token;
 692         TALLOC_CTX *_mem_save_unix_token_0;
 693         uint32_t _ptr_info;
 694         TALLOC_CTX *_mem_save_info_0;
 695         uint32_t _ptr_unix_info;
 696         TALLOC_CTX *_mem_save_unix_info_0;
 697         uint32_t _ptr_torture;
 698         uint32_t _ptr_credentials;
 699         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 700         if (ndr_flags & NDR_SCALARS) {
 701                 NDR_CHECK(ndr_pull_align(ndr, 5));
 702                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_security_token));
 703                 if (_ptr_security_token) {
 704                         NDR_PULL_ALLOC(ndr, r->security_token);
 705                 } else {
 706                         r->security_token = NULL;
 707                 }
 708                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unix_token));
 709                 if (_ptr_unix_token) {
 710                         NDR_PULL_ALLOC(ndr, r->unix_token);
 711                 } else {
 712                         r->unix_token = NULL;
 713                 }
 714                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
 715                 if (_ptr_info) {
 716                         NDR_PULL_ALLOC(ndr, r->info);
 717                 } else {
 718                         r->info = NULL;
 719                 }
 720                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unix_info));
 721                 if (_ptr_unix_info) {
 722                         NDR_PULL_ALLOC(ndr, r->unix_info);
 723                 } else {
 724                         r->unix_info = NULL;
 725                 }
 726                 NDR_CHECK(ndr_pull_uint3264(ndr, NDR_SCALARS, &_ptr_torture));
 727                 _ptr_torture = 0;
 728                 if (_ptr_torture) {
 729                 } else {
 730                         r->torture = NULL;
 731                 }
 732                 /* [ignore] 'torture' */
 733                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->session_key));
 734                 NDR_CHECK(ndr_pull_uint3264(ndr, NDR_SCALARS, &_ptr_credentials));
 735                 _ptr_credentials = 0;
 736                 if (_ptr_credentials) {
 737                 } else {
 738                         r->credentials = NULL;
 739                 }
 740                 /* [ignore] 'credentials' */
 741                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 742         }
 743         if (ndr_flags & NDR_BUFFERS) {
 744                 if (r->security_token) {
 745                         _mem_save_security_token_0 = NDR_PULL_GET_MEM_CTX(ndr);
 746                         NDR_PULL_SET_MEM_CTX(ndr, r->security_token, 0);
 747                         NDR_CHECK(ndr_pull_security_token(ndr, NDR_SCALARS, r->security_token));
 748                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_security_token_0, 0);
 749                 }
 750                 if (r->unix_token) {
 751                         _mem_save_unix_token_0 = NDR_PULL_GET_MEM_CTX(ndr);
 752                         NDR_PULL_SET_MEM_CTX(ndr, r->unix_token, 0);
 753                         NDR_CHECK(ndr_pull_security_unix_token(ndr, NDR_SCALARS, r->unix_token));
 754                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unix_token_0, 0);
 755                 }
 756                 if (r->info) {
 757                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 758                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
 759                         NDR_CHECK(ndr_pull_auth_user_info(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
 760                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
 761                 }
 762                 if (r->unix_info) {
 763                         _mem_save_unix_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 764                         NDR_PULL_SET_MEM_CTX(ndr, r->unix_info, 0);
 765                         NDR_CHECK(ndr_pull_auth_user_info_unix(ndr, NDR_SCALARS|NDR_BUFFERS, r->unix_info));
 766                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unix_info_0, 0);
 767                 }
 768                 /* [ignore] 'torture' */
 769                 /* [ignore] 'credentials' */
 770         }
 771         return NDR_ERR_SUCCESS;
 772 }
 773
 774 _PUBLIC_ void ndr_print_auth_session_info(struct ndr_print *ndr, const char *name, const struct auth_session_info *r)
 775 {
 776         ndr_print_struct(ndr, name, "auth_session_info");
 777         if (r == NULL) { ndr_print_null(ndr); return; }
 778         ndr->depth++;
 779         ndr_print_ptr(ndr, "security_token", r->security_token);
 780         ndr->depth++;
 781         if (r->security_token) {
 782                 ndr_print_security_token(ndr, "security_token", r->security_token);
 783         }
 784         ndr->depth--;
 785         ndr_print_ptr(ndr, "unix_token", r->unix_token);
 786         ndr->depth++;
 787         if (r->unix_token) {
 788                 ndr_print_security_unix_token(ndr, "unix_token", r->unix_token);
 789         }
 790         ndr->depth--;
 791         ndr_print_ptr(ndr, "info", r->info);
 792         ndr->depth++;
 793         if (r->info) {
 794                 ndr_print_auth_user_info(ndr, "info", r->info);
 795         }
 796         ndr->depth--;
 797         ndr_print_ptr(ndr, "unix_info", r->unix_info);
 798         ndr->depth++;
 799         if (r->unix_info) {
 800                 ndr_print_auth_user_info_unix(ndr, "unix_info", r->unix_info);
 801         }
 802         ndr->depth--;
 803         ndr_print_ptr(ndr, "torture", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?NULL:r->torture);
 804         /* [ignore] 'torture' */
 805         ndr_print_ptr(ndr, "credentials", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?NULL:r->credentials);
 806         /* [ignore] 'credentials' */
 807         ndr->depth--;
 808 }
 809
 810 _PUBLIC_ enum ndr_err_code ndr_push_auth_session_info_transport(struct ndr_push *ndr, int ndr_flags, const struct auth_session_info_transport *r)
 811 {
 812         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 813         if (ndr_flags & NDR_SCALARS) {
 814                 NDR_CHECK(ndr_push_align(ndr, 5));
 815                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->session_info));
 816                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->exported_gssapi_credentials));
 817                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 818         }
 819         if (ndr_flags & NDR_BUFFERS) {
 820                 if (r->session_info) {
 821                         NDR_CHECK(ndr_push_auth_session_info(ndr, NDR_SCALARS|NDR_BUFFERS, r->session_info));
 822                 }
 823         }
 824         return NDR_ERR_SUCCESS;
 825 }
 826
 827 _PUBLIC_ enum ndr_err_code ndr_pull_auth_session_info_transport(struct ndr_pull *ndr, int ndr_flags, struct auth_session_info_transport *r)
 828 {
 829         uint32_t _ptr_session_info;
 830         TALLOC_CTX *_mem_save_session_info_0;
 831         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 832         if (ndr_flags & NDR_SCALARS) {
 833                 NDR_CHECK(ndr_pull_align(ndr, 5));
 834                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_session_info));
 835                 if (_ptr_session_info) {
 836                         NDR_PULL_ALLOC(ndr, r->session_info);
 837                 } else {
 838                         r->session_info = NULL;
 839                 }
 840                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->exported_gssapi_credentials));
 841                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 842         }
 843         if (ndr_flags & NDR_BUFFERS) {
 844                 if (r->session_info) {
 845                         _mem_save_session_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 846                         NDR_PULL_SET_MEM_CTX(ndr, r->session_info, 0);
 847                         NDR_CHECK(ndr_pull_auth_session_info(ndr, NDR_SCALARS|NDR_BUFFERS, r->session_info));
 848                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_session_info_0, 0);
 849                 }
 850         }
 851         return NDR_ERR_SUCCESS;
 852 }
 853
 854 _PUBLIC_ void ndr_print_auth_session_info_transport(struct ndr_print *ndr, const char *name, const struct auth_session_info_transport *r)
 855 {
 856         ndr_print_struct(ndr, name, "auth_session_info_transport");
 857         if (r == NULL) { ndr_print_null(ndr); return; }
 858         ndr->depth++;
 859         ndr_print_ptr(ndr, "session_info", r->session_info);
 860         ndr->depth++;
 861         if (r->session_info) {
 862                 ndr_print_auth_session_info(ndr, "session_info", r->session_info);
 863         }
 864         ndr->depth--;
 865         ndr->depth--;
 866 }
 867