source3/librpc/gen_ndr/ndr_dfsblobs.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "librpc/gen_ndr/ndr_dfsblobs.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 static enum ndr_err_code ndr_push_DFS_HEADER_FLAG(struct ndr_push *ndr, int ndr_flags, uint32_t r)
   8 {
   9         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  10         return NDR_ERR_SUCCESS;
  11 }
  12
  13 static enum ndr_err_code ndr_pull_DFS_HEADER_FLAG(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
  14 {
  15         uint32_t v;
  16         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  17         *r = v;
  18         return NDR_ERR_SUCCESS;
  19 }
  20
  21 _PUBLIC_ void ndr_print_DFS_HEADER_FLAG(struct ndr_print *ndr, const char *name, uint32_t r)
  22 {
  23         ndr_print_uint32(ndr, name, r);
  24         ndr->depth++;
  25         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DFS_HEADER_FLAG_REFERAL_SVR", DFS_HEADER_FLAG_REFERAL_SVR, r);
  26         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DFS_HEADER_FLAG_STORAGE_SVR", DFS_HEADER_FLAG_STORAGE_SVR, r);
  27         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DFS_HEADER_FLAG_TARGET_BCK", DFS_HEADER_FLAG_TARGET_BCK, r);
  28         ndr->depth--;
  29 }
  30
  31 static enum ndr_err_code ndr_push_DFS_SERVER_TYPE(struct ndr_push *ndr, int ndr_flags, enum DFS_SERVER_TYPE r)
  32 {
  33         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
  34         return NDR_ERR_SUCCESS;
  35 }
  36
  37 static enum ndr_err_code ndr_pull_DFS_SERVER_TYPE(struct ndr_pull *ndr, int ndr_flags, enum DFS_SERVER_TYPE *r)
  38 {
  39         uint16_t v;
  40         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
  41         *r = v;
  42         return NDR_ERR_SUCCESS;
  43 }
  44
  45 _PUBLIC_ void ndr_print_DFS_SERVER_TYPE(struct ndr_print *ndr, const char *name, enum DFS_SERVER_TYPE r)
  46 {
  47         const char *val = NULL;
  48
  49         switch (r) {
  50                 case DFS_SERVER_NON_ROOT: val = "DFS_SERVER_NON_ROOT"; break;
  51                 case DFS_SERVER_ROOT: val = "DFS_SERVER_ROOT"; break;
  52         }
  53         ndr_print_enum(ndr, name, "ENUM", val, r);
  54 }
  55
  56 static enum ndr_err_code ndr_push_DFS_FLAGS_REFERRAL(struct ndr_push *ndr, int ndr_flags, enum DFS_FLAGS_REFERRAL r)
  57 {
  58         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
  59         return NDR_ERR_SUCCESS;
  60 }
  61
  62 static enum ndr_err_code ndr_pull_DFS_FLAGS_REFERRAL(struct ndr_pull *ndr, int ndr_flags, enum DFS_FLAGS_REFERRAL *r)
  63 {
  64         uint16_t v;
  65         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
  66         *r = v;
  67         return NDR_ERR_SUCCESS;
  68 }
  69
  70 _PUBLIC_ void ndr_print_DFS_FLAGS_REFERRAL(struct ndr_print *ndr, const char *name, enum DFS_FLAGS_REFERRAL r)
  71 {
  72         const char *val = NULL;
  73
  74         switch (r) {
  75                 case DFS_FLAG_REFERRAL_DOMAIN_RESP: val = "DFS_FLAG_REFERRAL_DOMAIN_RESP"; break;
  76                 case DFS_FLAG_REFERRAL_FIRST_TARGET_SET: val = "DFS_FLAG_REFERRAL_FIRST_TARGET_SET"; break;
  77         }
  78         ndr_print_enum(ndr, name, "ENUM", val, r);
  79 }
  80
  81 static enum ndr_err_code ndr_push_dfs_referral_v1(struct ndr_push *ndr, int ndr_flags, const struct dfs_referral_v1 *r)
  82 {
  83         if (ndr_flags & NDR_SCALARS) {
  84                 NDR_CHECK(ndr_push_align(ndr, 5));
  85                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
  86                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->server_type));
  87                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->entry_flags));
  88                 {
  89                         uint32_t _flags_save_string = ndr->flags;
  90                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
  91                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->share_name));
  92                         ndr->flags = _flags_save_string;
  93                 }
  94                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
  95         }
  96         if (ndr_flags & NDR_BUFFERS) {
  97                 {
  98                         uint32_t _flags_save_string = ndr->flags;
  99                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 100                         if (r->share_name) {
 101                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->share_name));
 102                         }
 103                         ndr->flags = _flags_save_string;
 104                 }
 105         }
 106         return NDR_ERR_SUCCESS;
 107 }
 108
 109 static enum ndr_err_code ndr_pull_dfs_referral_v1(struct ndr_pull *ndr, int ndr_flags, struct dfs_referral_v1 *r)
 110 {
 111         uint32_t _ptr_share_name;
 112         TALLOC_CTX *_mem_save_share_name_0;
 113         if (ndr_flags & NDR_SCALARS) {
 114                 NDR_CHECK(ndr_pull_align(ndr, 5));
 115                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 116                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->server_type));
 117                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->entry_flags));
 118                 {
 119                         uint32_t _flags_save_string = ndr->flags;
 120                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 121                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_share_name));
 122                         if (_ptr_share_name) {
 123                                 NDR_PULL_ALLOC(ndr, r->share_name);
 124                         } else {
 125                                 r->share_name = NULL;
 126                         }
 127                         ndr->flags = _flags_save_string;
 128                 }
 129                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 130         }
 131         if (ndr_flags & NDR_BUFFERS) {
 132                 {
 133                         uint32_t _flags_save_string = ndr->flags;
 134                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 135                         if (r->share_name) {
 136                                 _mem_save_share_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 137                                 NDR_PULL_SET_MEM_CTX(ndr, r->share_name, 0);
 138                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->share_name));
 139                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_share_name_0, 0);
 140                         }
 141                         ndr->flags = _flags_save_string;
 142                 }
 143         }
 144         return NDR_ERR_SUCCESS;
 145 }
 146
 147 _PUBLIC_ void ndr_print_dfs_referral_v1(struct ndr_print *ndr, const char *name, const struct dfs_referral_v1 *r)
 148 {
 149         ndr_print_struct(ndr, name, "dfs_referral_v1");
 150         ndr->depth++;
 151         ndr_print_uint16(ndr, "size", r->size);
 152         ndr_print_uint16(ndr, "server_type", r->server_type);
 153         ndr_print_uint16(ndr, "entry_flags", r->entry_flags);
 154         ndr_print_ptr(ndr, "share_name", r->share_name);
 155         ndr->depth++;
 156         if (r->share_name) {
 157                 ndr_print_string(ndr, "share_name", r->share_name);
 158         }
 159         ndr->depth--;
 160         ndr->depth--;
 161 }
 162
 163 static enum ndr_err_code ndr_push_dfs_referral_v2(struct ndr_push *ndr, int ndr_flags, const struct dfs_referral_v2 *r)
 164 {
 165         if (ndr_flags & NDR_SCALARS) {
 166                 NDR_CHECK(ndr_push_align(ndr, 5));
 167                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
 168                 NDR_CHECK(ndr_push_DFS_SERVER_TYPE(ndr, NDR_SCALARS, r->server_type));
 169                 NDR_CHECK(ndr_push_DFS_FLAGS_REFERRAL(ndr, NDR_SCALARS, r->entry_flags));
 170                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->proximity));
 171                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ttl));
 172                 {
 173                         uint32_t _flags_save_string = ndr->flags;
 174                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 175                         NDR_CHECK(ndr_push_short_relative_ptr1(ndr, r->DFS_path));
 176                         ndr->flags = _flags_save_string;
 177                 }
 178                 {
 179                         uint32_t _flags_save_string = ndr->flags;
 180                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 181                         NDR_CHECK(ndr_push_short_relative_ptr1(ndr, r->DFS_alt_path));
 182                         ndr->flags = _flags_save_string;
 183                 }
 184                 {
 185                         uint32_t _flags_save_string = ndr->flags;
 186                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 187                         NDR_CHECK(ndr_push_short_relative_ptr1(ndr, r->netw_address));
 188                         ndr->flags = _flags_save_string;
 189                 }
 190                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 191         }
 192         if (ndr_flags & NDR_BUFFERS) {
 193                 {
 194                         uint32_t _flags_save_string = ndr->flags;
 195                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 196                         if (r->DFS_path) {
 197                                 NDR_CHECK(ndr_push_short_relative_ptr2(ndr, r->DFS_path));
 198                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->DFS_path));
 199                         }
 200                         ndr->flags = _flags_save_string;
 201                 }
 202                 {
 203                         uint32_t _flags_save_string = ndr->flags;
 204                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 205                         if (r->DFS_alt_path) {
 206                                 NDR_CHECK(ndr_push_short_relative_ptr2(ndr, r->DFS_alt_path));
 207                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->DFS_alt_path));
 208                         }
 209                         ndr->flags = _flags_save_string;
 210                 }
 211                 {
 212                         uint32_t _flags_save_string = ndr->flags;
 213                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 214                         if (r->netw_address) {
 215                                 NDR_CHECK(ndr_push_short_relative_ptr2(ndr, r->netw_address));
 216                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->netw_address));
 217                         }
 218                         ndr->flags = _flags_save_string;
 219                 }
 220         }
 221         return NDR_ERR_SUCCESS;
 222 }
 223
 224 static enum ndr_err_code ndr_pull_dfs_referral_v2(struct ndr_pull *ndr, int ndr_flags, struct dfs_referral_v2 *r)
 225 {
 226         uint16_t _ptr_DFS_path;
 227         TALLOC_CTX *_mem_save_DFS_path_0;
 228         uint16_t _ptr_DFS_alt_path;
 229         TALLOC_CTX *_mem_save_DFS_alt_path_0;
 230         uint16_t _ptr_netw_address;
 231         TALLOC_CTX *_mem_save_netw_address_0;
 232         if (ndr_flags & NDR_SCALARS) {
 233                 NDR_CHECK(ndr_pull_align(ndr, 5));
 234                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 235                 NDR_CHECK(ndr_pull_DFS_SERVER_TYPE(ndr, NDR_SCALARS, &r->server_type));
 236                 NDR_CHECK(ndr_pull_DFS_FLAGS_REFERRAL(ndr, NDR_SCALARS, &r->entry_flags));
 237                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->proximity));
 238                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ttl));
 239                 {
 240                         uint32_t _flags_save_string = ndr->flags;
 241                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 242                         NDR_CHECK(ndr_pull_relative_ptr_short(ndr, &_ptr_DFS_path));
 243                         if (_ptr_DFS_path) {
 244                                 NDR_PULL_ALLOC(ndr, r->DFS_path);
 245                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->DFS_path, _ptr_DFS_path));
 246                         } else {
 247                                 r->DFS_path = NULL;
 248                         }
 249                         ndr->flags = _flags_save_string;
 250                 }
 251                 {
 252                         uint32_t _flags_save_string = ndr->flags;
 253                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 254                         NDR_CHECK(ndr_pull_relative_ptr_short(ndr, &_ptr_DFS_alt_path));
 255                         if (_ptr_DFS_alt_path) {
 256                                 NDR_PULL_ALLOC(ndr, r->DFS_alt_path);
 257                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->DFS_alt_path, _ptr_DFS_alt_path));
 258                         } else {
 259                                 r->DFS_alt_path = NULL;
 260                         }
 261                         ndr->flags = _flags_save_string;
 262                 }
 263                 {
 264                         uint32_t _flags_save_string = ndr->flags;
 265                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 266                         NDR_CHECK(ndr_pull_relative_ptr_short(ndr, &_ptr_netw_address));
 267                         if (_ptr_netw_address) {
 268                                 NDR_PULL_ALLOC(ndr, r->netw_address);
 269                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->netw_address, _ptr_netw_address));
 270                         } else {
 271                                 r->netw_address = NULL;
 272                         }
 273                         ndr->flags = _flags_save_string;
 274                 }
 275                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 276         }
 277         if (ndr_flags & NDR_BUFFERS) {
 278                 {
 279                         uint32_t _flags_save_string = ndr->flags;
 280                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 281                         if (r->DFS_path) {
 282                                 uint32_t _relative_save_offset;
 283                                 _relative_save_offset = ndr->offset;
 284                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->DFS_path));
 285                                 _mem_save_DFS_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
 286                                 NDR_PULL_SET_MEM_CTX(ndr, r->DFS_path, 0);
 287                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->DFS_path));
 288                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_DFS_path_0, 0);
 289                         }
 290                         ndr->flags = _flags_save_string;
 291                 }
 292                 {
 293                         uint32_t _flags_save_string = ndr->flags;
 294                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 295                         if (r->DFS_alt_path) {
 296                                 uint32_t _relative_save_offset;
 297                                 _relative_save_offset = ndr->offset;
 298                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->DFS_alt_path));
 299                                 _mem_save_DFS_alt_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
 300                                 NDR_PULL_SET_MEM_CTX(ndr, r->DFS_alt_path, 0);
 301                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->DFS_alt_path));
 302                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_DFS_alt_path_0, 0);
 303                         }
 304                         ndr->flags = _flags_save_string;
 305                 }
 306                 {
 307                         uint32_t _flags_save_string = ndr->flags;
 308                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 309                         if (r->netw_address) {
 310                                 uint32_t _relative_save_offset;
 311                                 _relative_save_offset = ndr->offset;
 312                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->netw_address));
 313                                 _mem_save_netw_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
 314                                 NDR_PULL_SET_MEM_CTX(ndr, r->netw_address, 0);
 315                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->netw_address));
 316                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netw_address_0, 0);
 317                         }
 318                         ndr->flags = _flags_save_string;
 319                 }
 320         }
 321         return NDR_ERR_SUCCESS;
 322 }
 323
 324 _PUBLIC_ void ndr_print_dfs_referral_v2(struct ndr_print *ndr, const char *name, const struct dfs_referral_v2 *r)
 325 {
 326         ndr_print_struct(ndr, name, "dfs_referral_v2");
 327         ndr->depth++;
 328         ndr_print_uint16(ndr, "size", r->size);
 329         ndr_print_DFS_SERVER_TYPE(ndr, "server_type", r->server_type);
 330         ndr_print_DFS_FLAGS_REFERRAL(ndr, "entry_flags", r->entry_flags);
 331         ndr_print_uint32(ndr, "proximity", r->proximity);
 332         ndr_print_uint32(ndr, "ttl", r->ttl);
 333         ndr_print_ptr(ndr, "DFS_path", r->DFS_path);
 334         ndr->depth++;
 335         if (r->DFS_path) {
 336                 ndr_print_string(ndr, "DFS_path", r->DFS_path);
 337         }
 338         ndr->depth--;
 339         ndr_print_ptr(ndr, "DFS_alt_path", r->DFS_alt_path);
 340         ndr->depth++;
 341         if (r->DFS_alt_path) {
 342                 ndr_print_string(ndr, "DFS_alt_path", r->DFS_alt_path);
 343         }
 344         ndr->depth--;
 345         ndr_print_ptr(ndr, "netw_address", r->netw_address);
 346         ndr->depth++;
 347         if (r->netw_address) {
 348                 ndr_print_string(ndr, "netw_address", r->netw_address);
 349         }
 350         ndr->depth--;
 351         ndr->depth--;
 352 }
 353
 354 static enum ndr_err_code ndr_push_dfs_normal_referral(struct ndr_push *ndr, int ndr_flags, const struct dfs_normal_referral *r)
 355 {
 356         if (ndr_flags & NDR_SCALARS) {
 357                 NDR_CHECK(ndr_push_align(ndr, 5));
 358                 {
 359                         uint32_t _flags_save_string = ndr->flags;
 360                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 361                         NDR_CHECK(ndr_push_short_relative_ptr1(ndr, r->DFS_path));
 362                         ndr->flags = _flags_save_string;
 363                 }
 364                 {
 365                         uint32_t _flags_save_string = ndr->flags;
 366                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 367                         NDR_CHECK(ndr_push_short_relative_ptr1(ndr, r->DFS_alt_path));
 368                         ndr->flags = _flags_save_string;
 369                 }
 370                 {
 371                         uint32_t _flags_save_string = ndr->flags;
 372                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 373                         NDR_CHECK(ndr_push_short_relative_ptr1(ndr, r->netw_address));
 374                         ndr->flags = _flags_save_string;
 375                 }
 376                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 377         }
 378         if (ndr_flags & NDR_BUFFERS) {
 379                 {
 380                         uint32_t _flags_save_string = ndr->flags;
 381                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 382                         if (r->DFS_path) {
 383                                 NDR_CHECK(ndr_push_short_relative_ptr2(ndr, r->DFS_path));
 384                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->DFS_path));
 385                         }
 386                         ndr->flags = _flags_save_string;
 387                 }
 388                 {
 389                         uint32_t _flags_save_string = ndr->flags;
 390                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 391                         if (r->DFS_alt_path) {
 392                                 NDR_CHECK(ndr_push_short_relative_ptr2(ndr, r->DFS_alt_path));
 393                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->DFS_alt_path));
 394                         }
 395                         ndr->flags = _flags_save_string;
 396                 }
 397                 {
 398                         uint32_t _flags_save_string = ndr->flags;
 399                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 400                         if (r->netw_address) {
 401                                 NDR_CHECK(ndr_push_short_relative_ptr2(ndr, r->netw_address));
 402                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->netw_address));
 403                         }
 404                         ndr->flags = _flags_save_string;
 405                 }
 406         }
 407         return NDR_ERR_SUCCESS;
 408 }
 409
 410 static enum ndr_err_code ndr_pull_dfs_normal_referral(struct ndr_pull *ndr, int ndr_flags, struct dfs_normal_referral *r)
 411 {
 412         uint16_t _ptr_DFS_path;
 413         TALLOC_CTX *_mem_save_DFS_path_0;
 414         uint16_t _ptr_DFS_alt_path;
 415         TALLOC_CTX *_mem_save_DFS_alt_path_0;
 416         uint16_t _ptr_netw_address;
 417         TALLOC_CTX *_mem_save_netw_address_0;
 418         if (ndr_flags & NDR_SCALARS) {
 419                 NDR_CHECK(ndr_pull_align(ndr, 5));
 420                 {
 421                         uint32_t _flags_save_string = ndr->flags;
 422                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 423                         NDR_CHECK(ndr_pull_relative_ptr_short(ndr, &_ptr_DFS_path));
 424                         if (_ptr_DFS_path) {
 425                                 NDR_PULL_ALLOC(ndr, r->DFS_path);
 426                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->DFS_path, _ptr_DFS_path));
 427                         } else {
 428                                 r->DFS_path = NULL;
 429                         }
 430                         ndr->flags = _flags_save_string;
 431                 }
 432                 {
 433                         uint32_t _flags_save_string = ndr->flags;
 434                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 435                         NDR_CHECK(ndr_pull_relative_ptr_short(ndr, &_ptr_DFS_alt_path));
 436                         if (_ptr_DFS_alt_path) {
 437                                 NDR_PULL_ALLOC(ndr, r->DFS_alt_path);
 438                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->DFS_alt_path, _ptr_DFS_alt_path));
 439                         } else {
 440                                 r->DFS_alt_path = NULL;
 441                         }
 442                         ndr->flags = _flags_save_string;
 443                 }
 444                 {
 445                         uint32_t _flags_save_string = ndr->flags;
 446                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 447                         NDR_CHECK(ndr_pull_relative_ptr_short(ndr, &_ptr_netw_address));
 448                         if (_ptr_netw_address) {
 449                                 NDR_PULL_ALLOC(ndr, r->netw_address);
 450                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->netw_address, _ptr_netw_address));
 451                         } else {
 452                                 r->netw_address = NULL;
 453                         }
 454                         ndr->flags = _flags_save_string;
 455                 }
 456                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 457         }
 458         if (ndr_flags & NDR_BUFFERS) {
 459                 {
 460                         uint32_t _flags_save_string = ndr->flags;
 461                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 462                         if (r->DFS_path) {
 463                                 uint32_t _relative_save_offset;
 464                                 _relative_save_offset = ndr->offset;
 465                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->DFS_path));
 466                                 _mem_save_DFS_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
 467                                 NDR_PULL_SET_MEM_CTX(ndr, r->DFS_path, 0);
 468                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->DFS_path));
 469                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_DFS_path_0, 0);
 470                         }
 471                         ndr->flags = _flags_save_string;
 472                 }
 473                 {
 474                         uint32_t _flags_save_string = ndr->flags;
 475                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 476                         if (r->DFS_alt_path) {
 477                                 uint32_t _relative_save_offset;
 478                                 _relative_save_offset = ndr->offset;
 479                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->DFS_alt_path));
 480                                 _mem_save_DFS_alt_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
 481                                 NDR_PULL_SET_MEM_CTX(ndr, r->DFS_alt_path, 0);
 482                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->DFS_alt_path));
 483                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_DFS_alt_path_0, 0);
 484                         }
 485                         ndr->flags = _flags_save_string;
 486                 }
 487                 {
 488                         uint32_t _flags_save_string = ndr->flags;
 489                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 490                         if (r->netw_address) {
 491                                 uint32_t _relative_save_offset;
 492                                 _relative_save_offset = ndr->offset;
 493                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->netw_address));
 494                                 _mem_save_netw_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
 495                                 NDR_PULL_SET_MEM_CTX(ndr, r->netw_address, 0);
 496                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->netw_address));
 497                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netw_address_0, 0);
 498                         }
 499                         ndr->flags = _flags_save_string;
 500                 }
 501         }
 502         return NDR_ERR_SUCCESS;
 503 }
 504
 505 _PUBLIC_ void ndr_print_dfs_normal_referral(struct ndr_print *ndr, const char *name, const struct dfs_normal_referral *r)
 506 {
 507         ndr_print_struct(ndr, name, "dfs_normal_referral");
 508         ndr->depth++;
 509         ndr_print_ptr(ndr, "DFS_path", r->DFS_path);
 510         ndr->depth++;
 511         if (r->DFS_path) {
 512                 ndr_print_string(ndr, "DFS_path", r->DFS_path);
 513         }
 514         ndr->depth--;
 515         ndr_print_ptr(ndr, "DFS_alt_path", r->DFS_alt_path);
 516         ndr->depth++;
 517         if (r->DFS_alt_path) {
 518                 ndr_print_string(ndr, "DFS_alt_path", r->DFS_alt_path);
 519         }
 520         ndr->depth--;
 521         ndr_print_ptr(ndr, "netw_address", r->netw_address);
 522         ndr->depth++;
 523         if (r->netw_address) {
 524                 ndr_print_string(ndr, "netw_address", r->netw_address);
 525         }
 526         ndr->depth--;
 527         ndr->depth--;
 528 }
 529
 530 static enum ndr_err_code ndr_push_dfs_domain_referral(struct ndr_push *ndr, int ndr_flags, const struct dfs_domain_referral *r)
 531 {
 532         if (ndr_flags & NDR_SCALARS) {
 533                 NDR_CHECK(ndr_push_align(ndr, 5));
 534                 {
 535                         uint32_t _flags_save_string = ndr->flags;
 536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 537                         NDR_CHECK(ndr_push_short_relative_ptr1(ndr, r->special_name));
 538                         ndr->flags = _flags_save_string;
 539                 }
 540                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->nb_expanded_names));
 541                 {
 542                         uint32_t _flags_save_string_array = ndr->flags;
 543                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
 544                         NDR_CHECK(ndr_push_short_relative_ptr1(ndr, r->expanded_names));
 545                         ndr->flags = _flags_save_string_array;
 546                 }
 547                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 548         }
 549         if (ndr_flags & NDR_BUFFERS) {
 550                 {
 551                         uint32_t _flags_save_string = ndr->flags;
 552                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 553                         if (r->special_name) {
 554                                 NDR_CHECK(ndr_push_short_relative_ptr2(ndr, r->special_name));
 555                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->special_name));
 556                         }
 557                         ndr->flags = _flags_save_string;
 558                 }
 559                 {
 560                         uint32_t _flags_save_string_array = ndr->flags;
 561                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
 562                         if (r->expanded_names) {
 563                                 NDR_CHECK(ndr_push_short_relative_ptr2(ndr, r->expanded_names));
 564                                 {
 565                                         struct ndr_push *_ndr_expanded_names;
 566                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_expanded_names, 0, -1));
 567                                         NDR_CHECK(ndr_push_string_array(_ndr_expanded_names, NDR_SCALARS, r->expanded_names));
 568                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_expanded_names, 0, -1));
 569                                 }
 570                         }
 571                         ndr->flags = _flags_save_string_array;
 572                 }
 573         }
 574         return NDR_ERR_SUCCESS;
 575 }
 576
 577 static enum ndr_err_code ndr_pull_dfs_domain_referral(struct ndr_pull *ndr, int ndr_flags, struct dfs_domain_referral *r)
 578 {
 579         uint16_t _ptr_special_name;
 580         TALLOC_CTX *_mem_save_special_name_0;
 581         uint16_t _ptr_expanded_names;
 582         TALLOC_CTX *_mem_save_expanded_names_0;
 583         if (ndr_flags & NDR_SCALARS) {
 584                 NDR_CHECK(ndr_pull_align(ndr, 5));
 585                 {
 586                         uint32_t _flags_save_string = ndr->flags;
 587                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 588                         NDR_CHECK(ndr_pull_relative_ptr_short(ndr, &_ptr_special_name));
 589                         if (_ptr_special_name) {
 590                                 NDR_PULL_ALLOC(ndr, r->special_name);
 591                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->special_name, _ptr_special_name));
 592                         } else {
 593                                 r->special_name = NULL;
 594                         }
 595                         ndr->flags = _flags_save_string;
 596                 }
 597                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->nb_expanded_names));
 598                 {
 599                         uint32_t _flags_save_string_array = ndr->flags;
 600                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
 601                         NDR_CHECK(ndr_pull_relative_ptr_short(ndr, &_ptr_expanded_names));
 602                         if (_ptr_expanded_names) {
 603                                 NDR_PULL_ALLOC(ndr, r->expanded_names);
 604                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->expanded_names, _ptr_expanded_names));
 605                         } else {
 606                                 r->expanded_names = NULL;
 607                         }
 608                         ndr->flags = _flags_save_string_array;
 609                 }
 610                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 611         }
 612         if (ndr_flags & NDR_BUFFERS) {
 613                 {
 614                         uint32_t _flags_save_string = ndr->flags;
 615                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 616                         if (r->special_name) {
 617                                 uint32_t _relative_save_offset;
 618                                 _relative_save_offset = ndr->offset;
 619                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->special_name));
 620                                 _mem_save_special_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 621                                 NDR_PULL_SET_MEM_CTX(ndr, r->special_name, 0);
 622                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->special_name));
 623                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_special_name_0, 0);
 624                         }
 625                         ndr->flags = _flags_save_string;
 626                 }
 627                 {
 628                         uint32_t _flags_save_string_array = ndr->flags;
 629                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
 630                         if (r->expanded_names) {
 631                                 uint32_t _relative_save_offset;
 632                                 _relative_save_offset = ndr->offset;
 633                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->expanded_names));
 634                                 _mem_save_expanded_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
 635                                 NDR_PULL_SET_MEM_CTX(ndr, r->expanded_names, 0);
 636                                 {
 637                                         struct ndr_pull *_ndr_expanded_names;
 638                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_expanded_names, 0, -1));
 639                                         NDR_CHECK(ndr_pull_string_array(_ndr_expanded_names, NDR_SCALARS, &r->expanded_names));
 640                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_expanded_names, 0, -1));
 641                                 }
 642                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_expanded_names_0, 0);
 643                         }
 644                         ndr->flags = _flags_save_string_array;
 645                 }
 646         }
 647         return NDR_ERR_SUCCESS;
 648 }
 649
 650 _PUBLIC_ void ndr_print_dfs_domain_referral(struct ndr_print *ndr, const char *name, const struct dfs_domain_referral *r)
 651 {
 652         ndr_print_struct(ndr, name, "dfs_domain_referral");
 653         ndr->depth++;
 654         ndr_print_ptr(ndr, "special_name", r->special_name);
 655         ndr->depth++;
 656         if (r->special_name) {
 657                 ndr_print_string(ndr, "special_name", r->special_name);
 658         }
 659         ndr->depth--;
 660         ndr_print_uint16(ndr, "nb_expanded_names", r->nb_expanded_names);
 661         ndr_print_ptr(ndr, "expanded_names", r->expanded_names);
 662         ndr->depth++;
 663         if (r->expanded_names) {
 664                 ndr_print_string_array(ndr, "expanded_names", r->expanded_names);
 665         }
 666         ndr->depth--;
 667         ndr->depth--;
 668 }
 669
 670 static enum ndr_err_code ndr_push_dfs_referral(struct ndr_push *ndr, int ndr_flags, const union dfs_referral *r)
 671 {
 672         if (ndr_flags & NDR_SCALARS) {
 673                 int level = ndr_push_get_switch_value(ndr, r);
 674                 NDR_CHECK(ndr_push_union_align(ndr, 5));
 675                 switch (level) {
 676                         case 0: {
 677                                 NDR_CHECK(ndr_push_dfs_normal_referral(ndr, NDR_SCALARS, &r->r1));
 678                         break; }
 679
 680                         case 2: {
 681                                 NDR_CHECK(ndr_push_dfs_domain_referral(ndr, NDR_SCALARS, &r->r2));
 682                         break; }
 683
 684                         default: {
 685                         break; }
 686
 687                 }
 688         }
 689         if (ndr_flags & NDR_BUFFERS) {
 690                 int level = ndr_push_get_switch_value(ndr, r);
 691                 switch (level) {
 692                         case 0:
 693                                 NDR_CHECK(ndr_push_dfs_normal_referral(ndr, NDR_BUFFERS, &r->r1));
 694                         break;
 695
 696                         case 2:
 697                                 NDR_CHECK(ndr_push_dfs_domain_referral(ndr, NDR_BUFFERS, &r->r2));
 698                         break;
 699
 700                         default:
 701                         break;
 702
 703                 }
 704         }
 705         return NDR_ERR_SUCCESS;
 706 }
 707
 708 static enum ndr_err_code ndr_pull_dfs_referral(struct ndr_pull *ndr, int ndr_flags, union dfs_referral *r)
 709 {
 710         int level;
 711         level = ndr_pull_get_switch_value(ndr, r);
 712         if (ndr_flags & NDR_SCALARS) {
 713                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
 714                 switch (level) {
 715                         case 0: {
 716                                 NDR_CHECK(ndr_pull_dfs_normal_referral(ndr, NDR_SCALARS, &r->r1));
 717                         break; }
 718
 719                         case 2: {
 720                                 NDR_CHECK(ndr_pull_dfs_domain_referral(ndr, NDR_SCALARS, &r->r2));
 721                         break; }
 722
 723                         default: {
 724                         break; }
 725
 726                 }
 727         }
 728         if (ndr_flags & NDR_BUFFERS) {
 729                 switch (level) {
 730                         case 0:
 731                                 NDR_CHECK(ndr_pull_dfs_normal_referral(ndr, NDR_BUFFERS, &r->r1));
 732                         break;
 733
 734                         case 2:
 735                                 NDR_CHECK(ndr_pull_dfs_domain_referral(ndr, NDR_BUFFERS, &r->r2));
 736                         break;
 737
 738                         default:
 739                         break;
 740
 741                 }
 742         }
 743         return NDR_ERR_SUCCESS;
 744 }
 745
 746 _PUBLIC_ void ndr_print_dfs_referral(struct ndr_print *ndr, const char *name, const union dfs_referral *r)
 747 {
 748         int level;
 749         level = ndr_print_get_switch_value(ndr, r);
 750         ndr_print_union(ndr, name, level, "dfs_referral");
 751         switch (level) {
 752                 case 0:
 753                         ndr_print_dfs_normal_referral(ndr, "r1", &r->r1);
 754                 break;
 755
 756                 case 2:
 757                         ndr_print_dfs_domain_referral(ndr, "r2", &r->r2);
 758                 break;
 759
 760                 default:
 761                 break;
 762
 763         }
 764 }
 765
 766 static enum ndr_err_code ndr_push_dfs_padding(struct ndr_push *ndr, int ndr_flags, const union dfs_padding *r)
 767 {
 768         if (ndr_flags & NDR_SCALARS) {
 769                 int level = ndr_push_get_switch_value(ndr, r);
 770                 NDR_CHECK(ndr_push_union_align(ndr, 5));
 771                 switch (level) {
 772                         case 16: {
 773                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->value));
 774                         break; }
 775
 776                         default: {
 777                         break; }
 778
 779                 }
 780         }
 781         if (ndr_flags & NDR_BUFFERS) {
 782                 int level = ndr_push_get_switch_value(ndr, r);
 783                 switch (level) {
 784                         case 16:
 785                                 if (r->value) {
 786                                         NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, *r->value));
 787                                 }
 788                         break;
 789
 790                         default:
 791                         break;
 792
 793                 }
 794         }
 795         return NDR_ERR_SUCCESS;
 796 }
 797
 798 static enum ndr_err_code ndr_pull_dfs_padding(struct ndr_pull *ndr, int ndr_flags, union dfs_padding *r)
 799 {
 800         int level;
 801         TALLOC_CTX *_mem_save_value_0;
 802         level = ndr_pull_get_switch_value(ndr, r);
 803         if (ndr_flags & NDR_SCALARS) {
 804                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
 805                 switch (level) {
 806                         case 16: {
 807                                 uint32_t _ptr_value;
 808                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value));
 809                                 if (_ptr_value) {
 810                                         NDR_PULL_ALLOC(ndr, r->value);
 811                                 } else {
 812                                         r->value = NULL;
 813                                 }
 814                         break; }
 815
 816                         default: {
 817                         break; }
 818
 819                 }
 820         }
 821         if (ndr_flags & NDR_BUFFERS) {
 822                 switch (level) {
 823                         case 16:
 824                                 if (r->value) {
 825                                         _mem_save_value_0 = NDR_PULL_GET_MEM_CTX(ndr);
 826                                         NDR_PULL_SET_MEM_CTX(ndr, r->value, 0);
 827                                         NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, r->value));
 828                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_0, 0);
 829                                 }
 830                         break;
 831
 832                         default:
 833                         break;
 834
 835                 }
 836         }
 837         return NDR_ERR_SUCCESS;
 838 }
 839
 840 _PUBLIC_ void ndr_print_dfs_padding(struct ndr_print *ndr, const char *name, const union dfs_padding *r)
 841 {
 842         int level;
 843         level = ndr_print_get_switch_value(ndr, r);
 844         ndr_print_union(ndr, name, level, "dfs_padding");
 845         switch (level) {
 846                 case 16:
 847                         ndr_print_ptr(ndr, "value", r->value);
 848                         ndr->depth++;
 849                         if (r->value) {
 850                                 ndr_print_uint8(ndr, "value", *r->value);
 851                         }
 852                         ndr->depth--;
 853                 break;
 854
 855                 default:
 856                 break;
 857
 858         }
 859 }
 860
 861 static enum ndr_err_code ndr_push_dfs_referral_v3_remaining(struct ndr_push *ndr, int ndr_flags, const struct dfs_referral_v3_remaining *r)
 862 {
 863         {
 864                 uint32_t _flags_save_STRUCT = ndr->flags;
 865                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 866                 if (ndr_flags & NDR_SCALARS) {
 867                         NDR_CHECK(ndr_push_align(ndr, 5));
 868                         NDR_CHECK(ndr_push_DFS_SERVER_TYPE(ndr, NDR_SCALARS, r->server_type));
 869                         NDR_CHECK(ndr_push_DFS_FLAGS_REFERRAL(ndr, NDR_SCALARS, r->entry_flags));
 870                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ttl));
 871                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->referrals, r->entry_flags & DFS_FLAG_REFERRAL_DOMAIN_RESP));
 872                         NDR_CHECK(ndr_push_dfs_referral(ndr, NDR_SCALARS, &r->referrals));
 873                         NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 874                 }
 875                 if (ndr_flags & NDR_BUFFERS) {
 876                         NDR_CHECK(ndr_push_dfs_referral(ndr, NDR_BUFFERS, &r->referrals));
 877                 }
 878                 ndr->flags = _flags_save_STRUCT;
 879         }
 880         return NDR_ERR_SUCCESS;
 881 }
 882
 883 static enum ndr_err_code ndr_pull_dfs_referral_v3_remaining(struct ndr_pull *ndr, int ndr_flags, struct dfs_referral_v3_remaining *r)
 884 {
 885         {
 886                 uint32_t _flags_save_STRUCT = ndr->flags;
 887                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 888                 if (ndr_flags & NDR_SCALARS) {
 889                         NDR_CHECK(ndr_pull_align(ndr, 5));
 890                         NDR_CHECK(ndr_pull_DFS_SERVER_TYPE(ndr, NDR_SCALARS, &r->server_type));
 891                         NDR_CHECK(ndr_pull_DFS_FLAGS_REFERRAL(ndr, NDR_SCALARS, &r->entry_flags));
 892                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ttl));
 893                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->referrals, r->entry_flags & DFS_FLAG_REFERRAL_DOMAIN_RESP));
 894                         NDR_CHECK(ndr_pull_dfs_referral(ndr, NDR_SCALARS, &r->referrals));
 895                         NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 896                 }
 897                 if (ndr_flags & NDR_BUFFERS) {
 898                         NDR_CHECK(ndr_pull_dfs_referral(ndr, NDR_BUFFERS, &r->referrals));
 899                 }
 900                 ndr->flags = _flags_save_STRUCT;
 901         }
 902         return NDR_ERR_SUCCESS;
 903 }
 904
 905 _PUBLIC_ void ndr_print_dfs_referral_v3_remaining(struct ndr_print *ndr, const char *name, const struct dfs_referral_v3_remaining *r)
 906 {
 907         ndr_print_struct(ndr, name, "dfs_referral_v3_remaining");
 908         {
 909                 uint32_t _flags_save_STRUCT = ndr->flags;
 910                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 911                 ndr->depth++;
 912                 ndr_print_DFS_SERVER_TYPE(ndr, "server_type", r->server_type);
 913                 ndr_print_DFS_FLAGS_REFERRAL(ndr, "entry_flags", r->entry_flags);
 914                 ndr_print_uint32(ndr, "ttl", r->ttl);
 915                 ndr_print_set_switch_value(ndr, &r->referrals, r->entry_flags & DFS_FLAG_REFERRAL_DOMAIN_RESP);
 916                 ndr_print_dfs_referral(ndr, "referrals", &r->referrals);
 917                 ndr->depth--;
 918                 ndr->flags = _flags_save_STRUCT;
 919         }
 920 }
 921
 922 static enum ndr_err_code ndr_push_dfs_referral_v3(struct ndr_push *ndr, int ndr_flags, const struct dfs_referral_v3 *r)
 923 {
 924         {
 925                 uint32_t _flags_save_STRUCT = ndr->flags;
 926                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 927                 if (ndr_flags & NDR_SCALARS) {
 928                         NDR_CHECK(ndr_push_align(ndr, 5));
 929                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
 930                         NDR_CHECK(ndr_push_dfs_referral_v3_remaining(ndr, NDR_SCALARS, &r->data));
 931                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->service_site_guid, r->size - 18));
 932                         NDR_CHECK(ndr_push_dfs_padding(ndr, NDR_SCALARS, &r->service_site_guid));
 933                         NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 934                 }
 935                 if (ndr_flags & NDR_BUFFERS) {
 936                         NDR_CHECK(ndr_push_dfs_referral_v3_remaining(ndr, NDR_BUFFERS, &r->data));
 937                         NDR_CHECK(ndr_push_dfs_padding(ndr, NDR_BUFFERS, &r->service_site_guid));
 938                 }
 939                 ndr->flags = _flags_save_STRUCT;
 940         }
 941         return NDR_ERR_SUCCESS;
 942 }
 943
 944 static enum ndr_err_code ndr_pull_dfs_referral_v3(struct ndr_pull *ndr, int ndr_flags, struct dfs_referral_v3 *r)
 945 {
 946         {
 947                 uint32_t _flags_save_STRUCT = ndr->flags;
 948                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 949                 if (ndr_flags & NDR_SCALARS) {
 950                         NDR_CHECK(ndr_pull_align(ndr, 5));
 951                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 952                         NDR_CHECK(ndr_pull_dfs_referral_v3_remaining(ndr, NDR_SCALARS, &r->data));
 953                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->service_site_guid, r->size - 18));
 954                         NDR_CHECK(ndr_pull_dfs_padding(ndr, NDR_SCALARS, &r->service_site_guid));
 955                         NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 956                 }
 957                 if (ndr_flags & NDR_BUFFERS) {
 958                         NDR_CHECK(ndr_pull_dfs_referral_v3_remaining(ndr, NDR_BUFFERS, &r->data));
 959                         NDR_CHECK(ndr_pull_dfs_padding(ndr, NDR_BUFFERS, &r->service_site_guid));
 960                 }
 961                 ndr->flags = _flags_save_STRUCT;
 962         }
 963         return NDR_ERR_SUCCESS;
 964 }
 965
 966 _PUBLIC_ void ndr_print_dfs_referral_v3(struct ndr_print *ndr, const char *name, const struct dfs_referral_v3 *r)
 967 {
 968         ndr_print_struct(ndr, name, "dfs_referral_v3");
 969         {
 970                 uint32_t _flags_save_STRUCT = ndr->flags;
 971                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 972                 ndr->depth++;
 973                 ndr_print_uint16(ndr, "size", r->size);
 974                 ndr_print_dfs_referral_v3_remaining(ndr, "data", &r->data);
 975                 ndr_print_set_switch_value(ndr, &r->service_site_guid, r->size - 18);
 976                 ndr_print_dfs_padding(ndr, "service_site_guid", &r->service_site_guid);
 977                 ndr->depth--;
 978                 ndr->flags = _flags_save_STRUCT;
 979         }
 980 }
 981
 982 static enum ndr_err_code ndr_push_dfs_referral_v4(struct ndr_push *ndr, int ndr_flags, const struct dfs_referral_v4 *r)
 983 {
 984         if (ndr_flags & NDR_SCALARS) {
 985                 NDR_CHECK(ndr_push_align(ndr, 5));
 986                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
 987                 NDR_CHECK(ndr_push_DFS_SERVER_TYPE(ndr, NDR_SCALARS, r->server_type));
 988                 NDR_CHECK(ndr_push_DFS_FLAGS_REFERRAL(ndr, NDR_SCALARS, r->entry_flags));
 989                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ttl));
 990                 NDR_CHECK(ndr_push_dfs_normal_referral(ndr, NDR_SCALARS, &r->r1));
 991                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 992         }
 993         if (ndr_flags & NDR_BUFFERS) {
 994                 NDR_CHECK(ndr_push_dfs_normal_referral(ndr, NDR_BUFFERS, &r->r1));
 995         }
 996         return NDR_ERR_SUCCESS;
 997 }
 998
 999 static enum ndr_err_code ndr_pull_dfs_referral_v4(struct ndr_pull *ndr, int ndr_flags, struct dfs_referral_v4 *r)
1000 {
1001         if (ndr_flags & NDR_SCALARS) {
1002                 NDR_CHECK(ndr_pull_align(ndr, 5));
1003                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
1004                 NDR_CHECK(ndr_pull_DFS_SERVER_TYPE(ndr, NDR_SCALARS, &r->server_type));
1005                 NDR_CHECK(ndr_pull_DFS_FLAGS_REFERRAL(ndr, NDR_SCALARS, &r->entry_flags));
1006                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ttl));
1007                 NDR_CHECK(ndr_pull_dfs_normal_referral(ndr, NDR_SCALARS, &r->r1));
1008                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1009         }
1010         if (ndr_flags & NDR_BUFFERS) {
1011                 NDR_CHECK(ndr_pull_dfs_normal_referral(ndr, NDR_BUFFERS, &r->r1));
1012         }
1013         return NDR_ERR_SUCCESS;
1014 }
1015
1016 _PUBLIC_ void ndr_print_dfs_referral_v4(struct ndr_print *ndr, const char *name, const struct dfs_referral_v4 *r)
1017 {
1018         ndr_print_struct(ndr, name, "dfs_referral_v4");
1019         ndr->depth++;
1020         ndr_print_uint16(ndr, "size", r->size);
1021         ndr_print_DFS_SERVER_TYPE(ndr, "server_type", r->server_type);
1022         ndr_print_DFS_FLAGS_REFERRAL(ndr, "entry_flags", r->entry_flags);
1023         ndr_print_uint32(ndr, "ttl", r->ttl);
1024         ndr_print_dfs_normal_referral(ndr, "r1", &r->r1);
1025         ndr->depth--;
1026 }
1027
1028 static enum ndr_err_code ndr_push_dfs_referral_version(struct ndr_push *ndr, int ndr_flags, const union dfs_referral_version *r)
1029 {
1030         if (ndr_flags & NDR_SCALARS) {
1031                 int level = ndr_push_get_switch_value(ndr, r);
1032                 NDR_CHECK(ndr_push_union_align(ndr, 5));
1033                 switch (level) {
1034                         case 1: {
1035                                 NDR_CHECK(ndr_push_dfs_referral_v1(ndr, NDR_SCALARS, &r->v1));
1036                         break; }
1037
1038                         case 2: {
1039                                 NDR_CHECK(ndr_push_dfs_referral_v2(ndr, NDR_SCALARS, &r->v2));
1040                         break; }
1041
1042                         case 3: {
1043                                 NDR_CHECK(ndr_push_dfs_referral_v3(ndr, NDR_SCALARS, &r->v3));
1044                         break; }
1045
1046                         case 4: {
1047                                 NDR_CHECK(ndr_push_dfs_referral_v4(ndr, NDR_SCALARS, &r->v4));
1048                         break; }
1049
1050                         default: {
1051                         break; }
1052
1053                 }
1054         }
1055         if (ndr_flags & NDR_BUFFERS) {
1056                 int level = ndr_push_get_switch_value(ndr, r);
1057                 switch (level) {
1058                         case 1:
1059                                 NDR_CHECK(ndr_push_dfs_referral_v1(ndr, NDR_BUFFERS, &r->v1));
1060                         break;
1061
1062                         case 2:
1063                                 NDR_CHECK(ndr_push_dfs_referral_v2(ndr, NDR_BUFFERS, &r->v2));
1064                         break;
1065
1066                         case 3:
1067                                 NDR_CHECK(ndr_push_dfs_referral_v3(ndr, NDR_BUFFERS, &r->v3));
1068                         break;
1069
1070                         case 4:
1071                                 NDR_CHECK(ndr_push_dfs_referral_v4(ndr, NDR_BUFFERS, &r->v4));
1072                         break;
1073
1074                         default:
1075                         break;
1076
1077                 }
1078         }
1079         return NDR_ERR_SUCCESS;
1080 }
1081
1082 static enum ndr_err_code ndr_pull_dfs_referral_version(struct ndr_pull *ndr, int ndr_flags, union dfs_referral_version *r)
1083 {
1084         int level;
1085         level = ndr_pull_get_switch_value(ndr, r);
1086         if (ndr_flags & NDR_SCALARS) {
1087                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
1088                 switch (level) {
1089                         case 1: {
1090                                 NDR_CHECK(ndr_pull_dfs_referral_v1(ndr, NDR_SCALARS, &r->v1));
1091                         break; }
1092
1093                         case 2: {
1094                                 NDR_CHECK(ndr_pull_dfs_referral_v2(ndr, NDR_SCALARS, &r->v2));
1095                         break; }
1096
1097                         case 3: {
1098                                 NDR_CHECK(ndr_pull_dfs_referral_v3(ndr, NDR_SCALARS, &r->v3));
1099                         break; }
1100
1101                         case 4: {
1102                                 NDR_CHECK(ndr_pull_dfs_referral_v4(ndr, NDR_SCALARS, &r->v4));
1103                         break; }
1104
1105                         default: {
1106                         break; }
1107
1108                 }
1109         }
1110         if (ndr_flags & NDR_BUFFERS) {
1111                 switch (level) {
1112                         case 1:
1113                                 NDR_CHECK(ndr_pull_dfs_referral_v1(ndr, NDR_BUFFERS, &r->v1));
1114                         break;
1115
1116                         case 2:
1117                                 NDR_CHECK(ndr_pull_dfs_referral_v2(ndr, NDR_BUFFERS, &r->v2));
1118                         break;
1119
1120                         case 3:
1121                                 NDR_CHECK(ndr_pull_dfs_referral_v3(ndr, NDR_BUFFERS, &r->v3));
1122                         break;
1123
1124                         case 4:
1125                                 NDR_CHECK(ndr_pull_dfs_referral_v4(ndr, NDR_BUFFERS, &r->v4));
1126                         break;
1127
1128                         default:
1129                         break;
1130
1131                 }
1132         }
1133         return NDR_ERR_SUCCESS;
1134 }
1135
1136 _PUBLIC_ void ndr_print_dfs_referral_version(struct ndr_print *ndr, const char *name, const union dfs_referral_version *r)
1137 {
1138         int level;
1139         level = ndr_print_get_switch_value(ndr, r);
1140         ndr_print_union(ndr, name, level, "dfs_referral_version");
1141         switch (level) {
1142                 case 1:
1143                         ndr_print_dfs_referral_v1(ndr, "v1", &r->v1);
1144                 break;
1145
1146                 case 2:
1147                         ndr_print_dfs_referral_v2(ndr, "v2", &r->v2);
1148                 break;
1149
1150                 case 3:
1151                         ndr_print_dfs_referral_v3(ndr, "v3", &r->v3);
1152                 break;
1153
1154                 case 4:
1155                         ndr_print_dfs_referral_v4(ndr, "v4", &r->v4);
1156                 break;
1157
1158                 default:
1159                 break;
1160
1161         }
1162 }
1163
1164 static enum ndr_err_code ndr_push_dfs_referral_type(struct ndr_push *ndr, int ndr_flags, const struct dfs_referral_type *r)
1165 {
1166         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
1167         {
1168                 uint32_t _flags_save_STRUCT = ndr->flags;
1169                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
1170                 if (ndr_flags & NDR_SCALARS) {
1171                         NDR_CHECK(ndr_push_align(ndr, 5));
1172                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
1173                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->version));
1174                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->referral, r->version));
1175                         NDR_CHECK(ndr_push_dfs_referral_version(ndr, NDR_SCALARS, &r->referral));
1176                         NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1177                 }
1178                 if (ndr_flags & NDR_BUFFERS) {
1179                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
1180                         NDR_CHECK(ndr_push_dfs_referral_version(ndr, NDR_BUFFERS, &r->referral));
1181                 }
1182                 ndr->flags = _flags_save_STRUCT;
1183         }
1184         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
1185         return NDR_ERR_SUCCESS;
1186 }
1187
1188 static enum ndr_err_code ndr_pull_dfs_referral_type(struct ndr_pull *ndr, int ndr_flags, struct dfs_referral_type *r)
1189 {
1190         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
1191         {
1192                 uint32_t _flags_save_STRUCT = ndr->flags;
1193                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
1194                 if (ndr_flags & NDR_SCALARS) {
1195                         NDR_CHECK(ndr_pull_align(ndr, 5));
1196                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
1197                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->version));
1198                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->referral, r->version));
1199                         NDR_CHECK(ndr_pull_dfs_referral_version(ndr, NDR_SCALARS, &r->referral));
1200                         NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1201                 }
1202                 if (ndr_flags & NDR_BUFFERS) {
1203                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
1204                         NDR_CHECK(ndr_pull_dfs_referral_version(ndr, NDR_BUFFERS, &r->referral));
1205                 }
1206                 ndr->flags = _flags_save_STRUCT;
1207         }
1208         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
1209         return NDR_ERR_SUCCESS;
1210 }
1211
1212 _PUBLIC_ void ndr_print_dfs_referral_type(struct ndr_print *ndr, const char *name, const struct dfs_referral_type *r)
1213 {
1214         ndr_print_struct(ndr, name, "dfs_referral_type");
1215         {
1216                 uint32_t _flags_save_STRUCT = ndr->flags;
1217                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
1218                 ndr->depth++;
1219                 ndr_print_uint16(ndr, "version", r->version);
1220                 ndr_print_set_switch_value(ndr, &r->referral, r->version);
1221                 ndr_print_dfs_referral_version(ndr, "referral", &r->referral);
1222                 ndr->depth--;
1223                 ndr->flags = _flags_save_STRUCT;
1224         }
1225 }
1226
1227 _PUBLIC_ enum ndr_err_code ndr_push_dfs_referral_resp(struct ndr_push *ndr, int ndr_flags, const struct dfs_referral_resp *r)
1228 {
1229         uint32_t cntr_referral_entries_0;
1230         if (ndr_flags & NDR_SCALARS) {
1231                 NDR_CHECK(ndr_push_align(ndr, 5));
1232                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->path_consumed));
1233                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->nb_referrals));
1234                 NDR_CHECK(ndr_push_DFS_HEADER_FLAG(ndr, NDR_SCALARS, r->header_flags));
1235                 for (cntr_referral_entries_0 = 0; cntr_referral_entries_0 < r->nb_referrals; cntr_referral_entries_0++) {
1236                         NDR_CHECK(ndr_push_dfs_referral_type(ndr, NDR_SCALARS, &r->referral_entries[cntr_referral_entries_0]));
1237                 }
1238                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1239         }
1240         if (ndr_flags & NDR_BUFFERS) {
1241                 for (cntr_referral_entries_0 = 0; cntr_referral_entries_0 < r->nb_referrals; cntr_referral_entries_0++) {
1242                         NDR_CHECK(ndr_push_dfs_referral_type(ndr, NDR_BUFFERS, &r->referral_entries[cntr_referral_entries_0]));
1243                 }
1244         }
1245         return NDR_ERR_SUCCESS;
1246 }
1247
1248 _PUBLIC_ enum ndr_err_code ndr_pull_dfs_referral_resp(struct ndr_pull *ndr, int ndr_flags, struct dfs_referral_resp *r)
1249 {
1250         uint32_t cntr_referral_entries_0;
1251         TALLOC_CTX *_mem_save_referral_entries_0;
1252         if (ndr_flags & NDR_SCALARS) {
1253                 NDR_CHECK(ndr_pull_align(ndr, 5));
1254                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->path_consumed));
1255                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->nb_referrals));
1256                 NDR_CHECK(ndr_pull_DFS_HEADER_FLAG(ndr, NDR_SCALARS, &r->header_flags));
1257                 NDR_PULL_ALLOC_N(ndr, r->referral_entries, r->nb_referrals);
1258                 _mem_save_referral_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
1259                 NDR_PULL_SET_MEM_CTX(ndr, r->referral_entries, 0);
1260                 for (cntr_referral_entries_0 = 0; cntr_referral_entries_0 < r->nb_referrals; cntr_referral_entries_0++) {
1261                         NDR_CHECK(ndr_pull_dfs_referral_type(ndr, NDR_SCALARS, &r->referral_entries[cntr_referral_entries_0]));
1262                 }
1263                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_referral_entries_0, 0);
1264                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1265         }
1266         if (ndr_flags & NDR_BUFFERS) {
1267                 _mem_save_referral_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
1268                 NDR_PULL_SET_MEM_CTX(ndr, r->referral_entries, 0);
1269                 for (cntr_referral_entries_0 = 0; cntr_referral_entries_0 < r->nb_referrals; cntr_referral_entries_0++) {
1270                         NDR_CHECK(ndr_pull_dfs_referral_type(ndr, NDR_BUFFERS, &r->referral_entries[cntr_referral_entries_0]));
1271                 }
1272                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_referral_entries_0, 0);
1273         }
1274         return NDR_ERR_SUCCESS;
1275 }
1276
1277 _PUBLIC_ void ndr_print_dfs_referral_resp(struct ndr_print *ndr, const char *name, const struct dfs_referral_resp *r)
1278 {
1279         uint32_t cntr_referral_entries_0;
1280         ndr_print_struct(ndr, name, "dfs_referral_resp");
1281         ndr->depth++;
1282         ndr_print_uint16(ndr, "path_consumed", r->path_consumed);
1283         ndr_print_uint16(ndr, "nb_referrals", r->nb_referrals);
1284         ndr_print_DFS_HEADER_FLAG(ndr, "header_flags", r->header_flags);
1285         ndr->print(ndr, "%s: ARRAY(%d)", "referral_entries", (int)r->nb_referrals);
1286         ndr->depth++;
1287         for (cntr_referral_entries_0=0;cntr_referral_entries_0<r->nb_referrals;cntr_referral_entries_0++) {
1288                 char *idx_0=NULL;
1289                 if (asprintf(&idx_0, "[%d]", cntr_referral_entries_0) != -1) {
1290                         ndr_print_dfs_referral_type(ndr, "referral_entries", &r->referral_entries[cntr_referral_entries_0]);
1291                         free(idx_0);
1292                 }
1293         }
1294         ndr->depth--;
1295         ndr->depth--;
1296 }
1297
1298 _PUBLIC_ enum ndr_err_code ndr_push_dfs_GetDFSReferral_in(struct ndr_push *ndr, int ndr_flags, const struct dfs_GetDFSReferral_in *r)
1299 {
1300         if (ndr_flags & NDR_SCALARS) {
1301                 NDR_CHECK(ndr_push_align(ndr, 4));
1302                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_referral_level));
1303                 {
1304                         uint32_t _flags_save_string = ndr->flags;
1305                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1306                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1307                         ndr->flags = _flags_save_string;
1308                 }
1309                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1310         }
1311         if (ndr_flags & NDR_BUFFERS) {
1312         }
1313         return NDR_ERR_SUCCESS;
1314 }
1315
1316 _PUBLIC_ enum ndr_err_code ndr_pull_dfs_GetDFSReferral_in(struct ndr_pull *ndr, int ndr_flags, struct dfs_GetDFSReferral_in *r)
1317 {
1318         if (ndr_flags & NDR_SCALARS) {
1319                 NDR_CHECK(ndr_pull_align(ndr, 4));
1320                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_referral_level));
1321                 {
1322                         uint32_t _flags_save_string = ndr->flags;
1323                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1324                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1325                         ndr->flags = _flags_save_string;
1326                 }
1327                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1328         }
1329         if (ndr_flags & NDR_BUFFERS) {
1330         }
1331         return NDR_ERR_SUCCESS;
1332 }
1333
1334 _PUBLIC_ void ndr_print_dfs_GetDFSReferral_in(struct ndr_print *ndr, const char *name, const struct dfs_GetDFSReferral_in *r)
1335 {
1336         ndr_print_struct(ndr, name, "dfs_GetDFSReferral_in");
1337         ndr->depth++;
1338         ndr_print_uint16(ndr, "max_referral_level", r->max_referral_level);
1339         ndr_print_string(ndr, "servername", r->servername);
1340         ndr->depth--;
1341 }
1342
1343 _PUBLIC_ enum ndr_err_code ndr_push_dfs_GetDFSReferral(struct ndr_push *ndr, int flags, const struct dfs_GetDFSReferral *r)
1344 {
1345         if (flags & NDR_IN) {
1346                 NDR_CHECK(ndr_push_dfs_GetDFSReferral_in(ndr, NDR_SCALARS, &r->in.req));
1347         }
1348         if (flags & NDR_OUT) {
1349                 if (r->out.resp == NULL) {
1350                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1351                 }
1352                 NDR_CHECK(ndr_push_dfs_referral_resp(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.resp));
1353         }
1354         return NDR_ERR_SUCCESS;
1355 }
1356
1357 _PUBLIC_ enum ndr_err_code ndr_pull_dfs_GetDFSReferral(struct ndr_pull *ndr, int flags, struct dfs_GetDFSReferral *r)
1358 {
1359         TALLOC_CTX *_mem_save_resp_0;
1360         if (flags & NDR_IN) {
1361                 ZERO_STRUCT(r->out);
1362
1363                 NDR_CHECK(ndr_pull_dfs_GetDFSReferral_in(ndr, NDR_SCALARS, &r->in.req));
1364                 NDR_PULL_ALLOC(ndr, r->out.resp);
1365                 ZERO_STRUCTP(r->out.resp);
1366         }
1367         if (flags & NDR_OUT) {
1368                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1369                         NDR_PULL_ALLOC(ndr, r->out.resp);
1370                 }
1371                 _mem_save_resp_0 = NDR_PULL_GET_MEM_CTX(ndr);
1372                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resp, LIBNDR_FLAG_REF_ALLOC);
1373                 NDR_CHECK(ndr_pull_dfs_referral_resp(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.resp));
1374                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resp_0, LIBNDR_FLAG_REF_ALLOC);
1375         }
1376         return NDR_ERR_SUCCESS;
1377 }
1378
1379 _PUBLIC_ void ndr_print_dfs_GetDFSReferral(struct ndr_print *ndr, const char *name, int flags, const struct dfs_GetDFSReferral *r)
1380 {
1381         ndr_print_struct(ndr, name, "dfs_GetDFSReferral");
1382         ndr->depth++;
1383         if (flags & NDR_SET_VALUES) {
1384                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1385         }
1386         if (flags & NDR_IN) {
1387                 ndr_print_struct(ndr, "in", "dfs_GetDFSReferral");
1388                 ndr->depth++;
1389                 ndr_print_dfs_GetDFSReferral_in(ndr, "req", &r->in.req);
1390                 ndr->depth--;
1391         }
1392         if (flags & NDR_OUT) {
1393                 ndr_print_struct(ndr, "out", "dfs_GetDFSReferral");
1394                 ndr->depth++;
1395                 ndr_print_ptr(ndr, "resp", r->out.resp);
1396                 ndr->depth++;
1397                 ndr_print_dfs_referral_resp(ndr, "resp", r->out.resp);
1398                 ndr->depth--;
1399                 ndr->depth--;
1400         }
1401         ndr->depth--;
1402 }
1403
1404 static const struct ndr_interface_call dfsblobs_calls[] = {
1405         {
1406                 "dfs_GetDFSReferral",
1407                 sizeof(struct dfs_GetDFSReferral),
1408                 (ndr_push_flags_fn_t) ndr_push_dfs_GetDFSReferral,
1409                 (ndr_pull_flags_fn_t) ndr_pull_dfs_GetDFSReferral,
1410                 (ndr_print_function_t) ndr_print_dfs_GetDFSReferral,
1411                 false,
1412         },
1413         { NULL, 0, NULL, NULL, NULL, false }
1414 };
1415
1416 static const char * const dfsblobs_endpoint_strings[] = {
1417         "ncacn_np:[\\pipe\\dfsblobs]",
1418 };
1419
1420 static const struct ndr_interface_string_array dfsblobs_endpoints = {
1421         .count  = 1,
1422         .names  = dfsblobs_endpoint_strings
1423 };
1424
1425 static const char * const dfsblobs_authservice_strings[] = {
1426         "host",
1427 };
1428
1429 static const struct ndr_interface_string_array dfsblobs_authservices = {
1430         .count  = 1,
1431         .names  = dfsblobs_authservice_strings
1432 };
1433
1434
1435 const struct ndr_interface_table ndr_table_dfsblobs = {
1436         .name           = "dfsblobs",
1437         .syntax_id      = {
1438                 {0x12345778,0x1234,0xabcd,{0x00,0x01},{0x00,0x00,0x00,0x03}},
1439                 NDR_DFSBLOBS_VERSION
1440         },
1441         .helpstring     = NDR_DFSBLOBS_HELPSTRING,
1442         .num_calls      = 1,
1443         .calls          = dfsblobs_calls,
1444         .endpoints      = &dfsblobs_endpoints,
1445         .authservices   = &dfsblobs_authservices
1446 };
1447