librpc/gen_ndr/ndr_named_pipe_auth.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_named_pipe_auth.h"
   5
   6 #include "librpc/gen_ndr/ndr_netlogon.h"
   7 static enum ndr_err_code ndr_push_named_pipe_auth_req_info2(struct ndr_push *ndr, int ndr_flags, const struct named_pipe_auth_req_info2 *r)
   8 {
   9         if (ndr_flags & NDR_SCALARS) {
  10                 NDR_CHECK(ndr_push_align(ndr, 4));
  11                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client_name));
  12                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client_addr));
  13                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->client_port));
  14                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
  15                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_addr));
  16                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->server_port));
  17                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sam_info3));
  18                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_key_length));
  19                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->session_key));
  20         }
  21         if (ndr_flags & NDR_BUFFERS) {
  22                 if (r->client_name) {
  23                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client_name, CH_UTF8)));
  24                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  25                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client_name, CH_UTF8)));
  26                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client_name, ndr_charset_length(r->client_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
  27                 }
  28                 if (r->client_addr) {
  29                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client_addr, CH_DOS)));
  30                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  31                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client_addr, CH_DOS)));
  32                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client_addr, ndr_charset_length(r->client_addr, CH_DOS), sizeof(uint8_t), CH_DOS));
  33                 }
  34                 if (r->server_name) {
  35                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF8)));
  36                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  37                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF8)));
  38                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
  39                 }
  40                 if (r->server_addr) {
  41                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_addr, CH_DOS)));
  42                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  43                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_addr, CH_DOS)));
  44                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_addr, ndr_charset_length(r->server_addr, CH_DOS), sizeof(uint8_t), CH_DOS));
  45                 }
  46                 if (r->sam_info3) {
  47                         NDR_CHECK(ndr_push_netr_SamInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->sam_info3));
  48                 }
  49                 if (r->session_key) {
  50                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_key_length));
  51                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->session_key, r->session_key_length));
  52                 }
  53         }
  54         return NDR_ERR_SUCCESS;
  55 }
  56
  57 static enum ndr_err_code ndr_pull_named_pipe_auth_req_info2(struct ndr_pull *ndr, int ndr_flags, struct named_pipe_auth_req_info2 *r)
  58 {
  59         uint32_t _ptr_client_name;
  60         TALLOC_CTX *_mem_save_client_name_0;
  61         uint32_t _ptr_client_addr;
  62         TALLOC_CTX *_mem_save_client_addr_0;
  63         uint32_t _ptr_server_name;
  64         TALLOC_CTX *_mem_save_server_name_0;
  65         uint32_t _ptr_server_addr;
  66         TALLOC_CTX *_mem_save_server_addr_0;
  67         uint32_t _ptr_sam_info3;
  68         TALLOC_CTX *_mem_save_sam_info3_0;
  69         uint32_t _ptr_session_key;
  70         TALLOC_CTX *_mem_save_session_key_0;
  71         if (ndr_flags & NDR_SCALARS) {
  72                 NDR_CHECK(ndr_pull_align(ndr, 4));
  73                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client_name));
  74                 if (_ptr_client_name) {
  75                         NDR_PULL_ALLOC(ndr, r->client_name);
  76                 } else {
  77                         r->client_name = NULL;
  78                 }
  79                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client_addr));
  80                 if (_ptr_client_addr) {
  81                         NDR_PULL_ALLOC(ndr, r->client_addr);
  82                 } else {
  83                         r->client_addr = NULL;
  84                 }
  85                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->client_port));
  86                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
  87                 if (_ptr_server_name) {
  88                         NDR_PULL_ALLOC(ndr, r->server_name);
  89                 } else {
  90                         r->server_name = NULL;
  91                 }
  92                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_addr));
  93                 if (_ptr_server_addr) {
  94                         NDR_PULL_ALLOC(ndr, r->server_addr);
  95                 } else {
  96                         r->server_addr = NULL;
  97                 }
  98                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->server_port));
  99                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam_info3));
 100                 if (_ptr_sam_info3) {
 101                         NDR_PULL_ALLOC(ndr, r->sam_info3);
 102                 } else {
 103                         r->sam_info3 = NULL;
 104                 }
 105                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_key_length));
 106                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_session_key));
 107                 if (_ptr_session_key) {
 108                         NDR_PULL_ALLOC(ndr, r->session_key);
 109                 } else {
 110                         r->session_key = NULL;
 111                 }
 112         }
 113         if (ndr_flags & NDR_BUFFERS) {
 114                 if (r->client_name) {
 115                         _mem_save_client_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 116                         NDR_PULL_SET_MEM_CTX(ndr, r->client_name, 0);
 117                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client_name));
 118                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client_name));
 119                         if (ndr_get_array_length(ndr, &r->client_name) > ndr_get_array_size(ndr, &r->client_name)) {
 120                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->client_name), ndr_get_array_length(ndr, &r->client_name));
 121                         }
 122                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client_name), sizeof(uint8_t)));
 123                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client_name, ndr_get_array_length(ndr, &r->client_name), sizeof(uint8_t), CH_UTF8));
 124                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_name_0, 0);
 125                 }
 126                 if (r->client_addr) {
 127                         _mem_save_client_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);
 128                         NDR_PULL_SET_MEM_CTX(ndr, r->client_addr, 0);
 129                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client_addr));
 130                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client_addr));
 131                         if (ndr_get_array_length(ndr, &r->client_addr) > ndr_get_array_size(ndr, &r->client_addr)) {
 132                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->client_addr), ndr_get_array_length(ndr, &r->client_addr));
 133                         }
 134                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client_addr), sizeof(uint8_t)));
 135                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client_addr, ndr_get_array_length(ndr, &r->client_addr), sizeof(uint8_t), CH_DOS));
 136                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_addr_0, 0);
 137                 }
 138                 if (r->server_name) {
 139                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 140                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
 141                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
 142                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
 143                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
 144                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
 145                         }
 146                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint8_t)));
 147                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint8_t), CH_UTF8));
 148                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
 149                 }
 150                 if (r->server_addr) {
 151                         _mem_save_server_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);
 152                         NDR_PULL_SET_MEM_CTX(ndr, r->server_addr, 0);
 153                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_addr));
 154                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_addr));
 155                         if (ndr_get_array_length(ndr, &r->server_addr) > ndr_get_array_size(ndr, &r->server_addr)) {
 156                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_addr), ndr_get_array_length(ndr, &r->server_addr));
 157                         }
 158                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_addr), sizeof(uint8_t)));
 159                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_addr, ndr_get_array_length(ndr, &r->server_addr), sizeof(uint8_t), CH_DOS));
 160                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_addr_0, 0);
 161                 }
 162                 if (r->sam_info3) {
 163                         _mem_save_sam_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
 164                         NDR_PULL_SET_MEM_CTX(ndr, r->sam_info3, 0);
 165                         NDR_CHECK(ndr_pull_netr_SamInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->sam_info3));
 166                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_info3_0, 0);
 167                 }
 168                 if (r->session_key) {
 169                         _mem_save_session_key_0 = NDR_PULL_GET_MEM_CTX(ndr);
 170                         NDR_PULL_SET_MEM_CTX(ndr, r->session_key, 0);
 171                         NDR_CHECK(ndr_pull_array_size(ndr, &r->session_key));
 172                         NDR_PULL_ALLOC_N(ndr, r->session_key, ndr_get_array_size(ndr, &r->session_key));
 173                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->session_key, ndr_get_array_size(ndr, &r->session_key)));
 174                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_session_key_0, 0);
 175                 }
 176                 if (r->session_key) {
 177                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->session_key, r->session_key_length));
 178                 }
 179         }
 180         return NDR_ERR_SUCCESS;
 181 }
 182
 183 _PUBLIC_ void ndr_print_named_pipe_auth_req_info2(struct ndr_print *ndr, const char *name, const struct named_pipe_auth_req_info2 *r)
 184 {
 185         ndr_print_struct(ndr, name, "named_pipe_auth_req_info2");
 186         ndr->depth++;
 187         ndr_print_ptr(ndr, "client_name", r->client_name);
 188         ndr->depth++;
 189         if (r->client_name) {
 190                 ndr_print_string(ndr, "client_name", r->client_name);
 191         }
 192         ndr->depth--;
 193         ndr_print_ptr(ndr, "client_addr", r->client_addr);
 194         ndr->depth++;
 195         if (r->client_addr) {
 196                 ndr_print_string(ndr, "client_addr", r->client_addr);
 197         }
 198         ndr->depth--;
 199         ndr_print_uint16(ndr, "client_port", r->client_port);
 200         ndr_print_ptr(ndr, "server_name", r->server_name);
 201         ndr->depth++;
 202         if (r->server_name) {
 203                 ndr_print_string(ndr, "server_name", r->server_name);
 204         }
 205         ndr->depth--;
 206         ndr_print_ptr(ndr, "server_addr", r->server_addr);
 207         ndr->depth++;
 208         if (r->server_addr) {
 209                 ndr_print_string(ndr, "server_addr", r->server_addr);
 210         }
 211         ndr->depth--;
 212         ndr_print_uint16(ndr, "server_port", r->server_port);
 213         ndr_print_ptr(ndr, "sam_info3", r->sam_info3);
 214         ndr->depth++;
 215         if (r->sam_info3) {
 216                 ndr_print_netr_SamInfo3(ndr, "sam_info3", r->sam_info3);
 217         }
 218         ndr->depth--;
 219         ndr_print_uint32(ndr, "session_key_length", r->session_key_length);
 220         ndr_print_ptr(ndr, "session_key", r->session_key);
 221         ndr->depth++;
 222         if (r->session_key) {
 223                 ndr_print_array_uint8(ndr, "session_key", r->session_key, r->session_key_length);
 224         }
 225         ndr->depth--;
 226         ndr->depth--;
 227 }
 228
 229 static enum ndr_err_code ndr_push_named_pipe_auth_req_info(struct ndr_push *ndr, int ndr_flags, const union named_pipe_auth_req_info *r)
 230 {
 231         if (ndr_flags & NDR_SCALARS) {
 232                 int level = ndr_push_get_switch_value(ndr, r);
 233                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
 234                 switch (level) {
 235                         case 0: {
 236                         break; }
 237
 238                         case 1: {
 239                                 NDR_CHECK(ndr_push_netr_SamInfo3(ndr, NDR_SCALARS, &r->info1));
 240                         break; }
 241
 242                         case 2: {
 243                                 NDR_CHECK(ndr_push_named_pipe_auth_req_info2(ndr, NDR_SCALARS, &r->info2));
 244                         break; }
 245
 246                         default:
 247                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 248                 }
 249         }
 250         if (ndr_flags & NDR_BUFFERS) {
 251                 int level = ndr_push_get_switch_value(ndr, r);
 252                 switch (level) {
 253                         case 0:
 254                         break;
 255
 256                         case 1:
 257                                 NDR_CHECK(ndr_push_netr_SamInfo3(ndr, NDR_BUFFERS, &r->info1));
 258                         break;
 259
 260                         case 2:
 261                                 NDR_CHECK(ndr_push_named_pipe_auth_req_info2(ndr, NDR_BUFFERS, &r->info2));
 262                         break;
 263
 264                         default:
 265                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 266                 }
 267         }
 268         return NDR_ERR_SUCCESS;
 269 }
 270
 271 static enum ndr_err_code ndr_pull_named_pipe_auth_req_info(struct ndr_pull *ndr, int ndr_flags, union named_pipe_auth_req_info *r)
 272 {
 273         int level;
 274         uint32_t _level;
 275         level = ndr_pull_get_switch_value(ndr, r);
 276         if (ndr_flags & NDR_SCALARS) {
 277                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
 278                 if (_level != level) {
 279                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
 280                 }
 281                 switch (level) {
 282                         case 0: {
 283                         break; }
 284
 285                         case 1: {
 286                                 NDR_CHECK(ndr_pull_netr_SamInfo3(ndr, NDR_SCALARS, &r->info1));
 287                         break; }
 288
 289                         case 2: {
 290                                 NDR_CHECK(ndr_pull_named_pipe_auth_req_info2(ndr, NDR_SCALARS, &r->info2));
 291                         break; }
 292
 293                         default:
 294                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 295                 }
 296         }
 297         if (ndr_flags & NDR_BUFFERS) {
 298                 switch (level) {
 299                         case 0:
 300                         break;
 301
 302                         case 1:
 303                                 NDR_CHECK(ndr_pull_netr_SamInfo3(ndr, NDR_BUFFERS, &r->info1));
 304                         break;
 305
 306                         case 2:
 307                                 NDR_CHECK(ndr_pull_named_pipe_auth_req_info2(ndr, NDR_BUFFERS, &r->info2));
 308                         break;
 309
 310                         default:
 311                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 312                 }
 313         }
 314         return NDR_ERR_SUCCESS;
 315 }
 316
 317 _PUBLIC_ void ndr_print_named_pipe_auth_req_info(struct ndr_print *ndr, const char *name, const union named_pipe_auth_req_info *r)
 318 {
 319         int level;
 320         level = ndr_print_get_switch_value(ndr, r);
 321         ndr_print_union(ndr, name, level, "named_pipe_auth_req_info");
 322         switch (level) {
 323                 case 0:
 324                 break;
 325
 326                 case 1:
 327                         ndr_print_netr_SamInfo3(ndr, "info1", &r->info1);
 328                 break;
 329
 330                 case 2:
 331                         ndr_print_named_pipe_auth_req_info2(ndr, "info2", &r->info2);
 332                 break;
 333
 334                 default:
 335                         ndr_print_bad_level(ndr, name, level);
 336         }
 337 }
 338
 339 _PUBLIC_ enum ndr_err_code ndr_push_named_pipe_auth_req(struct ndr_push *ndr, int ndr_flags, const struct named_pipe_auth_req *r)
 340 {
 341         if (ndr_flags & NDR_SCALARS) {
 342                 NDR_CHECK(ndr_push_align(ndr, 4));
 343                 {
 344                         uint32_t _flags_save_uint32 = ndr->flags;
 345                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
 346                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_named_pipe_auth_req(r, ndr->iconv_convenience, ndr->flags) - 4));
 347                         ndr->flags = _flags_save_uint32;
 348                 }
 349                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, NAMED_PIPE_AUTH_MAGIC, 4, sizeof(uint8_t), CH_DOS));
 350                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
 351                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
 352                 NDR_CHECK(ndr_push_named_pipe_auth_req_info(ndr, NDR_SCALARS, &r->info));
 353         }
 354         if (ndr_flags & NDR_BUFFERS) {
 355                 NDR_CHECK(ndr_push_named_pipe_auth_req_info(ndr, NDR_BUFFERS, &r->info));
 356         }
 357         return NDR_ERR_SUCCESS;
 358 }
 359
 360 _PUBLIC_ enum ndr_err_code ndr_pull_named_pipe_auth_req(struct ndr_pull *ndr, int ndr_flags, struct named_pipe_auth_req *r)
 361 {
 362         if (ndr_flags & NDR_SCALARS) {
 363                 NDR_CHECK(ndr_pull_align(ndr, 4));
 364                 {
 365                         uint32_t _flags_save_uint32 = ndr->flags;
 366                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
 367                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
 368                         ndr->flags = _flags_save_uint32;
 369                 }
 370                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->magic, 4, sizeof(uint8_t), CH_DOS));
 371                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
 372                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
 373                 NDR_CHECK(ndr_pull_named_pipe_auth_req_info(ndr, NDR_SCALARS, &r->info));
 374         }
 375         if (ndr_flags & NDR_BUFFERS) {
 376                 NDR_CHECK(ndr_pull_named_pipe_auth_req_info(ndr, NDR_BUFFERS, &r->info));
 377         }
 378         return NDR_ERR_SUCCESS;
 379 }
 380
 381 _PUBLIC_ void ndr_print_named_pipe_auth_req(struct ndr_print *ndr, const char *name, const struct named_pipe_auth_req *r)
 382 {
 383         ndr_print_struct(ndr, name, "named_pipe_auth_req");
 384         ndr->depth++;
 385         ndr_print_uint32(ndr, "length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_named_pipe_auth_req(r, ndr->iconv_convenience, ndr->flags) - 4:r->length);
 386         ndr_print_string(ndr, "magic", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?NAMED_PIPE_AUTH_MAGIC:r->magic);
 387         ndr_print_uint32(ndr, "level", r->level);
 388         ndr_print_set_switch_value(ndr, &r->info, r->level);
 389         ndr_print_named_pipe_auth_req_info(ndr, "info", &r->info);
 390         ndr->depth--;
 391 }
 392
 393 _PUBLIC_ size_t ndr_size_named_pipe_auth_req(const struct named_pipe_auth_req *r, struct smb_iconv_convenience *ic, int flags)
 394 {
 395         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_named_pipe_auth_req, ic);
 396 }
 397
 398 static enum ndr_err_code ndr_push_named_pipe_auth_rep_info2(struct ndr_push *ndr, int ndr_flags, const struct named_pipe_auth_rep_info2 *r)
 399 {
 400         if (ndr_flags & NDR_SCALARS) {
 401                 NDR_CHECK(ndr_push_align(ndr, 8));
 402                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->file_type));
 403                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->device_state));
 404                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->allocation_size));
 405         }
 406         if (ndr_flags & NDR_BUFFERS) {
 407         }
 408         return NDR_ERR_SUCCESS;
 409 }
 410
 411 static enum ndr_err_code ndr_pull_named_pipe_auth_rep_info2(struct ndr_pull *ndr, int ndr_flags, struct named_pipe_auth_rep_info2 *r)
 412 {
 413         if (ndr_flags & NDR_SCALARS) {
 414                 NDR_CHECK(ndr_pull_align(ndr, 8));
 415                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->file_type));
 416                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->device_state));
 417                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->allocation_size));
 418         }
 419         if (ndr_flags & NDR_BUFFERS) {
 420         }
 421         return NDR_ERR_SUCCESS;
 422 }
 423
 424 _PUBLIC_ void ndr_print_named_pipe_auth_rep_info2(struct ndr_print *ndr, const char *name, const struct named_pipe_auth_rep_info2 *r)
 425 {
 426         ndr_print_struct(ndr, name, "named_pipe_auth_rep_info2");
 427         ndr->depth++;
 428         ndr_print_uint16(ndr, "file_type", r->file_type);
 429         ndr_print_uint16(ndr, "device_state", r->device_state);
 430         ndr_print_hyper(ndr, "allocation_size", r->allocation_size);
 431         ndr->depth--;
 432 }
 433
 434 static enum ndr_err_code ndr_push_named_pipe_auth_rep_info(struct ndr_push *ndr, int ndr_flags, const union named_pipe_auth_rep_info *r)
 435 {
 436         if (ndr_flags & NDR_SCALARS) {
 437                 int level = ndr_push_get_switch_value(ndr, r);
 438                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
 439                 switch (level) {
 440                         case 0: {
 441                         break; }
 442
 443                         case 1: {
 444                         break; }
 445
 446                         case 2: {
 447                                 NDR_CHECK(ndr_push_named_pipe_auth_rep_info2(ndr, NDR_SCALARS, &r->info2));
 448                         break; }
 449
 450                         default:
 451                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 452                 }
 453         }
 454         if (ndr_flags & NDR_BUFFERS) {
 455                 int level = ndr_push_get_switch_value(ndr, r);
 456                 switch (level) {
 457                         case 0:
 458                         break;
 459
 460                         case 1:
 461                         break;
 462
 463                         case 2:
 464                         break;
 465
 466                         default:
 467                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 468                 }
 469         }
 470         return NDR_ERR_SUCCESS;
 471 }
 472
 473 static enum ndr_err_code ndr_pull_named_pipe_auth_rep_info(struct ndr_pull *ndr, int ndr_flags, union named_pipe_auth_rep_info *r)
 474 {
 475         int level;
 476         uint32_t _level;
 477         level = ndr_pull_get_switch_value(ndr, r);
 478         if (ndr_flags & NDR_SCALARS) {
 479                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
 480                 if (_level != level) {
 481                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
 482                 }
 483                 switch (level) {
 484                         case 0: {
 485                         break; }
 486
 487                         case 1: {
 488                         break; }
 489
 490                         case 2: {
 491                                 NDR_CHECK(ndr_pull_named_pipe_auth_rep_info2(ndr, NDR_SCALARS, &r->info2));
 492                         break; }
 493
 494                         default:
 495                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 496                 }
 497         }
 498         if (ndr_flags & NDR_BUFFERS) {
 499                 switch (level) {
 500                         case 0:
 501                         break;
 502
 503                         case 1:
 504                         break;
 505
 506                         case 2:
 507                         break;
 508
 509                         default:
 510                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 511                 }
 512         }
 513         return NDR_ERR_SUCCESS;
 514 }
 515
 516 _PUBLIC_ void ndr_print_named_pipe_auth_rep_info(struct ndr_print *ndr, const char *name, const union named_pipe_auth_rep_info *r)
 517 {
 518         int level;
 519         level = ndr_print_get_switch_value(ndr, r);
 520         ndr_print_union(ndr, name, level, "named_pipe_auth_rep_info");
 521         switch (level) {
 522                 case 0:
 523                 break;
 524
 525                 case 1:
 526                 break;
 527
 528                 case 2:
 529                         ndr_print_named_pipe_auth_rep_info2(ndr, "info2", &r->info2);
 530                 break;
 531
 532                 default:
 533                         ndr_print_bad_level(ndr, name, level);
 534         }
 535 }
 536
 537 _PUBLIC_ enum ndr_err_code ndr_push_named_pipe_auth_rep(struct ndr_push *ndr, int ndr_flags, const struct named_pipe_auth_rep *r)
 538 {
 539         if (ndr_flags & NDR_SCALARS) {
 540                 NDR_CHECK(ndr_push_align(ndr, 8));
 541                 {
 542                         uint32_t _flags_save_uint32 = ndr->flags;
 543                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
 544                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_named_pipe_auth_rep(r, ndr->iconv_convenience, ndr->flags) - 4));
 545                         ndr->flags = _flags_save_uint32;
 546                 }
 547                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, NAMED_PIPE_AUTH_MAGIC, 4, sizeof(uint8_t), CH_DOS));
 548                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
 549                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
 550                 NDR_CHECK(ndr_push_named_pipe_auth_rep_info(ndr, NDR_SCALARS, &r->info));
 551                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
 552         }
 553         if (ndr_flags & NDR_BUFFERS) {
 554                 NDR_CHECK(ndr_push_named_pipe_auth_rep_info(ndr, NDR_BUFFERS, &r->info));
 555         }
 556         return NDR_ERR_SUCCESS;
 557 }
 558
 559 _PUBLIC_ enum ndr_err_code ndr_pull_named_pipe_auth_rep(struct ndr_pull *ndr, int ndr_flags, struct named_pipe_auth_rep *r)
 560 {
 561         if (ndr_flags & NDR_SCALARS) {
 562                 NDR_CHECK(ndr_pull_align(ndr, 8));
 563                 {
 564                         uint32_t _flags_save_uint32 = ndr->flags;
 565                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
 566                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
 567                         ndr->flags = _flags_save_uint32;
 568                 }
 569                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->magic, 4, sizeof(uint8_t), CH_DOS));
 570                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
 571                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
 572                 NDR_CHECK(ndr_pull_named_pipe_auth_rep_info(ndr, NDR_SCALARS, &r->info));
 573                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
 574         }
 575         if (ndr_flags & NDR_BUFFERS) {
 576                 NDR_CHECK(ndr_pull_named_pipe_auth_rep_info(ndr, NDR_BUFFERS, &r->info));
 577         }
 578         return NDR_ERR_SUCCESS;
 579 }
 580
 581 _PUBLIC_ void ndr_print_named_pipe_auth_rep(struct ndr_print *ndr, const char *name, const struct named_pipe_auth_rep *r)
 582 {
 583         ndr_print_struct(ndr, name, "named_pipe_auth_rep");
 584         ndr->depth++;
 585         ndr_print_uint32(ndr, "length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_named_pipe_auth_rep(r, ndr->iconv_convenience, ndr->flags) - 4:r->length);
 586         ndr_print_string(ndr, "magic", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?NAMED_PIPE_AUTH_MAGIC:r->magic);
 587         ndr_print_uint32(ndr, "level", r->level);
 588         ndr_print_set_switch_value(ndr, &r->info, r->level);
 589         ndr_print_named_pipe_auth_rep_info(ndr, "info", &r->info);
 590         ndr_print_NTSTATUS(ndr, "status", r->status);
 591         ndr->depth--;
 592 }
 593
 594 _PUBLIC_ size_t ndr_size_named_pipe_auth_rep(const struct named_pipe_auth_rep *r, struct smb_iconv_convenience *ic, int flags)
 595 {
 596         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_named_pipe_auth_rep, ic);
 597 }
 598