source/librpc/gen_ndr/ndr_dfs.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "librpc/gen_ndr/ndr_dfs.h"
   5
   6 NTSTATUS ndr_push_dfs_ManagerVersion(struct ndr_push *ndr, int ndr_flags, enum dfs_ManagerVersion r)
   7 {
   8         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
   9         return NT_STATUS_OK;
  10 }
  11
  12 NTSTATUS ndr_pull_dfs_ManagerVersion(struct ndr_pull *ndr, int ndr_flags, enum dfs_ManagerVersion *r)
  13 {
  14         uint32_t v;
  15         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  16         *r = v;
  17         return NT_STATUS_OK;
  18 }
  19
  20 _PUBLIC_ void ndr_print_dfs_ManagerVersion(struct ndr_print *ndr, const char *name, enum dfs_ManagerVersion r)
  21 {
  22         const char *val = NULL;
  23
  24         switch (r) {
  25                 case DFS_MANAGER_VERSION_NT4: val = "DFS_MANAGER_VERSION_NT4"; break;
  26                 case DFS_MANAGER_VERSION_W2K: val = "DFS_MANAGER_VERSION_W2K"; break;
  27                 case DFS_MANAGER_VERSION_W2K3: val = "DFS_MANAGER_VERSION_W2K3"; break;
  28         }
  29         ndr_print_enum(ndr, name, "ENUM", val, r);
  30 }
  31
  32 NTSTATUS ndr_push_dfs_Info0(struct ndr_push *ndr, int ndr_flags, const struct dfs_Info0 *r)
  33 {
  34         if (ndr_flags & NDR_SCALARS) {
  35                 NDR_CHECK(ndr_push_align(ndr, 1));
  36         }
  37         if (ndr_flags & NDR_BUFFERS) {
  38         }
  39         return NT_STATUS_OK;
  40 }
  41
  42 NTSTATUS ndr_pull_dfs_Info0(struct ndr_pull *ndr, int ndr_flags, struct dfs_Info0 *r)
  43 {
  44         if (ndr_flags & NDR_SCALARS) {
  45                 NDR_CHECK(ndr_pull_align(ndr, 1));
  46         }
  47         if (ndr_flags & NDR_BUFFERS) {
  48         }
  49         return NT_STATUS_OK;
  50 }
  51
  52 _PUBLIC_ void ndr_print_dfs_Info0(struct ndr_print *ndr, const char *name, const struct dfs_Info0 *r)
  53 {
  54         ndr_print_struct(ndr, name, "dfs_Info0");
  55         ndr->depth++;
  56         ndr->depth--;
  57 }
  58
  59 NTSTATUS ndr_push_dfs_Info1(struct ndr_push *ndr, int ndr_flags, const struct dfs_Info1 *r)
  60 {
  61         if (ndr_flags & NDR_SCALARS) {
  62                 NDR_CHECK(ndr_push_align(ndr, 4));
  63                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->path));
  64         }
  65         if (ndr_flags & NDR_BUFFERS) {
  66                 if (r->path) {
  67                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));
  68                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  69                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));
  70                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->path, ndr_charset_length(r->path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
  71                 }
  72         }
  73         return NT_STATUS_OK;
  74 }
  75
  76 NTSTATUS ndr_pull_dfs_Info1(struct ndr_pull *ndr, int ndr_flags, struct dfs_Info1 *r)
  77 {
  78         uint32_t _ptr_path;
  79         TALLOC_CTX *_mem_save_path_0;
  80         if (ndr_flags & NDR_SCALARS) {
  81                 NDR_CHECK(ndr_pull_align(ndr, 4));
  82                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_path));
  83                 if (_ptr_path) {
  84                         NDR_PULL_ALLOC(ndr, r->path);
  85                 } else {
  86                         r->path = NULL;
  87                 }
  88         }
  89         if (ndr_flags & NDR_BUFFERS) {
  90                 if (r->path) {
  91                         _mem_save_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
  92                         NDR_PULL_SET_MEM_CTX(ndr, r->path, 0);
  93                         NDR_CHECK(ndr_pull_array_size(ndr, &r->path));
  94                         NDR_CHECK(ndr_pull_array_length(ndr, &r->path));
  95                         if (ndr_get_array_length(ndr, &r->path) > ndr_get_array_size(ndr, &r->path)) {
  96                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->path), ndr_get_array_length(ndr, &r->path));
  97                         }
  98                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->path), sizeof(uint16_t)));
  99                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->path, ndr_get_array_length(ndr, &r->path), sizeof(uint16_t), CH_UTF16));
 100                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_path_0, 0);
 101                 }
 102         }
 103         return NT_STATUS_OK;
 104 }
 105
 106 _PUBLIC_ void ndr_print_dfs_Info1(struct ndr_print *ndr, const char *name, const struct dfs_Info1 *r)
 107 {
 108         ndr_print_struct(ndr, name, "dfs_Info1");
 109         ndr->depth++;
 110         ndr_print_ptr(ndr, "path", r->path);
 111         ndr->depth++;
 112         if (r->path) {
 113                 ndr_print_string(ndr, "path", r->path);
 114         }
 115         ndr->depth--;
 116         ndr->depth--;
 117 }
 118
 119 _PUBLIC_ NTSTATUS ndr_push_dfs_VolumeState(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 120 {
 121         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 122         return NT_STATUS_OK;
 123 }
 124
 125 _PUBLIC_ NTSTATUS ndr_pull_dfs_VolumeState(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 126 {
 127         uint32_t v;
 128         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 129         *r = v;
 130         return NT_STATUS_OK;
 131 }
 132
 133 _PUBLIC_ void ndr_print_dfs_VolumeState(struct ndr_print *ndr, const char *name, uint32_t r)
 134 {
 135         ndr_print_uint32(ndr, name, r);
 136         ndr->depth++;
 137         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DFS_VOLUME_STATE_OK", DFS_VOLUME_STATE_OK, r);
 138         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DFS_VOLUME_STATE_INCONSISTENT", DFS_VOLUME_STATE_INCONSISTENT, r);
 139         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DFS_VOLUME_STATE_OFFLINE", DFS_VOLUME_STATE_OFFLINE, r);
 140         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DFS_VOLUME_STATE_ONLINE", DFS_VOLUME_STATE_ONLINE, r);
 141         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DFS_VOLUME_STATE_STANDALONE", DFS_VOLUME_STATE_STANDALONE, r);
 142         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DFS_VOLUME_STATE_AD_BLOB", DFS_VOLUME_STATE_AD_BLOB, r);
 143         ndr->depth--;
 144 }
 145
 146 NTSTATUS ndr_push_dfs_Info2(struct ndr_push *ndr, int ndr_flags, const struct dfs_Info2 *r)
 147 {
 148         if (ndr_flags & NDR_SCALARS) {
 149                 NDR_CHECK(ndr_push_align(ndr, 4));
 150                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->path));
 151                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
 152                 NDR_CHECK(ndr_push_dfs_VolumeState(ndr, NDR_SCALARS, r->state));
 153                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_stores));
 154         }
 155         if (ndr_flags & NDR_BUFFERS) {
 156                 if (r->path) {
 157                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));
 158                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 159                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));
 160                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->path, ndr_charset_length(r->path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 161                 }
 162                 if (r->comment) {
 163                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
 164                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 165                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
 166                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 167                 }
 168         }
 169         return NT_STATUS_OK;
 170 }
 171
 172 NTSTATUS ndr_pull_dfs_Info2(struct ndr_pull *ndr, int ndr_flags, struct dfs_Info2 *r)
 173 {
 174         uint32_t _ptr_path;
 175         TALLOC_CTX *_mem_save_path_0;
 176         uint32_t _ptr_comment;
 177         TALLOC_CTX *_mem_save_comment_0;
 178         if (ndr_flags & NDR_SCALARS) {
 179                 NDR_CHECK(ndr_pull_align(ndr, 4));
 180                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_path));
 181                 if (_ptr_path) {
 182                         NDR_PULL_ALLOC(ndr, r->path);
 183                 } else {
 184                         r->path = NULL;
 185                 }
 186                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
 187                 if (_ptr_comment) {
 188                         NDR_PULL_ALLOC(ndr, r->comment);
 189                 } else {
 190                         r->comment = NULL;
 191                 }
 192                 NDR_CHECK(ndr_pull_dfs_VolumeState(ndr, NDR_SCALARS, &r->state));
 193                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_stores));
 194         }
 195         if (ndr_flags & NDR_BUFFERS) {
 196                 if (r->path) {
 197                         _mem_save_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
 198                         NDR_PULL_SET_MEM_CTX(ndr, r->path, 0);
 199                         NDR_CHECK(ndr_pull_array_size(ndr, &r->path));
 200                         NDR_CHECK(ndr_pull_array_length(ndr, &r->path));
 201                         if (ndr_get_array_length(ndr, &r->path) > ndr_get_array_size(ndr, &r->path)) {
 202                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->path), ndr_get_array_length(ndr, &r->path));
 203                         }
 204                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->path), sizeof(uint16_t)));
 205                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->path, ndr_get_array_length(ndr, &r->path), sizeof(uint16_t), CH_UTF16));
 206                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_path_0, 0);
 207                 }
 208                 if (r->comment) {
 209                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
 210                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
 211                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
 212                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
 213                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
 214                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
 215                         }
 216                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
 217                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
 218                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
 219                 }
 220         }
 221         return NT_STATUS_OK;
 222 }
 223
 224 _PUBLIC_ void ndr_print_dfs_Info2(struct ndr_print *ndr, const char *name, const struct dfs_Info2 *r)
 225 {
 226         ndr_print_struct(ndr, name, "dfs_Info2");
 227         ndr->depth++;
 228         ndr_print_ptr(ndr, "path", r->path);
 229         ndr->depth++;
 230         if (r->path) {
 231                 ndr_print_string(ndr, "path", r->path);
 232         }
 233         ndr->depth--;
 234         ndr_print_ptr(ndr, "comment", r->comment);
 235         ndr->depth++;
 236         if (r->comment) {
 237                 ndr_print_string(ndr, "comment", r->comment);
 238         }
 239         ndr->depth--;
 240         ndr_print_dfs_VolumeState(ndr, "state", r->state);
 241         ndr_print_uint32(ndr, "num_stores", r->num_stores);
 242         ndr->depth--;
 243 }
 244
 245 _PUBLIC_ NTSTATUS ndr_push_dfs_StorageState(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 246 {
 247         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 248         return NT_STATUS_OK;
 249 }
 250
 251 _PUBLIC_ NTSTATUS ndr_pull_dfs_StorageState(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 252 {
 253         uint32_t v;
 254         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 255         *r = v;
 256         return NT_STATUS_OK;
 257 }
 258
 259 _PUBLIC_ void ndr_print_dfs_StorageState(struct ndr_print *ndr, const char *name, uint32_t r)
 260 {
 261         ndr_print_uint32(ndr, name, r);
 262         ndr->depth++;
 263         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DFS_STORAGE_STATE_OFFLINE", DFS_STORAGE_STATE_OFFLINE, r);
 264         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DFS_STORAGE_STATE_ONLINE", DFS_STORAGE_STATE_ONLINE, r);
 265         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DFS_STORAGE_STATE_ACTIVE", DFS_STORAGE_STATE_ACTIVE, r);
 266         ndr->depth--;
 267 }
 268
 269 NTSTATUS ndr_push_dfs_StorageInfo(struct ndr_push *ndr, int ndr_flags, const struct dfs_StorageInfo *r)
 270 {
 271         if (ndr_flags & NDR_SCALARS) {
 272                 NDR_CHECK(ndr_push_align(ndr, 4));
 273                 NDR_CHECK(ndr_push_dfs_StorageState(ndr, NDR_SCALARS, r->state));
 274                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server));
 275                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->share));
 276         }
 277         if (ndr_flags & NDR_BUFFERS) {
 278                 if (r->server) {
 279                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server, CH_UTF16)));
 280                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 281                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server, CH_UTF16)));
 282                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server, ndr_charset_length(r->server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 283                 }
 284                 if (r->share) {
 285                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->share, CH_UTF16)));
 286                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 287                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->share, CH_UTF16)));
 288                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->share, ndr_charset_length(r->share, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 289                 }
 290         }
 291         return NT_STATUS_OK;
 292 }
 293
 294 NTSTATUS ndr_pull_dfs_StorageInfo(struct ndr_pull *ndr, int ndr_flags, struct dfs_StorageInfo *r)
 295 {
 296         uint32_t _ptr_server;
 297         TALLOC_CTX *_mem_save_server_0;
 298         uint32_t _ptr_share;
 299         TALLOC_CTX *_mem_save_share_0;
 300         if (ndr_flags & NDR_SCALARS) {
 301                 NDR_CHECK(ndr_pull_align(ndr, 4));
 302                 NDR_CHECK(ndr_pull_dfs_StorageState(ndr, NDR_SCALARS, &r->state));
 303                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
 304                 if (_ptr_server) {
 305                         NDR_PULL_ALLOC(ndr, r->server);
 306                 } else {
 307                         r->server = NULL;
 308                 }
 309                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_share));
 310                 if (_ptr_share) {
 311                         NDR_PULL_ALLOC(ndr, r->share);
 312                 } else {
 313                         r->share = NULL;
 314                 }
 315         }
 316         if (ndr_flags & NDR_BUFFERS) {
 317                 if (r->server) {
 318                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
 319                         NDR_PULL_SET_MEM_CTX(ndr, r->server, 0);
 320                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server));
 321                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server));
 322                         if (ndr_get_array_length(ndr, &r->server) > ndr_get_array_size(ndr, &r->server)) {
 323                                 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), ndr_get_array_length(ndr, &r->server));
 324                         }
 325                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server), sizeof(uint16_t)));
 326                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server, ndr_get_array_length(ndr, &r->server), sizeof(uint16_t), CH_UTF16));
 327                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
 328                 }
 329                 if (r->share) {
 330                         _mem_save_share_0 = NDR_PULL_GET_MEM_CTX(ndr);
 331                         NDR_PULL_SET_MEM_CTX(ndr, r->share, 0);
 332                         NDR_CHECK(ndr_pull_array_size(ndr, &r->share));
 333                         NDR_CHECK(ndr_pull_array_length(ndr, &r->share));
 334                         if (ndr_get_array_length(ndr, &r->share) > ndr_get_array_size(ndr, &r->share)) {
 335                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->share), ndr_get_array_length(ndr, &r->share));
 336                         }
 337                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->share), sizeof(uint16_t)));
 338                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->share, ndr_get_array_length(ndr, &r->share), sizeof(uint16_t), CH_UTF16));
 339                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_share_0, 0);
 340                 }
 341         }
 342         return NT_STATUS_OK;
 343 }
 344
 345 _PUBLIC_ void ndr_print_dfs_StorageInfo(struct ndr_print *ndr, const char *name, const struct dfs_StorageInfo *r)
 346 {
 347         ndr_print_struct(ndr, name, "dfs_StorageInfo");
 348         ndr->depth++;
 349         ndr_print_dfs_StorageState(ndr, "state", r->state);
 350         ndr_print_ptr(ndr, "server", r->server);
 351         ndr->depth++;
 352         if (r->server) {
 353                 ndr_print_string(ndr, "server", r->server);
 354         }
 355         ndr->depth--;
 356         ndr_print_ptr(ndr, "share", r->share);
 357         ndr->depth++;
 358         if (r->share) {
 359                 ndr_print_string(ndr, "share", r->share);
 360         }
 361         ndr->depth--;
 362         ndr->depth--;
 363 }
 364
 365 NTSTATUS ndr_push_dfs_Info3(struct ndr_push *ndr, int ndr_flags, const struct dfs_Info3 *r)
 366 {
 367         uint32_t cntr_stores_1;
 368         if (ndr_flags & NDR_SCALARS) {
 369                 NDR_CHECK(ndr_push_align(ndr, 4));
 370                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->path));
 371                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
 372                 NDR_CHECK(ndr_push_dfs_VolumeState(ndr, NDR_SCALARS, r->state));
 373                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_stores));
 374                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->stores));
 375         }
 376         if (ndr_flags & NDR_BUFFERS) {
 377                 if (r->path) {
 378                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));
 379                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 380                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));
 381                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->path, ndr_charset_length(r->path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 382                 }
 383                 if (r->comment) {
 384                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
 385                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 386                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
 387                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 388                 }
 389                 if (r->stores) {
 390                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_stores));
 391                         for (cntr_stores_1 = 0; cntr_stores_1 < r->num_stores; cntr_stores_1++) {
 392                                 NDR_CHECK(ndr_push_dfs_StorageInfo(ndr, NDR_SCALARS, &r->stores[cntr_stores_1]));
 393                         }
 394                         for (cntr_stores_1 = 0; cntr_stores_1 < r->num_stores; cntr_stores_1++) {
 395                                 NDR_CHECK(ndr_push_dfs_StorageInfo(ndr, NDR_BUFFERS, &r->stores[cntr_stores_1]));
 396                         }
 397                 }
 398         }
 399         return NT_STATUS_OK;
 400 }
 401
 402 NTSTATUS ndr_pull_dfs_Info3(struct ndr_pull *ndr, int ndr_flags, struct dfs_Info3 *r)
 403 {
 404         uint32_t _ptr_path;
 405         TALLOC_CTX *_mem_save_path_0;
 406         uint32_t _ptr_comment;
 407         TALLOC_CTX *_mem_save_comment_0;
 408         uint32_t _ptr_stores;
 409         uint32_t cntr_stores_1;
 410         TALLOC_CTX *_mem_save_stores_0;
 411         TALLOC_CTX *_mem_save_stores_1;
 412         if (ndr_flags & NDR_SCALARS) {
 413                 NDR_CHECK(ndr_pull_align(ndr, 4));
 414                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_path));
 415                 if (_ptr_path) {
 416                         NDR_PULL_ALLOC(ndr, r->path);
 417                 } else {
 418                         r->path = NULL;
 419                 }
 420                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
 421                 if (_ptr_comment) {
 422                         NDR_PULL_ALLOC(ndr, r->comment);
 423                 } else {
 424                         r->comment = NULL;
 425                 }
 426                 NDR_CHECK(ndr_pull_dfs_VolumeState(ndr, NDR_SCALARS, &r->state));
 427                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_stores));
 428                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_stores));
 429                 if (_ptr_stores) {
 430                         NDR_PULL_ALLOC(ndr, r->stores);
 431                 } else {
 432                         r->stores = NULL;
 433                 }
 434         }
 435         if (ndr_flags & NDR_BUFFERS) {
 436                 if (r->path) {
 437                         _mem_save_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
 438                         NDR_PULL_SET_MEM_CTX(ndr, r->path, 0);
 439                         NDR_CHECK(ndr_pull_array_size(ndr, &r->path));
 440                         NDR_CHECK(ndr_pull_array_length(ndr, &r->path));
 441                         if (ndr_get_array_length(ndr, &r->path) > ndr_get_array_size(ndr, &r->path)) {
 442                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->path), ndr_get_array_length(ndr, &r->path));
 443                         }
 444                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->path), sizeof(uint16_t)));
 445                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->path, ndr_get_array_length(ndr, &r->path), sizeof(uint16_t), CH_UTF16));
 446                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_path_0, 0);
 447                 }
 448                 if (r->comment) {
 449                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
 450                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
 451                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
 452                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
 453                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
 454                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
 455                         }
 456                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
 457                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
 458                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
 459                 }
 460                 if (r->stores) {
 461                         _mem_save_stores_0 = NDR_PULL_GET_MEM_CTX(ndr);
 462                         NDR_PULL_SET_MEM_CTX(ndr, r->stores, 0);
 463                         NDR_CHECK(ndr_pull_array_size(ndr, &r->stores));
 464                         NDR_PULL_ALLOC_N(ndr, r->stores, ndr_get_array_size(ndr, &r->stores));
 465                         _mem_save_stores_1 = NDR_PULL_GET_MEM_CTX(ndr);
 466                         NDR_PULL_SET_MEM_CTX(ndr, r->stores, 0);
 467                         for (cntr_stores_1 = 0; cntr_stores_1 < r->num_stores; cntr_stores_1++) {
 468                                 NDR_CHECK(ndr_pull_dfs_StorageInfo(ndr, NDR_SCALARS, &r->stores[cntr_stores_1]));
 469                         }
 470                         for (cntr_stores_1 = 0; cntr_stores_1 < r->num_stores; cntr_stores_1++) {
 471                                 NDR_CHECK(ndr_pull_dfs_StorageInfo(ndr, NDR_BUFFERS, &r->stores[cntr_stores_1]));
 472                         }
 473                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_stores_1, 0);
 474                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_stores_0, 0);
 475                 }
 476                 if (r->stores) {
 477                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->stores, r->num_stores));
 478                 }
 479         }
 480         return NT_STATUS_OK;
 481 }
 482
 483 _PUBLIC_ void ndr_print_dfs_Info3(struct ndr_print *ndr, const char *name, const struct dfs_Info3 *r)
 484 {
 485         uint32_t cntr_stores_1;
 486         ndr_print_struct(ndr, name, "dfs_Info3");
 487         ndr->depth++;
 488         ndr_print_ptr(ndr, "path", r->path);
 489         ndr->depth++;
 490         if (r->path) {
 491                 ndr_print_string(ndr, "path", r->path);
 492         }
 493         ndr->depth--;
 494         ndr_print_ptr(ndr, "comment", r->comment);
 495         ndr->depth++;
 496         if (r->comment) {
 497                 ndr_print_string(ndr, "comment", r->comment);
 498         }
 499         ndr->depth--;
 500         ndr_print_dfs_VolumeState(ndr, "state", r->state);
 501         ndr_print_uint32(ndr, "num_stores", r->num_stores);
 502         ndr_print_ptr(ndr, "stores", r->stores);
 503         ndr->depth++;
 504         if (r->stores) {
 505                 ndr->print(ndr, "%s: ARRAY(%d)", "stores", r->num_stores);
 506                 ndr->depth++;
 507                 for (cntr_stores_1=0;cntr_stores_1<r->num_stores;cntr_stores_1++) {
 508                         char *idx_1=NULL;
 509                         asprintf(&idx_1, "[%d]", cntr_stores_1);
 510                         if (idx_1) {
 511                                 ndr_print_dfs_StorageInfo(ndr, "stores", &r->stores[cntr_stores_1]);
 512                                 free(idx_1);
 513                         }
 514                 }
 515                 ndr->depth--;
 516         }
 517         ndr->depth--;
 518         ndr->depth--;
 519 }
 520
 521 NTSTATUS ndr_push_dfs_Info4(struct ndr_push *ndr, int ndr_flags, const struct dfs_Info4 *r)
 522 {
 523         uint32_t cntr_stores_1;
 524         if (ndr_flags & NDR_SCALARS) {
 525                 NDR_CHECK(ndr_push_align(ndr, 4));
 526                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->path));
 527                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
 528                 NDR_CHECK(ndr_push_dfs_VolumeState(ndr, NDR_SCALARS, r->state));
 529                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->timeout));
 530                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
 531                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_stores));
 532                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->stores));
 533         }
 534         if (ndr_flags & NDR_BUFFERS) {
 535                 if (r->path) {
 536                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));
 537                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 538                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));
 539                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->path, ndr_charset_length(r->path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 540                 }
 541                 if (r->comment) {
 542                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
 543                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 544                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
 545                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 546                 }
 547                 NDR_CHECK(ndr_push_GUID(ndr, NDR_BUFFERS, &r->guid));
 548                 if (r->stores) {
 549                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_stores));
 550                         for (cntr_stores_1 = 0; cntr_stores_1 < r->num_stores; cntr_stores_1++) {
 551                                 NDR_CHECK(ndr_push_dfs_StorageInfo(ndr, NDR_SCALARS, &r->stores[cntr_stores_1]));
 552                         }
 553                         for (cntr_stores_1 = 0; cntr_stores_1 < r->num_stores; cntr_stores_1++) {
 554                                 NDR_CHECK(ndr_push_dfs_StorageInfo(ndr, NDR_BUFFERS, &r->stores[cntr_stores_1]));
 555                         }
 556                 }
 557         }
 558         return NT_STATUS_OK;
 559 }
 560
 561 NTSTATUS ndr_pull_dfs_Info4(struct ndr_pull *ndr, int ndr_flags, struct dfs_Info4 *r)
 562 {
 563         uint32_t _ptr_path;
 564         TALLOC_CTX *_mem_save_path_0;
 565         uint32_t _ptr_comment;
 566         TALLOC_CTX *_mem_save_comment_0;
 567         uint32_t _ptr_stores;
 568         uint32_t cntr_stores_1;
 569         TALLOC_CTX *_mem_save_stores_0;
 570         TALLOC_CTX *_mem_save_stores_1;
 571         if (ndr_flags & NDR_SCALARS) {
 572                 NDR_CHECK(ndr_pull_align(ndr, 4));
 573                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_path));
 574                 if (_ptr_path) {
 575                         NDR_PULL_ALLOC(ndr, r->path);
 576                 } else {
 577                         r->path = NULL;
 578                 }
 579                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
 580                 if (_ptr_comment) {
 581                         NDR_PULL_ALLOC(ndr, r->comment);
 582                 } else {
 583                         r->comment = NULL;
 584                 }
 585                 NDR_CHECK(ndr_pull_dfs_VolumeState(ndr, NDR_SCALARS, &r->state));
 586                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->timeout));
 587                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
 588                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_stores));
 589                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_stores));
 590                 if (_ptr_stores) {
 591                         NDR_PULL_ALLOC(ndr, r->stores);
 592                 } else {
 593                         r->stores = NULL;
 594                 }
 595         }
 596         if (ndr_flags & NDR_BUFFERS) {
 597                 if (r->path) {
 598                         _mem_save_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
 599                         NDR_PULL_SET_MEM_CTX(ndr, r->path, 0);
 600                         NDR_CHECK(ndr_pull_array_size(ndr, &r->path));
 601                         NDR_CHECK(ndr_pull_array_length(ndr, &r->path));
 602                         if (ndr_get_array_length(ndr, &r->path) > ndr_get_array_size(ndr, &r->path)) {
 603                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->path), ndr_get_array_length(ndr, &r->path));
 604                         }
 605                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->path), sizeof(uint16_t)));
 606                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->path, ndr_get_array_length(ndr, &r->path), sizeof(uint16_t), CH_UTF16));
 607                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_path_0, 0);
 608                 }
 609                 if (r->comment) {
 610                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
 611                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
 612                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
 613                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
 614                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
 615                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
 616                         }
 617                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
 618                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
 619                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
 620                 }
 621                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_BUFFERS, &r->guid));
 622                 if (r->stores) {
 623                         _mem_save_stores_0 = NDR_PULL_GET_MEM_CTX(ndr);
 624                         NDR_PULL_SET_MEM_CTX(ndr, r->stores, 0);
 625                         NDR_CHECK(ndr_pull_array_size(ndr, &r->stores));
 626                         NDR_PULL_ALLOC_N(ndr, r->stores, ndr_get_array_size(ndr, &r->stores));
 627                         _mem_save_stores_1 = NDR_PULL_GET_MEM_CTX(ndr);
 628                         NDR_PULL_SET_MEM_CTX(ndr, r->stores, 0);
 629                         for (cntr_stores_1 = 0; cntr_stores_1 < r->num_stores; cntr_stores_1++) {
 630                                 NDR_CHECK(ndr_pull_dfs_StorageInfo(ndr, NDR_SCALARS, &r->stores[cntr_stores_1]));
 631                         }
 632                         for (cntr_stores_1 = 0; cntr_stores_1 < r->num_stores; cntr_stores_1++) {
 633                                 NDR_CHECK(ndr_pull_dfs_StorageInfo(ndr, NDR_BUFFERS, &r->stores[cntr_stores_1]));
 634                         }
 635                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_stores_1, 0);
 636                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_stores_0, 0);
 637                 }
 638                 if (r->stores) {
 639                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->stores, r->num_stores));
 640                 }
 641         }
 642         return NT_STATUS_OK;
 643 }
 644
 645 _PUBLIC_ void ndr_print_dfs_Info4(struct ndr_print *ndr, const char *name, const struct dfs_Info4 *r)
 646 {
 647         uint32_t cntr_stores_1;
 648         ndr_print_struct(ndr, name, "dfs_Info4");
 649         ndr->depth++;
 650         ndr_print_ptr(ndr, "path", r->path);
 651         ndr->depth++;
 652         if (r->path) {
 653                 ndr_print_string(ndr, "path", r->path);
 654         }
 655         ndr->depth--;
 656         ndr_print_ptr(ndr, "comment", r->comment);
 657         ndr->depth++;
 658         if (r->comment) {
 659                 ndr_print_string(ndr, "comment", r->comment);
 660         }
 661         ndr->depth--;
 662         ndr_print_dfs_VolumeState(ndr, "state", r->state);
 663         ndr_print_uint32(ndr, "timeout", r->timeout);
 664         ndr_print_GUID(ndr, "guid", &r->guid);
 665         ndr_print_uint32(ndr, "num_stores", r->num_stores);
 666         ndr_print_ptr(ndr, "stores", r->stores);
 667         ndr->depth++;
 668         if (r->stores) {
 669                 ndr->print(ndr, "%s: ARRAY(%d)", "stores", r->num_stores);
 670                 ndr->depth++;
 671                 for (cntr_stores_1=0;cntr_stores_1<r->num_stores;cntr_stores_1++) {
 672                         char *idx_1=NULL;
 673                         asprintf(&idx_1, "[%d]", cntr_stores_1);
 674                         if (idx_1) {
 675                                 ndr_print_dfs_StorageInfo(ndr, "stores", &r->stores[cntr_stores_1]);
 676                                 free(idx_1);
 677                         }
 678                 }
 679                 ndr->depth--;
 680         }
 681         ndr->depth--;
 682         ndr->depth--;
 683 }
 684
 685 _PUBLIC_ NTSTATUS ndr_push_dfs_PropertyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 686 {
 687         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 688         return NT_STATUS_OK;
 689 }
 690
 691 _PUBLIC_ NTSTATUS ndr_pull_dfs_PropertyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 692 {
 693         uint32_t v;
 694         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 695         *r = v;
 696         return NT_STATUS_OK;
 697 }
 698
 699 _PUBLIC_ void ndr_print_dfs_PropertyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
 700 {
 701         ndr_print_uint32(ndr, name, r);
 702         ndr->depth++;
 703         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DFS_PROPERTY_FLAG_INSITE_REFERRALS", DFS_PROPERTY_FLAG_INSITE_REFERRALS, r);
 704         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DFS_PROPERTY_FLAG_ROOT_SCALABILITY", DFS_PROPERTY_FLAG_ROOT_SCALABILITY, r);
 705         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DFS_PROPERTY_FLAG_SITE_COSTING", DFS_PROPERTY_FLAG_SITE_COSTING, r);
 706         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DFS_PROPERTY_FLAG_TARGET_FAILBACK", DFS_PROPERTY_FLAG_TARGET_FAILBACK, r);
 707         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DFS_PROPERTY_FLAG_CLUSTER_ENABLED", DFS_PROPERTY_FLAG_CLUSTER_ENABLED, r);
 708         ndr->depth--;
 709 }
 710
 711 NTSTATUS ndr_push_dfs_Info5(struct ndr_push *ndr, int ndr_flags, const struct dfs_Info5 *r)
 712 {
 713         if (ndr_flags & NDR_SCALARS) {
 714                 NDR_CHECK(ndr_push_align(ndr, 4));
 715                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->path));
 716                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
 717                 NDR_CHECK(ndr_push_dfs_VolumeState(ndr, NDR_SCALARS, r->state));
 718                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->timeout));
 719                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
 720                 NDR_CHECK(ndr_push_dfs_PropertyFlags(ndr, NDR_SCALARS, r->flags));
 721                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pktsize));
 722                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_stores));
 723         }
 724         if (ndr_flags & NDR_BUFFERS) {
 725                 if (r->path) {
 726                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));
 727                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 728                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));
 729                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->path, ndr_charset_length(r->path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 730                 }
 731                 if (r->comment) {
 732                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
 733                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 734                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
 735                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 736                 }
 737                 NDR_CHECK(ndr_push_GUID(ndr, NDR_BUFFERS, &r->guid));
 738         }
 739         return NT_STATUS_OK;
 740 }
 741
 742 NTSTATUS ndr_pull_dfs_Info5(struct ndr_pull *ndr, int ndr_flags, struct dfs_Info5 *r)
 743 {
 744         uint32_t _ptr_path;
 745         TALLOC_CTX *_mem_save_path_0;
 746         uint32_t _ptr_comment;
 747         TALLOC_CTX *_mem_save_comment_0;
 748         if (ndr_flags & NDR_SCALARS) {
 749                 NDR_CHECK(ndr_pull_align(ndr, 4));
 750                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_path));
 751                 if (_ptr_path) {
 752                         NDR_PULL_ALLOC(ndr, r->path);
 753                 } else {
 754                         r->path = NULL;
 755                 }
 756                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
 757                 if (_ptr_comment) {
 758                         NDR_PULL_ALLOC(ndr, r->comment);
 759                 } else {
 760                         r->comment = NULL;
 761                 }
 762                 NDR_CHECK(ndr_pull_dfs_VolumeState(ndr, NDR_SCALARS, &r->state));
 763                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->timeout));
 764                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
 765                 NDR_CHECK(ndr_pull_dfs_PropertyFlags(ndr, NDR_SCALARS, &r->flags));
 766                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pktsize));
 767                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_stores));
 768         }
 769         if (ndr_flags & NDR_BUFFERS) {
 770                 if (r->path) {
 771                         _mem_save_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
 772                         NDR_PULL_SET_MEM_CTX(ndr, r->path, 0);
 773                         NDR_CHECK(ndr_pull_array_size(ndr, &r->path));
 774                         NDR_CHECK(ndr_pull_array_length(ndr, &r->path));
 775                         if (ndr_get_array_length(ndr, &r->path) > ndr_get_array_size(ndr, &r->path)) {
 776                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->path), ndr_get_array_length(ndr, &r->path));
 777                         }
 778                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->path), sizeof(uint16_t)));
 779                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->path, ndr_get_array_length(ndr, &r->path), sizeof(uint16_t), CH_UTF16));
 780                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_path_0, 0);
 781                 }
 782                 if (r->comment) {
 783                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
 784                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
 785                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
 786                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
 787                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
 788                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
 789                         }
 790                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
 791                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
 792                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
 793                 }
 794                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_BUFFERS, &r->guid));
 795         }
 796         return NT_STATUS_OK;
 797 }
 798
 799 _PUBLIC_ void ndr_print_dfs_Info5(struct ndr_print *ndr, const char *name, const struct dfs_Info5 *r)
 800 {
 801         ndr_print_struct(ndr, name, "dfs_Info5");
 802         ndr->depth++;
 803         ndr_print_ptr(ndr, "path", r->path);
 804         ndr->depth++;
 805         if (r->path) {
 806                 ndr_print_string(ndr, "path", r->path);
 807         }
 808         ndr->depth--;
 809         ndr_print_ptr(ndr, "comment", r->comment);
 810         ndr->depth++;
 811         if (r->comment) {
 812                 ndr_print_string(ndr, "comment", r->comment);
 813         }
 814         ndr->depth--;
 815         ndr_print_dfs_VolumeState(ndr, "state", r->state);
 816         ndr_print_uint32(ndr, "timeout", r->timeout);
 817         ndr_print_GUID(ndr, "guid", &r->guid);
 818         ndr_print_dfs_PropertyFlags(ndr, "flags", r->flags);
 819         ndr_print_uint32(ndr, "pktsize", r->pktsize);
 820         ndr_print_uint32(ndr, "num_stores", r->num_stores);
 821         ndr->depth--;
 822 }
 823
 824 NTSTATUS ndr_push_dfs_Target_PriorityClass(struct ndr_push *ndr, int ndr_flags, enum dfs_Target_PriorityClass r)
 825 {
 826         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 827         return NT_STATUS_OK;
 828 }
 829
 830 NTSTATUS ndr_pull_dfs_Target_PriorityClass(struct ndr_pull *ndr, int ndr_flags, enum dfs_Target_PriorityClass *r)
 831 {
 832         uint32_t v;
 833         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 834         *r = v;
 835         return NT_STATUS_OK;
 836 }
 837
 838 _PUBLIC_ void ndr_print_dfs_Target_PriorityClass(struct ndr_print *ndr, const char *name, enum dfs_Target_PriorityClass r)
 839 {
 840         const char *val = NULL;
 841
 842         switch (r) {
 843                 case DFS_INVALID_PRIORITY_CLASS: val = "DFS_INVALID_PRIORITY_CLASS"; break;
 844                 case DFS_SITE_COST_NORMAL_PRIORITY_CLASS: val = "DFS_SITE_COST_NORMAL_PRIORITY_CLASS"; break;
 845                 case DFS_GLOBAL_HIGH_PRIORITY_CLASS: val = "DFS_GLOBAL_HIGH_PRIORITY_CLASS"; break;
 846                 case DFS_SITE_COST_HIGH_PRIORITY_CLASS: val = "DFS_SITE_COST_HIGH_PRIORITY_CLASS"; break;
 847                 case DFS_SITE_COST_LOW_PRIORITY_CLASS: val = "DFS_SITE_COST_LOW_PRIORITY_CLASS"; break;
 848                 case DFS_GLOBAL_LOW_PRIORITY_CLASS: val = "DFS_GLOBAL_LOW_PRIORITY_CLASS"; break;
 849         }
 850         ndr_print_enum(ndr, name, "ENUM", val, r);
 851 }
 852
 853 NTSTATUS ndr_push_dfs_Target_Priority(struct ndr_push *ndr, int ndr_flags, const struct dfs_Target_Priority *r)
 854 {
 855         if (ndr_flags & NDR_SCALARS) {
 856                 NDR_CHECK(ndr_push_align(ndr, 4));
 857                 NDR_CHECK(ndr_push_dfs_Target_PriorityClass(ndr, NDR_SCALARS, r->target_priority_class));
 858                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->target_priority_rank));
 859                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->reserved));
 860         }
 861         if (ndr_flags & NDR_BUFFERS) {
 862         }
 863         return NT_STATUS_OK;
 864 }
 865
 866 NTSTATUS ndr_pull_dfs_Target_Priority(struct ndr_pull *ndr, int ndr_flags, struct dfs_Target_Priority *r)
 867 {
 868         if (ndr_flags & NDR_SCALARS) {
 869                 NDR_CHECK(ndr_pull_align(ndr, 4));
 870                 NDR_CHECK(ndr_pull_dfs_Target_PriorityClass(ndr, NDR_SCALARS, &r->target_priority_class));
 871                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->target_priority_rank));
 872                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reserved));
 873         }
 874         if (ndr_flags & NDR_BUFFERS) {
 875         }
 876         return NT_STATUS_OK;
 877 }
 878
 879 _PUBLIC_ void ndr_print_dfs_Target_Priority(struct ndr_print *ndr, const char *name, const struct dfs_Target_Priority *r)
 880 {
 881         ndr_print_struct(ndr, name, "dfs_Target_Priority");
 882         ndr->depth++;
 883         ndr_print_dfs_Target_PriorityClass(ndr, "target_priority_class", r->target_priority_class);
 884         ndr_print_uint16(ndr, "target_priority_rank", r->target_priority_rank);
 885         ndr_print_uint16(ndr, "reserved", r->reserved);
 886         ndr->depth--;
 887 }
 888
 889 NTSTATUS ndr_push_dfs_StorageInfo2(struct ndr_push *ndr, int ndr_flags, const struct dfs_StorageInfo2 *r)
 890 {
 891         if (ndr_flags & NDR_SCALARS) {
 892                 NDR_CHECK(ndr_push_align(ndr, 4));
 893                 NDR_CHECK(ndr_push_dfs_StorageInfo(ndr, NDR_SCALARS, &r->info));
 894                 NDR_CHECK(ndr_push_dfs_Target_Priority(ndr, NDR_SCALARS, &r->target_priority));
 895         }
 896         if (ndr_flags & NDR_BUFFERS) {
 897                 NDR_CHECK(ndr_push_dfs_StorageInfo(ndr, NDR_BUFFERS, &r->info));
 898         }
 899         return NT_STATUS_OK;
 900 }
 901
 902 NTSTATUS ndr_pull_dfs_StorageInfo2(struct ndr_pull *ndr, int ndr_flags, struct dfs_StorageInfo2 *r)
 903 {
 904         if (ndr_flags & NDR_SCALARS) {
 905                 NDR_CHECK(ndr_pull_align(ndr, 4));
 906                 NDR_CHECK(ndr_pull_dfs_StorageInfo(ndr, NDR_SCALARS, &r->info));
 907                 NDR_CHECK(ndr_pull_dfs_Target_Priority(ndr, NDR_SCALARS, &r->target_priority));
 908         }
 909         if (ndr_flags & NDR_BUFFERS) {
 910                 NDR_CHECK(ndr_pull_dfs_StorageInfo(ndr, NDR_BUFFERS, &r->info));
 911         }
 912         return NT_STATUS_OK;
 913 }
 914
 915 _PUBLIC_ void ndr_print_dfs_StorageInfo2(struct ndr_print *ndr, const char *name, const struct dfs_StorageInfo2 *r)
 916 {
 917         ndr_print_struct(ndr, name, "dfs_StorageInfo2");
 918         ndr->depth++;
 919         ndr_print_dfs_StorageInfo(ndr, "info", &r->info);
 920         ndr_print_dfs_Target_Priority(ndr, "target_priority", &r->target_priority);
 921         ndr->depth--;
 922 }
 923
 924 NTSTATUS ndr_push_dfs_Info6(struct ndr_push *ndr, int ndr_flags, const struct dfs_Info6 *r)
 925 {
 926         uint32_t cntr_stores_1;
 927         if (ndr_flags & NDR_SCALARS) {
 928                 NDR_CHECK(ndr_push_align(ndr, 4));
 929                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entry_path));
 930                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
 931                 NDR_CHECK(ndr_push_dfs_VolumeState(ndr, NDR_SCALARS, r->state));
 932                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->timeout));
 933                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
 934                 NDR_CHECK(ndr_push_dfs_PropertyFlags(ndr, NDR_SCALARS, r->flags));
 935                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pktsize));
 936                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_stores));
 937                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->stores));
 938         }
 939         if (ndr_flags & NDR_BUFFERS) {
 940                 if (r->entry_path) {
 941                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->entry_path, CH_UTF16)));
 942                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 943                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->entry_path, CH_UTF16)));
 944                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->entry_path, ndr_charset_length(r->entry_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 945                 }
 946                 if (r->comment) {
 947                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
 948                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 949                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
 950                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 951                 }
 952                 NDR_CHECK(ndr_push_GUID(ndr, NDR_BUFFERS, &r->guid));
 953                 if (r->stores) {
 954                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_stores));
 955                         for (cntr_stores_1 = 0; cntr_stores_1 < r->num_stores; cntr_stores_1++) {
 956                                 NDR_CHECK(ndr_push_dfs_StorageInfo2(ndr, NDR_SCALARS, &r->stores[cntr_stores_1]));
 957                         }
 958                         for (cntr_stores_1 = 0; cntr_stores_1 < r->num_stores; cntr_stores_1++) {
 959                                 NDR_CHECK(ndr_push_dfs_StorageInfo2(ndr, NDR_BUFFERS, &r->stores[cntr_stores_1]));
 960                         }
 961                 }
 962         }
 963         return NT_STATUS_OK;
 964 }
 965
 966 NTSTATUS ndr_pull_dfs_Info6(struct ndr_pull *ndr, int ndr_flags, struct dfs_Info6 *r)
 967 {
 968         uint32_t _ptr_entry_path;
 969         TALLOC_CTX *_mem_save_entry_path_0;
 970         uint32_t _ptr_comment;
 971         TALLOC_CTX *_mem_save_comment_0;
 972         uint32_t _ptr_stores;
 973         uint32_t cntr_stores_1;
 974         TALLOC_CTX *_mem_save_stores_0;
 975         TALLOC_CTX *_mem_save_stores_1;
 976         if (ndr_flags & NDR_SCALARS) {
 977                 NDR_CHECK(ndr_pull_align(ndr, 4));
 978                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entry_path));
 979                 if (_ptr_entry_path) {
 980                         NDR_PULL_ALLOC(ndr, r->entry_path);
 981                 } else {
 982                         r->entry_path = NULL;
 983                 }
 984                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
 985                 if (_ptr_comment) {
 986                         NDR_PULL_ALLOC(ndr, r->comment);
 987                 } else {
 988                         r->comment = NULL;
 989                 }
 990                 NDR_CHECK(ndr_pull_dfs_VolumeState(ndr, NDR_SCALARS, &r->state));
 991                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->timeout));
 992                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
 993                 NDR_CHECK(ndr_pull_dfs_PropertyFlags(ndr, NDR_SCALARS, &r->flags));
 994                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pktsize));
 995                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_stores));
 996                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_stores));
 997                 if (_ptr_stores) {
 998                         NDR_PULL_ALLOC(ndr, r->stores);
 999                 } else {
1000                         r->stores = NULL;
1001                 }
1002         }
1003         if (ndr_flags & NDR_BUFFERS) {
1004                 if (r->entry_path) {
1005                         _mem_save_entry_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
1006                         NDR_PULL_SET_MEM_CTX(ndr, r->entry_path, 0);
1007                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entry_path));
1008                         NDR_CHECK(ndr_pull_array_length(ndr, &r->entry_path));
1009                         if (ndr_get_array_length(ndr, &r->entry_path) > ndr_get_array_size(ndr, &r->entry_path)) {
1010                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->entry_path), ndr_get_array_length(ndr, &r->entry_path));
1011                         }
1012                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->entry_path), sizeof(uint16_t)));
1013                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->entry_path, ndr_get_array_length(ndr, &r->entry_path), sizeof(uint16_t), CH_UTF16));
1014                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entry_path_0, 0);
1015                 }
1016                 if (r->comment) {
1017                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1018                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1019                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
1020                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
1021                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
1022                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
1023                         }
1024                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
1025                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
1026                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1027                 }
1028                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_BUFFERS, &r->guid));
1029                 if (r->stores) {
1030                         _mem_save_stores_0 = NDR_PULL_GET_MEM_CTX(ndr);
1031                         NDR_PULL_SET_MEM_CTX(ndr, r->stores, 0);
1032                         NDR_CHECK(ndr_pull_array_size(ndr, &r->stores));
1033                         NDR_PULL_ALLOC_N(ndr, r->stores, ndr_get_array_size(ndr, &r->stores));
1034                         _mem_save_stores_1 = NDR_PULL_GET_MEM_CTX(ndr);
1035                         NDR_PULL_SET_MEM_CTX(ndr, r->stores, 0);
1036                         for (cntr_stores_1 = 0; cntr_stores_1 < r->num_stores; cntr_stores_1++) {
1037                                 NDR_CHECK(ndr_pull_dfs_StorageInfo2(ndr, NDR_SCALARS, &r->stores[cntr_stores_1]));
1038                         }
1039                         for (cntr_stores_1 = 0; cntr_stores_1 < r->num_stores; cntr_stores_1++) {
1040                                 NDR_CHECK(ndr_pull_dfs_StorageInfo2(ndr, NDR_BUFFERS, &r->stores[cntr_stores_1]));
1041                         }
1042                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_stores_1, 0);
1043                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_stores_0, 0);
1044                 }
1045                 if (r->stores) {
1046                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->stores, r->num_stores));
1047                 }
1048         }
1049         return NT_STATUS_OK;
1050 }
1051
1052 _PUBLIC_ void ndr_print_dfs_Info6(struct ndr_print *ndr, const char *name, const struct dfs_Info6 *r)
1053 {
1054         uint32_t cntr_stores_1;
1055         ndr_print_struct(ndr, name, "dfs_Info6");
1056         ndr->depth++;
1057         ndr_print_ptr(ndr, "entry_path", r->entry_path);
1058         ndr->depth++;
1059         if (r->entry_path) {
1060                 ndr_print_string(ndr, "entry_path", r->entry_path);
1061         }
1062         ndr->depth--;
1063         ndr_print_ptr(ndr, "comment", r->comment);
1064         ndr->depth++;
1065         if (r->comment) {
1066                 ndr_print_string(ndr, "comment", r->comment);
1067         }
1068         ndr->depth--;
1069         ndr_print_dfs_VolumeState(ndr, "state", r->state);
1070         ndr_print_uint32(ndr, "timeout", r->timeout);
1071         ndr_print_GUID(ndr, "guid", &r->guid);
1072         ndr_print_dfs_PropertyFlags(ndr, "flags", r->flags);
1073         ndr_print_uint32(ndr, "pktsize", r->pktsize);
1074         ndr_print_uint16(ndr, "num_stores", r->num_stores);
1075         ndr_print_ptr(ndr, "stores", r->stores);
1076         ndr->depth++;
1077         if (r->stores) {
1078                 ndr->print(ndr, "%s: ARRAY(%d)", "stores", r->num_stores);
1079                 ndr->depth++;
1080                 for (cntr_stores_1=0;cntr_stores_1<r->num_stores;cntr_stores_1++) {
1081                         char *idx_1=NULL;
1082                         asprintf(&idx_1, "[%d]", cntr_stores_1);
1083                         if (idx_1) {
1084                                 ndr_print_dfs_StorageInfo2(ndr, "stores", &r->stores[cntr_stores_1]);
1085                                 free(idx_1);
1086                         }
1087                 }
1088                 ndr->depth--;
1089         }
1090         ndr->depth--;
1091         ndr->depth--;
1092 }
1093
1094 NTSTATUS ndr_push_dfs_Info7(struct ndr_push *ndr, int ndr_flags, const struct dfs_Info7 *r)
1095 {
1096         if (ndr_flags & NDR_SCALARS) {
1097                 NDR_CHECK(ndr_push_align(ndr, 4));
1098                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->generation_guid));
1099         }
1100         if (ndr_flags & NDR_BUFFERS) {
1101                 NDR_CHECK(ndr_push_GUID(ndr, NDR_BUFFERS, &r->generation_guid));
1102         }
1103         return NT_STATUS_OK;
1104 }
1105
1106 NTSTATUS ndr_pull_dfs_Info7(struct ndr_pull *ndr, int ndr_flags, struct dfs_Info7 *r)
1107 {
1108         if (ndr_flags & NDR_SCALARS) {
1109                 NDR_CHECK(ndr_pull_align(ndr, 4));
1110                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->generation_guid));
1111         }
1112         if (ndr_flags & NDR_BUFFERS) {
1113                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_BUFFERS, &r->generation_guid));
1114         }
1115         return NT_STATUS_OK;
1116 }
1117
1118 _PUBLIC_ void ndr_print_dfs_Info7(struct ndr_print *ndr, const char *name, const struct dfs_Info7 *r)
1119 {
1120         ndr_print_struct(ndr, name, "dfs_Info7");
1121         ndr->depth++;
1122         ndr_print_GUID(ndr, "generation_guid", &r->generation_guid);
1123         ndr->depth--;
1124 }
1125
1126 NTSTATUS ndr_push_dfs_Info100(struct ndr_push *ndr, int ndr_flags, const struct dfs_Info100 *r)
1127 {
1128         if (ndr_flags & NDR_SCALARS) {
1129                 NDR_CHECK(ndr_push_align(ndr, 4));
1130                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
1131         }
1132         if (ndr_flags & NDR_BUFFERS) {
1133                 if (r->comment) {
1134                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
1135                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1136                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
1137                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
1138                 }
1139         }
1140         return NT_STATUS_OK;
1141 }
1142
1143 NTSTATUS ndr_pull_dfs_Info100(struct ndr_pull *ndr, int ndr_flags, struct dfs_Info100 *r)
1144 {
1145         uint32_t _ptr_comment;
1146         TALLOC_CTX *_mem_save_comment_0;
1147         if (ndr_flags & NDR_SCALARS) {
1148                 NDR_CHECK(ndr_pull_align(ndr, 4));
1149                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1150                 if (_ptr_comment) {
1151                         NDR_PULL_ALLOC(ndr, r->comment);
1152                 } else {
1153                         r->comment = NULL;
1154                 }
1155         }
1156         if (ndr_flags & NDR_BUFFERS) {
1157                 if (r->comment) {
1158                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1159                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1160                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
1161                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
1162                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
1163                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
1164                         }
1165                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
1166                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
1167                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1168                 }
1169         }
1170         return NT_STATUS_OK;
1171 }
1172
1173 _PUBLIC_ void ndr_print_dfs_Info100(struct ndr_print *ndr, const char *name, const struct dfs_Info100 *r)
1174 {
1175         ndr_print_struct(ndr, name, "dfs_Info100");
1176         ndr->depth++;
1177         ndr_print_ptr(ndr, "comment", r->comment);
1178         ndr->depth++;
1179         if (r->comment) {
1180                 ndr_print_string(ndr, "comment", r->comment);
1181         }
1182         ndr->depth--;
1183         ndr->depth--;
1184 }
1185
1186 NTSTATUS ndr_push_dfs_Info101(struct ndr_push *ndr, int ndr_flags, const struct dfs_Info101 *r)
1187 {
1188         if (ndr_flags & NDR_SCALARS) {
1189                 NDR_CHECK(ndr_push_align(ndr, 4));
1190                 NDR_CHECK(ndr_push_dfs_StorageState(ndr, NDR_SCALARS, r->state));
1191         }
1192         if (ndr_flags & NDR_BUFFERS) {
1193         }
1194         return NT_STATUS_OK;
1195 }
1196
1197 NTSTATUS ndr_pull_dfs_Info101(struct ndr_pull *ndr, int ndr_flags, struct dfs_Info101 *r)
1198 {
1199         if (ndr_flags & NDR_SCALARS) {
1200                 NDR_CHECK(ndr_pull_align(ndr, 4));
1201                 NDR_CHECK(ndr_pull_dfs_StorageState(ndr, NDR_SCALARS, &r->state));
1202         }
1203         if (ndr_flags & NDR_BUFFERS) {
1204         }
1205         return NT_STATUS_OK;
1206 }
1207
1208 _PUBLIC_ void ndr_print_dfs_Info101(struct ndr_print *ndr, const char *name, const struct dfs_Info101 *r)
1209 {
1210         ndr_print_struct(ndr, name, "dfs_Info101");
1211         ndr->depth++;
1212         ndr_print_dfs_StorageState(ndr, "state", r->state);
1213         ndr->depth--;
1214 }
1215
1216 NTSTATUS ndr_push_dfs_Info102(struct ndr_push *ndr, int ndr_flags, const struct dfs_Info102 *r)
1217 {
1218         if (ndr_flags & NDR_SCALARS) {
1219                 NDR_CHECK(ndr_push_align(ndr, 4));
1220                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->timeout));
1221         }
1222         if (ndr_flags & NDR_BUFFERS) {
1223         }
1224         return NT_STATUS_OK;
1225 }
1226
1227 NTSTATUS ndr_pull_dfs_Info102(struct ndr_pull *ndr, int ndr_flags, struct dfs_Info102 *r)
1228 {
1229         if (ndr_flags & NDR_SCALARS) {
1230                 NDR_CHECK(ndr_pull_align(ndr, 4));
1231                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->timeout));
1232         }
1233         if (ndr_flags & NDR_BUFFERS) {
1234         }
1235         return NT_STATUS_OK;
1236 }
1237
1238 _PUBLIC_ void ndr_print_dfs_Info102(struct ndr_print *ndr, const char *name, const struct dfs_Info102 *r)
1239 {
1240         ndr_print_struct(ndr, name, "dfs_Info102");
1241         ndr->depth++;
1242         ndr_print_uint32(ndr, "timeout", r->timeout);
1243         ndr->depth--;
1244 }
1245
1246 NTSTATUS ndr_push_dfs_Info103(struct ndr_push *ndr, int ndr_flags, const struct dfs_Info103 *r)
1247 {
1248         if (ndr_flags & NDR_SCALARS) {
1249                 NDR_CHECK(ndr_push_align(ndr, 4));
1250                 NDR_CHECK(ndr_push_dfs_PropertyFlags(ndr, NDR_SCALARS, r->flags));
1251         }
1252         if (ndr_flags & NDR_BUFFERS) {
1253         }
1254         return NT_STATUS_OK;
1255 }
1256
1257 NTSTATUS ndr_pull_dfs_Info103(struct ndr_pull *ndr, int ndr_flags, struct dfs_Info103 *r)
1258 {
1259         if (ndr_flags & NDR_SCALARS) {
1260                 NDR_CHECK(ndr_pull_align(ndr, 4));
1261                 NDR_CHECK(ndr_pull_dfs_PropertyFlags(ndr, NDR_SCALARS, &r->flags));
1262         }
1263         if (ndr_flags & NDR_BUFFERS) {
1264         }
1265         return NT_STATUS_OK;
1266 }
1267
1268 _PUBLIC_ void ndr_print_dfs_Info103(struct ndr_print *ndr, const char *name, const struct dfs_Info103 *r)
1269 {
1270         ndr_print_struct(ndr, name, "dfs_Info103");
1271         ndr->depth++;
1272         ndr_print_dfs_PropertyFlags(ndr, "flags", r->flags);
1273         ndr->depth--;
1274 }
1275
1276 NTSTATUS ndr_push_dfs_Info104(struct ndr_push *ndr, int ndr_flags, const struct dfs_Info104 *r)
1277 {
1278         if (ndr_flags & NDR_SCALARS) {
1279                 NDR_CHECK(ndr_push_align(ndr, 4));
1280                 NDR_CHECK(ndr_push_dfs_Target_Priority(ndr, NDR_SCALARS, &r->priority));
1281         }
1282         if (ndr_flags & NDR_BUFFERS) {
1283         }
1284         return NT_STATUS_OK;
1285 }
1286
1287 NTSTATUS ndr_pull_dfs_Info104(struct ndr_pull *ndr, int ndr_flags, struct dfs_Info104 *r)
1288 {
1289         if (ndr_flags & NDR_SCALARS) {
1290                 NDR_CHECK(ndr_pull_align(ndr, 4));
1291                 NDR_CHECK(ndr_pull_dfs_Target_Priority(ndr, NDR_SCALARS, &r->priority));
1292         }
1293         if (ndr_flags & NDR_BUFFERS) {
1294         }
1295         return NT_STATUS_OK;
1296 }
1297
1298 _PUBLIC_ void ndr_print_dfs_Info104(struct ndr_print *ndr, const char *name, const struct dfs_Info104 *r)
1299 {
1300         ndr_print_struct(ndr, name, "dfs_Info104");
1301         ndr->depth++;
1302         ndr_print_dfs_Target_Priority(ndr, "priority", &r->priority);
1303         ndr->depth--;
1304 }
1305
1306 NTSTATUS ndr_push_dfs_Info105(struct ndr_push *ndr, int ndr_flags, const struct dfs_Info105 *r)
1307 {
1308         if (ndr_flags & NDR_SCALARS) {
1309                 NDR_CHECK(ndr_push_align(ndr, 4));
1310                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
1311                 NDR_CHECK(ndr_push_dfs_VolumeState(ndr, NDR_SCALARS, r->state));
1312                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->timeout));
1313                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->property_flag_mask));
1314                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->property_flags));
1315         }
1316         if (ndr_flags & NDR_BUFFERS) {
1317                 if (r->comment) {
1318                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
1319                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1320                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
1321                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
1322                 }
1323         }
1324         return NT_STATUS_OK;
1325 }
1326
1327 NTSTATUS ndr_pull_dfs_Info105(struct ndr_pull *ndr, int ndr_flags, struct dfs_Info105 *r)
1328 {
1329         uint32_t _ptr_comment;
1330         TALLOC_CTX *_mem_save_comment_0;
1331         if (ndr_flags & NDR_SCALARS) {
1332                 NDR_CHECK(ndr_pull_align(ndr, 4));
1333                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1334                 if (_ptr_comment) {
1335                         NDR_PULL_ALLOC(ndr, r->comment);
1336                 } else {
1337                         r->comment = NULL;
1338                 }
1339                 NDR_CHECK(ndr_pull_dfs_VolumeState(ndr, NDR_SCALARS, &r->state));
1340                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->timeout));
1341                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->property_flag_mask));
1342                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->property_flags));
1343         }
1344         if (ndr_flags & NDR_BUFFERS) {
1345                 if (r->comment) {
1346                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1347                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1348                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
1349                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
1350                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
1351                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
1352                         }
1353                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
1354                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
1355                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1356                 }
1357         }
1358         return NT_STATUS_OK;
1359 }
1360
1361 _PUBLIC_ void ndr_print_dfs_Info105(struct ndr_print *ndr, const char *name, const struct dfs_Info105 *r)
1362 {
1363         ndr_print_struct(ndr, name, "dfs_Info105");
1364         ndr->depth++;
1365         ndr_print_ptr(ndr, "comment", r->comment);
1366         ndr->depth++;
1367         if (r->comment) {
1368                 ndr_print_string(ndr, "comment", r->comment);
1369         }
1370         ndr->depth--;
1371         ndr_print_dfs_VolumeState(ndr, "state", r->state);
1372         ndr_print_uint32(ndr, "timeout", r->timeout);
1373         ndr_print_uint32(ndr, "property_flag_mask", r->property_flag_mask);
1374         ndr_print_uint32(ndr, "property_flags", r->property_flags);
1375         ndr->depth--;
1376 }
1377
1378 NTSTATUS ndr_push_dfs_Info106(struct ndr_push *ndr, int ndr_flags, const struct dfs_Info106 *r)
1379 {
1380         if (ndr_flags & NDR_SCALARS) {
1381                 NDR_CHECK(ndr_push_align(ndr, 4));
1382                 NDR_CHECK(ndr_push_dfs_StorageState(ndr, NDR_SCALARS, r->state));
1383                 NDR_CHECK(ndr_push_dfs_Target_Priority(ndr, NDR_SCALARS, &r->priority));
1384         }
1385         if (ndr_flags & NDR_BUFFERS) {
1386         }
1387         return NT_STATUS_OK;
1388 }
1389
1390 NTSTATUS ndr_pull_dfs_Info106(struct ndr_pull *ndr, int ndr_flags, struct dfs_Info106 *r)
1391 {
1392         if (ndr_flags & NDR_SCALARS) {
1393                 NDR_CHECK(ndr_pull_align(ndr, 4));
1394                 NDR_CHECK(ndr_pull_dfs_StorageState(ndr, NDR_SCALARS, &r->state));
1395                 NDR_CHECK(ndr_pull_dfs_Target_Priority(ndr, NDR_SCALARS, &r->priority));
1396         }
1397         if (ndr_flags & NDR_BUFFERS) {
1398         }
1399         return NT_STATUS_OK;
1400 }
1401
1402 _PUBLIC_ void ndr_print_dfs_Info106(struct ndr_print *ndr, const char *name, const struct dfs_Info106 *r)
1403 {
1404         ndr_print_struct(ndr, name, "dfs_Info106");
1405         ndr->depth++;
1406         ndr_print_dfs_StorageState(ndr, "state", r->state);
1407         ndr_print_dfs_Target_Priority(ndr, "priority", &r->priority);
1408         ndr->depth--;
1409 }
1410
1411 NTSTATUS ndr_push_dfs_Info200(struct ndr_push *ndr, int ndr_flags, const struct dfs_Info200 *r)
1412 {
1413         if (ndr_flags & NDR_SCALARS) {
1414                 NDR_CHECK(ndr_push_align(ndr, 4));
1415                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dom_root));
1416         }
1417         if (ndr_flags & NDR_BUFFERS) {
1418                 if (r->dom_root) {
1419                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dom_root, CH_UTF16)));
1420                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1421                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dom_root, CH_UTF16)));
1422                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dom_root, ndr_charset_length(r->dom_root, CH_UTF16), sizeof(uint16_t), CH_UTF16));
1423                 }
1424         }
1425         return NT_STATUS_OK;
1426 }
1427
1428 NTSTATUS ndr_pull_dfs_Info200(struct ndr_pull *ndr, int ndr_flags, struct dfs_Info200 *r)
1429 {
1430         uint32_t _ptr_dom_root;
1431         TALLOC_CTX *_mem_save_dom_root_0;
1432         if (ndr_flags & NDR_SCALARS) {
1433                 NDR_CHECK(ndr_pull_align(ndr, 4));
1434                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dom_root));
1435                 if (_ptr_dom_root) {
1436                         NDR_PULL_ALLOC(ndr, r->dom_root);
1437                 } else {
1438                         r->dom_root = NULL;
1439                 }
1440         }
1441         if (ndr_flags & NDR_BUFFERS) {
1442                 if (r->dom_root) {
1443                         _mem_save_dom_root_0 = NDR_PULL_GET_MEM_CTX(ndr);
1444                         NDR_PULL_SET_MEM_CTX(ndr, r->dom_root, 0);
1445                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dom_root));
1446                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dom_root));
1447                         if (ndr_get_array_length(ndr, &r->dom_root) > ndr_get_array_size(ndr, &r->dom_root)) {
1448                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->dom_root), ndr_get_array_length(ndr, &r->dom_root));
1449                         }
1450                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dom_root), sizeof(uint16_t)));
1451                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dom_root, ndr_get_array_length(ndr, &r->dom_root), sizeof(uint16_t), CH_UTF16));
1452                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dom_root_0, 0);
1453                 }
1454         }
1455         return NT_STATUS_OK;
1456 }
1457
1458 _PUBLIC_ void ndr_print_dfs_Info200(struct ndr_print *ndr, const char *name, const struct dfs_Info200 *r)
1459 {
1460         ndr_print_struct(ndr, name, "dfs_Info200");
1461         ndr->depth++;
1462         ndr_print_ptr(ndr, "dom_root", r->dom_root);
1463         ndr->depth++;
1464         if (r->dom_root) {
1465                 ndr_print_string(ndr, "dom_root", r->dom_root);
1466         }
1467         ndr->depth--;
1468         ndr->depth--;
1469 }
1470
1471 NTSTATUS ndr_push_dfs_VolumeFlavor(struct ndr_push *ndr, int ndr_flags, enum dfs_VolumeFlavor r)
1472 {
1473         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
1474         return NT_STATUS_OK;
1475 }
1476
1477 NTSTATUS ndr_pull_dfs_VolumeFlavor(struct ndr_pull *ndr, int ndr_flags, enum dfs_VolumeFlavor *r)
1478 {
1479         uint16_t v;
1480         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
1481         *r = v;
1482         return NT_STATUS_OK;
1483 }
1484
1485 _PUBLIC_ void ndr_print_dfs_VolumeFlavor(struct ndr_print *ndr, const char *name, enum dfs_VolumeFlavor r)
1486 {
1487         const char *val = NULL;
1488
1489         switch (r) {
1490                 case DFS_VOLUME_FLAVOR_STANDALONE: val = "DFS_VOLUME_FLAVOR_STANDALONE"; break;
1491                 case DFS_VOLUME_FLAVOR_AD_BLOB: val = "DFS_VOLUME_FLAVOR_AD_BLOB"; break;
1492         }
1493         ndr_print_enum(ndr, name, "ENUM", val, r);
1494 }
1495
1496 NTSTATUS ndr_push_dfs_Info300(struct ndr_push *ndr, int ndr_flags, const struct dfs_Info300 *r)
1497 {
1498         if (ndr_flags & NDR_SCALARS) {
1499                 NDR_CHECK(ndr_push_align(ndr, 4));
1500                 NDR_CHECK(ndr_push_dfs_VolumeFlavor(ndr, NDR_SCALARS, r->flavor));
1501                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dom_root));
1502         }
1503         if (ndr_flags & NDR_BUFFERS) {
1504                 if (r->dom_root) {
1505                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dom_root, CH_UTF16)));
1506                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1507                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dom_root, CH_UTF16)));
1508                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dom_root, ndr_charset_length(r->dom_root, CH_UTF16), sizeof(uint16_t), CH_UTF16));
1509                 }
1510         }
1511         return NT_STATUS_OK;
1512 }
1513
1514 NTSTATUS ndr_pull_dfs_Info300(struct ndr_pull *ndr, int ndr_flags, struct dfs_Info300 *r)
1515 {
1516         uint32_t _ptr_dom_root;
1517         TALLOC_CTX *_mem_save_dom_root_0;
1518         if (ndr_flags & NDR_SCALARS) {
1519                 NDR_CHECK(ndr_pull_align(ndr, 4));
1520                 NDR_CHECK(ndr_pull_dfs_VolumeFlavor(ndr, NDR_SCALARS, &r->flavor));
1521                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dom_root));
1522                 if (_ptr_dom_root) {
1523                         NDR_PULL_ALLOC(ndr, r->dom_root);
1524                 } else {
1525                         r->dom_root = NULL;
1526                 }
1527         }
1528         if (ndr_flags & NDR_BUFFERS) {
1529                 if (r->dom_root) {
1530                         _mem_save_dom_root_0 = NDR_PULL_GET_MEM_CTX(ndr);
1531                         NDR_PULL_SET_MEM_CTX(ndr, r->dom_root, 0);
1532                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dom_root));
1533                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dom_root));
1534                         if (ndr_get_array_length(ndr, &r->dom_root) > ndr_get_array_size(ndr, &r->dom_root)) {
1535                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->dom_root), ndr_get_array_length(ndr, &r->dom_root));
1536                         }
1537                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dom_root), sizeof(uint16_t)));
1538                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dom_root, ndr_get_array_length(ndr, &r->dom_root), sizeof(uint16_t), CH_UTF16));
1539                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dom_root_0, 0);
1540                 }
1541         }
1542         return NT_STATUS_OK;
1543 }
1544
1545 _PUBLIC_ void ndr_print_dfs_Info300(struct ndr_print *ndr, const char *name, const struct dfs_Info300 *r)
1546 {
1547         ndr_print_struct(ndr, name, "dfs_Info300");
1548         ndr->depth++;
1549         ndr_print_dfs_VolumeFlavor(ndr, "flavor", r->flavor);
1550         ndr_print_ptr(ndr, "dom_root", r->dom_root);
1551         ndr->depth++;
1552         if (r->dom_root) {
1553                 ndr_print_string(ndr, "dom_root", r->dom_root);
1554         }
1555         ndr->depth--;
1556         ndr->depth--;
1557 }
1558
1559 NTSTATUS ndr_push_dfs_Info(struct ndr_push *ndr, int ndr_flags, const union dfs_Info *r)
1560 {
1561         if (ndr_flags & NDR_SCALARS) {
1562                 int level = ndr_push_get_switch_value(ndr, r);
1563                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
1564                 switch (level) {
1565                         case 0:
1566                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
1567                         break;
1568
1569                         case 1:
1570                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
1571                         break;
1572
1573                         case 2:
1574                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
1575                         break;
1576
1577                         case 3:
1578                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
1579                         break;
1580
1581                         case 4:
1582                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
1583                         break;
1584
1585                         case 5:
1586                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
1587                         break;
1588
1589                         case 6:
1590                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
1591                         break;
1592
1593                         case 7:
1594                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
1595                         break;
1596
1597                         case 100:
1598                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info100));
1599                         break;
1600
1601                         case 101:
1602                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info101));
1603                         break;
1604
1605                         case 102:
1606                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info102));
1607                         break;
1608
1609                         case 103:
1610                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info103));
1611                         break;
1612
1613                         case 104:
1614                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info104));
1615                         break;
1616
1617                         case 105:
1618                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info105));
1619                         break;
1620
1621                         case 106:
1622                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info106));
1623                         break;
1624
1625                         default:
1626                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1627                 }
1628         }
1629         if (ndr_flags & NDR_BUFFERS) {
1630                 int level = ndr_push_get_switch_value(ndr, r);
1631                 switch (level) {
1632                         case 0:
1633                                 if (r->info0) {
1634                                         NDR_CHECK(ndr_push_dfs_Info0(ndr, NDR_SCALARS, r->info0));
1635                                 }
1636                         break;
1637
1638                         case 1:
1639                                 if (r->info1) {
1640                                         NDR_CHECK(ndr_push_dfs_Info1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
1641                                 }
1642                         break;
1643
1644                         case 2:
1645                                 if (r->info2) {
1646                                         NDR_CHECK(ndr_push_dfs_Info2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
1647                                 }
1648                         break;
1649
1650                         case 3:
1651                                 if (r->info3) {
1652                                         NDR_CHECK(ndr_push_dfs_Info3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
1653                                 }
1654                         break;
1655
1656                         case 4:
1657                                 if (r->info4) {
1658                                         NDR_CHECK(ndr_push_dfs_Info4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
1659                                 }
1660                         break;
1661
1662                         case 5:
1663                                 if (r->info5) {
1664                                         NDR_CHECK(ndr_push_dfs_Info5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
1665                                 }
1666                         break;
1667
1668                         case 6:
1669                                 if (r->info6) {
1670                                         NDR_CHECK(ndr_push_dfs_Info6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
1671                                 }
1672                         break;
1673
1674                         case 7:
1675                                 if (r->info7) {
1676                                         NDR_CHECK(ndr_push_dfs_Info7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
1677                                 }
1678                         break;
1679
1680                         case 100:
1681                                 if (r->info100) {
1682                                         NDR_CHECK(ndr_push_dfs_Info100(ndr, NDR_SCALARS|NDR_BUFFERS, r->info100));
1683                                 }
1684                         break;
1685
1686                         case 101:
1687                                 if (r->info101) {
1688                                         NDR_CHECK(ndr_push_dfs_Info101(ndr, NDR_SCALARS, r->info101));
1689                                 }
1690                         break;
1691
1692                         case 102:
1693                                 if (r->info102) {
1694                                         NDR_CHECK(ndr_push_dfs_Info102(ndr, NDR_SCALARS, r->info102));
1695                                 }
1696                         break;
1697
1698                         case 103:
1699                                 if (r->info103) {
1700                                         NDR_CHECK(ndr_push_dfs_Info103(ndr, NDR_SCALARS, r->info103));
1701                                 }
1702                         break;
1703
1704                         case 104:
1705                                 if (r->info104) {
1706                                         NDR_CHECK(ndr_push_dfs_Info104(ndr, NDR_SCALARS, r->info104));
1707                                 }
1708                         break;
1709
1710                         case 105:
1711                                 if (r->info105) {
1712                                         NDR_CHECK(ndr_push_dfs_Info105(ndr, NDR_SCALARS|NDR_BUFFERS, r->info105));
1713                                 }
1714                         break;
1715
1716                         case 106:
1717                                 if (r->info106) {
1718                                         NDR_CHECK(ndr_push_dfs_Info106(ndr, NDR_SCALARS, r->info106));
1719                                 }
1720                         break;
1721
1722                         default:
1723                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1724                 }
1725         }
1726         return NT_STATUS_OK;
1727 }
1728
1729 NTSTATUS ndr_pull_dfs_Info(struct ndr_pull *ndr, int ndr_flags, union dfs_Info *r)
1730 {
1731         int level;
1732         uint32_t _level;
1733         TALLOC_CTX *_mem_save_info0_0;
1734         TALLOC_CTX *_mem_save_info1_0;
1735         TALLOC_CTX *_mem_save_info2_0;
1736         TALLOC_CTX *_mem_save_info3_0;
1737         TALLOC_CTX *_mem_save_info4_0;
1738         TALLOC_CTX *_mem_save_info5_0;
1739         TALLOC_CTX *_mem_save_info6_0;
1740         TALLOC_CTX *_mem_save_info7_0;
1741         TALLOC_CTX *_mem_save_info100_0;
1742         TALLOC_CTX *_mem_save_info101_0;
1743         TALLOC_CTX *_mem_save_info102_0;
1744         TALLOC_CTX *_mem_save_info103_0;
1745         TALLOC_CTX *_mem_save_info104_0;
1746         TALLOC_CTX *_mem_save_info105_0;
1747         TALLOC_CTX *_mem_save_info106_0;
1748         level = ndr_pull_get_switch_value(ndr, r);
1749         if (ndr_flags & NDR_SCALARS) {
1750                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
1751                 if (_level != level) {
1752                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1753                 }
1754                 switch (level) {
1755                         case 0: {
1756                                 uint32_t _ptr_info0;
1757                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
1758                                 if (_ptr_info0) {
1759                                         NDR_PULL_ALLOC(ndr, r->info0);
1760                                 } else {
1761                                         r->info0 = NULL;
1762                                 }
1763                         break; }
1764
1765                         case 1: {
1766                                 uint32_t _ptr_info1;
1767                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
1768                                 if (_ptr_info1) {
1769                                         NDR_PULL_ALLOC(ndr, r->info1);
1770                                 } else {
1771                                         r->info1 = NULL;
1772                                 }
1773                         break; }
1774
1775                         case 2: {
1776                                 uint32_t _ptr_info2;
1777                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
1778                                 if (_ptr_info2) {
1779                                         NDR_PULL_ALLOC(ndr, r->info2);
1780                                 } else {
1781                                         r->info2 = NULL;
1782                                 }
1783                         break; }
1784
1785                         case 3: {
1786                                 uint32_t _ptr_info3;
1787                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
1788                                 if (_ptr_info3) {
1789                                         NDR_PULL_ALLOC(ndr, r->info3);
1790                                 } else {
1791                                         r->info3 = NULL;
1792                                 }
1793                         break; }
1794
1795                         case 4: {
1796                                 uint32_t _ptr_info4;
1797                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
1798                                 if (_ptr_info4) {
1799                                         NDR_PULL_ALLOC(ndr, r->info4);
1800                                 } else {
1801                                         r->info4 = NULL;
1802                                 }
1803                         break; }
1804
1805                         case 5: {
1806                                 uint32_t _ptr_info5;
1807                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
1808                                 if (_ptr_info5) {
1809                                         NDR_PULL_ALLOC(ndr, r->info5);
1810                                 } else {
1811                                         r->info5 = NULL;
1812                                 }
1813                         break; }
1814
1815                         case 6: {
1816                                 uint32_t _ptr_info6;
1817                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
1818                                 if (_ptr_info6) {
1819                                         NDR_PULL_ALLOC(ndr, r->info6);
1820                                 } else {
1821                                         r->info6 = NULL;
1822                                 }
1823                         break; }
1824
1825                         case 7: {
1826                                 uint32_t _ptr_info7;
1827                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
1828                                 if (_ptr_info7) {
1829                                         NDR_PULL_ALLOC(ndr, r->info7);
1830                                 } else {
1831                                         r->info7 = NULL;
1832                                 }
1833                         break; }
1834
1835                         case 100: {
1836                                 uint32_t _ptr_info100;
1837                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info100));
1838                                 if (_ptr_info100) {
1839                                         NDR_PULL_ALLOC(ndr, r->info100);
1840                                 } else {
1841                                         r->info100 = NULL;
1842                                 }
1843                         break; }
1844
1845                         case 101: {
1846                                 uint32_t _ptr_info101;
1847                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info101));
1848                                 if (_ptr_info101) {
1849                                         NDR_PULL_ALLOC(ndr, r->info101);
1850                                 } else {
1851                                         r->info101 = NULL;
1852                                 }
1853                         break; }
1854
1855                         case 102: {
1856                                 uint32_t _ptr_info102;
1857                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info102));
1858                                 if (_ptr_info102) {
1859                                         NDR_PULL_ALLOC(ndr, r->info102);
1860                                 } else {
1861                                         r->info102 = NULL;
1862                                 }
1863                         break; }
1864
1865                         case 103: {
1866                                 uint32_t _ptr_info103;
1867                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info103));
1868                                 if (_ptr_info103) {
1869                                         NDR_PULL_ALLOC(ndr, r->info103);
1870                                 } else {
1871                                         r->info103 = NULL;
1872                                 }
1873                         break; }
1874
1875                         case 104: {
1876                                 uint32_t _ptr_info104;
1877                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info104));
1878                                 if (_ptr_info104) {
1879                                         NDR_PULL_ALLOC(ndr, r->info104);
1880                                 } else {
1881                                         r->info104 = NULL;
1882                                 }
1883                         break; }
1884
1885                         case 105: {
1886                                 uint32_t _ptr_info105;
1887                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info105));
1888                                 if (_ptr_info105) {
1889                                         NDR_PULL_ALLOC(ndr, r->info105);
1890                                 } else {
1891                                         r->info105 = NULL;
1892                                 }
1893                         break; }
1894
1895                         case 106: {
1896                                 uint32_t _ptr_info106;
1897                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info106));
1898                                 if (_ptr_info106) {
1899                                         NDR_PULL_ALLOC(ndr, r->info106);
1900                                 } else {
1901                                         r->info106 = NULL;
1902                                 }
1903                         break; }
1904
1905                         default:
1906                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1907                 }
1908         }
1909         if (ndr_flags & NDR_BUFFERS) {
1910                 switch (level) {
1911                         case 0:
1912                                 if (r->info0) {
1913                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
1914                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
1915                                         NDR_CHECK(ndr_pull_dfs_Info0(ndr, NDR_SCALARS, r->info0));
1916                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
1917                                 }
1918                         break;
1919
1920                         case 1:
1921                                 if (r->info1) {
1922                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
1923                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
1924                                         NDR_CHECK(ndr_pull_dfs_Info1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
1925                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
1926                                 }
1927                         break;
1928
1929                         case 2:
1930                                 if (r->info2) {
1931                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
1932                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
1933                                         NDR_CHECK(ndr_pull_dfs_Info2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
1934                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
1935                                 }
1936                         break;
1937
1938                         case 3:
1939                                 if (r->info3) {
1940                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
1941                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
1942                                         NDR_CHECK(ndr_pull_dfs_Info3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
1943                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
1944                                 }
1945                         break;
1946
1947                         case 4:
1948                                 if (r->info4) {
1949                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
1950                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
1951                                         NDR_CHECK(ndr_pull_dfs_Info4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
1952                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
1953                                 }
1954                         break;
1955
1956                         case 5:
1957                                 if (r->info5) {
1958                                         _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
1959                                         NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
1960                                         NDR_CHECK(ndr_pull_dfs_Info5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
1961                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
1962                                 }
1963                         break;
1964
1965                         case 6:
1966                                 if (r->info6) {
1967                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
1968                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
1969                                         NDR_CHECK(ndr_pull_dfs_Info6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
1970                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
1971                                 }
1972                         break;
1973
1974                         case 7:
1975                                 if (r->info7) {
1976                                         _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
1977                                         NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
1978                                         NDR_CHECK(ndr_pull_dfs_Info7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
1979                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
1980                                 }
1981                         break;
1982
1983                         case 100:
1984                                 if (r->info100) {
1985                                         _mem_save_info100_0 = NDR_PULL_GET_MEM_CTX(ndr);
1986                                         NDR_PULL_SET_MEM_CTX(ndr, r->info100, 0);
1987                                         NDR_CHECK(ndr_pull_dfs_Info100(ndr, NDR_SCALARS|NDR_BUFFERS, r->info100));
1988                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info100_0, 0);
1989                                 }
1990                         break;
1991
1992                         case 101:
1993                                 if (r->info101) {
1994                                         _mem_save_info101_0 = NDR_PULL_GET_MEM_CTX(ndr);
1995                                         NDR_PULL_SET_MEM_CTX(ndr, r->info101, 0);
1996                                         NDR_CHECK(ndr_pull_dfs_Info101(ndr, NDR_SCALARS, r->info101));
1997                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info101_0, 0);
1998                                 }
1999                         break;
2000
2001                         case 102:
2002                                 if (r->info102) {
2003                                         _mem_save_info102_0 = NDR_PULL_GET_MEM_CTX(ndr);
2004                                         NDR_PULL_SET_MEM_CTX(ndr, r->info102, 0);
2005                                         NDR_CHECK(ndr_pull_dfs_Info102(ndr, NDR_SCALARS, r->info102));
2006                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info102_0, 0);
2007                                 }
2008                         break;
2009
2010                         case 103:
2011                                 if (r->info103) {
2012                                         _mem_save_info103_0 = NDR_PULL_GET_MEM_CTX(ndr);
2013                                         NDR_PULL_SET_MEM_CTX(ndr, r->info103, 0);
2014                                         NDR_CHECK(ndr_pull_dfs_Info103(ndr, NDR_SCALARS, r->info103));
2015                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info103_0, 0);
2016                                 }
2017                         break;
2018
2019                         case 104:
2020                                 if (r->info104) {
2021                                         _mem_save_info104_0 = NDR_PULL_GET_MEM_CTX(ndr);
2022                                         NDR_PULL_SET_MEM_CTX(ndr, r->info104, 0);
2023                                         NDR_CHECK(ndr_pull_dfs_Info104(ndr, NDR_SCALARS, r->info104));
2024                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info104_0, 0);
2025                                 }
2026                         break;
2027
2028                         case 105:
2029                                 if (r->info105) {
2030                                         _mem_save_info105_0 = NDR_PULL_GET_MEM_CTX(ndr);
2031                                         NDR_PULL_SET_MEM_CTX(ndr, r->info105, 0);
2032                                         NDR_CHECK(ndr_pull_dfs_Info105(ndr, NDR_SCALARS|NDR_BUFFERS, r->info105));
2033                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info105_0, 0);
2034                                 }
2035                         break;
2036
2037                         case 106:
2038                                 if (r->info106) {
2039                                         _mem_save_info106_0 = NDR_PULL_GET_MEM_CTX(ndr);
2040                                         NDR_PULL_SET_MEM_CTX(ndr, r->info106, 0);
2041                                         NDR_CHECK(ndr_pull_dfs_Info106(ndr, NDR_SCALARS, r->info106));
2042                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info106_0, 0);
2043                                 }
2044                         break;
2045
2046                         default:
2047                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
2048                 }
2049         }
2050         return NT_STATUS_OK;
2051 }
2052
2053 _PUBLIC_ void ndr_print_dfs_Info(struct ndr_print *ndr, const char *name, const union dfs_Info *r)
2054 {
2055         int level;
2056         level = ndr_print_get_switch_value(ndr, r);
2057         ndr_print_union(ndr, name, level, "dfs_Info");
2058         switch (level) {
2059                 case 0:
2060                         ndr_print_ptr(ndr, "info0", r->info0);
2061                         ndr->depth++;
2062                         if (r->info0) {
2063                                 ndr_print_dfs_Info0(ndr, "info0", r->info0);
2064                         }
2065                         ndr->depth--;
2066                 break;
2067
2068                 case 1:
2069                         ndr_print_ptr(ndr, "info1", r->info1);
2070                         ndr->depth++;
2071                         if (r->info1) {
2072                                 ndr_print_dfs_Info1(ndr, "info1", r->info1);
2073                         }
2074                         ndr->depth--;
2075                 break;
2076
2077                 case 2:
2078                         ndr_print_ptr(ndr, "info2", r->info2);
2079                         ndr->depth++;
2080                         if (r->info2) {
2081                                 ndr_print_dfs_Info2(ndr, "info2", r->info2);
2082                         }
2083                         ndr->depth--;
2084                 break;
2085
2086                 case 3:
2087                         ndr_print_ptr(ndr, "info3", r->info3);
2088                         ndr->depth++;
2089                         if (r->info3) {
2090                                 ndr_print_dfs_Info3(ndr, "info3", r->info3);
2091                         }
2092                         ndr->depth--;
2093                 break;
2094
2095                 case 4:
2096                         ndr_print_ptr(ndr, "info4", r->info4);
2097                         ndr->depth++;
2098                         if (r->info4) {
2099                                 ndr_print_dfs_Info4(ndr, "info4", r->info4);
2100                         }
2101                         ndr->depth--;
2102                 break;
2103
2104                 case 5:
2105                         ndr_print_ptr(ndr, "info5", r->info5);
2106                         ndr->depth++;
2107                         if (r->info5) {
2108                                 ndr_print_dfs_Info5(ndr, "info5", r->info5);
2109                         }
2110                         ndr->depth--;
2111                 break;
2112
2113                 case 6:
2114                         ndr_print_ptr(ndr, "info6", r->info6);
2115                         ndr->depth++;
2116                         if (r->info6) {
2117                                 ndr_print_dfs_Info6(ndr, "info6", r->info6);
2118                         }
2119                         ndr->depth--;
2120                 break;
2121
2122                 case 7:
2123                         ndr_print_ptr(ndr, "info7", r->info7);
2124                         ndr->depth++;
2125                         if (r->info7) {
2126                                 ndr_print_dfs_Info7(ndr, "info7", r->info7);
2127                         }
2128                         ndr->depth--;
2129                 break;
2130
2131                 case 100:
2132                         ndr_print_ptr(ndr, "info100", r->info100);
2133                         ndr->depth++;
2134                         if (r->info100) {
2135                                 ndr_print_dfs_Info100(ndr, "info100", r->info100);
2136                         }
2137                         ndr->depth--;
2138                 break;
2139
2140                 case 101:
2141                         ndr_print_ptr(ndr, "info101", r->info101);
2142                         ndr->depth++;
2143                         if (r->info101) {
2144                                 ndr_print_dfs_Info101(ndr, "info101", r->info101);
2145                         }
2146                         ndr->depth--;
2147                 break;
2148
2149                 case 102:
2150                         ndr_print_ptr(ndr, "info102", r->info102);
2151                         ndr->depth++;
2152                         if (r->info102) {
2153                                 ndr_print_dfs_Info102(ndr, "info102", r->info102);
2154                         }
2155                         ndr->depth--;
2156                 break;
2157
2158                 case 103:
2159                         ndr_print_ptr(ndr, "info103", r->info103);
2160                         ndr->depth++;
2161                         if (r->info103) {
2162                                 ndr_print_dfs_Info103(ndr, "info103", r->info103);
2163                         }
2164                         ndr->depth--;
2165                 break;
2166
2167                 case 104:
2168                         ndr_print_ptr(ndr, "info104", r->info104);
2169                         ndr->depth++;
2170                         if (r->info104) {
2171                                 ndr_print_dfs_Info104(ndr, "info104", r->info104);
2172                         }
2173                         ndr->depth--;
2174                 break;
2175
2176                 case 105:
2177                         ndr_print_ptr(ndr, "info105", r->info105);
2178                         ndr->depth++;
2179                         if (r->info105) {
2180                                 ndr_print_dfs_Info105(ndr, "info105", r->info105);
2181                         }
2182                         ndr->depth--;
2183                 break;
2184
2185                 case 106:
2186                         ndr_print_ptr(ndr, "info106", r->info106);
2187                         ndr->depth++;
2188                         if (r->info106) {
2189                                 ndr_print_dfs_Info106(ndr, "info106", r->info106);
2190                         }
2191                         ndr->depth--;
2192                 break;
2193
2194                 default:
2195                         ndr_print_bad_level(ndr, name, level);
2196         }
2197 }
2198
2199 NTSTATUS ndr_push_dfs_EnumArray1(struct ndr_push *ndr, int ndr_flags, const struct dfs_EnumArray1 *r)
2200 {
2201         uint32_t cntr_s_1;
2202         if (ndr_flags & NDR_SCALARS) {
2203                 NDR_CHECK(ndr_push_align(ndr, 4));
2204                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2205                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->s));
2206         }
2207         if (ndr_flags & NDR_BUFFERS) {
2208                 if (r->s) {
2209                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2210                         for (cntr_s_1 = 0; cntr_s_1 < r->count; cntr_s_1++) {
2211                                 NDR_CHECK(ndr_push_dfs_Info1(ndr, NDR_SCALARS, &r->s[cntr_s_1]));
2212                         }
2213                         for (cntr_s_1 = 0; cntr_s_1 < r->count; cntr_s_1++) {
2214                                 NDR_CHECK(ndr_push_dfs_Info1(ndr, NDR_BUFFERS, &r->s[cntr_s_1]));
2215                         }
2216                 }
2217         }
2218         return NT_STATUS_OK;
2219 }
2220
2221 NTSTATUS ndr_pull_dfs_EnumArray1(struct ndr_pull *ndr, int ndr_flags, struct dfs_EnumArray1 *r)
2222 {
2223         uint32_t _ptr_s;
2224         uint32_t cntr_s_1;
2225         TALLOC_CTX *_mem_save_s_0;
2226         TALLOC_CTX *_mem_save_s_1;
2227         if (ndr_flags & NDR_SCALARS) {
2228                 NDR_CHECK(ndr_pull_align(ndr, 4));
2229                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2230                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_s));
2231                 if (_ptr_s) {
2232                         NDR_PULL_ALLOC(ndr, r->s);
2233                 } else {
2234                         r->s = NULL;
2235                 }
2236         }
2237         if (ndr_flags & NDR_BUFFERS) {
2238                 if (r->s) {
2239                         _mem_save_s_0 = NDR_PULL_GET_MEM_CTX(ndr);
2240                         NDR_PULL_SET_MEM_CTX(ndr, r->s, 0);
2241                         NDR_CHECK(ndr_pull_array_size(ndr, &r->s));
2242                         NDR_PULL_ALLOC_N(ndr, r->s, ndr_get_array_size(ndr, &r->s));
2243                         _mem_save_s_1 = NDR_PULL_GET_MEM_CTX(ndr);
2244                         NDR_PULL_SET_MEM_CTX(ndr, r->s, 0);
2245                         for (cntr_s_1 = 0; cntr_s_1 < r->count; cntr_s_1++) {
2246                                 NDR_CHECK(ndr_pull_dfs_Info1(ndr, NDR_SCALARS, &r->s[cntr_s_1]));
2247                         }
2248                         for (cntr_s_1 = 0; cntr_s_1 < r->count; cntr_s_1++) {
2249                                 NDR_CHECK(ndr_pull_dfs_Info1(ndr, NDR_BUFFERS, &r->s[cntr_s_1]));
2250                         }
2251                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_s_1, 0);
2252                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_s_0, 0);
2253                 }
2254                 if (r->s) {
2255                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->s, r->count));
2256                 }
2257         }
2258         return NT_STATUS_OK;
2259 }
2260
2261 _PUBLIC_ void ndr_print_dfs_EnumArray1(struct ndr_print *ndr, const char *name, const struct dfs_EnumArray1 *r)
2262 {
2263         uint32_t cntr_s_1;
2264         ndr_print_struct(ndr, name, "dfs_EnumArray1");
2265         ndr->depth++;
2266         ndr_print_uint32(ndr, "count", r->count);
2267         ndr_print_ptr(ndr, "s", r->s);
2268         ndr->depth++;
2269         if (r->s) {
2270                 ndr->print(ndr, "%s: ARRAY(%d)", "s", r->count);
2271                 ndr->depth++;
2272                 for (cntr_s_1=0;cntr_s_1<r->count;cntr_s_1++) {
2273                         char *idx_1=NULL;
2274                         asprintf(&idx_1, "[%d]", cntr_s_1);
2275                         if (idx_1) {
2276                                 ndr_print_dfs_Info1(ndr, "s", &r->s[cntr_s_1]);
2277                                 free(idx_1);
2278                         }
2279                 }
2280                 ndr->depth--;
2281         }
2282         ndr->depth--;
2283         ndr->depth--;
2284 }
2285
2286 NTSTATUS ndr_push_dfs_EnumArray2(struct ndr_push *ndr, int ndr_flags, const struct dfs_EnumArray2 *r)
2287 {
2288         uint32_t cntr_s_1;
2289         if (ndr_flags & NDR_SCALARS) {
2290                 NDR_CHECK(ndr_push_align(ndr, 4));
2291                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2292                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->s));
2293         }
2294         if (ndr_flags & NDR_BUFFERS) {
2295                 if (r->s) {
2296                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2297                         for (cntr_s_1 = 0; cntr_s_1 < r->count; cntr_s_1++) {
2298                                 NDR_CHECK(ndr_push_dfs_Info2(ndr, NDR_SCALARS, &r->s[cntr_s_1]));
2299                         }
2300                         for (cntr_s_1 = 0; cntr_s_1 < r->count; cntr_s_1++) {
2301                                 NDR_CHECK(ndr_push_dfs_Info2(ndr, NDR_BUFFERS, &r->s[cntr_s_1]));
2302                         }
2303                 }
2304         }
2305         return NT_STATUS_OK;
2306 }
2307
2308 NTSTATUS ndr_pull_dfs_EnumArray2(struct ndr_pull *ndr, int ndr_flags, struct dfs_EnumArray2 *r)
2309 {
2310         uint32_t _ptr_s;
2311         uint32_t cntr_s_1;
2312         TALLOC_CTX *_mem_save_s_0;
2313         TALLOC_CTX *_mem_save_s_1;
2314         if (ndr_flags & NDR_SCALARS) {
2315                 NDR_CHECK(ndr_pull_align(ndr, 4));
2316                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2317                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_s));
2318                 if (_ptr_s) {
2319                         NDR_PULL_ALLOC(ndr, r->s);
2320                 } else {
2321                         r->s = NULL;
2322                 }
2323         }
2324         if (ndr_flags & NDR_BUFFERS) {
2325                 if (r->s) {
2326                         _mem_save_s_0 = NDR_PULL_GET_MEM_CTX(ndr);
2327                         NDR_PULL_SET_MEM_CTX(ndr, r->s, 0);
2328                         NDR_CHECK(ndr_pull_array_size(ndr, &r->s));
2329                         NDR_PULL_ALLOC_N(ndr, r->s, ndr_get_array_size(ndr, &r->s));
2330                         _mem_save_s_1 = NDR_PULL_GET_MEM_CTX(ndr);
2331                         NDR_PULL_SET_MEM_CTX(ndr, r->s, 0);
2332                         for (cntr_s_1 = 0; cntr_s_1 < r->count; cntr_s_1++) {
2333                                 NDR_CHECK(ndr_pull_dfs_Info2(ndr, NDR_SCALARS, &r->s[cntr_s_1]));
2334                         }
2335                         for (cntr_s_1 = 0; cntr_s_1 < r->count; cntr_s_1++) {
2336                                 NDR_CHECK(ndr_pull_dfs_Info2(ndr, NDR_BUFFERS, &r->s[cntr_s_1]));
2337                         }
2338                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_s_1, 0);
2339                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_s_0, 0);
2340                 }
2341                 if (r->s) {
2342                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->s, r->count));
2343                 }
2344         }
2345         return NT_STATUS_OK;
2346 }
2347
2348 _PUBLIC_ void ndr_print_dfs_EnumArray2(struct ndr_print *ndr, const char *name, const struct dfs_EnumArray2 *r)
2349 {
2350         uint32_t cntr_s_1;
2351         ndr_print_struct(ndr, name, "dfs_EnumArray2");
2352         ndr->depth++;
2353         ndr_print_uint32(ndr, "count", r->count);
2354         ndr_print_ptr(ndr, "s", r->s);
2355         ndr->depth++;
2356         if (r->s) {
2357                 ndr->print(ndr, "%s: ARRAY(%d)", "s", r->count);
2358                 ndr->depth++;
2359                 for (cntr_s_1=0;cntr_s_1<r->count;cntr_s_1++) {
2360                         char *idx_1=NULL;
2361                         asprintf(&idx_1, "[%d]", cntr_s_1);
2362                         if (idx_1) {
2363                                 ndr_print_dfs_Info2(ndr, "s", &r->s[cntr_s_1]);
2364                                 free(idx_1);
2365                         }
2366                 }
2367                 ndr->depth--;
2368         }
2369         ndr->depth--;
2370         ndr->depth--;
2371 }
2372
2373 NTSTATUS ndr_push_dfs_EnumArray3(struct ndr_push *ndr, int ndr_flags, const struct dfs_EnumArray3 *r)
2374 {
2375         uint32_t cntr_s_1;
2376         if (ndr_flags & NDR_SCALARS) {
2377                 NDR_CHECK(ndr_push_align(ndr, 4));
2378                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2379                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->s));
2380         }
2381         if (ndr_flags & NDR_BUFFERS) {
2382                 if (r->s) {
2383                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2384                         for (cntr_s_1 = 0; cntr_s_1 < r->count; cntr_s_1++) {
2385                                 NDR_CHECK(ndr_push_dfs_Info3(ndr, NDR_SCALARS, &r->s[cntr_s_1]));
2386                         }
2387                         for (cntr_s_1 = 0; cntr_s_1 < r->count; cntr_s_1++) {
2388                                 NDR_CHECK(ndr_push_dfs_Info3(ndr, NDR_BUFFERS, &r->s[cntr_s_1]));
2389                         }
2390                 }
2391         }
2392         return NT_STATUS_OK;
2393 }
2394
2395 NTSTATUS ndr_pull_dfs_EnumArray3(struct ndr_pull *ndr, int ndr_flags, struct dfs_EnumArray3 *r)
2396 {
2397         uint32_t _ptr_s;
2398         uint32_t cntr_s_1;
2399         TALLOC_CTX *_mem_save_s_0;
2400         TALLOC_CTX *_mem_save_s_1;
2401         if (ndr_flags & NDR_SCALARS) {
2402                 NDR_CHECK(ndr_pull_align(ndr, 4));
2403                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2404                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_s));
2405                 if (_ptr_s) {
2406                         NDR_PULL_ALLOC(ndr, r->s);
2407                 } else {
2408                         r->s = NULL;
2409                 }
2410         }
2411         if (ndr_flags & NDR_BUFFERS) {
2412                 if (r->s) {
2413                         _mem_save_s_0 = NDR_PULL_GET_MEM_CTX(ndr);
2414                         NDR_PULL_SET_MEM_CTX(ndr, r->s, 0);
2415                         NDR_CHECK(ndr_pull_array_size(ndr, &r->s));
2416                         NDR_PULL_ALLOC_N(ndr, r->s, ndr_get_array_size(ndr, &r->s));
2417                         _mem_save_s_1 = NDR_PULL_GET_MEM_CTX(ndr);
2418                         NDR_PULL_SET_MEM_CTX(ndr, r->s, 0);
2419                         for (cntr_s_1 = 0; cntr_s_1 < r->count; cntr_s_1++) {
2420                                 NDR_CHECK(ndr_pull_dfs_Info3(ndr, NDR_SCALARS, &r->s[cntr_s_1]));
2421                         }
2422                         for (cntr_s_1 = 0; cntr_s_1 < r->count; cntr_s_1++) {
2423                                 NDR_CHECK(ndr_pull_dfs_Info3(ndr, NDR_BUFFERS, &r->s[cntr_s_1]));
2424                         }
2425                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_s_1, 0);
2426                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_s_0, 0);
2427                 }
2428                 if (r->s) {
2429                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->s, r->count));
2430                 }
2431         }
2432         return NT_STATUS_OK;
2433 }
2434
2435 _PUBLIC_ void ndr_print_dfs_EnumArray3(struct ndr_print *ndr, const char *name, const struct dfs_EnumArray3 *r)
2436 {
2437         uint32_t cntr_s_1;
2438         ndr_print_struct(ndr, name, "dfs_EnumArray3");
2439         ndr->depth++;
2440         ndr_print_uint32(ndr, "count", r->count);
2441         ndr_print_ptr(ndr, "s", r->s);
2442         ndr->depth++;
2443         if (r->s) {
2444                 ndr->print(ndr, "%s: ARRAY(%d)", "s", r->count);
2445                 ndr->depth++;
2446                 for (cntr_s_1=0;cntr_s_1<r->count;cntr_s_1++) {
2447                         char *idx_1=NULL;
2448                         asprintf(&idx_1, "[%d]", cntr_s_1);
2449                         if (idx_1) {
2450                                 ndr_print_dfs_Info3(ndr, "s", &r->s[cntr_s_1]);
2451                                 free(idx_1);
2452                         }
2453                 }
2454                 ndr->depth--;
2455         }
2456         ndr->depth--;
2457         ndr->depth--;
2458 }
2459
2460 NTSTATUS ndr_push_dfs_EnumArray4(struct ndr_push *ndr, int ndr_flags, const struct dfs_EnumArray4 *r)
2461 {
2462         uint32_t cntr_s_1;
2463         if (ndr_flags & NDR_SCALARS) {
2464                 NDR_CHECK(ndr_push_align(ndr, 4));
2465                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2466                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->s));
2467         }
2468         if (ndr_flags & NDR_BUFFERS) {
2469                 if (r->s) {
2470                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2471                         for (cntr_s_1 = 0; cntr_s_1 < r->count; cntr_s_1++) {
2472                                 NDR_CHECK(ndr_push_dfs_Info4(ndr, NDR_SCALARS, &r->s[cntr_s_1]));
2473                         }
2474                         for (cntr_s_1 = 0; cntr_s_1 < r->count; cntr_s_1++) {
2475                                 NDR_CHECK(ndr_push_dfs_Info4(ndr, NDR_BUFFERS, &r->s[cntr_s_1]));
2476                         }
2477                 }
2478         }
2479         return NT_STATUS_OK;
2480 }
2481
2482 NTSTATUS ndr_pull_dfs_EnumArray4(struct ndr_pull *ndr, int ndr_flags, struct dfs_EnumArray4 *r)
2483 {
2484         uint32_t _ptr_s;
2485         uint32_t cntr_s_1;
2486         TALLOC_CTX *_mem_save_s_0;
2487         TALLOC_CTX *_mem_save_s_1;
2488         if (ndr_flags & NDR_SCALARS) {
2489                 NDR_CHECK(ndr_pull_align(ndr, 4));
2490                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2491                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_s));
2492                 if (_ptr_s) {
2493                         NDR_PULL_ALLOC(ndr, r->s);
2494                 } else {
2495                         r->s = NULL;
2496                 }
2497         }
2498         if (ndr_flags & NDR_BUFFERS) {
2499                 if (r->s) {
2500                         _mem_save_s_0 = NDR_PULL_GET_MEM_CTX(ndr);
2501                         NDR_PULL_SET_MEM_CTX(ndr, r->s, 0);
2502                         NDR_CHECK(ndr_pull_array_size(ndr, &r->s));
2503                         NDR_PULL_ALLOC_N(ndr, r->s, ndr_get_array_size(ndr, &r->s));
2504                         _mem_save_s_1 = NDR_PULL_GET_MEM_CTX(ndr);
2505                         NDR_PULL_SET_MEM_CTX(ndr, r->s, 0);
2506                         for (cntr_s_1 = 0; cntr_s_1 < r->count; cntr_s_1++) {
2507                                 NDR_CHECK(ndr_pull_dfs_Info4(ndr, NDR_SCALARS, &r->s[cntr_s_1]));
2508                         }
2509                         for (cntr_s_1 = 0; cntr_s_1 < r->count; cntr_s_1++) {
2510                                 NDR_CHECK(ndr_pull_dfs_Info4(ndr, NDR_BUFFERS, &r->s[cntr_s_1]));
2511                         }
2512                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_s_1, 0);
2513                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_s_0, 0);
2514                 }
2515                 if (r->s) {
2516                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->s, r->count));
2517                 }
2518         }
2519         return NT_STATUS_OK;
2520 }
2521
2522 _PUBLIC_ void ndr_print_dfs_EnumArray4(struct ndr_print *ndr, const char *name, const struct dfs_EnumArray4 *r)
2523 {
2524         uint32_t cntr_s_1;
2525         ndr_print_struct(ndr, name, "dfs_EnumArray4");
2526         ndr->depth++;
2527         ndr_print_uint32(ndr, "count", r->count);
2528         ndr_print_ptr(ndr, "s", r->s);
2529         ndr->depth++;
2530         if (r->s) {
2531                 ndr->print(ndr, "%s: ARRAY(%d)", "s", r->count);
2532                 ndr->depth++;
2533                 for (cntr_s_1=0;cntr_s_1<r->count;cntr_s_1++) {
2534                         char *idx_1=NULL;
2535                         asprintf(&idx_1, "[%d]", cntr_s_1);
2536                         if (idx_1) {
2537                                 ndr_print_dfs_Info4(ndr, "s", &r->s[cntr_s_1]);
2538                                 free(idx_1);
2539                         }
2540                 }
2541                 ndr->depth--;
2542         }
2543         ndr->depth--;
2544         ndr->depth--;
2545 }
2546
2547 NTSTATUS ndr_push_dfs_EnumArray200(struct ndr_push *ndr, int ndr_flags, const struct dfs_EnumArray200 *r)
2548 {
2549         uint32_t cntr_s_1;
2550         if (ndr_flags & NDR_SCALARS) {
2551                 NDR_CHECK(ndr_push_align(ndr, 4));
2552                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2553                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->s));
2554         }
2555         if (ndr_flags & NDR_BUFFERS) {
2556                 if (r->s) {
2557                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2558                         for (cntr_s_1 = 0; cntr_s_1 < r->count; cntr_s_1++) {
2559                                 NDR_CHECK(ndr_push_dfs_Info200(ndr, NDR_SCALARS, &r->s[cntr_s_1]));
2560                         }
2561                         for (cntr_s_1 = 0; cntr_s_1 < r->count; cntr_s_1++) {
2562                                 NDR_CHECK(ndr_push_dfs_Info200(ndr, NDR_BUFFERS, &r->s[cntr_s_1]));
2563                         }
2564                 }
2565         }
2566         return NT_STATUS_OK;
2567 }
2568
2569 NTSTATUS ndr_pull_dfs_EnumArray200(struct ndr_pull *ndr, int ndr_flags, struct dfs_EnumArray200 *r)
2570 {
2571         uint32_t _ptr_s;
2572         uint32_t cntr_s_1;
2573         TALLOC_CTX *_mem_save_s_0;
2574         TALLOC_CTX *_mem_save_s_1;
2575         if (ndr_flags & NDR_SCALARS) {
2576                 NDR_CHECK(ndr_pull_align(ndr, 4));
2577                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2578                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_s));
2579                 if (_ptr_s) {
2580                         NDR_PULL_ALLOC(ndr, r->s);
2581                 } else {
2582                         r->s = NULL;
2583                 }
2584         }
2585         if (ndr_flags & NDR_BUFFERS) {
2586                 if (r->s) {
2587                         _mem_save_s_0 = NDR_PULL_GET_MEM_CTX(ndr);
2588                         NDR_PULL_SET_MEM_CTX(ndr, r->s, 0);
2589                         NDR_CHECK(ndr_pull_array_size(ndr, &r->s));
2590                         NDR_PULL_ALLOC_N(ndr, r->s, ndr_get_array_size(ndr, &r->s));
2591                         _mem_save_s_1 = NDR_PULL_GET_MEM_CTX(ndr);
2592                         NDR_PULL_SET_MEM_CTX(ndr, r->s, 0);
2593                         for (cntr_s_1 = 0; cntr_s_1 < r->count; cntr_s_1++) {
2594                                 NDR_CHECK(ndr_pull_dfs_Info200(ndr, NDR_SCALARS, &r->s[cntr_s_1]));
2595                         }
2596                         for (cntr_s_1 = 0; cntr_s_1 < r->count; cntr_s_1++) {
2597                                 NDR_CHECK(ndr_pull_dfs_Info200(ndr, NDR_BUFFERS, &r->s[cntr_s_1]));
2598                         }
2599                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_s_1, 0);
2600                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_s_0, 0);
2601                 }
2602                 if (r->s) {
2603                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->s, r->count));
2604                 }
2605         }
2606         return NT_STATUS_OK;
2607 }
2608
2609 _PUBLIC_ void ndr_print_dfs_EnumArray200(struct ndr_print *ndr, const char *name, const struct dfs_EnumArray200 *r)
2610 {
2611         uint32_t cntr_s_1;
2612         ndr_print_struct(ndr, name, "dfs_EnumArray200");
2613         ndr->depth++;
2614         ndr_print_uint32(ndr, "count", r->count);
2615         ndr_print_ptr(ndr, "s", r->s);
2616         ndr->depth++;
2617         if (r->s) {
2618                 ndr->print(ndr, "%s: ARRAY(%d)", "s", r->count);
2619                 ndr->depth++;
2620                 for (cntr_s_1=0;cntr_s_1<r->count;cntr_s_1++) {
2621                         char *idx_1=NULL;
2622                         asprintf(&idx_1, "[%d]", cntr_s_1);
2623                         if (idx_1) {
2624                                 ndr_print_dfs_Info200(ndr, "s", &r->s[cntr_s_1]);
2625                                 free(idx_1);
2626                         }
2627                 }
2628                 ndr->depth--;
2629         }
2630         ndr->depth--;
2631         ndr->depth--;
2632 }
2633
2634 NTSTATUS ndr_push_dfs_EnumArray300(struct ndr_push *ndr, int ndr_flags, const struct dfs_EnumArray300 *r)
2635 {
2636         uint32_t cntr_s_1;
2637         if (ndr_flags & NDR_SCALARS) {
2638                 NDR_CHECK(ndr_push_align(ndr, 4));
2639                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2640                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->s));
2641         }
2642         if (ndr_flags & NDR_BUFFERS) {
2643                 if (r->s) {
2644                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2645                         for (cntr_s_1 = 0; cntr_s_1 < r->count; cntr_s_1++) {
2646                                 NDR_CHECK(ndr_push_dfs_Info300(ndr, NDR_SCALARS, &r->s[cntr_s_1]));
2647                         }
2648                         for (cntr_s_1 = 0; cntr_s_1 < r->count; cntr_s_1++) {
2649                                 NDR_CHECK(ndr_push_dfs_Info300(ndr, NDR_BUFFERS, &r->s[cntr_s_1]));
2650                         }
2651                 }
2652         }
2653         return NT_STATUS_OK;
2654 }
2655
2656 NTSTATUS ndr_pull_dfs_EnumArray300(struct ndr_pull *ndr, int ndr_flags, struct dfs_EnumArray300 *r)
2657 {
2658         uint32_t _ptr_s;
2659         uint32_t cntr_s_1;
2660         TALLOC_CTX *_mem_save_s_0;
2661         TALLOC_CTX *_mem_save_s_1;
2662         if (ndr_flags & NDR_SCALARS) {
2663                 NDR_CHECK(ndr_pull_align(ndr, 4));
2664                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2665                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_s));
2666                 if (_ptr_s) {
2667                         NDR_PULL_ALLOC(ndr, r->s);
2668                 } else {
2669                         r->s = NULL;
2670                 }
2671         }
2672         if (ndr_flags & NDR_BUFFERS) {
2673                 if (r->s) {
2674                         _mem_save_s_0 = NDR_PULL_GET_MEM_CTX(ndr);
2675                         NDR_PULL_SET_MEM_CTX(ndr, r->s, 0);
2676                         NDR_CHECK(ndr_pull_array_size(ndr, &r->s));
2677                         NDR_PULL_ALLOC_N(ndr, r->s, ndr_get_array_size(ndr, &r->s));
2678                         _mem_save_s_1 = NDR_PULL_GET_MEM_CTX(ndr);
2679                         NDR_PULL_SET_MEM_CTX(ndr, r->s, 0);
2680                         for (cntr_s_1 = 0; cntr_s_1 < r->count; cntr_s_1++) {
2681                                 NDR_CHECK(ndr_pull_dfs_Info300(ndr, NDR_SCALARS, &r->s[cntr_s_1]));
2682                         }
2683                         for (cntr_s_1 = 0; cntr_s_1 < r->count; cntr_s_1++) {
2684                                 NDR_CHECK(ndr_pull_dfs_Info300(ndr, NDR_BUFFERS, &r->s[cntr_s_1]));
2685                         }
2686                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_s_1, 0);
2687                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_s_0, 0);
2688                 }
2689                 if (r->s) {
2690                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->s, r->count));
2691                 }
2692         }
2693         return NT_STATUS_OK;
2694 }
2695
2696 _PUBLIC_ void ndr_print_dfs_EnumArray300(struct ndr_print *ndr, const char *name, const struct dfs_EnumArray300 *r)
2697 {
2698         uint32_t cntr_s_1;
2699         ndr_print_struct(ndr, name, "dfs_EnumArray300");
2700         ndr->depth++;
2701         ndr_print_uint32(ndr, "count", r->count);
2702         ndr_print_ptr(ndr, "s", r->s);
2703         ndr->depth++;
2704         if (r->s) {
2705                 ndr->print(ndr, "%s: ARRAY(%d)", "s", r->count);
2706                 ndr->depth++;
2707                 for (cntr_s_1=0;cntr_s_1<r->count;cntr_s_1++) {
2708                         char *idx_1=NULL;
2709                         asprintf(&idx_1, "[%d]", cntr_s_1);
2710                         if (idx_1) {
2711                                 ndr_print_dfs_Info300(ndr, "s", &r->s[cntr_s_1]);
2712                                 free(idx_1);
2713                         }
2714                 }
2715                 ndr->depth--;
2716         }
2717         ndr->depth--;
2718         ndr->depth--;
2719 }
2720
2721 NTSTATUS ndr_push_dfs_EnumInfo(struct ndr_push *ndr, int ndr_flags, const union dfs_EnumInfo *r)
2722 {
2723         if (ndr_flags & NDR_SCALARS) {
2724                 int level = ndr_push_get_switch_value(ndr, r);
2725                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
2726                 switch (level) {
2727                         case 1:
2728                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
2729                         break;
2730
2731                         case 2:
2732                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
2733                         break;
2734
2735                         case 3:
2736                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
2737                         break;
2738
2739                         case 4:
2740                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
2741                         break;
2742
2743                         case 200:
2744                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info200));
2745                         break;
2746
2747                         case 300:
2748                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info300));
2749                         break;
2750
2751                         default:
2752                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
2753                 }
2754         }
2755         if (ndr_flags & NDR_BUFFERS) {
2756                 int level = ndr_push_get_switch_value(ndr, r);
2757                 switch (level) {
2758                         case 1:
2759                                 if (r->info1) {
2760                                         NDR_CHECK(ndr_push_dfs_EnumArray1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
2761                                 }
2762                         break;
2763
2764                         case 2:
2765                                 if (r->info2) {
2766                                         NDR_CHECK(ndr_push_dfs_EnumArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
2767                                 }
2768                         break;
2769
2770                         case 3:
2771                                 if (r->info3) {
2772                                         NDR_CHECK(ndr_push_dfs_EnumArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
2773                                 }
2774                         break;
2775
2776                         case 4:
2777                                 if (r->info4) {
2778                                         NDR_CHECK(ndr_push_dfs_EnumArray4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
2779                                 }
2780                         break;
2781
2782                         case 200:
2783                                 if (r->info200) {
2784                                         NDR_CHECK(ndr_push_dfs_EnumArray200(ndr, NDR_SCALARS|NDR_BUFFERS, r->info200));
2785                                 }
2786                         break;
2787
2788                         case 300:
2789                                 if (r->info300) {
2790                                         NDR_CHECK(ndr_push_dfs_EnumArray300(ndr, NDR_SCALARS|NDR_BUFFERS, r->info300));
2791                                 }
2792                         break;
2793
2794                         default:
2795                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
2796                 }
2797         }
2798         return NT_STATUS_OK;
2799 }
2800
2801 NTSTATUS ndr_pull_dfs_EnumInfo(struct ndr_pull *ndr, int ndr_flags, union dfs_EnumInfo *r)
2802 {
2803         int level;
2804         uint32_t _level;
2805         TALLOC_CTX *_mem_save_info1_0;
2806         TALLOC_CTX *_mem_save_info2_0;
2807         TALLOC_CTX *_mem_save_info3_0;
2808         TALLOC_CTX *_mem_save_info4_0;
2809         TALLOC_CTX *_mem_save_info200_0;
2810         TALLOC_CTX *_mem_save_info300_0;
2811         level = ndr_pull_get_switch_value(ndr, r);
2812         if (ndr_flags & NDR_SCALARS) {
2813                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
2814                 if (_level != level) {
2815                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
2816                 }
2817                 switch (level) {
2818                         case 1: {
2819                                 uint32_t _ptr_info1;
2820                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
2821                                 if (_ptr_info1) {
2822                                         NDR_PULL_ALLOC(ndr, r->info1);
2823                                 } else {
2824                                         r->info1 = NULL;
2825                                 }
2826                         break; }
2827
2828                         case 2: {
2829                                 uint32_t _ptr_info2;
2830                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
2831                                 if (_ptr_info2) {
2832                                         NDR_PULL_ALLOC(ndr, r->info2);
2833                                 } else {
2834                                         r->info2 = NULL;
2835                                 }
2836                         break; }
2837
2838                         case 3: {
2839                                 uint32_t _ptr_info3;
2840                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
2841                                 if (_ptr_info3) {
2842                                         NDR_PULL_ALLOC(ndr, r->info3);
2843                                 } else {
2844                                         r->info3 = NULL;
2845                                 }
2846                         break; }
2847
2848                         case 4: {
2849                                 uint32_t _ptr_info4;
2850                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
2851                                 if (_ptr_info4) {
2852                                         NDR_PULL_ALLOC(ndr, r->info4);
2853                                 } else {
2854                                         r->info4 = NULL;
2855                                 }
2856                         break; }
2857
2858                         case 200: {
2859                                 uint32_t _ptr_info200;
2860                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info200));
2861                                 if (_ptr_info200) {
2862                                         NDR_PULL_ALLOC(ndr, r->info200);
2863                                 } else {
2864                                         r->info200 = NULL;
2865                                 }
2866                         break; }
2867
2868                         case 300: {
2869                                 uint32_t _ptr_info300;
2870                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info300));
2871                                 if (_ptr_info300) {
2872                                         NDR_PULL_ALLOC(ndr, r->info300);
2873                                 } else {
2874                                         r->info300 = NULL;
2875                                 }
2876                         break; }
2877
2878                         default:
2879                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
2880                 }
2881         }
2882         if (ndr_flags & NDR_BUFFERS) {
2883                 switch (level) {
2884                         case 1:
2885                                 if (r->info1) {
2886                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
2887                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
2888                                         NDR_CHECK(ndr_pull_dfs_EnumArray1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
2889                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
2890                                 }
2891                         break;
2892
2893                         case 2:
2894                                 if (r->info2) {
2895                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
2896                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
2897                                         NDR_CHECK(ndr_pull_dfs_EnumArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
2898                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
2899                                 }
2900                         break;
2901
2902                         case 3:
2903                                 if (r->info3) {
2904                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
2905                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
2906                                         NDR_CHECK(ndr_pull_dfs_EnumArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
2907                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
2908                                 }
2909                         break;
2910
2911                         case 4:
2912                                 if (r->info4) {
2913                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
2914                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
2915                                         NDR_CHECK(ndr_pull_dfs_EnumArray4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
2916                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
2917                                 }
2918                         break;
2919
2920                         case 200:
2921                                 if (r->info200) {
2922                                         _mem_save_info200_0 = NDR_PULL_GET_MEM_CTX(ndr);
2923                                         NDR_PULL_SET_MEM_CTX(ndr, r->info200, 0);
2924                                         NDR_CHECK(ndr_pull_dfs_EnumArray200(ndr, NDR_SCALARS|NDR_BUFFERS, r->info200));
2925                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info200_0, 0);
2926                                 }
2927                         break;
2928
2929                         case 300:
2930                                 if (r->info300) {
2931                                         _mem_save_info300_0 = NDR_PULL_GET_MEM_CTX(ndr);
2932                                         NDR_PULL_SET_MEM_CTX(ndr, r->info300, 0);
2933                                         NDR_CHECK(ndr_pull_dfs_EnumArray300(ndr, NDR_SCALARS|NDR_BUFFERS, r->info300));
2934                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info300_0, 0);
2935                                 }
2936                         break;
2937
2938                         default:
2939                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
2940                 }
2941         }
2942         return NT_STATUS_OK;
2943 }
2944
2945 _PUBLIC_ void ndr_print_dfs_EnumInfo(struct ndr_print *ndr, const char *name, const union dfs_EnumInfo *r)
2946 {
2947         int level;
2948         level = ndr_print_get_switch_value(ndr, r);
2949         ndr_print_union(ndr, name, level, "dfs_EnumInfo");
2950         switch (level) {
2951                 case 1:
2952                         ndr_print_ptr(ndr, "info1", r->info1);
2953                         ndr->depth++;
2954                         if (r->info1) {
2955                                 ndr_print_dfs_EnumArray1(ndr, "info1", r->info1);
2956                         }
2957                         ndr->depth--;
2958                 break;
2959
2960                 case 2:
2961                         ndr_print_ptr(ndr, "info2", r->info2);
2962                         ndr->depth++;
2963                         if (r->info2) {
2964                                 ndr_print_dfs_EnumArray2(ndr, "info2", r->info2);
2965                         }
2966                         ndr->depth--;
2967                 break;
2968
2969                 case 3:
2970                         ndr_print_ptr(ndr, "info3", r->info3);
2971                         ndr->depth++;
2972                         if (r->info3) {
2973                                 ndr_print_dfs_EnumArray3(ndr, "info3", r->info3);
2974                         }
2975                         ndr->depth--;
2976                 break;
2977
2978                 case 4:
2979                         ndr_print_ptr(ndr, "info4", r->info4);
2980                         ndr->depth++;
2981                         if (r->info4) {
2982                                 ndr_print_dfs_EnumArray4(ndr, "info4", r->info4);
2983                         }
2984                         ndr->depth--;
2985                 break;
2986
2987                 case 200:
2988                         ndr_print_ptr(ndr, "info200", r->info200);
2989                         ndr->depth++;
2990                         if (r->info200) {
2991                                 ndr_print_dfs_EnumArray200(ndr, "info200", r->info200);
2992                         }
2993                         ndr->depth--;
2994                 break;
2995
2996                 case 300:
2997                         ndr_print_ptr(ndr, "info300", r->info300);
2998                         ndr->depth++;
2999                         if (r->info300) {
3000                                 ndr_print_dfs_EnumArray300(ndr, "info300", r->info300);
3001                         }
3002                         ndr->depth--;
3003                 break;
3004
3005                 default:
3006                         ndr_print_bad_level(ndr, name, level);
3007         }
3008 }
3009
3010 NTSTATUS ndr_push_dfs_EnumStruct(struct ndr_push *ndr, int ndr_flags, const struct dfs_EnumStruct *r)
3011 {
3012         if (ndr_flags & NDR_SCALARS) {
3013                 NDR_CHECK(ndr_push_align(ndr, 4));
3014                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
3015                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->e, r->level));
3016                 NDR_CHECK(ndr_push_dfs_EnumInfo(ndr, NDR_SCALARS, &r->e));
3017         }
3018         if (ndr_flags & NDR_BUFFERS) {
3019                 NDR_CHECK(ndr_push_dfs_EnumInfo(ndr, NDR_BUFFERS, &r->e));
3020         }
3021         return NT_STATUS_OK;
3022 }
3023
3024 NTSTATUS ndr_pull_dfs_EnumStruct(struct ndr_pull *ndr, int ndr_flags, struct dfs_EnumStruct *r)
3025 {
3026         if (ndr_flags & NDR_SCALARS) {
3027                 NDR_CHECK(ndr_pull_align(ndr, 4));
3028                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
3029                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->e, r->level));
3030                 NDR_CHECK(ndr_pull_dfs_EnumInfo(ndr, NDR_SCALARS, &r->e));
3031         }
3032         if (ndr_flags & NDR_BUFFERS) {
3033                 NDR_CHECK(ndr_pull_dfs_EnumInfo(ndr, NDR_BUFFERS, &r->e));
3034         }
3035         return NT_STATUS_OK;
3036 }
3037
3038 _PUBLIC_ void ndr_print_dfs_EnumStruct(struct ndr_print *ndr, const char *name, const struct dfs_EnumStruct *r)
3039 {
3040         ndr_print_struct(ndr, name, "dfs_EnumStruct");
3041         ndr->depth++;
3042         ndr_print_uint32(ndr, "level", r->level);
3043         ndr_print_set_switch_value(ndr, &r->e, r->level);
3044         ndr_print_dfs_EnumInfo(ndr, "e", &r->e);
3045         ndr->depth--;
3046 }
3047
3048 NTSTATUS ndr_push_dfs_UnknownStruct(struct ndr_push *ndr, int ndr_flags, const struct dfs_UnknownStruct *r)
3049 {
3050         if (ndr_flags & NDR_SCALARS) {
3051                 NDR_CHECK(ndr_push_align(ndr, 4));
3052                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
3053                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->unknown2));
3054         }
3055         if (ndr_flags & NDR_BUFFERS) {
3056                 if (r->unknown2) {
3057                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->unknown2, CH_UTF16)));
3058                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3059                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->unknown2, CH_UTF16)));
3060                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->unknown2, ndr_charset_length(r->unknown2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3061                 }
3062         }
3063         return NT_STATUS_OK;
3064 }
3065
3066 NTSTATUS ndr_pull_dfs_UnknownStruct(struct ndr_pull *ndr, int ndr_flags, struct dfs_UnknownStruct *r)
3067 {
3068         uint32_t _ptr_unknown2;
3069         TALLOC_CTX *_mem_save_unknown2_0;
3070         if (ndr_flags & NDR_SCALARS) {
3071                 NDR_CHECK(ndr_pull_align(ndr, 4));
3072                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
3073                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown2));
3074                 if (_ptr_unknown2) {
3075                         NDR_PULL_ALLOC(ndr, r->unknown2);
3076                 } else {
3077                         r->unknown2 = NULL;
3078                 }
3079         }
3080         if (ndr_flags & NDR_BUFFERS) {
3081                 if (r->unknown2) {
3082                         _mem_save_unknown2_0 = NDR_PULL_GET_MEM_CTX(ndr);
3083                         NDR_PULL_SET_MEM_CTX(ndr, r->unknown2, 0);
3084                         NDR_CHECK(ndr_pull_array_size(ndr, &r->unknown2));
3085                         NDR_CHECK(ndr_pull_array_length(ndr, &r->unknown2));
3086                         if (ndr_get_array_length(ndr, &r->unknown2) > ndr_get_array_size(ndr, &r->unknown2)) {
3087                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->unknown2), ndr_get_array_length(ndr, &r->unknown2));
3088                         }
3089                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->unknown2), sizeof(uint16_t)));
3090                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->unknown2, ndr_get_array_length(ndr, &r->unknown2), sizeof(uint16_t), CH_UTF16));
3091                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown2_0, 0);
3092                 }
3093         }
3094         return NT_STATUS_OK;
3095 }
3096
3097 _PUBLIC_ void ndr_print_dfs_UnknownStruct(struct ndr_print *ndr, const char *name, const struct dfs_UnknownStruct *r)
3098 {
3099         ndr_print_struct(ndr, name, "dfs_UnknownStruct");
3100         ndr->depth++;
3101         ndr_print_uint32(ndr, "unknown1", r->unknown1);
3102         ndr_print_ptr(ndr, "unknown2", r->unknown2);
3103         ndr->depth++;
3104         if (r->unknown2) {
3105                 ndr_print_string(ndr, "unknown2", r->unknown2);
3106         }
3107         ndr->depth--;
3108         ndr->depth--;
3109 }
3110
3111 _PUBLIC_ NTSTATUS ndr_push_dfs_GetManagerVersion(struct ndr_push *ndr, int flags, const struct dfs_GetManagerVersion *r)
3112 {
3113         if (flags & NDR_IN) {
3114         }
3115         if (flags & NDR_OUT) {
3116                 if (r->out.version == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3117                 NDR_CHECK(ndr_push_dfs_ManagerVersion(ndr, NDR_SCALARS, *r->out.version));
3118         }
3119         return NT_STATUS_OK;
3120 }
3121
3122 _PUBLIC_ NTSTATUS ndr_pull_dfs_GetManagerVersion(struct ndr_pull *ndr, int flags, struct dfs_GetManagerVersion *r)
3123 {
3124         TALLOC_CTX *_mem_save_version_0;
3125         if (flags & NDR_IN) {
3126                 ZERO_STRUCT(r->out);
3127
3128                 NDR_PULL_ALLOC(ndr, r->out.version);
3129                 ZERO_STRUCTP(r->out.version);
3130         }
3131         if (flags & NDR_OUT) {
3132                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3133                         NDR_PULL_ALLOC(ndr, r->out.version);
3134                 }
3135                 _mem_save_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
3136                 NDR_PULL_SET_MEM_CTX(ndr, r->out.version, LIBNDR_FLAG_REF_ALLOC);
3137                 NDR_CHECK(ndr_pull_dfs_ManagerVersion(ndr, NDR_SCALARS, r->out.version));
3138                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_version_0, LIBNDR_FLAG_REF_ALLOC);
3139         }
3140         return NT_STATUS_OK;
3141 }
3142
3143 _PUBLIC_ void ndr_print_dfs_GetManagerVersion(struct ndr_print *ndr, const char *name, int flags, const struct dfs_GetManagerVersion *r)
3144 {
3145         ndr_print_struct(ndr, name, "dfs_GetManagerVersion");
3146         ndr->depth++;
3147         if (flags & NDR_SET_VALUES) {
3148                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3149         }
3150         if (flags & NDR_IN) {
3151                 ndr_print_struct(ndr, "in", "dfs_GetManagerVersion");
3152                 ndr->depth++;
3153                 ndr->depth--;
3154         }
3155         if (flags & NDR_OUT) {
3156                 ndr_print_struct(ndr, "out", "dfs_GetManagerVersion");
3157                 ndr->depth++;
3158                 ndr_print_ptr(ndr, "version", r->out.version);
3159                 ndr->depth++;
3160                 ndr_print_dfs_ManagerVersion(ndr, "version", *r->out.version);
3161                 ndr->depth--;
3162                 ndr->depth--;
3163         }
3164         ndr->depth--;
3165 }
3166
3167 NTSTATUS ndr_push_dfs_Add(struct ndr_push *ndr, int flags, const struct dfs_Add *r)
3168 {
3169         if (flags & NDR_IN) {
3170                 if (r->in.path == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3171                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));
3172                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3173                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));
3174                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.path, ndr_charset_length(r->in.path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3175                 if (r->in.server == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3176                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
3177                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3178                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
3179                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3180                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.share));
3181                 if (r->in.share) {
3182                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share, CH_UTF16)));
3183                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3184                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share, CH_UTF16)));
3185                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.share, ndr_charset_length(r->in.share, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3186                 }
3187                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.comment));
3188                 if (r->in.comment) {
3189                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.comment, CH_UTF16)));
3190                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3191                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.comment, CH_UTF16)));
3192                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.comment, ndr_charset_length(r->in.comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3193                 }
3194                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
3195         }
3196         if (flags & NDR_OUT) {
3197                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3198         }
3199         return NT_STATUS_OK;
3200 }
3201
3202 NTSTATUS ndr_pull_dfs_Add(struct ndr_pull *ndr, int flags, struct dfs_Add *r)
3203 {
3204         uint32_t _ptr_share;
3205         uint32_t _ptr_comment;
3206         TALLOC_CTX *_mem_save_share_0;
3207         TALLOC_CTX *_mem_save_comment_0;
3208         if (flags & NDR_IN) {
3209                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path));
3210                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path));
3211                 if (ndr_get_array_length(ndr, &r->in.path) > ndr_get_array_size(ndr, &r->in.path)) {
3212                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.path), ndr_get_array_length(ndr, &r->in.path));
3213                 }
3214                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path), sizeof(uint16_t)));
3215                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.path, ndr_get_array_length(ndr, &r->in.path), sizeof(uint16_t), CH_UTF16));
3216                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
3217                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
3218                 if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
3219                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server), ndr_get_array_length(ndr, &r->in.server));
3220                 }
3221                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
3222                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
3223                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_share));
3224                 if (_ptr_share) {
3225                         NDR_PULL_ALLOC(ndr, r->in.share);
3226                 } else {
3227                         r->in.share = NULL;
3228                 }
3229                 if (r->in.share) {
3230                         _mem_save_share_0 = NDR_PULL_GET_MEM_CTX(ndr);
3231                         NDR_PULL_SET_MEM_CTX(ndr, r->in.share, 0);
3232                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.share));
3233                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.share));
3234                         if (ndr_get_array_length(ndr, &r->in.share) > ndr_get_array_size(ndr, &r->in.share)) {
3235                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.share), ndr_get_array_length(ndr, &r->in.share));
3236                         }
3237                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.share), sizeof(uint16_t)));
3238                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.share, ndr_get_array_length(ndr, &r->in.share), sizeof(uint16_t), CH_UTF16));
3239                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_share_0, 0);
3240                 }
3241                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
3242                 if (_ptr_comment) {
3243                         NDR_PULL_ALLOC(ndr, r->in.comment);
3244                 } else {
3245                         r->in.comment = NULL;
3246                 }
3247                 if (r->in.comment) {
3248                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
3249                         NDR_PULL_SET_MEM_CTX(ndr, r->in.comment, 0);
3250                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.comment));
3251                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.comment));
3252                         if (ndr_get_array_length(ndr, &r->in.comment) > ndr_get_array_size(ndr, &r->in.comment)) {
3253                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.comment), ndr_get_array_length(ndr, &r->in.comment));
3254                         }
3255                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.comment), sizeof(uint16_t)));
3256                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.comment, ndr_get_array_length(ndr, &r->in.comment), sizeof(uint16_t), CH_UTF16));
3257                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
3258                 }
3259                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
3260         }
3261         if (flags & NDR_OUT) {
3262                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3263         }
3264         return NT_STATUS_OK;
3265 }
3266
3267 _PUBLIC_ void ndr_print_dfs_Add(struct ndr_print *ndr, const char *name, int flags, const struct dfs_Add *r)
3268 {
3269         ndr_print_struct(ndr, name, "dfs_Add");
3270         ndr->depth++;
3271         if (flags & NDR_SET_VALUES) {
3272                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3273         }
3274         if (flags & NDR_IN) {
3275                 ndr_print_struct(ndr, "in", "dfs_Add");
3276                 ndr->depth++;
3277                 ndr_print_ptr(ndr, "path", r->in.path);
3278                 ndr->depth++;
3279                 ndr_print_string(ndr, "path", r->in.path);
3280                 ndr->depth--;
3281                 ndr_print_ptr(ndr, "server", r->in.server);
3282                 ndr->depth++;
3283                 ndr_print_string(ndr, "server", r->in.server);
3284                 ndr->depth--;
3285                 ndr_print_ptr(ndr, "share", r->in.share);
3286                 ndr->depth++;
3287                 if (r->in.share) {
3288                         ndr_print_string(ndr, "share", r->in.share);
3289                 }
3290                 ndr->depth--;
3291                 ndr_print_ptr(ndr, "comment", r->in.comment);
3292                 ndr->depth++;
3293                 if (r->in.comment) {
3294                         ndr_print_string(ndr, "comment", r->in.comment);
3295                 }
3296                 ndr->depth--;
3297                 ndr_print_uint32(ndr, "flags", r->in.flags);
3298                 ndr->depth--;
3299         }
3300         if (flags & NDR_OUT) {
3301                 ndr_print_struct(ndr, "out", "dfs_Add");
3302                 ndr->depth++;
3303                 ndr_print_WERROR(ndr, "result", r->out.result);
3304                 ndr->depth--;
3305         }
3306         ndr->depth--;
3307 }
3308
3309 NTSTATUS ndr_push_dfs_Remove(struct ndr_push *ndr, int flags, const struct dfs_Remove *r)
3310 {
3311         if (flags & NDR_IN) {
3312                 if (r->in.dfs_entry_path == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3313                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dfs_entry_path, CH_UTF16)));
3314                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3315                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dfs_entry_path, CH_UTF16)));
3316                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dfs_entry_path, ndr_charset_length(r->in.dfs_entry_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3317                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
3318                 if (r->in.servername) {
3319                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
3320                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3321                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
3322                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3323                 }
3324                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.sharename));
3325                 if (r->in.sharename) {
3326                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.sharename, CH_UTF16)));
3327                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3328                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.sharename, CH_UTF16)));
3329                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.sharename, ndr_charset_length(r->in.sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3330                 }
3331         }
3332         if (flags & NDR_OUT) {
3333                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3334         }
3335         return NT_STATUS_OK;
3336 }
3337
3338 NTSTATUS ndr_pull_dfs_Remove(struct ndr_pull *ndr, int flags, struct dfs_Remove *r)
3339 {
3340         uint32_t _ptr_servername;
3341         uint32_t _ptr_sharename;
3342         TALLOC_CTX *_mem_save_servername_0;
3343         TALLOC_CTX *_mem_save_sharename_0;
3344         if (flags & NDR_IN) {
3345                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dfs_entry_path));
3346                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dfs_entry_path));
3347                 if (ndr_get_array_length(ndr, &r->in.dfs_entry_path) > ndr_get_array_size(ndr, &r->in.dfs_entry_path)) {
3348                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.dfs_entry_path), ndr_get_array_length(ndr, &r->in.dfs_entry_path));
3349                 }
3350                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.dfs_entry_path), sizeof(uint16_t)));
3351                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dfs_entry_path, ndr_get_array_length(ndr, &r->in.dfs_entry_path), sizeof(uint16_t), CH_UTF16));
3352                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
3353                 if (_ptr_servername) {
3354                         NDR_PULL_ALLOC(ndr, r->in.servername);
3355                 } else {
3356                         r->in.servername = NULL;
3357                 }
3358                 if (r->in.servername) {
3359                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3360                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
3361                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
3362                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
3363                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
3364                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.servername), ndr_get_array_length(ndr, &r->in.servername));
3365                         }
3366                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
3367                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
3368                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
3369                 }
3370                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
3371                 if (_ptr_sharename) {
3372                         NDR_PULL_ALLOC(ndr, r->in.sharename);
3373                 } else {
3374                         r->in.sharename = NULL;
3375                 }
3376                 if (r->in.sharename) {
3377                         _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
3378                         NDR_PULL_SET_MEM_CTX(ndr, r->in.sharename, 0);
3379                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.sharename));
3380                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.sharename));
3381                         if (ndr_get_array_length(ndr, &r->in.sharename) > ndr_get_array_size(ndr, &r->in.sharename)) {
3382                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.sharename), ndr_get_array_length(ndr, &r->in.sharename));
3383                         }
3384                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.sharename), sizeof(uint16_t)));
3385                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.sharename, ndr_get_array_length(ndr, &r->in.sharename), sizeof(uint16_t), CH_UTF16));
3386                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
3387                 }
3388         }
3389         if (flags & NDR_OUT) {
3390                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3391         }
3392         return NT_STATUS_OK;
3393 }
3394
3395 _PUBLIC_ void ndr_print_dfs_Remove(struct ndr_print *ndr, const char *name, int flags, const struct dfs_Remove *r)
3396 {
3397         ndr_print_struct(ndr, name, "dfs_Remove");
3398         ndr->depth++;
3399         if (flags & NDR_SET_VALUES) {
3400                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3401         }
3402         if (flags & NDR_IN) {
3403                 ndr_print_struct(ndr, "in", "dfs_Remove");
3404                 ndr->depth++;
3405                 ndr_print_ptr(ndr, "dfs_entry_path", r->in.dfs_entry_path);
3406                 ndr->depth++;
3407                 ndr_print_string(ndr, "dfs_entry_path", r->in.dfs_entry_path);
3408                 ndr->depth--;
3409                 ndr_print_ptr(ndr, "servername", r->in.servername);
3410                 ndr->depth++;
3411                 if (r->in.servername) {
3412                         ndr_print_string(ndr, "servername", r->in.servername);
3413                 }
3414                 ndr->depth--;
3415                 ndr_print_ptr(ndr, "sharename", r->in.sharename);
3416                 ndr->depth++;
3417                 if (r->in.sharename) {
3418                         ndr_print_string(ndr, "sharename", r->in.sharename);
3419                 }
3420                 ndr->depth--;
3421                 ndr->depth--;
3422         }
3423         if (flags & NDR_OUT) {
3424                 ndr_print_struct(ndr, "out", "dfs_Remove");
3425                 ndr->depth++;
3426                 ndr_print_WERROR(ndr, "result", r->out.result);
3427                 ndr->depth--;
3428         }
3429         ndr->depth--;
3430 }
3431
3432 NTSTATUS ndr_push_dfs_SetInfo(struct ndr_push *ndr, int flags, const struct dfs_SetInfo *r)
3433 {
3434         if (flags & NDR_IN) {
3435                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dfs_entry_path, CH_UTF16)));
3436                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3437                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dfs_entry_path, CH_UTF16)));
3438                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dfs_entry_path, ndr_charset_length(r->in.dfs_entry_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3439                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
3440                 if (r->in.servername) {
3441                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
3442                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3443                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
3444                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3445                 }
3446                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.sharename));
3447                 if (r->in.sharename) {
3448                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.sharename, CH_UTF16)));
3449                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3450                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.sharename, CH_UTF16)));
3451                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.sharename, ndr_charset_length(r->in.sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3452                 }
3453                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
3454                 if (r->in.info == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3455                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
3456                 NDR_CHECK(ndr_push_dfs_Info(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
3457         }
3458         if (flags & NDR_OUT) {
3459                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3460         }
3461         return NT_STATUS_OK;
3462 }
3463
3464 NTSTATUS ndr_pull_dfs_SetInfo(struct ndr_pull *ndr, int flags, struct dfs_SetInfo *r)
3465 {
3466         uint32_t _ptr_servername;
3467         uint32_t _ptr_sharename;
3468         TALLOC_CTX *_mem_save_servername_0;
3469         TALLOC_CTX *_mem_save_sharename_0;
3470         TALLOC_CTX *_mem_save_info_0;
3471         if (flags & NDR_IN) {
3472                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dfs_entry_path));
3473                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dfs_entry_path));
3474                 if (ndr_get_array_length(ndr, &r->in.dfs_entry_path) > ndr_get_array_size(ndr, &r->in.dfs_entry_path)) {
3475                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.dfs_entry_path), ndr_get_array_length(ndr, &r->in.dfs_entry_path));
3476                 }
3477                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.dfs_entry_path), sizeof(uint16_t)));
3478                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dfs_entry_path, ndr_get_array_length(ndr, &r->in.dfs_entry_path), sizeof(uint16_t), CH_UTF16));
3479                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
3480                 if (_ptr_servername) {
3481                         NDR_PULL_ALLOC(ndr, r->in.servername);
3482                 } else {
3483                         r->in.servername = NULL;
3484                 }
3485                 if (r->in.servername) {
3486                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3487                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
3488                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
3489                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
3490                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
3491                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.servername), ndr_get_array_length(ndr, &r->in.servername));
3492                         }
3493                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
3494                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
3495                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
3496                 }
3497                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
3498                 if (_ptr_sharename) {
3499                         NDR_PULL_ALLOC(ndr, r->in.sharename);
3500                 } else {
3501                         r->in.sharename = NULL;
3502                 }
3503                 if (r->in.sharename) {
3504                         _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
3505                         NDR_PULL_SET_MEM_CTX(ndr, r->in.sharename, 0);
3506                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.sharename));
3507                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.sharename));
3508                         if (ndr_get_array_length(ndr, &r->in.sharename) > ndr_get_array_size(ndr, &r->in.sharename)) {
3509                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.sharename), ndr_get_array_length(ndr, &r->in.sharename));
3510                         }
3511                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.sharename), sizeof(uint16_t)));
3512                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.sharename, ndr_get_array_length(ndr, &r->in.sharename), sizeof(uint16_t), CH_UTF16));
3513                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
3514                 }
3515                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
3516                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3517                         NDR_PULL_ALLOC(ndr, r->in.info);
3518                 }
3519                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
3520                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
3521                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
3522                 NDR_CHECK(ndr_pull_dfs_Info(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
3523                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
3524         }
3525         if (flags & NDR_OUT) {
3526                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3527         }
3528         return NT_STATUS_OK;
3529 }
3530
3531 _PUBLIC_ void ndr_print_dfs_SetInfo(struct ndr_print *ndr, const char *name, int flags, const struct dfs_SetInfo *r)
3532 {
3533         ndr_print_struct(ndr, name, "dfs_SetInfo");
3534         ndr->depth++;
3535         if (flags & NDR_SET_VALUES) {
3536                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3537         }
3538         if (flags & NDR_IN) {
3539                 ndr_print_struct(ndr, "in", "dfs_SetInfo");
3540                 ndr->depth++;
3541                 ndr_print_string(ndr, "dfs_entry_path", r->in.dfs_entry_path);
3542                 ndr_print_ptr(ndr, "servername", r->in.servername);
3543                 ndr->depth++;
3544                 if (r->in.servername) {
3545                         ndr_print_string(ndr, "servername", r->in.servername);
3546                 }
3547                 ndr->depth--;
3548                 ndr_print_ptr(ndr, "sharename", r->in.sharename);
3549                 ndr->depth++;
3550                 if (r->in.sharename) {
3551                         ndr_print_string(ndr, "sharename", r->in.sharename);
3552                 }
3553                 ndr->depth--;
3554                 ndr_print_uint32(ndr, "level", r->in.level);
3555                 ndr_print_ptr(ndr, "info", r->in.info);
3556                 ndr->depth++;
3557                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
3558                 ndr_print_dfs_Info(ndr, "info", r->in.info);
3559                 ndr->depth--;
3560                 ndr->depth--;
3561         }
3562         if (flags & NDR_OUT) {
3563                 ndr_print_struct(ndr, "out", "dfs_SetInfo");
3564                 ndr->depth++;
3565                 ndr_print_WERROR(ndr, "result", r->out.result);
3566                 ndr->depth--;
3567         }
3568         ndr->depth--;
3569 }
3570
3571 NTSTATUS ndr_push_dfs_GetInfo(struct ndr_push *ndr, int flags, const struct dfs_GetInfo *r)
3572 {
3573         if (flags & NDR_IN) {
3574                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dfs_entry_path, CH_UTF16)));
3575                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3576                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dfs_entry_path, CH_UTF16)));
3577                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dfs_entry_path, ndr_charset_length(r->in.dfs_entry_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3578                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
3579                 if (r->in.servername) {
3580                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
3581                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3582                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
3583                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3584                 }
3585                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.sharename));
3586                 if (r->in.sharename) {
3587                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.sharename, CH_UTF16)));
3588                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3589                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.sharename, CH_UTF16)));
3590                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.sharename, ndr_charset_length(r->in.sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3591                 }
3592                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
3593         }
3594         if (flags & NDR_OUT) {
3595                 if (r->out.info == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3596                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
3597                 NDR_CHECK(ndr_push_dfs_Info(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
3598                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3599         }
3600         return NT_STATUS_OK;
3601 }
3602
3603 NTSTATUS ndr_pull_dfs_GetInfo(struct ndr_pull *ndr, int flags, struct dfs_GetInfo *r)
3604 {
3605         uint32_t _ptr_servername;
3606         uint32_t _ptr_sharename;
3607         TALLOC_CTX *_mem_save_servername_0;
3608         TALLOC_CTX *_mem_save_sharename_0;
3609         TALLOC_CTX *_mem_save_info_0;
3610         if (flags & NDR_IN) {
3611                 ZERO_STRUCT(r->out);
3612
3613                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dfs_entry_path));
3614                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dfs_entry_path));
3615                 if (ndr_get_array_length(ndr, &r->in.dfs_entry_path) > ndr_get_array_size(ndr, &r->in.dfs_entry_path)) {
3616                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.dfs_entry_path), ndr_get_array_length(ndr, &r->in.dfs_entry_path));
3617                 }
3618                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.dfs_entry_path), sizeof(uint16_t)));
3619                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dfs_entry_path, ndr_get_array_length(ndr, &r->in.dfs_entry_path), sizeof(uint16_t), CH_UTF16));
3620                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
3621                 if (_ptr_servername) {
3622                         NDR_PULL_ALLOC(ndr, r->in.servername);
3623                 } else {
3624                         r->in.servername = NULL;
3625                 }
3626                 if (r->in.servername) {
3627                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3628                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
3629                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
3630                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
3631                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
3632                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.servername), ndr_get_array_length(ndr, &r->in.servername));
3633                         }
3634                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
3635                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
3636                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
3637                 }
3638                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
3639                 if (_ptr_sharename) {
3640                         NDR_PULL_ALLOC(ndr, r->in.sharename);
3641                 } else {
3642                         r->in.sharename = NULL;
3643                 }
3644                 if (r->in.sharename) {
3645                         _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
3646                         NDR_PULL_SET_MEM_CTX(ndr, r->in.sharename, 0);
3647                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.sharename));
3648                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.sharename));
3649                         if (ndr_get_array_length(ndr, &r->in.sharename) > ndr_get_array_size(ndr, &r->in.sharename)) {
3650                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.sharename), ndr_get_array_length(ndr, &r->in.sharename));
3651                         }
3652                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.sharename), sizeof(uint16_t)));
3653                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.sharename, ndr_get_array_length(ndr, &r->in.sharename), sizeof(uint16_t), CH_UTF16));
3654                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
3655                 }
3656                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
3657                 NDR_PULL_ALLOC(ndr, r->out.info);
3658                 ZERO_STRUCTP(r->out.info);
3659         }
3660         if (flags & NDR_OUT) {
3661                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3662                         NDR_PULL_ALLOC(ndr, r->out.info);
3663                 }
3664                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
3665                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
3666                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
3667                 NDR_CHECK(ndr_pull_dfs_Info(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
3668                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
3669                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3670         }
3671         return NT_STATUS_OK;
3672 }
3673
3674 _PUBLIC_ void ndr_print_dfs_GetInfo(struct ndr_print *ndr, const char *name, int flags, const struct dfs_GetInfo *r)
3675 {
3676         ndr_print_struct(ndr, name, "dfs_GetInfo");
3677         ndr->depth++;
3678         if (flags & NDR_SET_VALUES) {
3679                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3680         }
3681         if (flags & NDR_IN) {
3682                 ndr_print_struct(ndr, "in", "dfs_GetInfo");
3683                 ndr->depth++;
3684                 ndr_print_string(ndr, "dfs_entry_path", r->in.dfs_entry_path);
3685                 ndr_print_ptr(ndr, "servername", r->in.servername);
3686                 ndr->depth++;
3687                 if (r->in.servername) {
3688                         ndr_print_string(ndr, "servername", r->in.servername);
3689                 }
3690                 ndr->depth--;
3691                 ndr_print_ptr(ndr, "sharename", r->in.sharename);
3692                 ndr->depth++;
3693                 if (r->in.sharename) {
3694                         ndr_print_string(ndr, "sharename", r->in.sharename);
3695                 }
3696                 ndr->depth--;
3697                 ndr_print_uint32(ndr, "level", r->in.level);
3698                 ndr->depth--;
3699         }
3700         if (flags & NDR_OUT) {
3701                 ndr_print_struct(ndr, "out", "dfs_GetInfo");
3702                 ndr->depth++;
3703                 ndr_print_ptr(ndr, "info", r->out.info);
3704                 ndr->depth++;
3705                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
3706                 ndr_print_dfs_Info(ndr, "info", r->out.info);
3707                 ndr->depth--;
3708                 ndr_print_WERROR(ndr, "result", r->out.result);
3709                 ndr->depth--;
3710         }
3711         ndr->depth--;
3712 }
3713
3714 NTSTATUS ndr_push_dfs_Enum(struct ndr_push *ndr, int flags, const struct dfs_Enum *r)
3715 {
3716         if (flags & NDR_IN) {
3717                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
3718                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
3719                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.info));
3720                 if (r->in.info) {
3721                         NDR_CHECK(ndr_push_dfs_EnumStruct(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
3722                 }
3723                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.total));
3724                 if (r->in.total) {
3725                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.total));
3726                 }
3727         }
3728         if (flags & NDR_OUT) {
3729                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
3730                 if (r->out.info) {
3731                         NDR_CHECK(ndr_push_dfs_EnumStruct(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
3732                 }
3733                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.total));
3734                 if (r->out.total) {
3735                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total));
3736                 }
3737                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3738         }
3739         return NT_STATUS_OK;
3740 }
3741
3742 NTSTATUS ndr_pull_dfs_Enum(struct ndr_pull *ndr, int flags, struct dfs_Enum *r)
3743 {
3744         uint32_t _ptr_info;
3745         uint32_t _ptr_total;
3746         TALLOC_CTX *_mem_save_info_0;
3747         TALLOC_CTX *_mem_save_total_0;
3748         if (flags & NDR_IN) {
3749                 ZERO_STRUCT(r->out);
3750
3751                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
3752                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
3753                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
3754                 if (_ptr_info) {
3755                         NDR_PULL_ALLOC(ndr, r->in.info);
3756                 } else {
3757                         r->in.info = NULL;
3758                 }
3759                 if (r->in.info) {
3760                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
3761                         NDR_PULL_SET_MEM_CTX(ndr, r->in.info, 0);
3762                         NDR_CHECK(ndr_pull_dfs_EnumStruct(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
3763                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
3764                 }
3765                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_total));
3766                 if (_ptr_total) {
3767                         NDR_PULL_ALLOC(ndr, r->in.total);
3768                 } else {
3769                         r->in.total = NULL;
3770                 }
3771                 if (r->in.total) {
3772                         _mem_save_total_0 = NDR_PULL_GET_MEM_CTX(ndr);
3773                         NDR_PULL_SET_MEM_CTX(ndr, r->in.total, 0);
3774                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.total));
3775                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_0, 0);
3776                 }
3777         }
3778         if (flags & NDR_OUT) {
3779                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
3780                 if (_ptr_info) {
3781                         NDR_PULL_ALLOC(ndr, r->out.info);
3782                 } else {
3783                         r->out.info = NULL;
3784                 }
3785                 if (r->out.info) {
3786                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
3787                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
3788                         NDR_CHECK(ndr_pull_dfs_EnumStruct(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
3789                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
3790                 }
3791                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_total));
3792                 if (_ptr_total) {
3793                         NDR_PULL_ALLOC(ndr, r->out.total);
3794                 } else {
3795                         r->out.total = NULL;
3796                 }
3797                 if (r->out.total) {
3798                         _mem_save_total_0 = NDR_PULL_GET_MEM_CTX(ndr);
3799                         NDR_PULL_SET_MEM_CTX(ndr, r->out.total, 0);
3800                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total));
3801                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_0, 0);
3802                 }
3803                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3804         }
3805         return NT_STATUS_OK;
3806 }
3807
3808 _PUBLIC_ void ndr_print_dfs_Enum(struct ndr_print *ndr, const char *name, int flags, const struct dfs_Enum *r)
3809 {
3810         ndr_print_struct(ndr, name, "dfs_Enum");
3811         ndr->depth++;
3812         if (flags & NDR_SET_VALUES) {
3813                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3814         }
3815         if (flags & NDR_IN) {
3816                 ndr_print_struct(ndr, "in", "dfs_Enum");
3817                 ndr->depth++;
3818                 ndr_print_uint32(ndr, "level", r->in.level);
3819                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
3820                 ndr_print_ptr(ndr, "info", r->in.info);
3821                 ndr->depth++;
3822                 if (r->in.info) {
3823                         ndr_print_dfs_EnumStruct(ndr, "info", r->in.info);
3824                 }
3825                 ndr->depth--;
3826                 ndr_print_ptr(ndr, "total", r->in.total);
3827                 ndr->depth++;
3828                 if (r->in.total) {
3829                         ndr_print_uint32(ndr, "total", *r->in.total);
3830                 }
3831                 ndr->depth--;
3832                 ndr->depth--;
3833         }
3834         if (flags & NDR_OUT) {
3835                 ndr_print_struct(ndr, "out", "dfs_Enum");
3836                 ndr->depth++;
3837                 ndr_print_ptr(ndr, "info", r->out.info);
3838                 ndr->depth++;
3839                 if (r->out.info) {
3840                         ndr_print_dfs_EnumStruct(ndr, "info", r->out.info);
3841                 }
3842                 ndr->depth--;
3843                 ndr_print_ptr(ndr, "total", r->out.total);
3844                 ndr->depth++;
3845                 if (r->out.total) {
3846                         ndr_print_uint32(ndr, "total", *r->out.total);
3847                 }
3848                 ndr->depth--;
3849                 ndr_print_WERROR(ndr, "result", r->out.result);
3850                 ndr->depth--;
3851         }
3852         ndr->depth--;
3853 }
3854
3855 NTSTATUS ndr_push_dfs_Rename(struct ndr_push *ndr, int flags, const struct dfs_Rename *r)
3856 {
3857         if (flags & NDR_IN) {
3858         }
3859         if (flags & NDR_OUT) {
3860                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3861         }
3862         return NT_STATUS_OK;
3863 }
3864
3865 NTSTATUS ndr_pull_dfs_Rename(struct ndr_pull *ndr, int flags, struct dfs_Rename *r)
3866 {
3867         if (flags & NDR_IN) {
3868         }
3869         if (flags & NDR_OUT) {
3870                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3871         }
3872         return NT_STATUS_OK;
3873 }
3874
3875 _PUBLIC_ void ndr_print_dfs_Rename(struct ndr_print *ndr, const char *name, int flags, const struct dfs_Rename *r)
3876 {
3877         ndr_print_struct(ndr, name, "dfs_Rename");
3878         ndr->depth++;
3879         if (flags & NDR_SET_VALUES) {
3880                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3881         }
3882         if (flags & NDR_IN) {
3883                 ndr_print_struct(ndr, "in", "dfs_Rename");
3884                 ndr->depth++;
3885                 ndr->depth--;
3886         }
3887         if (flags & NDR_OUT) {
3888                 ndr_print_struct(ndr, "out", "dfs_Rename");
3889                 ndr->depth++;
3890                 ndr_print_WERROR(ndr, "result", r->out.result);
3891                 ndr->depth--;
3892         }
3893         ndr->depth--;
3894 }
3895
3896 NTSTATUS ndr_push_dfs_Move(struct ndr_push *ndr, int flags, const struct dfs_Move *r)
3897 {
3898         if (flags & NDR_IN) {
3899         }
3900         if (flags & NDR_OUT) {
3901                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3902         }
3903         return NT_STATUS_OK;
3904 }
3905
3906 NTSTATUS ndr_pull_dfs_Move(struct ndr_pull *ndr, int flags, struct dfs_Move *r)
3907 {
3908         if (flags & NDR_IN) {
3909         }
3910         if (flags & NDR_OUT) {
3911                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3912         }
3913         return NT_STATUS_OK;
3914 }
3915
3916 _PUBLIC_ void ndr_print_dfs_Move(struct ndr_print *ndr, const char *name, int flags, const struct dfs_Move *r)
3917 {
3918         ndr_print_struct(ndr, name, "dfs_Move");
3919         ndr->depth++;
3920         if (flags & NDR_SET_VALUES) {
3921                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3922         }
3923         if (flags & NDR_IN) {
3924                 ndr_print_struct(ndr, "in", "dfs_Move");
3925                 ndr->depth++;
3926                 ndr->depth--;
3927         }
3928         if (flags & NDR_OUT) {
3929                 ndr_print_struct(ndr, "out", "dfs_Move");
3930                 ndr->depth++;
3931                 ndr_print_WERROR(ndr, "result", r->out.result);
3932                 ndr->depth--;
3933         }
3934         ndr->depth--;
3935 }
3936
3937 NTSTATUS ndr_push_dfs_ManagerGetConfigInfo(struct ndr_push *ndr, int flags, const struct dfs_ManagerGetConfigInfo *r)
3938 {
3939         if (flags & NDR_IN) {
3940         }
3941         if (flags & NDR_OUT) {
3942                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3943         }
3944         return NT_STATUS_OK;
3945 }
3946
3947 NTSTATUS ndr_pull_dfs_ManagerGetConfigInfo(struct ndr_pull *ndr, int flags, struct dfs_ManagerGetConfigInfo *r)
3948 {
3949         if (flags & NDR_IN) {
3950         }
3951         if (flags & NDR_OUT) {
3952                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3953         }
3954         return NT_STATUS_OK;
3955 }
3956
3957 _PUBLIC_ void ndr_print_dfs_ManagerGetConfigInfo(struct ndr_print *ndr, const char *name, int flags, const struct dfs_ManagerGetConfigInfo *r)
3958 {
3959         ndr_print_struct(ndr, name, "dfs_ManagerGetConfigInfo");
3960         ndr->depth++;
3961         if (flags & NDR_SET_VALUES) {
3962                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3963         }
3964         if (flags & NDR_IN) {
3965                 ndr_print_struct(ndr, "in", "dfs_ManagerGetConfigInfo");
3966                 ndr->depth++;
3967                 ndr->depth--;
3968         }
3969         if (flags & NDR_OUT) {
3970                 ndr_print_struct(ndr, "out", "dfs_ManagerGetConfigInfo");
3971                 ndr->depth++;
3972                 ndr_print_WERROR(ndr, "result", r->out.result);
3973                 ndr->depth--;
3974         }
3975         ndr->depth--;
3976 }
3977
3978 NTSTATUS ndr_push_dfs_ManagerSendSiteInfo(struct ndr_push *ndr, int flags, const struct dfs_ManagerSendSiteInfo *r)
3979 {
3980         if (flags & NDR_IN) {
3981         }
3982         if (flags & NDR_OUT) {
3983                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3984         }
3985         return NT_STATUS_OK;
3986 }
3987
3988 NTSTATUS ndr_pull_dfs_ManagerSendSiteInfo(struct ndr_pull *ndr, int flags, struct dfs_ManagerSendSiteInfo *r)
3989 {
3990         if (flags & NDR_IN) {
3991         }
3992         if (flags & NDR_OUT) {
3993                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3994         }
3995         return NT_STATUS_OK;
3996 }
3997
3998 _PUBLIC_ void ndr_print_dfs_ManagerSendSiteInfo(struct ndr_print *ndr, const char *name, int flags, const struct dfs_ManagerSendSiteInfo *r)
3999 {
4000         ndr_print_struct(ndr, name, "dfs_ManagerSendSiteInfo");
4001         ndr->depth++;
4002         if (flags & NDR_SET_VALUES) {
4003                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4004         }
4005         if (flags & NDR_IN) {
4006                 ndr_print_struct(ndr, "in", "dfs_ManagerSendSiteInfo");
4007                 ndr->depth++;
4008                 ndr->depth--;
4009         }
4010         if (flags & NDR_OUT) {
4011                 ndr_print_struct(ndr, "out", "dfs_ManagerSendSiteInfo");
4012                 ndr->depth++;
4013                 ndr_print_WERROR(ndr, "result", r->out.result);
4014                 ndr->depth--;
4015         }
4016         ndr->depth--;
4017 }
4018
4019 NTSTATUS ndr_push_dfs_AddFtRoot(struct ndr_push *ndr, int flags, const struct dfs_AddFtRoot *r)
4020 {
4021         if (flags & NDR_IN) {
4022                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
4023                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4024                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
4025                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4026                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dns_servername, CH_UTF16)));
4027                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4028                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dns_servername, CH_UTF16)));
4029                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dns_servername, ndr_charset_length(r->in.dns_servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4030                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dfsname, CH_UTF16)));
4031                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4032                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dfsname, CH_UTF16)));
4033                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dfsname, ndr_charset_length(r->in.dfsname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4034                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.rootshare, CH_UTF16)));
4035                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4036                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.rootshare, CH_UTF16)));
4037                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.rootshare, ndr_charset_length(r->in.rootshare, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4038                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.comment, CH_UTF16)));
4039                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4040                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.comment, CH_UTF16)));
4041                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.comment, ndr_charset_length(r->in.comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4042                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dfs_config_dn, CH_UTF16)));
4043                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4044                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dfs_config_dn, CH_UTF16)));
4045                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dfs_config_dn, ndr_charset_length(r->in.dfs_config_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4046                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.unknown1));
4047                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
4048                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown2));
4049                 if (r->in.unknown2) {
4050                         NDR_CHECK(ndr_push_unique_ptr(ndr, *r->in.unknown2));
4051                         if (*r->in.unknown2) {
4052                                 NDR_CHECK(ndr_push_dfs_UnknownStruct(ndr, NDR_SCALARS|NDR_BUFFERS, *r->in.unknown2));
4053                         }
4054                 }
4055         }
4056         if (flags & NDR_OUT) {
4057                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.unknown2));
4058                 if (r->out.unknown2) {
4059                         NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.unknown2));
4060                         if (*r->out.unknown2) {
4061                                 NDR_CHECK(ndr_push_dfs_UnknownStruct(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.unknown2));
4062                         }
4063                 }
4064                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4065         }
4066         return NT_STATUS_OK;
4067 }
4068
4069 NTSTATUS ndr_pull_dfs_AddFtRoot(struct ndr_pull *ndr, int flags, struct dfs_AddFtRoot *r)
4070 {
4071         uint32_t _ptr_unknown2;
4072         TALLOC_CTX *_mem_save_unknown2_0;
4073         TALLOC_CTX *_mem_save_unknown2_1;
4074         if (flags & NDR_IN) {
4075                 ZERO_STRUCT(r->out);
4076
4077                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
4078                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
4079                 if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
4080                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.servername), ndr_get_array_length(ndr, &r->in.servername));
4081                 }
4082                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
4083                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
4084                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dns_servername));
4085                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dns_servername));
4086                 if (ndr_get_array_length(ndr, &r->in.dns_servername) > ndr_get_array_size(ndr, &r->in.dns_servername)) {
4087                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.dns_servername), ndr_get_array_length(ndr, &r->in.dns_servername));
4088                 }
4089                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.dns_servername), sizeof(uint16_t)));
4090                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dns_servername, ndr_get_array_length(ndr, &r->in.dns_servername), sizeof(uint16_t), CH_UTF16));
4091                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dfsname));
4092                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dfsname));
4093                 if (ndr_get_array_length(ndr, &r->in.dfsname) > ndr_get_array_size(ndr, &r->in.dfsname)) {
4094                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.dfsname), ndr_get_array_length(ndr, &r->in.dfsname));
4095                 }
4096                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.dfsname), sizeof(uint16_t)));
4097                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dfsname, ndr_get_array_length(ndr, &r->in.dfsname), sizeof(uint16_t), CH_UTF16));
4098                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.rootshare));
4099                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.rootshare));
4100                 if (ndr_get_array_length(ndr, &r->in.rootshare) > ndr_get_array_size(ndr, &r->in.rootshare)) {
4101                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.rootshare), ndr_get_array_length(ndr, &r->in.rootshare));
4102                 }
4103                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.rootshare), sizeof(uint16_t)));
4104                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.rootshare, ndr_get_array_length(ndr, &r->in.rootshare), sizeof(uint16_t), CH_UTF16));
4105                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.comment));
4106                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.comment));
4107                 if (ndr_get_array_length(ndr, &r->in.comment) > ndr_get_array_size(ndr, &r->in.comment)) {
4108                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.comment), ndr_get_array_length(ndr, &r->in.comment));
4109                 }
4110                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.comment), sizeof(uint16_t)));
4111                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.comment, ndr_get_array_length(ndr, &r->in.comment), sizeof(uint16_t), CH_UTF16));
4112                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dfs_config_dn));
4113                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dfs_config_dn));
4114                 if (ndr_get_array_length(ndr, &r->in.dfs_config_dn) > ndr_get_array_size(ndr, &r->in.dfs_config_dn)) {
4115                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.dfs_config_dn), ndr_get_array_length(ndr, &r->in.dfs_config_dn));
4116                 }
4117                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.dfs_config_dn), sizeof(uint16_t)));
4118                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dfs_config_dn, ndr_get_array_length(ndr, &r->in.dfs_config_dn), sizeof(uint16_t), CH_UTF16));
4119                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.unknown1));
4120                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
4121                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown2));
4122                 if (_ptr_unknown2) {
4123                         NDR_PULL_ALLOC(ndr, r->in.unknown2);
4124                 } else {
4125                         r->in.unknown2 = NULL;
4126                 }
4127                 if (r->in.unknown2) {
4128                         _mem_save_unknown2_0 = NDR_PULL_GET_MEM_CTX(ndr);
4129                         NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown2, 0);
4130                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown2));
4131                         if (_ptr_unknown2) {
4132                                 NDR_PULL_ALLOC(ndr, *r->in.unknown2);
4133                         } else {
4134                                 *r->in.unknown2 = NULL;
4135                         }
4136                         if (*r->in.unknown2) {
4137                                 _mem_save_unknown2_1 = NDR_PULL_GET_MEM_CTX(ndr);
4138                                 NDR_PULL_SET_MEM_CTX(ndr, *r->in.unknown2, 0);
4139                                 NDR_CHECK(ndr_pull_dfs_UnknownStruct(ndr, NDR_SCALARS|NDR_BUFFERS, *r->in.unknown2));
4140                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown2_1, 0);
4141                         }
4142                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown2_0, 0);
4143                 }
4144         }
4145         if (flags & NDR_OUT) {
4146                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown2));
4147                 if (_ptr_unknown2) {
4148                         NDR_PULL_ALLOC(ndr, r->out.unknown2);
4149                 } else {
4150                         r->out.unknown2 = NULL;
4151                 }
4152                 if (r->out.unknown2) {
4153                         _mem_save_unknown2_0 = NDR_PULL_GET_MEM_CTX(ndr);
4154                         NDR_PULL_SET_MEM_CTX(ndr, r->out.unknown2, 0);
4155                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown2));
4156                         if (_ptr_unknown2) {
4157                                 NDR_PULL_ALLOC(ndr, *r->out.unknown2);
4158                         } else {
4159                                 *r->out.unknown2 = NULL;
4160                         }
4161                         if (*r->out.unknown2) {
4162                                 _mem_save_unknown2_1 = NDR_PULL_GET_MEM_CTX(ndr);
4163                                 NDR_PULL_SET_MEM_CTX(ndr, *r->out.unknown2, 0);
4164                                 NDR_CHECK(ndr_pull_dfs_UnknownStruct(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.unknown2));
4165                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown2_1, 0);
4166                         }
4167                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown2_0, 0);
4168                 }
4169                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4170         }
4171         return NT_STATUS_OK;
4172 }
4173
4174 _PUBLIC_ void ndr_print_dfs_AddFtRoot(struct ndr_print *ndr, const char *name, int flags, const struct dfs_AddFtRoot *r)
4175 {
4176         ndr_print_struct(ndr, name, "dfs_AddFtRoot");
4177         ndr->depth++;
4178         if (flags & NDR_SET_VALUES) {
4179                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4180         }
4181         if (flags & NDR_IN) {
4182                 ndr_print_struct(ndr, "in", "dfs_AddFtRoot");
4183                 ndr->depth++;
4184                 ndr_print_string(ndr, "servername", r->in.servername);
4185                 ndr_print_string(ndr, "dns_servername", r->in.dns_servername);
4186                 ndr_print_string(ndr, "dfsname", r->in.dfsname);
4187                 ndr_print_string(ndr, "rootshare", r->in.rootshare);
4188                 ndr_print_string(ndr, "comment", r->in.comment);
4189                 ndr_print_string(ndr, "dfs_config_dn", r->in.dfs_config_dn);
4190                 ndr_print_uint8(ndr, "unknown1", r->in.unknown1);
4191                 ndr_print_uint32(ndr, "flags", r->in.flags);
4192                 ndr_print_ptr(ndr, "unknown2", r->in.unknown2);
4193                 ndr->depth++;
4194                 if (r->in.unknown2) {
4195                         ndr_print_ptr(ndr, "unknown2", *r->in.unknown2);
4196                         ndr->depth++;
4197                         if (*r->in.unknown2) {
4198                                 ndr_print_dfs_UnknownStruct(ndr, "unknown2", *r->in.unknown2);
4199                         }
4200                         ndr->depth--;
4201                 }
4202                 ndr->depth--;
4203                 ndr->depth--;
4204         }
4205         if (flags & NDR_OUT) {
4206                 ndr_print_struct(ndr, "out", "dfs_AddFtRoot");
4207                 ndr->depth++;
4208                 ndr_print_ptr(ndr, "unknown2", r->out.unknown2);
4209                 ndr->depth++;
4210                 if (r->out.unknown2) {
4211                         ndr_print_ptr(ndr, "unknown2", *r->out.unknown2);
4212                         ndr->depth++;
4213                         if (*r->out.unknown2) {
4214                                 ndr_print_dfs_UnknownStruct(ndr, "unknown2", *r->out.unknown2);
4215                         }
4216                         ndr->depth--;
4217                 }
4218                 ndr->depth--;
4219                 ndr_print_WERROR(ndr, "result", r->out.result);
4220                 ndr->depth--;
4221         }
4222         ndr->depth--;
4223 }
4224
4225 NTSTATUS ndr_push_dfs_RemoveFtRoot(struct ndr_push *ndr, int flags, const struct dfs_RemoveFtRoot *r)
4226 {
4227         if (flags & NDR_IN) {
4228                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
4229                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4230                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
4231                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4232                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dns_servername, CH_UTF16)));
4233                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4234                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dns_servername, CH_UTF16)));
4235                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dns_servername, ndr_charset_length(r->in.dns_servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4236                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dfsname, CH_UTF16)));
4237                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4238                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dfsname, CH_UTF16)));
4239                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dfsname, ndr_charset_length(r->in.dfsname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4240                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.rootshare, CH_UTF16)));
4241                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4242                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.rootshare, CH_UTF16)));
4243                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.rootshare, ndr_charset_length(r->in.rootshare, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4244                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
4245                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown));
4246                 if (r->in.unknown) {
4247                         NDR_CHECK(ndr_push_unique_ptr(ndr, *r->in.unknown));
4248                         if (*r->in.unknown) {
4249                                 NDR_CHECK(ndr_push_dfs_UnknownStruct(ndr, NDR_SCALARS|NDR_BUFFERS, *r->in.unknown));
4250                         }
4251                 }
4252         }
4253         if (flags & NDR_OUT) {
4254                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.unknown));
4255                 if (r->out.unknown) {
4256                         NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.unknown));
4257                         if (*r->out.unknown) {
4258                                 NDR_CHECK(ndr_push_dfs_UnknownStruct(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.unknown));
4259                         }
4260                 }
4261                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4262         }
4263         return NT_STATUS_OK;
4264 }
4265
4266 NTSTATUS ndr_pull_dfs_RemoveFtRoot(struct ndr_pull *ndr, int flags, struct dfs_RemoveFtRoot *r)
4267 {
4268         uint32_t _ptr_unknown;
4269         TALLOC_CTX *_mem_save_unknown_0;
4270         TALLOC_CTX *_mem_save_unknown_1;
4271         if (flags & NDR_IN) {
4272                 ZERO_STRUCT(r->out);
4273
4274                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
4275                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
4276                 if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
4277                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.servername), ndr_get_array_length(ndr, &r->in.servername));
4278                 }
4279                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
4280                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
4281                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dns_servername));
4282                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dns_servername));
4283                 if (ndr_get_array_length(ndr, &r->in.dns_servername) > ndr_get_array_size(ndr, &r->in.dns_servername)) {
4284                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.dns_servername), ndr_get_array_length(ndr, &r->in.dns_servername));
4285                 }
4286                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.dns_servername), sizeof(uint16_t)));
4287                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dns_servername, ndr_get_array_length(ndr, &r->in.dns_servername), sizeof(uint16_t), CH_UTF16));
4288                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dfsname));
4289                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dfsname));
4290                 if (ndr_get_array_length(ndr, &r->in.dfsname) > ndr_get_array_size(ndr, &r->in.dfsname)) {
4291                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.dfsname), ndr_get_array_length(ndr, &r->in.dfsname));
4292                 }
4293                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.dfsname), sizeof(uint16_t)));
4294                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dfsname, ndr_get_array_length(ndr, &r->in.dfsname), sizeof(uint16_t), CH_UTF16));
4295                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.rootshare));
4296                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.rootshare));
4297                 if (ndr_get_array_length(ndr, &r->in.rootshare) > ndr_get_array_size(ndr, &r->in.rootshare)) {
4298                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.rootshare), ndr_get_array_length(ndr, &r->in.rootshare));
4299                 }
4300                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.rootshare), sizeof(uint16_t)));
4301                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.rootshare, ndr_get_array_length(ndr, &r->in.rootshare), sizeof(uint16_t), CH_UTF16));
4302                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
4303                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown));
4304                 if (_ptr_unknown) {
4305                         NDR_PULL_ALLOC(ndr, r->in.unknown);
4306                 } else {
4307                         r->in.unknown = NULL;
4308                 }
4309                 if (r->in.unknown) {
4310                         _mem_save_unknown_0 = NDR_PULL_GET_MEM_CTX(ndr);
4311                         NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown, 0);
4312                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown));
4313                         if (_ptr_unknown) {
4314                                 NDR_PULL_ALLOC(ndr, *r->in.unknown);
4315                         } else {
4316                                 *r->in.unknown = NULL;
4317                         }
4318                         if (*r->in.unknown) {
4319                                 _mem_save_unknown_1 = NDR_PULL_GET_MEM_CTX(ndr);
4320                                 NDR_PULL_SET_MEM_CTX(ndr, *r->in.unknown, 0);
4321                                 NDR_CHECK(ndr_pull_dfs_UnknownStruct(ndr, NDR_SCALARS|NDR_BUFFERS, *r->in.unknown));
4322                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown_1, 0);
4323                         }
4324                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown_0, 0);
4325                 }
4326         }
4327         if (flags & NDR_OUT) {
4328                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown));
4329                 if (_ptr_unknown) {
4330                         NDR_PULL_ALLOC(ndr, r->out.unknown);
4331                 } else {
4332                         r->out.unknown = NULL;
4333                 }
4334                 if (r->out.unknown) {
4335                         _mem_save_unknown_0 = NDR_PULL_GET_MEM_CTX(ndr);
4336                         NDR_PULL_SET_MEM_CTX(ndr, r->out.unknown, 0);
4337                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown));
4338                         if (_ptr_unknown) {
4339                                 NDR_PULL_ALLOC(ndr, *r->out.unknown);
4340                         } else {
4341                                 *r->out.unknown = NULL;
4342                         }
4343                         if (*r->out.unknown) {
4344                                 _mem_save_unknown_1 = NDR_PULL_GET_MEM_CTX(ndr);
4345                                 NDR_PULL_SET_MEM_CTX(ndr, *r->out.unknown, 0);
4346                                 NDR_CHECK(ndr_pull_dfs_UnknownStruct(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.unknown));
4347                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown_1, 0);
4348                         }
4349                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown_0, 0);
4350                 }
4351                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4352         }
4353         return NT_STATUS_OK;
4354 }
4355
4356 _PUBLIC_ void ndr_print_dfs_RemoveFtRoot(struct ndr_print *ndr, const char *name, int flags, const struct dfs_RemoveFtRoot *r)
4357 {
4358         ndr_print_struct(ndr, name, "dfs_RemoveFtRoot");
4359         ndr->depth++;
4360         if (flags & NDR_SET_VALUES) {
4361                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4362         }
4363         if (flags & NDR_IN) {
4364                 ndr_print_struct(ndr, "in", "dfs_RemoveFtRoot");
4365                 ndr->depth++;
4366                 ndr_print_string(ndr, "servername", r->in.servername);
4367                 ndr_print_string(ndr, "dns_servername", r->in.dns_servername);
4368                 ndr_print_string(ndr, "dfsname", r->in.dfsname);
4369                 ndr_print_string(ndr, "rootshare", r->in.rootshare);
4370                 ndr_print_uint32(ndr, "flags", r->in.flags);
4371                 ndr_print_ptr(ndr, "unknown", r->in.unknown);
4372                 ndr->depth++;
4373                 if (r->in.unknown) {
4374                         ndr_print_ptr(ndr, "unknown", *r->in.unknown);
4375                         ndr->depth++;
4376                         if (*r->in.unknown) {
4377                                 ndr_print_dfs_UnknownStruct(ndr, "unknown", *r->in.unknown);
4378                         }
4379                         ndr->depth--;
4380                 }
4381                 ndr->depth--;
4382                 ndr->depth--;
4383         }
4384         if (flags & NDR_OUT) {
4385                 ndr_print_struct(ndr, "out", "dfs_RemoveFtRoot");
4386                 ndr->depth++;
4387                 ndr_print_ptr(ndr, "unknown", r->out.unknown);
4388                 ndr->depth++;
4389                 if (r->out.unknown) {
4390                         ndr_print_ptr(ndr, "unknown", *r->out.unknown);
4391                         ndr->depth++;
4392                         if (*r->out.unknown) {
4393                                 ndr_print_dfs_UnknownStruct(ndr, "unknown", *r->out.unknown);
4394                         }
4395                         ndr->depth--;
4396                 }
4397                 ndr->depth--;
4398                 ndr_print_WERROR(ndr, "result", r->out.result);
4399                 ndr->depth--;
4400         }
4401         ndr->depth--;
4402 }
4403
4404 NTSTATUS ndr_push_dfs_AddStdRoot(struct ndr_push *ndr, int flags, const struct dfs_AddStdRoot *r)
4405 {
4406         if (flags & NDR_IN) {
4407                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
4408                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4409                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
4410                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4411                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.rootshare, CH_UTF16)));
4412                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4413                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.rootshare, CH_UTF16)));
4414                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.rootshare, ndr_charset_length(r->in.rootshare, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4415                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.comment, CH_UTF16)));
4416                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4417                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.comment, CH_UTF16)));
4418                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.comment, ndr_charset_length(r->in.comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4419                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
4420         }
4421         if (flags & NDR_OUT) {
4422                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4423         }
4424         return NT_STATUS_OK;
4425 }
4426
4427 NTSTATUS ndr_pull_dfs_AddStdRoot(struct ndr_pull *ndr, int flags, struct dfs_AddStdRoot *r)
4428 {
4429         if (flags & NDR_IN) {
4430                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
4431                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
4432                 if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
4433                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.servername), ndr_get_array_length(ndr, &r->in.servername));
4434                 }
4435                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
4436                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
4437                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.rootshare));
4438                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.rootshare));
4439                 if (ndr_get_array_length(ndr, &r->in.rootshare) > ndr_get_array_size(ndr, &r->in.rootshare)) {
4440                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.rootshare), ndr_get_array_length(ndr, &r->in.rootshare));
4441                 }
4442                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.rootshare), sizeof(uint16_t)));
4443                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.rootshare, ndr_get_array_length(ndr, &r->in.rootshare), sizeof(uint16_t), CH_UTF16));
4444                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.comment));
4445                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.comment));
4446                 if (ndr_get_array_length(ndr, &r->in.comment) > ndr_get_array_size(ndr, &r->in.comment)) {
4447                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.comment), ndr_get_array_length(ndr, &r->in.comment));
4448                 }
4449                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.comment), sizeof(uint16_t)));
4450                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.comment, ndr_get_array_length(ndr, &r->in.comment), sizeof(uint16_t), CH_UTF16));
4451                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
4452         }
4453         if (flags & NDR_OUT) {
4454                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4455         }
4456         return NT_STATUS_OK;
4457 }
4458
4459 _PUBLIC_ void ndr_print_dfs_AddStdRoot(struct ndr_print *ndr, const char *name, int flags, const struct dfs_AddStdRoot *r)
4460 {
4461         ndr_print_struct(ndr, name, "dfs_AddStdRoot");
4462         ndr->depth++;
4463         if (flags & NDR_SET_VALUES) {
4464                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4465         }
4466         if (flags & NDR_IN) {
4467                 ndr_print_struct(ndr, "in", "dfs_AddStdRoot");
4468                 ndr->depth++;
4469                 ndr_print_string(ndr, "servername", r->in.servername);
4470                 ndr_print_string(ndr, "rootshare", r->in.rootshare);
4471                 ndr_print_string(ndr, "comment", r->in.comment);
4472                 ndr_print_uint32(ndr, "flags", r->in.flags);
4473                 ndr->depth--;
4474         }
4475         if (flags & NDR_OUT) {
4476                 ndr_print_struct(ndr, "out", "dfs_AddStdRoot");
4477                 ndr->depth++;
4478                 ndr_print_WERROR(ndr, "result", r->out.result);
4479                 ndr->depth--;
4480         }
4481         ndr->depth--;
4482 }
4483
4484 NTSTATUS ndr_push_dfs_RemoveStdRoot(struct ndr_push *ndr, int flags, const struct dfs_RemoveStdRoot *r)
4485 {
4486         if (flags & NDR_IN) {
4487                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
4488                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4489                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
4490                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4491                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.rootshare, CH_UTF16)));
4492                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4493                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.rootshare, CH_UTF16)));
4494                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.rootshare, ndr_charset_length(r->in.rootshare, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4495                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
4496         }
4497         if (flags & NDR_OUT) {
4498                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4499         }
4500         return NT_STATUS_OK;
4501 }
4502
4503 NTSTATUS ndr_pull_dfs_RemoveStdRoot(struct ndr_pull *ndr, int flags, struct dfs_RemoveStdRoot *r)
4504 {
4505         if (flags & NDR_IN) {
4506                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
4507                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
4508                 if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
4509                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.servername), ndr_get_array_length(ndr, &r->in.servername));
4510                 }
4511                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
4512                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
4513                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.rootshare));
4514                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.rootshare));
4515                 if (ndr_get_array_length(ndr, &r->in.rootshare) > ndr_get_array_size(ndr, &r->in.rootshare)) {
4516                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.rootshare), ndr_get_array_length(ndr, &r->in.rootshare));
4517                 }
4518                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.rootshare), sizeof(uint16_t)));
4519                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.rootshare, ndr_get_array_length(ndr, &r->in.rootshare), sizeof(uint16_t), CH_UTF16));
4520                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
4521         }
4522         if (flags & NDR_OUT) {
4523                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4524         }
4525         return NT_STATUS_OK;
4526 }
4527
4528 _PUBLIC_ void ndr_print_dfs_RemoveStdRoot(struct ndr_print *ndr, const char *name, int flags, const struct dfs_RemoveStdRoot *r)
4529 {
4530         ndr_print_struct(ndr, name, "dfs_RemoveStdRoot");
4531         ndr->depth++;
4532         if (flags & NDR_SET_VALUES) {
4533                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4534         }
4535         if (flags & NDR_IN) {
4536                 ndr_print_struct(ndr, "in", "dfs_RemoveStdRoot");
4537                 ndr->depth++;
4538                 ndr_print_string(ndr, "servername", r->in.servername);
4539                 ndr_print_string(ndr, "rootshare", r->in.rootshare);
4540                 ndr_print_uint32(ndr, "flags", r->in.flags);
4541                 ndr->depth--;
4542         }
4543         if (flags & NDR_OUT) {
4544                 ndr_print_struct(ndr, "out", "dfs_RemoveStdRoot");
4545                 ndr->depth++;
4546                 ndr_print_WERROR(ndr, "result", r->out.result);
4547                 ndr->depth--;
4548         }
4549         ndr->depth--;
4550 }
4551
4552 NTSTATUS ndr_push_dfs_ManagerInitialize(struct ndr_push *ndr, int flags, const struct dfs_ManagerInitialize *r)
4553 {
4554         if (flags & NDR_IN) {
4555                 if (r->in.servername == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4556                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
4557                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4558                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
4559                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4560                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
4561         }
4562         if (flags & NDR_OUT) {
4563                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4564         }
4565         return NT_STATUS_OK;
4566 }
4567
4568 NTSTATUS ndr_pull_dfs_ManagerInitialize(struct ndr_pull *ndr, int flags, struct dfs_ManagerInitialize *r)
4569 {
4570         if (flags & NDR_IN) {
4571                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
4572                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
4573                 if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
4574                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.servername), ndr_get_array_length(ndr, &r->in.servername));
4575                 }
4576                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
4577                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
4578                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
4579         }
4580         if (flags & NDR_OUT) {
4581                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4582         }
4583         return NT_STATUS_OK;
4584 }
4585
4586 _PUBLIC_ void ndr_print_dfs_ManagerInitialize(struct ndr_print *ndr, const char *name, int flags, const struct dfs_ManagerInitialize *r)
4587 {
4588         ndr_print_struct(ndr, name, "dfs_ManagerInitialize");
4589         ndr->depth++;
4590         if (flags & NDR_SET_VALUES) {
4591                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4592         }
4593         if (flags & NDR_IN) {
4594                 ndr_print_struct(ndr, "in", "dfs_ManagerInitialize");
4595                 ndr->depth++;
4596                 ndr_print_ptr(ndr, "servername", r->in.servername);
4597                 ndr->depth++;
4598                 ndr_print_string(ndr, "servername", r->in.servername);
4599                 ndr->depth--;
4600                 ndr_print_uint32(ndr, "flags", r->in.flags);
4601                 ndr->depth--;
4602         }
4603         if (flags & NDR_OUT) {
4604                 ndr_print_struct(ndr, "out", "dfs_ManagerInitialize");
4605                 ndr->depth++;
4606                 ndr_print_WERROR(ndr, "result", r->out.result);
4607                 ndr->depth--;
4608         }
4609         ndr->depth--;
4610 }
4611
4612 NTSTATUS ndr_push_dfs_AddStdRootForced(struct ndr_push *ndr, int flags, const struct dfs_AddStdRootForced *r)
4613 {
4614         if (flags & NDR_IN) {
4615                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
4616                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4617                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
4618                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4619                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.rootshare, CH_UTF16)));
4620                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4621                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.rootshare, CH_UTF16)));
4622                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.rootshare, ndr_charset_length(r->in.rootshare, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4623                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.comment, CH_UTF16)));
4624                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4625                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.comment, CH_UTF16)));
4626                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.comment, ndr_charset_length(r->in.comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4627                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.store, CH_UTF16)));
4628                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4629                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.store, CH_UTF16)));
4630                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.store, ndr_charset_length(r->in.store, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4631         }
4632         if (flags & NDR_OUT) {
4633                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4634         }
4635         return NT_STATUS_OK;
4636 }
4637
4638 NTSTATUS ndr_pull_dfs_AddStdRootForced(struct ndr_pull *ndr, int flags, struct dfs_AddStdRootForced *r)
4639 {
4640         if (flags & NDR_IN) {
4641                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
4642                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
4643                 if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
4644                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.servername), ndr_get_array_length(ndr, &r->in.servername));
4645                 }
4646                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
4647                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
4648                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.rootshare));
4649                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.rootshare));
4650                 if (ndr_get_array_length(ndr, &r->in.rootshare) > ndr_get_array_size(ndr, &r->in.rootshare)) {
4651                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.rootshare), ndr_get_array_length(ndr, &r->in.rootshare));
4652                 }
4653                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.rootshare), sizeof(uint16_t)));
4654                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.rootshare, ndr_get_array_length(ndr, &r->in.rootshare), sizeof(uint16_t), CH_UTF16));
4655                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.comment));
4656                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.comment));
4657                 if (ndr_get_array_length(ndr, &r->in.comment) > ndr_get_array_size(ndr, &r->in.comment)) {
4658                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.comment), ndr_get_array_length(ndr, &r->in.comment));
4659                 }
4660                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.comment), sizeof(uint16_t)));
4661                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.comment, ndr_get_array_length(ndr, &r->in.comment), sizeof(uint16_t), CH_UTF16));
4662                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.store));
4663                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.store));
4664                 if (ndr_get_array_length(ndr, &r->in.store) > ndr_get_array_size(ndr, &r->in.store)) {
4665                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.store), ndr_get_array_length(ndr, &r->in.store));
4666                 }
4667                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.store), sizeof(uint16_t)));
4668                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.store, ndr_get_array_length(ndr, &r->in.store), sizeof(uint16_t), CH_UTF16));
4669         }
4670         if (flags & NDR_OUT) {
4671                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4672         }
4673         return NT_STATUS_OK;
4674 }
4675
4676 _PUBLIC_ void ndr_print_dfs_AddStdRootForced(struct ndr_print *ndr, const char *name, int flags, const struct dfs_AddStdRootForced *r)
4677 {
4678         ndr_print_struct(ndr, name, "dfs_AddStdRootForced");
4679         ndr->depth++;
4680         if (flags & NDR_SET_VALUES) {
4681                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4682         }
4683         if (flags & NDR_IN) {
4684                 ndr_print_struct(ndr, "in", "dfs_AddStdRootForced");
4685                 ndr->depth++;
4686                 ndr_print_string(ndr, "servername", r->in.servername);
4687                 ndr_print_string(ndr, "rootshare", r->in.rootshare);
4688                 ndr_print_string(ndr, "comment", r->in.comment);
4689                 ndr_print_string(ndr, "store", r->in.store);
4690                 ndr->depth--;
4691         }
4692         if (flags & NDR_OUT) {
4693                 ndr_print_struct(ndr, "out", "dfs_AddStdRootForced");
4694                 ndr->depth++;
4695                 ndr_print_WERROR(ndr, "result", r->out.result);
4696                 ndr->depth--;
4697         }
4698         ndr->depth--;
4699 }
4700
4701 NTSTATUS ndr_push_dfs_GetDcAddress(struct ndr_push *ndr, int flags, const struct dfs_GetDcAddress *r)
4702 {
4703         if (flags & NDR_IN) {
4704         }
4705         if (flags & NDR_OUT) {
4706                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4707         }
4708         return NT_STATUS_OK;
4709 }
4710
4711 NTSTATUS ndr_pull_dfs_GetDcAddress(struct ndr_pull *ndr, int flags, struct dfs_GetDcAddress *r)
4712 {
4713         if (flags & NDR_IN) {
4714         }
4715         if (flags & NDR_OUT) {
4716                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4717         }
4718         return NT_STATUS_OK;
4719 }
4720
4721 _PUBLIC_ void ndr_print_dfs_GetDcAddress(struct ndr_print *ndr, const char *name, int flags, const struct dfs_GetDcAddress *r)
4722 {
4723         ndr_print_struct(ndr, name, "dfs_GetDcAddress");
4724         ndr->depth++;
4725         if (flags & NDR_SET_VALUES) {
4726                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4727         }
4728         if (flags & NDR_IN) {
4729                 ndr_print_struct(ndr, "in", "dfs_GetDcAddress");
4730                 ndr->depth++;
4731                 ndr->depth--;
4732         }
4733         if (flags & NDR_OUT) {
4734                 ndr_print_struct(ndr, "out", "dfs_GetDcAddress");
4735                 ndr->depth++;
4736                 ndr_print_WERROR(ndr, "result", r->out.result);
4737                 ndr->depth--;
4738         }
4739         ndr->depth--;
4740 }
4741
4742 NTSTATUS ndr_push_dfs_SetDcAddress(struct ndr_push *ndr, int flags, const struct dfs_SetDcAddress *r)
4743 {
4744         if (flags & NDR_IN) {
4745         }
4746         if (flags & NDR_OUT) {
4747                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4748         }
4749         return NT_STATUS_OK;
4750 }
4751
4752 NTSTATUS ndr_pull_dfs_SetDcAddress(struct ndr_pull *ndr, int flags, struct dfs_SetDcAddress *r)
4753 {
4754         if (flags & NDR_IN) {
4755         }
4756         if (flags & NDR_OUT) {
4757                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4758         }
4759         return NT_STATUS_OK;
4760 }
4761
4762 _PUBLIC_ void ndr_print_dfs_SetDcAddress(struct ndr_print *ndr, const char *name, int flags, const struct dfs_SetDcAddress *r)
4763 {
4764         ndr_print_struct(ndr, name, "dfs_SetDcAddress");
4765         ndr->depth++;
4766         if (flags & NDR_SET_VALUES) {
4767                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4768         }
4769         if (flags & NDR_IN) {
4770                 ndr_print_struct(ndr, "in", "dfs_SetDcAddress");
4771                 ndr->depth++;
4772                 ndr->depth--;
4773         }
4774         if (flags & NDR_OUT) {
4775                 ndr_print_struct(ndr, "out", "dfs_SetDcAddress");
4776                 ndr->depth++;
4777                 ndr_print_WERROR(ndr, "result", r->out.result);
4778                 ndr->depth--;
4779         }
4780         ndr->depth--;
4781 }
4782
4783 NTSTATUS ndr_push_dfs_FlushFtTable(struct ndr_push *ndr, int flags, const struct dfs_FlushFtTable *r)
4784 {
4785         if (flags & NDR_IN) {
4786                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
4787                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4788                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
4789                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4790                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.rootshare, CH_UTF16)));
4791                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4792                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.rootshare, CH_UTF16)));
4793                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.rootshare, ndr_charset_length(r->in.rootshare, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4794         }
4795         if (flags & NDR_OUT) {
4796                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4797         }
4798         return NT_STATUS_OK;
4799 }
4800
4801 NTSTATUS ndr_pull_dfs_FlushFtTable(struct ndr_pull *ndr, int flags, struct dfs_FlushFtTable *r)
4802 {
4803         if (flags & NDR_IN) {
4804                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
4805                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
4806                 if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
4807                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.servername), ndr_get_array_length(ndr, &r->in.servername));
4808                 }
4809                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
4810                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
4811                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.rootshare));
4812                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.rootshare));
4813                 if (ndr_get_array_length(ndr, &r->in.rootshare) > ndr_get_array_size(ndr, &r->in.rootshare)) {
4814                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.rootshare), ndr_get_array_length(ndr, &r->in.rootshare));
4815                 }
4816                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.rootshare), sizeof(uint16_t)));
4817                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.rootshare, ndr_get_array_length(ndr, &r->in.rootshare), sizeof(uint16_t), CH_UTF16));
4818         }
4819         if (flags & NDR_OUT) {
4820                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4821         }
4822         return NT_STATUS_OK;
4823 }
4824
4825 _PUBLIC_ void ndr_print_dfs_FlushFtTable(struct ndr_print *ndr, const char *name, int flags, const struct dfs_FlushFtTable *r)
4826 {
4827         ndr_print_struct(ndr, name, "dfs_FlushFtTable");
4828         ndr->depth++;
4829         if (flags & NDR_SET_VALUES) {
4830                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4831         }
4832         if (flags & NDR_IN) {
4833                 ndr_print_struct(ndr, "in", "dfs_FlushFtTable");
4834                 ndr->depth++;
4835                 ndr_print_string(ndr, "servername", r->in.servername);
4836                 ndr_print_string(ndr, "rootshare", r->in.rootshare);
4837                 ndr->depth--;
4838         }
4839         if (flags & NDR_OUT) {
4840                 ndr_print_struct(ndr, "out", "dfs_FlushFtTable");
4841                 ndr->depth++;
4842                 ndr_print_WERROR(ndr, "result", r->out.result);
4843                 ndr->depth--;
4844         }
4845         ndr->depth--;
4846 }
4847
4848 NTSTATUS ndr_push_dfs_Add2(struct ndr_push *ndr, int flags, const struct dfs_Add2 *r)
4849 {
4850         if (flags & NDR_IN) {
4851         }
4852         if (flags & NDR_OUT) {
4853                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4854         }
4855         return NT_STATUS_OK;
4856 }
4857
4858 NTSTATUS ndr_pull_dfs_Add2(struct ndr_pull *ndr, int flags, struct dfs_Add2 *r)
4859 {
4860         if (flags & NDR_IN) {
4861         }
4862         if (flags & NDR_OUT) {
4863                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4864         }
4865         return NT_STATUS_OK;
4866 }
4867
4868 _PUBLIC_ void ndr_print_dfs_Add2(struct ndr_print *ndr, const char *name, int flags, const struct dfs_Add2 *r)
4869 {
4870         ndr_print_struct(ndr, name, "dfs_Add2");
4871         ndr->depth++;
4872         if (flags & NDR_SET_VALUES) {
4873                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4874         }
4875         if (flags & NDR_IN) {
4876                 ndr_print_struct(ndr, "in", "dfs_Add2");
4877                 ndr->depth++;
4878                 ndr->depth--;
4879         }
4880         if (flags & NDR_OUT) {
4881                 ndr_print_struct(ndr, "out", "dfs_Add2");
4882                 ndr->depth++;
4883                 ndr_print_WERROR(ndr, "result", r->out.result);
4884                 ndr->depth--;
4885         }
4886         ndr->depth--;
4887 }
4888
4889 NTSTATUS ndr_push_dfs_Remove2(struct ndr_push *ndr, int flags, const struct dfs_Remove2 *r)
4890 {
4891         if (flags & NDR_IN) {
4892         }
4893         if (flags & NDR_OUT) {
4894                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4895         }
4896         return NT_STATUS_OK;
4897 }
4898
4899 NTSTATUS ndr_pull_dfs_Remove2(struct ndr_pull *ndr, int flags, struct dfs_Remove2 *r)
4900 {
4901         if (flags & NDR_IN) {
4902         }
4903         if (flags & NDR_OUT) {
4904                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4905         }
4906         return NT_STATUS_OK;
4907 }
4908
4909 _PUBLIC_ void ndr_print_dfs_Remove2(struct ndr_print *ndr, const char *name, int flags, const struct dfs_Remove2 *r)
4910 {
4911         ndr_print_struct(ndr, name, "dfs_Remove2");
4912         ndr->depth++;
4913         if (flags & NDR_SET_VALUES) {
4914                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4915         }
4916         if (flags & NDR_IN) {
4917                 ndr_print_struct(ndr, "in", "dfs_Remove2");
4918                 ndr->depth++;
4919                 ndr->depth--;
4920         }
4921         if (flags & NDR_OUT) {
4922                 ndr_print_struct(ndr, "out", "dfs_Remove2");
4923                 ndr->depth++;
4924                 ndr_print_WERROR(ndr, "result", r->out.result);
4925                 ndr->depth--;
4926         }
4927         ndr->depth--;
4928 }
4929
4930 _PUBLIC_ NTSTATUS ndr_push_dfs_EnumEx(struct ndr_push *ndr, int flags, const struct dfs_EnumEx *r)
4931 {
4932         if (flags & NDR_IN) {
4933                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dfs_name, CH_UTF16)));
4934                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4935                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dfs_name, CH_UTF16)));
4936                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dfs_name, ndr_charset_length(r->in.dfs_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4937                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
4938                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
4939                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.info));
4940                 if (r->in.info) {
4941                         NDR_CHECK(ndr_push_dfs_EnumStruct(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
4942                 }
4943                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.total));
4944                 if (r->in.total) {
4945                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.total));
4946                 }
4947         }
4948         if (flags & NDR_OUT) {
4949                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
4950                 if (r->out.info) {
4951                         NDR_CHECK(ndr_push_dfs_EnumStruct(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
4952                 }
4953                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.total));
4954                 if (r->out.total) {
4955                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total));
4956                 }
4957                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4958         }
4959         return NT_STATUS_OK;
4960 }
4961
4962 _PUBLIC_ NTSTATUS ndr_pull_dfs_EnumEx(struct ndr_pull *ndr, int flags, struct dfs_EnumEx *r)
4963 {
4964         uint32_t _ptr_info;
4965         uint32_t _ptr_total;
4966         TALLOC_CTX *_mem_save_info_0;
4967         TALLOC_CTX *_mem_save_total_0;
4968         if (flags & NDR_IN) {
4969                 ZERO_STRUCT(r->out);
4970
4971                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dfs_name));
4972                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dfs_name));
4973                 if (ndr_get_array_length(ndr, &r->in.dfs_name) > ndr_get_array_size(ndr, &r->in.dfs_name)) {
4974                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.dfs_name), ndr_get_array_length(ndr, &r->in.dfs_name));
4975                 }
4976                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.dfs_name), sizeof(uint16_t)));
4977                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dfs_name, ndr_get_array_length(ndr, &r->in.dfs_name), sizeof(uint16_t), CH_UTF16));
4978                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
4979                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
4980                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
4981                 if (_ptr_info) {
4982                         NDR_PULL_ALLOC(ndr, r->in.info);
4983                 } else {
4984                         r->in.info = NULL;
4985                 }
4986                 if (r->in.info) {
4987                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
4988                         NDR_PULL_SET_MEM_CTX(ndr, r->in.info, 0);
4989                         NDR_CHECK(ndr_pull_dfs_EnumStruct(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
4990                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
4991                 }
4992                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_total));
4993                 if (_ptr_total) {
4994                         NDR_PULL_ALLOC(ndr, r->in.total);
4995                 } else {
4996                         r->in.total = NULL;
4997                 }
4998                 if (r->in.total) {
4999                         _mem_save_total_0 = NDR_PULL_GET_MEM_CTX(ndr);
5000                         NDR_PULL_SET_MEM_CTX(ndr, r->in.total, 0);
5001                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.total));
5002                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_0, 0);
5003                 }
5004         }
5005         if (flags & NDR_OUT) {
5006                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
5007                 if (_ptr_info) {
5008                         NDR_PULL_ALLOC(ndr, r->out.info);
5009                 } else {
5010                         r->out.info = NULL;
5011                 }
5012                 if (r->out.info) {
5013                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
5014                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
5015                         NDR_CHECK(ndr_pull_dfs_EnumStruct(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
5016                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
5017                 }
5018                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_total));
5019                 if (_ptr_total) {
5020                         NDR_PULL_ALLOC(ndr, r->out.total);
5021                 } else {
5022                         r->out.total = NULL;
5023                 }
5024                 if (r->out.total) {
5025                         _mem_save_total_0 = NDR_PULL_GET_MEM_CTX(ndr);
5026                         NDR_PULL_SET_MEM_CTX(ndr, r->out.total, 0);
5027                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total));
5028                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_0, 0);
5029                 }
5030                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5031         }
5032         return NT_STATUS_OK;
5033 }
5034
5035 _PUBLIC_ void ndr_print_dfs_EnumEx(struct ndr_print *ndr, const char *name, int flags, const struct dfs_EnumEx *r)
5036 {
5037         ndr_print_struct(ndr, name, "dfs_EnumEx");
5038         ndr->depth++;
5039         if (flags & NDR_SET_VALUES) {
5040                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5041         }
5042         if (flags & NDR_IN) {
5043                 ndr_print_struct(ndr, "in", "dfs_EnumEx");
5044                 ndr->depth++;
5045                 ndr_print_string(ndr, "dfs_name", r->in.dfs_name);
5046                 ndr_print_uint32(ndr, "level", r->in.level);
5047                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
5048                 ndr_print_ptr(ndr, "info", r->in.info);
5049                 ndr->depth++;
5050                 if (r->in.info) {
5051                         ndr_print_dfs_EnumStruct(ndr, "info", r->in.info);
5052                 }
5053                 ndr->depth--;
5054                 ndr_print_ptr(ndr, "total", r->in.total);
5055                 ndr->depth++;
5056                 if (r->in.total) {
5057                         ndr_print_uint32(ndr, "total", *r->in.total);
5058                 }
5059                 ndr->depth--;
5060                 ndr->depth--;
5061         }
5062         if (flags & NDR_OUT) {
5063                 ndr_print_struct(ndr, "out", "dfs_EnumEx");
5064                 ndr->depth++;
5065                 ndr_print_ptr(ndr, "info", r->out.info);
5066                 ndr->depth++;
5067                 if (r->out.info) {
5068                         ndr_print_dfs_EnumStruct(ndr, "info", r->out.info);
5069                 }
5070                 ndr->depth--;
5071                 ndr_print_ptr(ndr, "total", r->out.total);
5072                 ndr->depth++;
5073                 if (r->out.total) {
5074                         ndr_print_uint32(ndr, "total", *r->out.total);
5075                 }
5076                 ndr->depth--;
5077                 ndr_print_WERROR(ndr, "result", r->out.result);
5078                 ndr->depth--;
5079         }
5080         ndr->depth--;
5081 }
5082
5083 NTSTATUS ndr_push_dfs_SetInfo2(struct ndr_push *ndr, int flags, const struct dfs_SetInfo2 *r)
5084 {
5085         if (flags & NDR_IN) {
5086         }
5087         if (flags & NDR_OUT) {
5088                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5089         }
5090         return NT_STATUS_OK;
5091 }
5092
5093 NTSTATUS ndr_pull_dfs_SetInfo2(struct ndr_pull *ndr, int flags, struct dfs_SetInfo2 *r)
5094 {
5095         if (flags & NDR_IN) {
5096         }
5097         if (flags & NDR_OUT) {
5098                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5099         }
5100         return NT_STATUS_OK;
5101 }
5102
5103 _PUBLIC_ void ndr_print_dfs_SetInfo2(struct ndr_print *ndr, const char *name, int flags, const struct dfs_SetInfo2 *r)
5104 {
5105         ndr_print_struct(ndr, name, "dfs_SetInfo2");
5106         ndr->depth++;
5107         if (flags & NDR_SET_VALUES) {
5108                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5109         }
5110         if (flags & NDR_IN) {
5111                 ndr_print_struct(ndr, "in", "dfs_SetInfo2");
5112                 ndr->depth++;
5113                 ndr->depth--;
5114         }
5115         if (flags & NDR_OUT) {
5116                 ndr_print_struct(ndr, "out", "dfs_SetInfo2");
5117                 ndr->depth++;
5118                 ndr_print_WERROR(ndr, "result", r->out.result);
5119                 ndr->depth--;
5120         }
5121         ndr->depth--;
5122 }
5123
5124 const struct ndr_interface_call netdfs_calls[] = {
5125         {
5126                 "dfs_GetManagerVersion",
5127                 sizeof(struct dfs_GetManagerVersion),
5128                 (ndr_push_flags_fn_t) ndr_push_dfs_GetManagerVersion,
5129                 (ndr_pull_flags_fn_t) ndr_pull_dfs_GetManagerVersion,
5130                 (ndr_print_function_t) ndr_print_dfs_GetManagerVersion,
5131                 False,
5132         },
5133         {
5134                 "dfs_Add",
5135                 sizeof(struct dfs_Add),
5136                 (ndr_push_flags_fn_t) ndr_push_dfs_Add,
5137                 (ndr_pull_flags_fn_t) ndr_pull_dfs_Add,
5138                 (ndr_print_function_t) ndr_print_dfs_Add,
5139                 False,
5140         },
5141         {
5142                 "dfs_Remove",
5143                 sizeof(struct dfs_Remove),
5144                 (ndr_push_flags_fn_t) ndr_push_dfs_Remove,
5145                 (ndr_pull_flags_fn_t) ndr_pull_dfs_Remove,
5146                 (ndr_print_function_t) ndr_print_dfs_Remove,
5147                 False,
5148         },
5149         {
5150                 "dfs_SetInfo",
5151                 sizeof(struct dfs_SetInfo),
5152                 (ndr_push_flags_fn_t) ndr_push_dfs_SetInfo,
5153                 (ndr_pull_flags_fn_t) ndr_pull_dfs_SetInfo,
5154                 (ndr_print_function_t) ndr_print_dfs_SetInfo,
5155                 False,
5156         },
5157         {
5158                 "dfs_GetInfo",
5159                 sizeof(struct dfs_GetInfo),
5160                 (ndr_push_flags_fn_t) ndr_push_dfs_GetInfo,
5161                 (ndr_pull_flags_fn_t) ndr_pull_dfs_GetInfo,
5162                 (ndr_print_function_t) ndr_print_dfs_GetInfo,
5163                 False,
5164         },
5165         {
5166                 "dfs_Enum",
5167                 sizeof(struct dfs_Enum),
5168                 (ndr_push_flags_fn_t) ndr_push_dfs_Enum,
5169                 (ndr_pull_flags_fn_t) ndr_pull_dfs_Enum,
5170                 (ndr_print_function_t) ndr_print_dfs_Enum,
5171                 False,
5172         },
5173         {
5174                 "dfs_Rename",
5175                 sizeof(struct dfs_Rename),
5176                 (ndr_push_flags_fn_t) ndr_push_dfs_Rename,
5177                 (ndr_pull_flags_fn_t) ndr_pull_dfs_Rename,
5178                 (ndr_print_function_t) ndr_print_dfs_Rename,
5179                 False,
5180         },
5181         {
5182                 "dfs_Move",
5183                 sizeof(struct dfs_Move),
5184                 (ndr_push_flags_fn_t) ndr_push_dfs_Move,
5185                 (ndr_pull_flags_fn_t) ndr_pull_dfs_Move,
5186                 (ndr_print_function_t) ndr_print_dfs_Move,
5187                 False,
5188         },
5189         {
5190                 "dfs_ManagerGetConfigInfo",
5191                 sizeof(struct dfs_ManagerGetConfigInfo),
5192                 (ndr_push_flags_fn_t) ndr_push_dfs_ManagerGetConfigInfo,
5193                 (ndr_pull_flags_fn_t) ndr_pull_dfs_ManagerGetConfigInfo,
5194                 (ndr_print_function_t) ndr_print_dfs_ManagerGetConfigInfo,
5195                 False,
5196         },
5197         {
5198                 "dfs_ManagerSendSiteInfo",
5199                 sizeof(struct dfs_ManagerSendSiteInfo),
5200                 (ndr_push_flags_fn_t) ndr_push_dfs_ManagerSendSiteInfo,
5201                 (ndr_pull_flags_fn_t) ndr_pull_dfs_ManagerSendSiteInfo,
5202                 (ndr_print_function_t) ndr_print_dfs_ManagerSendSiteInfo,
5203                 False,
5204         },
5205         {
5206                 "dfs_AddFtRoot",
5207                 sizeof(struct dfs_AddFtRoot),
5208                 (ndr_push_flags_fn_t) ndr_push_dfs_AddFtRoot,
5209                 (ndr_pull_flags_fn_t) ndr_pull_dfs_AddFtRoot,
5210                 (ndr_print_function_t) ndr_print_dfs_AddFtRoot,
5211                 False,
5212         },
5213         {
5214                 "dfs_RemoveFtRoot",
5215                 sizeof(struct dfs_RemoveFtRoot),
5216                 (ndr_push_flags_fn_t) ndr_push_dfs_RemoveFtRoot,
5217                 (ndr_pull_flags_fn_t) ndr_pull_dfs_RemoveFtRoot,
5218                 (ndr_print_function_t) ndr_print_dfs_RemoveFtRoot,
5219                 False,
5220         },
5221         {
5222                 "dfs_AddStdRoot",
5223                 sizeof(struct dfs_AddStdRoot),
5224                 (ndr_push_flags_fn_t) ndr_push_dfs_AddStdRoot,
5225                 (ndr_pull_flags_fn_t) ndr_pull_dfs_AddStdRoot,
5226                 (ndr_print_function_t) ndr_print_dfs_AddStdRoot,
5227                 False,
5228         },
5229         {
5230                 "dfs_RemoveStdRoot",
5231                 sizeof(struct dfs_RemoveStdRoot),
5232                 (ndr_push_flags_fn_t) ndr_push_dfs_RemoveStdRoot,
5233                 (ndr_pull_flags_fn_t) ndr_pull_dfs_RemoveStdRoot,
5234                 (ndr_print_function_t) ndr_print_dfs_RemoveStdRoot,
5235                 False,
5236         },
5237         {
5238                 "dfs_ManagerInitialize",
5239                 sizeof(struct dfs_ManagerInitialize),
5240                 (ndr_push_flags_fn_t) ndr_push_dfs_ManagerInitialize,
5241                 (ndr_pull_flags_fn_t) ndr_pull_dfs_ManagerInitialize,
5242                 (ndr_print_function_t) ndr_print_dfs_ManagerInitialize,
5243                 False,
5244         },
5245         {
5246                 "dfs_AddStdRootForced",
5247                 sizeof(struct dfs_AddStdRootForced),
5248                 (ndr_push_flags_fn_t) ndr_push_dfs_AddStdRootForced,
5249                 (ndr_pull_flags_fn_t) ndr_pull_dfs_AddStdRootForced,
5250                 (ndr_print_function_t) ndr_print_dfs_AddStdRootForced,
5251                 False,
5252         },
5253         {
5254                 "dfs_GetDcAddress",
5255                 sizeof(struct dfs_GetDcAddress),
5256                 (ndr_push_flags_fn_t) ndr_push_dfs_GetDcAddress,
5257                 (ndr_pull_flags_fn_t) ndr_pull_dfs_GetDcAddress,
5258                 (ndr_print_function_t) ndr_print_dfs_GetDcAddress,
5259                 False,
5260         },
5261         {
5262                 "dfs_SetDcAddress",
5263                 sizeof(struct dfs_SetDcAddress),
5264                 (ndr_push_flags_fn_t) ndr_push_dfs_SetDcAddress,
5265                 (ndr_pull_flags_fn_t) ndr_pull_dfs_SetDcAddress,
5266                 (ndr_print_function_t) ndr_print_dfs_SetDcAddress,
5267                 False,
5268         },
5269         {
5270                 "dfs_FlushFtTable",
5271                 sizeof(struct dfs_FlushFtTable),
5272                 (ndr_push_flags_fn_t) ndr_push_dfs_FlushFtTable,
5273                 (ndr_pull_flags_fn_t) ndr_pull_dfs_FlushFtTable,
5274                 (ndr_print_function_t) ndr_print_dfs_FlushFtTable,
5275                 False,
5276         },
5277         {
5278                 "dfs_Add2",
5279                 sizeof(struct dfs_Add2),
5280                 (ndr_push_flags_fn_t) ndr_push_dfs_Add2,
5281                 (ndr_pull_flags_fn_t) ndr_pull_dfs_Add2,
5282                 (ndr_print_function_t) ndr_print_dfs_Add2,
5283                 False,
5284         },
5285         {
5286                 "dfs_Remove2",
5287                 sizeof(struct dfs_Remove2),
5288                 (ndr_push_flags_fn_t) ndr_push_dfs_Remove2,
5289                 (ndr_pull_flags_fn_t) ndr_pull_dfs_Remove2,
5290                 (ndr_print_function_t) ndr_print_dfs_Remove2,
5291                 False,
5292         },
5293         {
5294                 "dfs_EnumEx",
5295                 sizeof(struct dfs_EnumEx),
5296                 (ndr_push_flags_fn_t) ndr_push_dfs_EnumEx,
5297                 (ndr_pull_flags_fn_t) ndr_pull_dfs_EnumEx,
5298                 (ndr_print_function_t) ndr_print_dfs_EnumEx,
5299                 False,
5300         },
5301         {
5302                 "dfs_SetInfo2",
5303                 sizeof(struct dfs_SetInfo2),
5304                 (ndr_push_flags_fn_t) ndr_push_dfs_SetInfo2,
5305                 (ndr_pull_flags_fn_t) ndr_pull_dfs_SetInfo2,
5306                 (ndr_print_function_t) ndr_print_dfs_SetInfo2,
5307                 False,
5308         },
5309         { NULL, 0, NULL, NULL, NULL, False }
5310 };
5311
5312 const char * const netdfs_endpoint_strings[] = {
5313         "ncacn_np:[\\pipe\\netdfs]",
5314 };
5315
5316 const struct ndr_interface_string_array netdfs_endpoints = {
5317         .count  = 1,
5318         .names  = netdfs_endpoint_strings
5319 };
5320
5321 const char * const netdfs_authservice_strings[] = {
5322         "host",
5323 };
5324
5325 const struct ndr_interface_string_array netdfs_authservices = {
5326         .count  = 1,
5327         .names  = netdfs_authservice_strings
5328 };
5329
5330
5331 const struct ndr_interface_table ndr_table_netdfs = {
5332         .name           = "netdfs",
5333         .syntax_id      = {
5334                 {0x4fc742e0,0x4a10,0x11cf,{0x82,0x73},{0x00,0xaa,0x00,0x4a,0xe6,0x73}},
5335                 DCERPC_NETDFS_VERSION
5336         },
5337         .helpstring     = DCERPC_NETDFS_HELPSTRING,
5338         .num_calls      = 23,
5339         .calls          = netdfs_calls,
5340         .endpoints      = &netdfs_endpoints,
5341         .authservices   = &netdfs_authservices
5342 };
5343