source3/librpc/gen_ndr/ndr_wkssvc.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "librpc/gen_ndr/ndr_wkssvc.h"
   5
   6 #include "librpc/gen_ndr/ndr_srvsvc.h"
   7 #include "librpc/gen_ndr/ndr_lsa.h"
   8 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo100(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo100 *r)
   9 {
  10         if (ndr_flags & NDR_SCALARS) {
  11                 NDR_CHECK(ndr_push_align(ndr, 4));
  12                 NDR_CHECK(ndr_push_srvsvc_PlatformId(ndr, NDR_SCALARS, r->platform_id));
  13                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
  14                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
  15                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_major));
  16                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_minor));
  17         }
  18         if (ndr_flags & NDR_BUFFERS) {
  19                 if (r->server_name) {
  20                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
  21                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  22                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
  23                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
  24                 }
  25                 if (r->domain_name) {
  26                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
  27                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  28                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
  29                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
  30                 }
  31         }
  32         return NDR_ERR_SUCCESS;
  33 }
  34
  35 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo100(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo100 *r)
  36 {
  37         uint32_t _ptr_server_name;
  38         TALLOC_CTX *_mem_save_server_name_0;
  39         uint32_t _ptr_domain_name;
  40         TALLOC_CTX *_mem_save_domain_name_0;
  41         if (ndr_flags & NDR_SCALARS) {
  42                 NDR_CHECK(ndr_pull_align(ndr, 4));
  43                 NDR_CHECK(ndr_pull_srvsvc_PlatformId(ndr, NDR_SCALARS, &r->platform_id));
  44                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
  45                 if (_ptr_server_name) {
  46                         NDR_PULL_ALLOC(ndr, r->server_name);
  47                 } else {
  48                         r->server_name = NULL;
  49                 }
  50                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
  51                 if (_ptr_domain_name) {
  52                         NDR_PULL_ALLOC(ndr, r->domain_name);
  53                 } else {
  54                         r->domain_name = NULL;
  55                 }
  56                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_major));
  57                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_minor));
  58         }
  59         if (ndr_flags & NDR_BUFFERS) {
  60                 if (r->server_name) {
  61                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
  62                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
  63                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
  64                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
  65                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
  66                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
  67                         }
  68                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
  69                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
  70                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
  71                 }
  72                 if (r->domain_name) {
  73                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
  74                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
  75                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
  76                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
  77                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
  78                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->domain_name), ndr_get_array_length(ndr, &r->domain_name));
  79                         }
  80                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
  81                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
  82                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
  83                 }
  84         }
  85         return NDR_ERR_SUCCESS;
  86 }
  87
  88 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo100(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo100 *r)
  89 {
  90         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo100");
  91         ndr->depth++;
  92         ndr_print_srvsvc_PlatformId(ndr, "platform_id", r->platform_id);
  93         ndr_print_ptr(ndr, "server_name", r->server_name);
  94         ndr->depth++;
  95         if (r->server_name) {
  96                 ndr_print_string(ndr, "server_name", r->server_name);
  97         }
  98         ndr->depth--;
  99         ndr_print_ptr(ndr, "domain_name", r->domain_name);
 100         ndr->depth++;
 101         if (r->domain_name) {
 102                 ndr_print_string(ndr, "domain_name", r->domain_name);
 103         }
 104         ndr->depth--;
 105         ndr_print_uint32(ndr, "version_major", r->version_major);
 106         ndr_print_uint32(ndr, "version_minor", r->version_minor);
 107         ndr->depth--;
 108 }
 109
 110 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo101(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo101 *r)
 111 {
 112         if (ndr_flags & NDR_SCALARS) {
 113                 NDR_CHECK(ndr_push_align(ndr, 4));
 114                 NDR_CHECK(ndr_push_srvsvc_PlatformId(ndr, NDR_SCALARS, r->platform_id));
 115                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
 116                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
 117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_major));
 118                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_minor));
 119                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->lan_root));
 120         }
 121         if (ndr_flags & NDR_BUFFERS) {
 122                 if (r->server_name) {
 123                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
 124                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 125                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
 126                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 127                 }
 128                 if (r->domain_name) {
 129                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
 130                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 131                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
 132                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 133                 }
 134                 if (r->lan_root) {
 135                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->lan_root, CH_UTF16)));
 136                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 137                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->lan_root, CH_UTF16)));
 138                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->lan_root, ndr_charset_length(r->lan_root, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 139                 }
 140         }
 141         return NDR_ERR_SUCCESS;
 142 }
 143
 144 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo101(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo101 *r)
 145 {
 146         uint32_t _ptr_server_name;
 147         TALLOC_CTX *_mem_save_server_name_0;
 148         uint32_t _ptr_domain_name;
 149         TALLOC_CTX *_mem_save_domain_name_0;
 150         uint32_t _ptr_lan_root;
 151         TALLOC_CTX *_mem_save_lan_root_0;
 152         if (ndr_flags & NDR_SCALARS) {
 153                 NDR_CHECK(ndr_pull_align(ndr, 4));
 154                 NDR_CHECK(ndr_pull_srvsvc_PlatformId(ndr, NDR_SCALARS, &r->platform_id));
 155                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
 156                 if (_ptr_server_name) {
 157                         NDR_PULL_ALLOC(ndr, r->server_name);
 158                 } else {
 159                         r->server_name = NULL;
 160                 }
 161                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
 162                 if (_ptr_domain_name) {
 163                         NDR_PULL_ALLOC(ndr, r->domain_name);
 164                 } else {
 165                         r->domain_name = NULL;
 166                 }
 167                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_major));
 168                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_minor));
 169                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lan_root));
 170                 if (_ptr_lan_root) {
 171                         NDR_PULL_ALLOC(ndr, r->lan_root);
 172                 } else {
 173                         r->lan_root = NULL;
 174                 }
 175         }
 176         if (ndr_flags & NDR_BUFFERS) {
 177                 if (r->server_name) {
 178                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 179                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
 180                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
 181                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
 182                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
 183                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
 184                         }
 185                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
 186                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
 187                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
 188                 }
 189                 if (r->domain_name) {
 190                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 191                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
 192                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
 193                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
 194                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
 195                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->domain_name), ndr_get_array_length(ndr, &r->domain_name));
 196                         }
 197                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
 198                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
 199                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
 200                 }
 201                 if (r->lan_root) {
 202                         _mem_save_lan_root_0 = NDR_PULL_GET_MEM_CTX(ndr);
 203                         NDR_PULL_SET_MEM_CTX(ndr, r->lan_root, 0);
 204                         NDR_CHECK(ndr_pull_array_size(ndr, &r->lan_root));
 205                         NDR_CHECK(ndr_pull_array_length(ndr, &r->lan_root));
 206                         if (ndr_get_array_length(ndr, &r->lan_root) > ndr_get_array_size(ndr, &r->lan_root)) {
 207                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->lan_root), ndr_get_array_length(ndr, &r->lan_root));
 208                         }
 209                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->lan_root), sizeof(uint16_t)));
 210                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->lan_root, ndr_get_array_length(ndr, &r->lan_root), sizeof(uint16_t), CH_UTF16));
 211                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lan_root_0, 0);
 212                 }
 213         }
 214         return NDR_ERR_SUCCESS;
 215 }
 216
 217 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo101(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo101 *r)
 218 {
 219         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo101");
 220         ndr->depth++;
 221         ndr_print_srvsvc_PlatformId(ndr, "platform_id", r->platform_id);
 222         ndr_print_ptr(ndr, "server_name", r->server_name);
 223         ndr->depth++;
 224         if (r->server_name) {
 225                 ndr_print_string(ndr, "server_name", r->server_name);
 226         }
 227         ndr->depth--;
 228         ndr_print_ptr(ndr, "domain_name", r->domain_name);
 229         ndr->depth++;
 230         if (r->domain_name) {
 231                 ndr_print_string(ndr, "domain_name", r->domain_name);
 232         }
 233         ndr->depth--;
 234         ndr_print_uint32(ndr, "version_major", r->version_major);
 235         ndr_print_uint32(ndr, "version_minor", r->version_minor);
 236         ndr_print_ptr(ndr, "lan_root", r->lan_root);
 237         ndr->depth++;
 238         if (r->lan_root) {
 239                 ndr_print_string(ndr, "lan_root", r->lan_root);
 240         }
 241         ndr->depth--;
 242         ndr->depth--;
 243 }
 244
 245 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo102(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo102 *r)
 246 {
 247         if (ndr_flags & NDR_SCALARS) {
 248                 NDR_CHECK(ndr_push_align(ndr, 4));
 249                 NDR_CHECK(ndr_push_srvsvc_PlatformId(ndr, NDR_SCALARS, r->platform_id));
 250                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
 251                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
 252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_major));
 253                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_minor));
 254                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->lan_root));
 255                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->logged_on_users));
 256         }
 257         if (ndr_flags & NDR_BUFFERS) {
 258                 if (r->server_name) {
 259                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
 260                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 261                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
 262                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 263                 }
 264                 if (r->domain_name) {
 265                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
 266                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 267                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
 268                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 269                 }
 270                 if (r->lan_root) {
 271                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->lan_root, CH_UTF16)));
 272                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 273                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->lan_root, CH_UTF16)));
 274                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->lan_root, ndr_charset_length(r->lan_root, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 275                 }
 276         }
 277         return NDR_ERR_SUCCESS;
 278 }
 279
 280 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo102(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo102 *r)
 281 {
 282         uint32_t _ptr_server_name;
 283         TALLOC_CTX *_mem_save_server_name_0;
 284         uint32_t _ptr_domain_name;
 285         TALLOC_CTX *_mem_save_domain_name_0;
 286         uint32_t _ptr_lan_root;
 287         TALLOC_CTX *_mem_save_lan_root_0;
 288         if (ndr_flags & NDR_SCALARS) {
 289                 NDR_CHECK(ndr_pull_align(ndr, 4));
 290                 NDR_CHECK(ndr_pull_srvsvc_PlatformId(ndr, NDR_SCALARS, &r->platform_id));
 291                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
 292                 if (_ptr_server_name) {
 293                         NDR_PULL_ALLOC(ndr, r->server_name);
 294                 } else {
 295                         r->server_name = NULL;
 296                 }
 297                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
 298                 if (_ptr_domain_name) {
 299                         NDR_PULL_ALLOC(ndr, r->domain_name);
 300                 } else {
 301                         r->domain_name = NULL;
 302                 }
 303                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_major));
 304                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_minor));
 305                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lan_root));
 306                 if (_ptr_lan_root) {
 307                         NDR_PULL_ALLOC(ndr, r->lan_root);
 308                 } else {
 309                         r->lan_root = NULL;
 310                 }
 311                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->logged_on_users));
 312         }
 313         if (ndr_flags & NDR_BUFFERS) {
 314                 if (r->server_name) {
 315                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 316                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
 317                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
 318                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
 319                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
 320                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
 321                         }
 322                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
 323                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
 324                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
 325                 }
 326                 if (r->domain_name) {
 327                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 328                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
 329                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
 330                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
 331                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
 332                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->domain_name), ndr_get_array_length(ndr, &r->domain_name));
 333                         }
 334                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
 335                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
 336                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
 337                 }
 338                 if (r->lan_root) {
 339                         _mem_save_lan_root_0 = NDR_PULL_GET_MEM_CTX(ndr);
 340                         NDR_PULL_SET_MEM_CTX(ndr, r->lan_root, 0);
 341                         NDR_CHECK(ndr_pull_array_size(ndr, &r->lan_root));
 342                         NDR_CHECK(ndr_pull_array_length(ndr, &r->lan_root));
 343                         if (ndr_get_array_length(ndr, &r->lan_root) > ndr_get_array_size(ndr, &r->lan_root)) {
 344                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->lan_root), ndr_get_array_length(ndr, &r->lan_root));
 345                         }
 346                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->lan_root), sizeof(uint16_t)));
 347                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->lan_root, ndr_get_array_length(ndr, &r->lan_root), sizeof(uint16_t), CH_UTF16));
 348                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lan_root_0, 0);
 349                 }
 350         }
 351         return NDR_ERR_SUCCESS;
 352 }
 353
 354 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo102(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo102 *r)
 355 {
 356         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo102");
 357         ndr->depth++;
 358         ndr_print_srvsvc_PlatformId(ndr, "platform_id", r->platform_id);
 359         ndr_print_ptr(ndr, "server_name", r->server_name);
 360         ndr->depth++;
 361         if (r->server_name) {
 362                 ndr_print_string(ndr, "server_name", r->server_name);
 363         }
 364         ndr->depth--;
 365         ndr_print_ptr(ndr, "domain_name", r->domain_name);
 366         ndr->depth++;
 367         if (r->domain_name) {
 368                 ndr_print_string(ndr, "domain_name", r->domain_name);
 369         }
 370         ndr->depth--;
 371         ndr_print_uint32(ndr, "version_major", r->version_major);
 372         ndr_print_uint32(ndr, "version_minor", r->version_minor);
 373         ndr_print_ptr(ndr, "lan_root", r->lan_root);
 374         ndr->depth++;
 375         if (r->lan_root) {
 376                 ndr_print_string(ndr, "lan_root", r->lan_root);
 377         }
 378         ndr->depth--;
 379         ndr_print_uint32(ndr, "logged_on_users", r->logged_on_users);
 380         ndr->depth--;
 381 }
 382
 383 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo502(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo502 *r)
 384 {
 385         if (ndr_flags & NDR_SCALARS) {
 386                 NDR_CHECK(ndr_push_align(ndr, 4));
 387                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->char_wait));
 388                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->collection_time));
 389                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maximum_collection_count));
 390                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->keep_connection));
 391                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_commands));
 392                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_timeout));
 393                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_char_buf));
 394                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_threads));
 395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_quota));
 396                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_increment));
 397                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_maximum));
 398                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pipe_increment));
 399                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pipe_maximum));
 400                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cache_file_timeout));
 401                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dormant_file_limit));
 402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->read_ahead_throughput));
 403                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_mailslot_buffers));
 404                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_srv_announce_buffers));
 405                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_illegal_dgram_events));
 406                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dgram_event_reset_freq));
 407                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->log_election_packets));
 408                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_opportunistic_locking));
 409                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_unlock_behind));
 410                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_close_behind));
 411                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_named_pipes));
 412                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_lock_read_unlock));
 413                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->utilize_nt_caching));
 414                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_raw_read));
 415                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_raw_write));
 416                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_write_raw_data));
 417                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_encryption));
 418                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_files_deny_write));
 419                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_read_only_files));
 420                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->force_core_create_mode));
 421                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_512_byte_max_transfer));
 422         }
 423         if (ndr_flags & NDR_BUFFERS) {
 424         }
 425         return NDR_ERR_SUCCESS;
 426 }
 427
 428 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo502(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo502 *r)
 429 {
 430         if (ndr_flags & NDR_SCALARS) {
 431                 NDR_CHECK(ndr_pull_align(ndr, 4));
 432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->char_wait));
 433                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->collection_time));
 434                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maximum_collection_count));
 435                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->keep_connection));
 436                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_commands));
 437                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_timeout));
 438                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_char_buf));
 439                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_threads));
 440                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_quota));
 441                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_increment));
 442                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_maximum));
 443                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pipe_increment));
 444                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pipe_maximum));
 445                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cache_file_timeout));
 446                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dormant_file_limit));
 447                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->read_ahead_throughput));
 448                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_mailslot_buffers));
 449                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_srv_announce_buffers));
 450                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_illegal_dgram_events));
 451                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dgram_event_reset_freq));
 452                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->log_election_packets));
 453                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_opportunistic_locking));
 454                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_unlock_behind));
 455                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_close_behind));
 456                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_named_pipes));
 457                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_lock_read_unlock));
 458                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->utilize_nt_caching));
 459                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_raw_read));
 460                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_raw_write));
 461                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_write_raw_data));
 462                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_encryption));
 463                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_files_deny_write));
 464                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_read_only_files));
 465                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->force_core_create_mode));
 466                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_512_byte_max_transfer));
 467         }
 468         if (ndr_flags & NDR_BUFFERS) {
 469         }
 470         return NDR_ERR_SUCCESS;
 471 }
 472
 473 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo502(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo502 *r)
 474 {
 475         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo502");
 476         ndr->depth++;
 477         ndr_print_uint32(ndr, "char_wait", r->char_wait);
 478         ndr_print_uint32(ndr, "collection_time", r->collection_time);
 479         ndr_print_uint32(ndr, "maximum_collection_count", r->maximum_collection_count);
 480         ndr_print_uint32(ndr, "keep_connection", r->keep_connection);
 481         ndr_print_uint32(ndr, "max_commands", r->max_commands);
 482         ndr_print_uint32(ndr, "session_timeout", r->session_timeout);
 483         ndr_print_uint32(ndr, "size_char_buf", r->size_char_buf);
 484         ndr_print_uint32(ndr, "max_threads", r->max_threads);
 485         ndr_print_uint32(ndr, "lock_quota", r->lock_quota);
 486         ndr_print_uint32(ndr, "lock_increment", r->lock_increment);
 487         ndr_print_uint32(ndr, "lock_maximum", r->lock_maximum);
 488         ndr_print_uint32(ndr, "pipe_increment", r->pipe_increment);
 489         ndr_print_uint32(ndr, "pipe_maximum", r->pipe_maximum);
 490         ndr_print_uint32(ndr, "cache_file_timeout", r->cache_file_timeout);
 491         ndr_print_uint32(ndr, "dormant_file_limit", r->dormant_file_limit);
 492         ndr_print_uint32(ndr, "read_ahead_throughput", r->read_ahead_throughput);
 493         ndr_print_uint32(ndr, "num_mailslot_buffers", r->num_mailslot_buffers);
 494         ndr_print_uint32(ndr, "num_srv_announce_buffers", r->num_srv_announce_buffers);
 495         ndr_print_uint32(ndr, "max_illegal_dgram_events", r->max_illegal_dgram_events);
 496         ndr_print_uint32(ndr, "dgram_event_reset_freq", r->dgram_event_reset_freq);
 497         ndr_print_uint32(ndr, "log_election_packets", r->log_election_packets);
 498         ndr_print_uint32(ndr, "use_opportunistic_locking", r->use_opportunistic_locking);
 499         ndr_print_uint32(ndr, "use_unlock_behind", r->use_unlock_behind);
 500         ndr_print_uint32(ndr, "use_close_behind", r->use_close_behind);
 501         ndr_print_uint32(ndr, "buf_named_pipes", r->buf_named_pipes);
 502         ndr_print_uint32(ndr, "use_lock_read_unlock", r->use_lock_read_unlock);
 503         ndr_print_uint32(ndr, "utilize_nt_caching", r->utilize_nt_caching);
 504         ndr_print_uint32(ndr, "use_raw_read", r->use_raw_read);
 505         ndr_print_uint32(ndr, "use_raw_write", r->use_raw_write);
 506         ndr_print_uint32(ndr, "use_write_raw_data", r->use_write_raw_data);
 507         ndr_print_uint32(ndr, "use_encryption", r->use_encryption);
 508         ndr_print_uint32(ndr, "buf_files_deny_write", r->buf_files_deny_write);
 509         ndr_print_uint32(ndr, "buf_read_only_files", r->buf_read_only_files);
 510         ndr_print_uint32(ndr, "force_core_create_mode", r->force_core_create_mode);
 511         ndr_print_uint32(ndr, "use_512_byte_max_transfer", r->use_512_byte_max_transfer);
 512         ndr->depth--;
 513 }
 514
 515 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1010(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1010 *r)
 516 {
 517         if (ndr_flags & NDR_SCALARS) {
 518                 NDR_CHECK(ndr_push_align(ndr, 4));
 519                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->char_wait));
 520         }
 521         if (ndr_flags & NDR_BUFFERS) {
 522         }
 523         return NDR_ERR_SUCCESS;
 524 }
 525
 526 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1010(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1010 *r)
 527 {
 528         if (ndr_flags & NDR_SCALARS) {
 529                 NDR_CHECK(ndr_pull_align(ndr, 4));
 530                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->char_wait));
 531         }
 532         if (ndr_flags & NDR_BUFFERS) {
 533         }
 534         return NDR_ERR_SUCCESS;
 535 }
 536
 537 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1010(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1010 *r)
 538 {
 539         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1010");
 540         ndr->depth++;
 541         ndr_print_uint32(ndr, "char_wait", r->char_wait);
 542         ndr->depth--;
 543 }
 544
 545 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1011(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1011 *r)
 546 {
 547         if (ndr_flags & NDR_SCALARS) {
 548                 NDR_CHECK(ndr_push_align(ndr, 4));
 549                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->collection_time));
 550         }
 551         if (ndr_flags & NDR_BUFFERS) {
 552         }
 553         return NDR_ERR_SUCCESS;
 554 }
 555
 556 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1011(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1011 *r)
 557 {
 558         if (ndr_flags & NDR_SCALARS) {
 559                 NDR_CHECK(ndr_pull_align(ndr, 4));
 560                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->collection_time));
 561         }
 562         if (ndr_flags & NDR_BUFFERS) {
 563         }
 564         return NDR_ERR_SUCCESS;
 565 }
 566
 567 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1011(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1011 *r)
 568 {
 569         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1011");
 570         ndr->depth++;
 571         ndr_print_uint32(ndr, "collection_time", r->collection_time);
 572         ndr->depth--;
 573 }
 574
 575 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1012(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1012 *r)
 576 {
 577         if (ndr_flags & NDR_SCALARS) {
 578                 NDR_CHECK(ndr_push_align(ndr, 4));
 579                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maximum_collection_count));
 580         }
 581         if (ndr_flags & NDR_BUFFERS) {
 582         }
 583         return NDR_ERR_SUCCESS;
 584 }
 585
 586 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1012(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1012 *r)
 587 {
 588         if (ndr_flags & NDR_SCALARS) {
 589                 NDR_CHECK(ndr_pull_align(ndr, 4));
 590                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maximum_collection_count));
 591         }
 592         if (ndr_flags & NDR_BUFFERS) {
 593         }
 594         return NDR_ERR_SUCCESS;
 595 }
 596
 597 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1012(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1012 *r)
 598 {
 599         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1012");
 600         ndr->depth++;
 601         ndr_print_uint32(ndr, "maximum_collection_count", r->maximum_collection_count);
 602         ndr->depth--;
 603 }
 604
 605 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1013(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1013 *r)
 606 {
 607         if (ndr_flags & NDR_SCALARS) {
 608                 NDR_CHECK(ndr_push_align(ndr, 4));
 609                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->keep_connection));
 610         }
 611         if (ndr_flags & NDR_BUFFERS) {
 612         }
 613         return NDR_ERR_SUCCESS;
 614 }
 615
 616 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1013(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1013 *r)
 617 {
 618         if (ndr_flags & NDR_SCALARS) {
 619                 NDR_CHECK(ndr_pull_align(ndr, 4));
 620                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->keep_connection));
 621         }
 622         if (ndr_flags & NDR_BUFFERS) {
 623         }
 624         return NDR_ERR_SUCCESS;
 625 }
 626
 627 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1013(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1013 *r)
 628 {
 629         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1013");
 630         ndr->depth++;
 631         ndr_print_uint32(ndr, "keep_connection", r->keep_connection);
 632         ndr->depth--;
 633 }
 634
 635 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1018(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1018 *r)
 636 {
 637         if (ndr_flags & NDR_SCALARS) {
 638                 NDR_CHECK(ndr_push_align(ndr, 4));
 639                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_timeout));
 640         }
 641         if (ndr_flags & NDR_BUFFERS) {
 642         }
 643         return NDR_ERR_SUCCESS;
 644 }
 645
 646 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1018(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1018 *r)
 647 {
 648         if (ndr_flags & NDR_SCALARS) {
 649                 NDR_CHECK(ndr_pull_align(ndr, 4));
 650                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_timeout));
 651         }
 652         if (ndr_flags & NDR_BUFFERS) {
 653         }
 654         return NDR_ERR_SUCCESS;
 655 }
 656
 657 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1018(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1018 *r)
 658 {
 659         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1018");
 660         ndr->depth++;
 661         ndr_print_uint32(ndr, "session_timeout", r->session_timeout);
 662         ndr->depth--;
 663 }
 664
 665 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1023(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1023 *r)
 666 {
 667         if (ndr_flags & NDR_SCALARS) {
 668                 NDR_CHECK(ndr_push_align(ndr, 4));
 669                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_char_buf));
 670         }
 671         if (ndr_flags & NDR_BUFFERS) {
 672         }
 673         return NDR_ERR_SUCCESS;
 674 }
 675
 676 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1023(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1023 *r)
 677 {
 678         if (ndr_flags & NDR_SCALARS) {
 679                 NDR_CHECK(ndr_pull_align(ndr, 4));
 680                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_char_buf));
 681         }
 682         if (ndr_flags & NDR_BUFFERS) {
 683         }
 684         return NDR_ERR_SUCCESS;
 685 }
 686
 687 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1023(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1023 *r)
 688 {
 689         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1023");
 690         ndr->depth++;
 691         ndr_print_uint32(ndr, "size_char_buf", r->size_char_buf);
 692         ndr->depth--;
 693 }
 694
 695 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1027(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1027 *r)
 696 {
 697         if (ndr_flags & NDR_SCALARS) {
 698                 NDR_CHECK(ndr_push_align(ndr, 4));
 699                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->errorlog_sz));
 700         }
 701         if (ndr_flags & NDR_BUFFERS) {
 702         }
 703         return NDR_ERR_SUCCESS;
 704 }
 705
 706 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1027(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1027 *r)
 707 {
 708         if (ndr_flags & NDR_SCALARS) {
 709                 NDR_CHECK(ndr_pull_align(ndr, 4));
 710                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->errorlog_sz));
 711         }
 712         if (ndr_flags & NDR_BUFFERS) {
 713         }
 714         return NDR_ERR_SUCCESS;
 715 }
 716
 717 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1027(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1027 *r)
 718 {
 719         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1027");
 720         ndr->depth++;
 721         ndr_print_uint32(ndr, "errorlog_sz", r->errorlog_sz);
 722         ndr->depth--;
 723 }
 724
 725 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1028(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1028 *r)
 726 {
 727         if (ndr_flags & NDR_SCALARS) {
 728                 NDR_CHECK(ndr_push_align(ndr, 4));
 729                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->print_buf_time));
 730         }
 731         if (ndr_flags & NDR_BUFFERS) {
 732         }
 733         return NDR_ERR_SUCCESS;
 734 }
 735
 736 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1028(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1028 *r)
 737 {
 738         if (ndr_flags & NDR_SCALARS) {
 739                 NDR_CHECK(ndr_pull_align(ndr, 4));
 740                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->print_buf_time));
 741         }
 742         if (ndr_flags & NDR_BUFFERS) {
 743         }
 744         return NDR_ERR_SUCCESS;
 745 }
 746
 747 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1028(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1028 *r)
 748 {
 749         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1028");
 750         ndr->depth++;
 751         ndr_print_uint32(ndr, "print_buf_time", r->print_buf_time);
 752         ndr->depth--;
 753 }
 754
 755 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1032(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1032 *r)
 756 {
 757         if (ndr_flags & NDR_SCALARS) {
 758                 NDR_CHECK(ndr_push_align(ndr, 4));
 759                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->wrk_heuristics));
 760         }
 761         if (ndr_flags & NDR_BUFFERS) {
 762         }
 763         return NDR_ERR_SUCCESS;
 764 }
 765
 766 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1032(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1032 *r)
 767 {
 768         if (ndr_flags & NDR_SCALARS) {
 769                 NDR_CHECK(ndr_pull_align(ndr, 4));
 770                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->wrk_heuristics));
 771         }
 772         if (ndr_flags & NDR_BUFFERS) {
 773         }
 774         return NDR_ERR_SUCCESS;
 775 }
 776
 777 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1032(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1032 *r)
 778 {
 779         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1032");
 780         ndr->depth++;
 781         ndr_print_uint32(ndr, "wrk_heuristics", r->wrk_heuristics);
 782         ndr->depth--;
 783 }
 784
 785 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1033(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1033 *r)
 786 {
 787         if (ndr_flags & NDR_SCALARS) {
 788                 NDR_CHECK(ndr_push_align(ndr, 4));
 789                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_threads));
 790         }
 791         if (ndr_flags & NDR_BUFFERS) {
 792         }
 793         return NDR_ERR_SUCCESS;
 794 }
 795
 796 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1033(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1033 *r)
 797 {
 798         if (ndr_flags & NDR_SCALARS) {
 799                 NDR_CHECK(ndr_pull_align(ndr, 4));
 800                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_threads));
 801         }
 802         if (ndr_flags & NDR_BUFFERS) {
 803         }
 804         return NDR_ERR_SUCCESS;
 805 }
 806
 807 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1033(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1033 *r)
 808 {
 809         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1033");
 810         ndr->depth++;
 811         ndr_print_uint32(ndr, "max_threads", r->max_threads);
 812         ndr->depth--;
 813 }
 814
 815 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1041(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1041 *r)
 816 {
 817         if (ndr_flags & NDR_SCALARS) {
 818                 NDR_CHECK(ndr_push_align(ndr, 4));
 819                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_quota));
 820         }
 821         if (ndr_flags & NDR_BUFFERS) {
 822         }
 823         return NDR_ERR_SUCCESS;
 824 }
 825
 826 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1041(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1041 *r)
 827 {
 828         if (ndr_flags & NDR_SCALARS) {
 829                 NDR_CHECK(ndr_pull_align(ndr, 4));
 830                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_quota));
 831         }
 832         if (ndr_flags & NDR_BUFFERS) {
 833         }
 834         return NDR_ERR_SUCCESS;
 835 }
 836
 837 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1041(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1041 *r)
 838 {
 839         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1041");
 840         ndr->depth++;
 841         ndr_print_uint32(ndr, "lock_quota", r->lock_quota);
 842         ndr->depth--;
 843 }
 844
 845 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1042(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1042 *r)
 846 {
 847         if (ndr_flags & NDR_SCALARS) {
 848                 NDR_CHECK(ndr_push_align(ndr, 4));
 849                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_increment));
 850         }
 851         if (ndr_flags & NDR_BUFFERS) {
 852         }
 853         return NDR_ERR_SUCCESS;
 854 }
 855
 856 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1042(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1042 *r)
 857 {
 858         if (ndr_flags & NDR_SCALARS) {
 859                 NDR_CHECK(ndr_pull_align(ndr, 4));
 860                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_increment));
 861         }
 862         if (ndr_flags & NDR_BUFFERS) {
 863         }
 864         return NDR_ERR_SUCCESS;
 865 }
 866
 867 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1042(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1042 *r)
 868 {
 869         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1042");
 870         ndr->depth++;
 871         ndr_print_uint32(ndr, "lock_increment", r->lock_increment);
 872         ndr->depth--;
 873 }
 874
 875 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1043(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1043 *r)
 876 {
 877         if (ndr_flags & NDR_SCALARS) {
 878                 NDR_CHECK(ndr_push_align(ndr, 4));
 879                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_maximum));
 880         }
 881         if (ndr_flags & NDR_BUFFERS) {
 882         }
 883         return NDR_ERR_SUCCESS;
 884 }
 885
 886 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1043(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1043 *r)
 887 {
 888         if (ndr_flags & NDR_SCALARS) {
 889                 NDR_CHECK(ndr_pull_align(ndr, 4));
 890                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_maximum));
 891         }
 892         if (ndr_flags & NDR_BUFFERS) {
 893         }
 894         return NDR_ERR_SUCCESS;
 895 }
 896
 897 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1043(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1043 *r)
 898 {
 899         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1043");
 900         ndr->depth++;
 901         ndr_print_uint32(ndr, "lock_maximum", r->lock_maximum);
 902         ndr->depth--;
 903 }
 904
 905 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1044(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1044 *r)
 906 {
 907         if (ndr_flags & NDR_SCALARS) {
 908                 NDR_CHECK(ndr_push_align(ndr, 4));
 909                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pipe_increment));
 910         }
 911         if (ndr_flags & NDR_BUFFERS) {
 912         }
 913         return NDR_ERR_SUCCESS;
 914 }
 915
 916 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1044(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1044 *r)
 917 {
 918         if (ndr_flags & NDR_SCALARS) {
 919                 NDR_CHECK(ndr_pull_align(ndr, 4));
 920                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pipe_increment));
 921         }
 922         if (ndr_flags & NDR_BUFFERS) {
 923         }
 924         return NDR_ERR_SUCCESS;
 925 }
 926
 927 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1044(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1044 *r)
 928 {
 929         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1044");
 930         ndr->depth++;
 931         ndr_print_uint32(ndr, "pipe_increment", r->pipe_increment);
 932         ndr->depth--;
 933 }
 934
 935 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1045(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1045 *r)
 936 {
 937         if (ndr_flags & NDR_SCALARS) {
 938                 NDR_CHECK(ndr_push_align(ndr, 4));
 939                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pipe_maximum));
 940         }
 941         if (ndr_flags & NDR_BUFFERS) {
 942         }
 943         return NDR_ERR_SUCCESS;
 944 }
 945
 946 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1045(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1045 *r)
 947 {
 948         if (ndr_flags & NDR_SCALARS) {
 949                 NDR_CHECK(ndr_pull_align(ndr, 4));
 950                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pipe_maximum));
 951         }
 952         if (ndr_flags & NDR_BUFFERS) {
 953         }
 954         return NDR_ERR_SUCCESS;
 955 }
 956
 957 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1045(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1045 *r)
 958 {
 959         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1045");
 960         ndr->depth++;
 961         ndr_print_uint32(ndr, "pipe_maximum", r->pipe_maximum);
 962         ndr->depth--;
 963 }
 964
 965 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1046(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1046 *r)
 966 {
 967         if (ndr_flags & NDR_SCALARS) {
 968                 NDR_CHECK(ndr_push_align(ndr, 4));
 969                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dormant_file_limit));
 970         }
 971         if (ndr_flags & NDR_BUFFERS) {
 972         }
 973         return NDR_ERR_SUCCESS;
 974 }
 975
 976 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1046(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1046 *r)
 977 {
 978         if (ndr_flags & NDR_SCALARS) {
 979                 NDR_CHECK(ndr_pull_align(ndr, 4));
 980                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dormant_file_limit));
 981         }
 982         if (ndr_flags & NDR_BUFFERS) {
 983         }
 984         return NDR_ERR_SUCCESS;
 985 }
 986
 987 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1046(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1046 *r)
 988 {
 989         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1046");
 990         ndr->depth++;
 991         ndr_print_uint32(ndr, "dormant_file_limit", r->dormant_file_limit);
 992         ndr->depth--;
 993 }
 994
 995 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1047(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1047 *r)
 996 {
 997         if (ndr_flags & NDR_SCALARS) {
 998                 NDR_CHECK(ndr_push_align(ndr, 4));
 999                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cache_file_timeout));
1000         }
1001         if (ndr_flags & NDR_BUFFERS) {
1002         }
1003         return NDR_ERR_SUCCESS;
1004 }
1005
1006 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1047(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1047 *r)
1007 {
1008         if (ndr_flags & NDR_SCALARS) {
1009                 NDR_CHECK(ndr_pull_align(ndr, 4));
1010                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cache_file_timeout));
1011         }
1012         if (ndr_flags & NDR_BUFFERS) {
1013         }
1014         return NDR_ERR_SUCCESS;
1015 }
1016
1017 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1047(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1047 *r)
1018 {
1019         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1047");
1020         ndr->depth++;
1021         ndr_print_uint32(ndr, "cache_file_timeout", r->cache_file_timeout);
1022         ndr->depth--;
1023 }
1024
1025 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1048(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1048 *r)
1026 {
1027         if (ndr_flags & NDR_SCALARS) {
1028                 NDR_CHECK(ndr_push_align(ndr, 4));
1029                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_opportunistic_locking));
1030         }
1031         if (ndr_flags & NDR_BUFFERS) {
1032         }
1033         return NDR_ERR_SUCCESS;
1034 }
1035
1036 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1048(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1048 *r)
1037 {
1038         if (ndr_flags & NDR_SCALARS) {
1039                 NDR_CHECK(ndr_pull_align(ndr, 4));
1040                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_opportunistic_locking));
1041         }
1042         if (ndr_flags & NDR_BUFFERS) {
1043         }
1044         return NDR_ERR_SUCCESS;
1045 }
1046
1047 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1048(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1048 *r)
1048 {
1049         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1048");
1050         ndr->depth++;
1051         ndr_print_uint32(ndr, "use_opportunistic_locking", r->use_opportunistic_locking);
1052         ndr->depth--;
1053 }
1054
1055 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1049(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1049 *r)
1056 {
1057         if (ndr_flags & NDR_SCALARS) {
1058                 NDR_CHECK(ndr_push_align(ndr, 4));
1059                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_unlock_behind));
1060         }
1061         if (ndr_flags & NDR_BUFFERS) {
1062         }
1063         return NDR_ERR_SUCCESS;
1064 }
1065
1066 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1049(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1049 *r)
1067 {
1068         if (ndr_flags & NDR_SCALARS) {
1069                 NDR_CHECK(ndr_pull_align(ndr, 4));
1070                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_unlock_behind));
1071         }
1072         if (ndr_flags & NDR_BUFFERS) {
1073         }
1074         return NDR_ERR_SUCCESS;
1075 }
1076
1077 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1049(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1049 *r)
1078 {
1079         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1049");
1080         ndr->depth++;
1081         ndr_print_uint32(ndr, "use_unlock_behind", r->use_unlock_behind);
1082         ndr->depth--;
1083 }
1084
1085 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1050(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1050 *r)
1086 {
1087         if (ndr_flags & NDR_SCALARS) {
1088                 NDR_CHECK(ndr_push_align(ndr, 4));
1089                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_close_behind));
1090         }
1091         if (ndr_flags & NDR_BUFFERS) {
1092         }
1093         return NDR_ERR_SUCCESS;
1094 }
1095
1096 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1050(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1050 *r)
1097 {
1098         if (ndr_flags & NDR_SCALARS) {
1099                 NDR_CHECK(ndr_pull_align(ndr, 4));
1100                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_close_behind));
1101         }
1102         if (ndr_flags & NDR_BUFFERS) {
1103         }
1104         return NDR_ERR_SUCCESS;
1105 }
1106
1107 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1050(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1050 *r)
1108 {
1109         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1050");
1110         ndr->depth++;
1111         ndr_print_uint32(ndr, "use_close_behind", r->use_close_behind);
1112         ndr->depth--;
1113 }
1114
1115 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1051(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1051 *r)
1116 {
1117         if (ndr_flags & NDR_SCALARS) {
1118                 NDR_CHECK(ndr_push_align(ndr, 4));
1119                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_named_pipes));
1120         }
1121         if (ndr_flags & NDR_BUFFERS) {
1122         }
1123         return NDR_ERR_SUCCESS;
1124 }
1125
1126 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1051(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1051 *r)
1127 {
1128         if (ndr_flags & NDR_SCALARS) {
1129                 NDR_CHECK(ndr_pull_align(ndr, 4));
1130                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_named_pipes));
1131         }
1132         if (ndr_flags & NDR_BUFFERS) {
1133         }
1134         return NDR_ERR_SUCCESS;
1135 }
1136
1137 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1051(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1051 *r)
1138 {
1139         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1051");
1140         ndr->depth++;
1141         ndr_print_uint32(ndr, "buf_named_pipes", r->buf_named_pipes);
1142         ndr->depth--;
1143 }
1144
1145 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1052(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1052 *r)
1146 {
1147         if (ndr_flags & NDR_SCALARS) {
1148                 NDR_CHECK(ndr_push_align(ndr, 4));
1149                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_lock_read_unlock));
1150         }
1151         if (ndr_flags & NDR_BUFFERS) {
1152         }
1153         return NDR_ERR_SUCCESS;
1154 }
1155
1156 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1052(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1052 *r)
1157 {
1158         if (ndr_flags & NDR_SCALARS) {
1159                 NDR_CHECK(ndr_pull_align(ndr, 4));
1160                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_lock_read_unlock));
1161         }
1162         if (ndr_flags & NDR_BUFFERS) {
1163         }
1164         return NDR_ERR_SUCCESS;
1165 }
1166
1167 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1052(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1052 *r)
1168 {
1169         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1052");
1170         ndr->depth++;
1171         ndr_print_uint32(ndr, "use_lock_read_unlock", r->use_lock_read_unlock);
1172         ndr->depth--;
1173 }
1174
1175 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1053(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1053 *r)
1176 {
1177         if (ndr_flags & NDR_SCALARS) {
1178                 NDR_CHECK(ndr_push_align(ndr, 4));
1179                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->utilize_nt_caching));
1180         }
1181         if (ndr_flags & NDR_BUFFERS) {
1182         }
1183         return NDR_ERR_SUCCESS;
1184 }
1185
1186 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1053(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1053 *r)
1187 {
1188         if (ndr_flags & NDR_SCALARS) {
1189                 NDR_CHECK(ndr_pull_align(ndr, 4));
1190                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->utilize_nt_caching));
1191         }
1192         if (ndr_flags & NDR_BUFFERS) {
1193         }
1194         return NDR_ERR_SUCCESS;
1195 }
1196
1197 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1053(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1053 *r)
1198 {
1199         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1053");
1200         ndr->depth++;
1201         ndr_print_uint32(ndr, "utilize_nt_caching", r->utilize_nt_caching);
1202         ndr->depth--;
1203 }
1204
1205 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1054(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1054 *r)
1206 {
1207         if (ndr_flags & NDR_SCALARS) {
1208                 NDR_CHECK(ndr_push_align(ndr, 4));
1209                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_raw_read));
1210         }
1211         if (ndr_flags & NDR_BUFFERS) {
1212         }
1213         return NDR_ERR_SUCCESS;
1214 }
1215
1216 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1054(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1054 *r)
1217 {
1218         if (ndr_flags & NDR_SCALARS) {
1219                 NDR_CHECK(ndr_pull_align(ndr, 4));
1220                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_raw_read));
1221         }
1222         if (ndr_flags & NDR_BUFFERS) {
1223         }
1224         return NDR_ERR_SUCCESS;
1225 }
1226
1227 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1054(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1054 *r)
1228 {
1229         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1054");
1230         ndr->depth++;
1231         ndr_print_uint32(ndr, "use_raw_read", r->use_raw_read);
1232         ndr->depth--;
1233 }
1234
1235 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1055(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1055 *r)
1236 {
1237         if (ndr_flags & NDR_SCALARS) {
1238                 NDR_CHECK(ndr_push_align(ndr, 4));
1239                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_raw_write));
1240         }
1241         if (ndr_flags & NDR_BUFFERS) {
1242         }
1243         return NDR_ERR_SUCCESS;
1244 }
1245
1246 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1055(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1055 *r)
1247 {
1248         if (ndr_flags & NDR_SCALARS) {
1249                 NDR_CHECK(ndr_pull_align(ndr, 4));
1250                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_raw_write));
1251         }
1252         if (ndr_flags & NDR_BUFFERS) {
1253         }
1254         return NDR_ERR_SUCCESS;
1255 }
1256
1257 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1055(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1055 *r)
1258 {
1259         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1055");
1260         ndr->depth++;
1261         ndr_print_uint32(ndr, "use_raw_write", r->use_raw_write);
1262         ndr->depth--;
1263 }
1264
1265 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1056(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1056 *r)
1266 {
1267         if (ndr_flags & NDR_SCALARS) {
1268                 NDR_CHECK(ndr_push_align(ndr, 4));
1269                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_write_raw_data));
1270         }
1271         if (ndr_flags & NDR_BUFFERS) {
1272         }
1273         return NDR_ERR_SUCCESS;
1274 }
1275
1276 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1056(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1056 *r)
1277 {
1278         if (ndr_flags & NDR_SCALARS) {
1279                 NDR_CHECK(ndr_pull_align(ndr, 4));
1280                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_write_raw_data));
1281         }
1282         if (ndr_flags & NDR_BUFFERS) {
1283         }
1284         return NDR_ERR_SUCCESS;
1285 }
1286
1287 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1056(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1056 *r)
1288 {
1289         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1056");
1290         ndr->depth++;
1291         ndr_print_uint32(ndr, "use_write_raw_data", r->use_write_raw_data);
1292         ndr->depth--;
1293 }
1294
1295 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1057(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1057 *r)
1296 {
1297         if (ndr_flags & NDR_SCALARS) {
1298                 NDR_CHECK(ndr_push_align(ndr, 4));
1299                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_encryption));
1300         }
1301         if (ndr_flags & NDR_BUFFERS) {
1302         }
1303         return NDR_ERR_SUCCESS;
1304 }
1305
1306 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1057(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1057 *r)
1307 {
1308         if (ndr_flags & NDR_SCALARS) {
1309                 NDR_CHECK(ndr_pull_align(ndr, 4));
1310                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_encryption));
1311         }
1312         if (ndr_flags & NDR_BUFFERS) {
1313         }
1314         return NDR_ERR_SUCCESS;
1315 }
1316
1317 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1057(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1057 *r)
1318 {
1319         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1057");
1320         ndr->depth++;
1321         ndr_print_uint32(ndr, "use_encryption", r->use_encryption);
1322         ndr->depth--;
1323 }
1324
1325 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1058(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1058 *r)
1326 {
1327         if (ndr_flags & NDR_SCALARS) {
1328                 NDR_CHECK(ndr_push_align(ndr, 4));
1329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_files_deny_write));
1330         }
1331         if (ndr_flags & NDR_BUFFERS) {
1332         }
1333         return NDR_ERR_SUCCESS;
1334 }
1335
1336 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1058(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1058 *r)
1337 {
1338         if (ndr_flags & NDR_SCALARS) {
1339                 NDR_CHECK(ndr_pull_align(ndr, 4));
1340                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_files_deny_write));
1341         }
1342         if (ndr_flags & NDR_BUFFERS) {
1343         }
1344         return NDR_ERR_SUCCESS;
1345 }
1346
1347 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1058(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1058 *r)
1348 {
1349         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1058");
1350         ndr->depth++;
1351         ndr_print_uint32(ndr, "buf_files_deny_write", r->buf_files_deny_write);
1352         ndr->depth--;
1353 }
1354
1355 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1059(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1059 *r)
1356 {
1357         if (ndr_flags & NDR_SCALARS) {
1358                 NDR_CHECK(ndr_push_align(ndr, 4));
1359                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_read_only_files));
1360         }
1361         if (ndr_flags & NDR_BUFFERS) {
1362         }
1363         return NDR_ERR_SUCCESS;
1364 }
1365
1366 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1059(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1059 *r)
1367 {
1368         if (ndr_flags & NDR_SCALARS) {
1369                 NDR_CHECK(ndr_pull_align(ndr, 4));
1370                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_read_only_files));
1371         }
1372         if (ndr_flags & NDR_BUFFERS) {
1373         }
1374         return NDR_ERR_SUCCESS;
1375 }
1376
1377 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1059(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1059 *r)
1378 {
1379         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1059");
1380         ndr->depth++;
1381         ndr_print_uint32(ndr, "buf_read_only_files", r->buf_read_only_files);
1382         ndr->depth--;
1383 }
1384
1385 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1060(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1060 *r)
1386 {
1387         if (ndr_flags & NDR_SCALARS) {
1388                 NDR_CHECK(ndr_push_align(ndr, 4));
1389                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->force_core_create_mode));
1390         }
1391         if (ndr_flags & NDR_BUFFERS) {
1392         }
1393         return NDR_ERR_SUCCESS;
1394 }
1395
1396 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1060(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1060 *r)
1397 {
1398         if (ndr_flags & NDR_SCALARS) {
1399                 NDR_CHECK(ndr_pull_align(ndr, 4));
1400                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->force_core_create_mode));
1401         }
1402         if (ndr_flags & NDR_BUFFERS) {
1403         }
1404         return NDR_ERR_SUCCESS;
1405 }
1406
1407 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1060(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1060 *r)
1408 {
1409         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1060");
1410         ndr->depth++;
1411         ndr_print_uint32(ndr, "force_core_create_mode", r->force_core_create_mode);
1412         ndr->depth--;
1413 }
1414
1415 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1061(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1061 *r)
1416 {
1417         if (ndr_flags & NDR_SCALARS) {
1418                 NDR_CHECK(ndr_push_align(ndr, 4));
1419                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_512_byte_max_transfer));
1420         }
1421         if (ndr_flags & NDR_BUFFERS) {
1422         }
1423         return NDR_ERR_SUCCESS;
1424 }
1425
1426 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1061(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1061 *r)
1427 {
1428         if (ndr_flags & NDR_SCALARS) {
1429                 NDR_CHECK(ndr_pull_align(ndr, 4));
1430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_512_byte_max_transfer));
1431         }
1432         if (ndr_flags & NDR_BUFFERS) {
1433         }
1434         return NDR_ERR_SUCCESS;
1435 }
1436
1437 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1061(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1061 *r)
1438 {
1439         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1061");
1440         ndr->depth++;
1441         ndr_print_uint32(ndr, "use_512_byte_max_transfer", r->use_512_byte_max_transfer);
1442         ndr->depth--;
1443 }
1444
1445 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1062(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1062 *r)
1446 {
1447         if (ndr_flags & NDR_SCALARS) {
1448                 NDR_CHECK(ndr_push_align(ndr, 4));
1449                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->read_ahead_throughput));
1450         }
1451         if (ndr_flags & NDR_BUFFERS) {
1452         }
1453         return NDR_ERR_SUCCESS;
1454 }
1455
1456 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1062(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1062 *r)
1457 {
1458         if (ndr_flags & NDR_SCALARS) {
1459                 NDR_CHECK(ndr_pull_align(ndr, 4));
1460                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->read_ahead_throughput));
1461         }
1462         if (ndr_flags & NDR_BUFFERS) {
1463         }
1464         return NDR_ERR_SUCCESS;
1465 }
1466
1467 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1062(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1062 *r)
1468 {
1469         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1062");
1470         ndr->depth++;
1471         ndr_print_uint32(ndr, "read_ahead_throughput", r->read_ahead_throughput);
1472         ndr->depth--;
1473 }
1474
1475 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetWkstaInfo *r)
1476 {
1477         if (ndr_flags & NDR_SCALARS) {
1478                 int level = ndr_push_get_switch_value(ndr, r);
1479                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
1480                 switch (level) {
1481                         case 100:
1482                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info100));
1483                         break;
1484
1485                         case 101:
1486                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info101));
1487                         break;
1488
1489                         case 102:
1490                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info102));
1491                         break;
1492
1493                         case 502:
1494                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info502));
1495                         break;
1496
1497                         case 1010:
1498                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1010));
1499                         break;
1500
1501                         case 1011:
1502                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1011));
1503                         break;
1504
1505                         case 1012:
1506                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1012));
1507                         break;
1508
1509                         case 1013:
1510                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1013));
1511                         break;
1512
1513                         case 1018:
1514                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1018));
1515                         break;
1516
1517                         case 1023:
1518                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1023));
1519                         break;
1520
1521                         case 1027:
1522                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1027));
1523                         break;
1524
1525                         case 1028:
1526                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1028));
1527                         break;
1528
1529                         case 1032:
1530                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1032));
1531                         break;
1532
1533                         case 1033:
1534                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1033));
1535                         break;
1536
1537                         case 1041:
1538                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1041));
1539                         break;
1540
1541                         case 1042:
1542                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1042));
1543                         break;
1544
1545                         case 1043:
1546                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1043));
1547                         break;
1548
1549                         case 1044:
1550                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1044));
1551                         break;
1552
1553                         case 1045:
1554                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1045));
1555                         break;
1556
1557                         case 1046:
1558                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1046));
1559                         break;
1560
1561                         case 1047:
1562                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1047));
1563                         break;
1564
1565                         case 1048:
1566                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1048));
1567                         break;
1568
1569                         case 1049:
1570                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1049));
1571                         break;
1572
1573                         case 1050:
1574                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1050));
1575                         break;
1576
1577                         case 1051:
1578                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1051));
1579                         break;
1580
1581                         case 1052:
1582                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1052));
1583                         break;
1584
1585                         case 1053:
1586                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1053));
1587                         break;
1588
1589                         case 1054:
1590                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1054));
1591                         break;
1592
1593                         case 1055:
1594                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1055));
1595                         break;
1596
1597                         case 1056:
1598                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1056));
1599                         break;
1600
1601                         case 1057:
1602                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1057));
1603                         break;
1604
1605                         case 1058:
1606                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1058));
1607                         break;
1608
1609                         case 1059:
1610                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1059));
1611                         break;
1612
1613                         case 1060:
1614                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1060));
1615                         break;
1616
1617                         case 1061:
1618                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1061));
1619                         break;
1620
1621                         case 1062:
1622                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1062));
1623                         break;
1624
1625                         default:
1626                         break;
1627
1628                 }
1629         }
1630         if (ndr_flags & NDR_BUFFERS) {
1631                 int level = ndr_push_get_switch_value(ndr, r);
1632                 switch (level) {
1633                         case 100:
1634                                 if (r->info100) {
1635                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo100(ndr, NDR_SCALARS|NDR_BUFFERS, r->info100));
1636                                 }
1637                         break;
1638
1639                         case 101:
1640                                 if (r->info101) {
1641                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info101));
1642                                 }
1643                         break;
1644
1645                         case 102:
1646                                 if (r->info102) {
1647                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo102(ndr, NDR_SCALARS|NDR_BUFFERS, r->info102));
1648                                 }
1649                         break;
1650
1651                         case 502:
1652                                 if (r->info502) {
1653                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo502(ndr, NDR_SCALARS, r->info502));
1654                                 }
1655                         break;
1656
1657                         case 1010:
1658                                 if (r->info1010) {
1659                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1010(ndr, NDR_SCALARS, r->info1010));
1660                                 }
1661                         break;
1662
1663                         case 1011:
1664                                 if (r->info1011) {
1665                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1011(ndr, NDR_SCALARS, r->info1011));
1666                                 }
1667                         break;
1668
1669                         case 1012:
1670                                 if (r->info1012) {
1671                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1012(ndr, NDR_SCALARS, r->info1012));
1672                                 }
1673                         break;
1674
1675                         case 1013:
1676                                 if (r->info1013) {
1677                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1013(ndr, NDR_SCALARS, r->info1013));
1678                                 }
1679                         break;
1680
1681                         case 1018:
1682                                 if (r->info1018) {
1683                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1018(ndr, NDR_SCALARS, r->info1018));
1684                                 }
1685                         break;
1686
1687                         case 1023:
1688                                 if (r->info1023) {
1689                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1023(ndr, NDR_SCALARS, r->info1023));
1690                                 }
1691                         break;
1692
1693                         case 1027:
1694                                 if (r->info1027) {
1695                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1027(ndr, NDR_SCALARS, r->info1027));
1696                                 }
1697                         break;
1698
1699                         case 1028:
1700                                 if (r->info1028) {
1701                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1028(ndr, NDR_SCALARS, r->info1028));
1702                                 }
1703                         break;
1704
1705                         case 1032:
1706                                 if (r->info1032) {
1707                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1032(ndr, NDR_SCALARS, r->info1032));
1708                                 }
1709                         break;
1710
1711                         case 1033:
1712                                 if (r->info1033) {
1713                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1033(ndr, NDR_SCALARS, r->info1033));
1714                                 }
1715                         break;
1716
1717                         case 1041:
1718                                 if (r->info1041) {
1719                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1041(ndr, NDR_SCALARS, r->info1041));
1720                                 }
1721                         break;
1722
1723                         case 1042:
1724                                 if (r->info1042) {
1725                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1042(ndr, NDR_SCALARS, r->info1042));
1726                                 }
1727                         break;
1728
1729                         case 1043:
1730                                 if (r->info1043) {
1731                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1043(ndr, NDR_SCALARS, r->info1043));
1732                                 }
1733                         break;
1734
1735                         case 1044:
1736                                 if (r->info1044) {
1737                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1044(ndr, NDR_SCALARS, r->info1044));
1738                                 }
1739                         break;
1740
1741                         case 1045:
1742                                 if (r->info1045) {
1743                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1045(ndr, NDR_SCALARS, r->info1045));
1744                                 }
1745                         break;
1746
1747                         case 1046:
1748                                 if (r->info1046) {
1749                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1046(ndr, NDR_SCALARS, r->info1046));
1750                                 }
1751                         break;
1752
1753                         case 1047:
1754                                 if (r->info1047) {
1755                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1047(ndr, NDR_SCALARS, r->info1047));
1756                                 }
1757                         break;
1758
1759                         case 1048:
1760                                 if (r->info1048) {
1761                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1048(ndr, NDR_SCALARS, r->info1048));
1762                                 }
1763                         break;
1764
1765                         case 1049:
1766                                 if (r->info1049) {
1767                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1049(ndr, NDR_SCALARS, r->info1049));
1768                                 }
1769                         break;
1770
1771                         case 1050:
1772                                 if (r->info1050) {
1773                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1050(ndr, NDR_SCALARS, r->info1050));
1774                                 }
1775                         break;
1776
1777                         case 1051:
1778                                 if (r->info1051) {
1779                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1051(ndr, NDR_SCALARS, r->info1051));
1780                                 }
1781                         break;
1782
1783                         case 1052:
1784                                 if (r->info1052) {
1785                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1052(ndr, NDR_SCALARS, r->info1052));
1786                                 }
1787                         break;
1788
1789                         case 1053:
1790                                 if (r->info1053) {
1791                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1053(ndr, NDR_SCALARS, r->info1053));
1792                                 }
1793                         break;
1794
1795                         case 1054:
1796                                 if (r->info1054) {
1797                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1054(ndr, NDR_SCALARS, r->info1054));
1798                                 }
1799                         break;
1800
1801                         case 1055:
1802                                 if (r->info1055) {
1803                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1055(ndr, NDR_SCALARS, r->info1055));
1804                                 }
1805                         break;
1806
1807                         case 1056:
1808                                 if (r->info1056) {
1809                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1056(ndr, NDR_SCALARS, r->info1056));
1810                                 }
1811                         break;
1812
1813                         case 1057:
1814                                 if (r->info1057) {
1815                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1057(ndr, NDR_SCALARS, r->info1057));
1816                                 }
1817                         break;
1818
1819                         case 1058:
1820                                 if (r->info1058) {
1821                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1058(ndr, NDR_SCALARS, r->info1058));
1822                                 }
1823                         break;
1824
1825                         case 1059:
1826                                 if (r->info1059) {
1827                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1059(ndr, NDR_SCALARS, r->info1059));
1828                                 }
1829                         break;
1830
1831                         case 1060:
1832                                 if (r->info1060) {
1833                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1060(ndr, NDR_SCALARS, r->info1060));
1834                                 }
1835                         break;
1836
1837                         case 1061:
1838                                 if (r->info1061) {
1839                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1061(ndr, NDR_SCALARS, r->info1061));
1840                                 }
1841                         break;
1842
1843                         case 1062:
1844                                 if (r->info1062) {
1845                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1062(ndr, NDR_SCALARS, r->info1062));
1846                                 }
1847                         break;
1848
1849                         default:
1850                         break;
1851
1852                 }
1853         }
1854         return NDR_ERR_SUCCESS;
1855 }
1856
1857 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetWkstaInfo *r)
1858 {
1859         int level;
1860         uint32_t _level;
1861         TALLOC_CTX *_mem_save_info100_0;
1862         TALLOC_CTX *_mem_save_info101_0;
1863         TALLOC_CTX *_mem_save_info102_0;
1864         TALLOC_CTX *_mem_save_info502_0;
1865         TALLOC_CTX *_mem_save_info1010_0;
1866         TALLOC_CTX *_mem_save_info1011_0;
1867         TALLOC_CTX *_mem_save_info1012_0;
1868         TALLOC_CTX *_mem_save_info1013_0;
1869         TALLOC_CTX *_mem_save_info1018_0;
1870         TALLOC_CTX *_mem_save_info1023_0;
1871         TALLOC_CTX *_mem_save_info1027_0;
1872         TALLOC_CTX *_mem_save_info1028_0;
1873         TALLOC_CTX *_mem_save_info1032_0;
1874         TALLOC_CTX *_mem_save_info1033_0;
1875         TALLOC_CTX *_mem_save_info1041_0;
1876         TALLOC_CTX *_mem_save_info1042_0;
1877         TALLOC_CTX *_mem_save_info1043_0;
1878         TALLOC_CTX *_mem_save_info1044_0;
1879         TALLOC_CTX *_mem_save_info1045_0;
1880         TALLOC_CTX *_mem_save_info1046_0;
1881         TALLOC_CTX *_mem_save_info1047_0;
1882         TALLOC_CTX *_mem_save_info1048_0;
1883         TALLOC_CTX *_mem_save_info1049_0;
1884         TALLOC_CTX *_mem_save_info1050_0;
1885         TALLOC_CTX *_mem_save_info1051_0;
1886         TALLOC_CTX *_mem_save_info1052_0;
1887         TALLOC_CTX *_mem_save_info1053_0;
1888         TALLOC_CTX *_mem_save_info1054_0;
1889         TALLOC_CTX *_mem_save_info1055_0;
1890         TALLOC_CTX *_mem_save_info1056_0;
1891         TALLOC_CTX *_mem_save_info1057_0;
1892         TALLOC_CTX *_mem_save_info1058_0;
1893         TALLOC_CTX *_mem_save_info1059_0;
1894         TALLOC_CTX *_mem_save_info1060_0;
1895         TALLOC_CTX *_mem_save_info1061_0;
1896         TALLOC_CTX *_mem_save_info1062_0;
1897         level = ndr_pull_get_switch_value(ndr, r);
1898         if (ndr_flags & NDR_SCALARS) {
1899                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
1900                 if (_level != level) {
1901                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1902                 }
1903                 switch (level) {
1904                         case 100: {
1905                                 uint32_t _ptr_info100;
1906                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info100));
1907                                 if (_ptr_info100) {
1908                                         NDR_PULL_ALLOC(ndr, r->info100);
1909                                 } else {
1910                                         r->info100 = NULL;
1911                                 }
1912                         break; }
1913
1914                         case 101: {
1915                                 uint32_t _ptr_info101;
1916                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info101));
1917                                 if (_ptr_info101) {
1918                                         NDR_PULL_ALLOC(ndr, r->info101);
1919                                 } else {
1920                                         r->info101 = NULL;
1921                                 }
1922                         break; }
1923
1924                         case 102: {
1925                                 uint32_t _ptr_info102;
1926                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info102));
1927                                 if (_ptr_info102) {
1928                                         NDR_PULL_ALLOC(ndr, r->info102);
1929                                 } else {
1930                                         r->info102 = NULL;
1931                                 }
1932                         break; }
1933
1934                         case 502: {
1935                                 uint32_t _ptr_info502;
1936                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info502));
1937                                 if (_ptr_info502) {
1938                                         NDR_PULL_ALLOC(ndr, r->info502);
1939                                 } else {
1940                                         r->info502 = NULL;
1941                                 }
1942                         break; }
1943
1944                         case 1010: {
1945                                 uint32_t _ptr_info1010;
1946                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1010));
1947                                 if (_ptr_info1010) {
1948                                         NDR_PULL_ALLOC(ndr, r->info1010);
1949                                 } else {
1950                                         r->info1010 = NULL;
1951                                 }
1952                         break; }
1953
1954                         case 1011: {
1955                                 uint32_t _ptr_info1011;
1956                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1011));
1957                                 if (_ptr_info1011) {
1958                                         NDR_PULL_ALLOC(ndr, r->info1011);
1959                                 } else {
1960                                         r->info1011 = NULL;
1961                                 }
1962                         break; }
1963
1964                         case 1012: {
1965                                 uint32_t _ptr_info1012;
1966                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1012));
1967                                 if (_ptr_info1012) {
1968                                         NDR_PULL_ALLOC(ndr, r->info1012);
1969                                 } else {
1970                                         r->info1012 = NULL;
1971                                 }
1972                         break; }
1973
1974                         case 1013: {
1975                                 uint32_t _ptr_info1013;
1976                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1013));
1977                                 if (_ptr_info1013) {
1978                                         NDR_PULL_ALLOC(ndr, r->info1013);
1979                                 } else {
1980                                         r->info1013 = NULL;
1981                                 }
1982                         break; }
1983
1984                         case 1018: {
1985                                 uint32_t _ptr_info1018;
1986                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1018));
1987                                 if (_ptr_info1018) {
1988                                         NDR_PULL_ALLOC(ndr, r->info1018);
1989                                 } else {
1990                                         r->info1018 = NULL;
1991                                 }
1992                         break; }
1993
1994                         case 1023: {
1995                                 uint32_t _ptr_info1023;
1996                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1023));
1997                                 if (_ptr_info1023) {
1998                                         NDR_PULL_ALLOC(ndr, r->info1023);
1999                                 } else {
2000                                         r->info1023 = NULL;
2001                                 }
2002                         break; }
2003
2004                         case 1027: {
2005                                 uint32_t _ptr_info1027;
2006                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1027));
2007                                 if (_ptr_info1027) {
2008                                         NDR_PULL_ALLOC(ndr, r->info1027);
2009                                 } else {
2010                                         r->info1027 = NULL;
2011                                 }
2012                         break; }
2013
2014                         case 1028: {
2015                                 uint32_t _ptr_info1028;
2016                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1028));
2017                                 if (_ptr_info1028) {
2018                                         NDR_PULL_ALLOC(ndr, r->info1028);
2019                                 } else {
2020                                         r->info1028 = NULL;
2021                                 }
2022                         break; }
2023
2024                         case 1032: {
2025                                 uint32_t _ptr_info1032;
2026                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1032));
2027                                 if (_ptr_info1032) {
2028                                         NDR_PULL_ALLOC(ndr, r->info1032);
2029                                 } else {
2030                                         r->info1032 = NULL;
2031                                 }
2032                         break; }
2033
2034                         case 1033: {
2035                                 uint32_t _ptr_info1033;
2036                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1033));
2037                                 if (_ptr_info1033) {
2038                                         NDR_PULL_ALLOC(ndr, r->info1033);
2039                                 } else {
2040                                         r->info1033 = NULL;
2041                                 }
2042                         break; }
2043
2044                         case 1041: {
2045                                 uint32_t _ptr_info1041;
2046                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1041));
2047                                 if (_ptr_info1041) {
2048                                         NDR_PULL_ALLOC(ndr, r->info1041);
2049                                 } else {
2050                                         r->info1041 = NULL;
2051                                 }
2052                         break; }
2053
2054                         case 1042: {
2055                                 uint32_t _ptr_info1042;
2056                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1042));
2057                                 if (_ptr_info1042) {
2058                                         NDR_PULL_ALLOC(ndr, r->info1042);
2059                                 } else {
2060                                         r->info1042 = NULL;
2061                                 }
2062                         break; }
2063
2064                         case 1043: {
2065                                 uint32_t _ptr_info1043;
2066                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1043));
2067                                 if (_ptr_info1043) {
2068                                         NDR_PULL_ALLOC(ndr, r->info1043);
2069                                 } else {
2070                                         r->info1043 = NULL;
2071                                 }
2072                         break; }
2073
2074                         case 1044: {
2075                                 uint32_t _ptr_info1044;
2076                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1044));
2077                                 if (_ptr_info1044) {
2078                                         NDR_PULL_ALLOC(ndr, r->info1044);
2079                                 } else {
2080                                         r->info1044 = NULL;
2081                                 }
2082                         break; }
2083
2084                         case 1045: {
2085                                 uint32_t _ptr_info1045;
2086                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1045));
2087                                 if (_ptr_info1045) {
2088                                         NDR_PULL_ALLOC(ndr, r->info1045);
2089                                 } else {
2090                                         r->info1045 = NULL;
2091                                 }
2092                         break; }
2093
2094                         case 1046: {
2095                                 uint32_t _ptr_info1046;
2096                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1046));
2097                                 if (_ptr_info1046) {
2098                                         NDR_PULL_ALLOC(ndr, r->info1046);
2099                                 } else {
2100                                         r->info1046 = NULL;
2101                                 }
2102                         break; }
2103
2104                         case 1047: {
2105                                 uint32_t _ptr_info1047;
2106                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1047));
2107                                 if (_ptr_info1047) {
2108                                         NDR_PULL_ALLOC(ndr, r->info1047);
2109                                 } else {
2110                                         r->info1047 = NULL;
2111                                 }
2112                         break; }
2113
2114                         case 1048: {
2115                                 uint32_t _ptr_info1048;
2116                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1048));
2117                                 if (_ptr_info1048) {
2118                                         NDR_PULL_ALLOC(ndr, r->info1048);
2119                                 } else {
2120                                         r->info1048 = NULL;
2121                                 }
2122                         break; }
2123
2124                         case 1049: {
2125                                 uint32_t _ptr_info1049;
2126                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1049));
2127                                 if (_ptr_info1049) {
2128                                         NDR_PULL_ALLOC(ndr, r->info1049);
2129                                 } else {
2130                                         r->info1049 = NULL;
2131                                 }
2132                         break; }
2133
2134                         case 1050: {
2135                                 uint32_t _ptr_info1050;
2136                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1050));
2137                                 if (_ptr_info1050) {
2138                                         NDR_PULL_ALLOC(ndr, r->info1050);
2139                                 } else {
2140                                         r->info1050 = NULL;
2141                                 }
2142                         break; }
2143
2144                         case 1051: {
2145                                 uint32_t _ptr_info1051;
2146                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1051));
2147                                 if (_ptr_info1051) {
2148                                         NDR_PULL_ALLOC(ndr, r->info1051);
2149                                 } else {
2150                                         r->info1051 = NULL;
2151                                 }
2152                         break; }
2153
2154                         case 1052: {
2155                                 uint32_t _ptr_info1052;
2156                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1052));
2157                                 if (_ptr_info1052) {
2158                                         NDR_PULL_ALLOC(ndr, r->info1052);
2159                                 } else {
2160                                         r->info1052 = NULL;
2161                                 }
2162                         break; }
2163
2164                         case 1053: {
2165                                 uint32_t _ptr_info1053;
2166                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1053));
2167                                 if (_ptr_info1053) {
2168                                         NDR_PULL_ALLOC(ndr, r->info1053);
2169                                 } else {
2170                                         r->info1053 = NULL;
2171                                 }
2172                         break; }
2173
2174                         case 1054: {
2175                                 uint32_t _ptr_info1054;
2176                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1054));
2177                                 if (_ptr_info1054) {
2178                                         NDR_PULL_ALLOC(ndr, r->info1054);
2179                                 } else {
2180                                         r->info1054 = NULL;
2181                                 }
2182                         break; }
2183
2184                         case 1055: {
2185                                 uint32_t _ptr_info1055;
2186                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1055));
2187                                 if (_ptr_info1055) {
2188                                         NDR_PULL_ALLOC(ndr, r->info1055);
2189                                 } else {
2190                                         r->info1055 = NULL;
2191                                 }
2192                         break; }
2193
2194                         case 1056: {
2195                                 uint32_t _ptr_info1056;
2196                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1056));
2197                                 if (_ptr_info1056) {
2198                                         NDR_PULL_ALLOC(ndr, r->info1056);
2199                                 } else {
2200                                         r->info1056 = NULL;
2201                                 }
2202                         break; }
2203
2204                         case 1057: {
2205                                 uint32_t _ptr_info1057;
2206                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1057));
2207                                 if (_ptr_info1057) {
2208                                         NDR_PULL_ALLOC(ndr, r->info1057);
2209                                 } else {
2210                                         r->info1057 = NULL;
2211                                 }
2212                         break; }
2213
2214                         case 1058: {
2215                                 uint32_t _ptr_info1058;
2216                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1058));
2217                                 if (_ptr_info1058) {
2218                                         NDR_PULL_ALLOC(ndr, r->info1058);
2219                                 } else {
2220                                         r->info1058 = NULL;
2221                                 }
2222                         break; }
2223
2224                         case 1059: {
2225                                 uint32_t _ptr_info1059;
2226                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1059));
2227                                 if (_ptr_info1059) {
2228                                         NDR_PULL_ALLOC(ndr, r->info1059);
2229                                 } else {
2230                                         r->info1059 = NULL;
2231                                 }
2232                         break; }
2233
2234                         case 1060: {
2235                                 uint32_t _ptr_info1060;
2236                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1060));
2237                                 if (_ptr_info1060) {
2238                                         NDR_PULL_ALLOC(ndr, r->info1060);
2239                                 } else {
2240                                         r->info1060 = NULL;
2241                                 }
2242                         break; }
2243
2244                         case 1061: {
2245                                 uint32_t _ptr_info1061;
2246                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1061));
2247                                 if (_ptr_info1061) {
2248                                         NDR_PULL_ALLOC(ndr, r->info1061);
2249                                 } else {
2250                                         r->info1061 = NULL;
2251                                 }
2252                         break; }
2253
2254                         case 1062: {
2255                                 uint32_t _ptr_info1062;
2256                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1062));
2257                                 if (_ptr_info1062) {
2258                                         NDR_PULL_ALLOC(ndr, r->info1062);
2259                                 } else {
2260                                         r->info1062 = NULL;
2261                                 }
2262                         break; }
2263
2264                         default: {
2265                         break; }
2266
2267                 }
2268         }
2269         if (ndr_flags & NDR_BUFFERS) {
2270                 switch (level) {
2271                         case 100:
2272                                 if (r->info100) {
2273                                         _mem_save_info100_0 = NDR_PULL_GET_MEM_CTX(ndr);
2274                                         NDR_PULL_SET_MEM_CTX(ndr, r->info100, 0);
2275                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo100(ndr, NDR_SCALARS|NDR_BUFFERS, r->info100));
2276                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info100_0, 0);
2277                                 }
2278                         break;
2279
2280                         case 101:
2281                                 if (r->info101) {
2282                                         _mem_save_info101_0 = NDR_PULL_GET_MEM_CTX(ndr);
2283                                         NDR_PULL_SET_MEM_CTX(ndr, r->info101, 0);
2284                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info101));
2285                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info101_0, 0);
2286                                 }
2287                         break;
2288
2289                         case 102:
2290                                 if (r->info102) {
2291                                         _mem_save_info102_0 = NDR_PULL_GET_MEM_CTX(ndr);
2292                                         NDR_PULL_SET_MEM_CTX(ndr, r->info102, 0);
2293                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo102(ndr, NDR_SCALARS|NDR_BUFFERS, r->info102));
2294                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info102_0, 0);
2295                                 }
2296                         break;
2297
2298                         case 502:
2299                                 if (r->info502) {
2300                                         _mem_save_info502_0 = NDR_PULL_GET_MEM_CTX(ndr);
2301                                         NDR_PULL_SET_MEM_CTX(ndr, r->info502, 0);
2302                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo502(ndr, NDR_SCALARS, r->info502));
2303                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info502_0, 0);
2304                                 }
2305                         break;
2306
2307                         case 1010:
2308                                 if (r->info1010) {
2309                                         _mem_save_info1010_0 = NDR_PULL_GET_MEM_CTX(ndr);
2310                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1010, 0);
2311                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1010(ndr, NDR_SCALARS, r->info1010));
2312                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1010_0, 0);
2313                                 }
2314                         break;
2315
2316                         case 1011:
2317                                 if (r->info1011) {
2318                                         _mem_save_info1011_0 = NDR_PULL_GET_MEM_CTX(ndr);
2319                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1011, 0);
2320                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1011(ndr, NDR_SCALARS, r->info1011));
2321                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1011_0, 0);
2322                                 }
2323                         break;
2324
2325                         case 1012:
2326                                 if (r->info1012) {
2327                                         _mem_save_info1012_0 = NDR_PULL_GET_MEM_CTX(ndr);
2328                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1012, 0);
2329                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1012(ndr, NDR_SCALARS, r->info1012));
2330                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1012_0, 0);
2331                                 }
2332                         break;
2333
2334                         case 1013:
2335                                 if (r->info1013) {
2336                                         _mem_save_info1013_0 = NDR_PULL_GET_MEM_CTX(ndr);
2337                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1013, 0);
2338                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1013(ndr, NDR_SCALARS, r->info1013));
2339                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1013_0, 0);
2340                                 }
2341                         break;
2342
2343                         case 1018:
2344                                 if (r->info1018) {
2345                                         _mem_save_info1018_0 = NDR_PULL_GET_MEM_CTX(ndr);
2346                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1018, 0);
2347                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1018(ndr, NDR_SCALARS, r->info1018));
2348                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1018_0, 0);
2349                                 }
2350                         break;
2351
2352                         case 1023:
2353                                 if (r->info1023) {
2354                                         _mem_save_info1023_0 = NDR_PULL_GET_MEM_CTX(ndr);
2355                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1023, 0);
2356                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1023(ndr, NDR_SCALARS, r->info1023));
2357                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1023_0, 0);
2358                                 }
2359                         break;
2360
2361                         case 1027:
2362                                 if (r->info1027) {
2363                                         _mem_save_info1027_0 = NDR_PULL_GET_MEM_CTX(ndr);
2364                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1027, 0);
2365                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1027(ndr, NDR_SCALARS, r->info1027));
2366                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1027_0, 0);
2367                                 }
2368                         break;
2369
2370                         case 1028:
2371                                 if (r->info1028) {
2372                                         _mem_save_info1028_0 = NDR_PULL_GET_MEM_CTX(ndr);
2373                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1028, 0);
2374                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1028(ndr, NDR_SCALARS, r->info1028));
2375                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1028_0, 0);
2376                                 }
2377                         break;
2378
2379                         case 1032:
2380                                 if (r->info1032) {
2381                                         _mem_save_info1032_0 = NDR_PULL_GET_MEM_CTX(ndr);
2382                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1032, 0);
2383                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1032(ndr, NDR_SCALARS, r->info1032));
2384                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1032_0, 0);
2385                                 }
2386                         break;
2387
2388                         case 1033:
2389                                 if (r->info1033) {
2390                                         _mem_save_info1033_0 = NDR_PULL_GET_MEM_CTX(ndr);
2391                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1033, 0);
2392                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1033(ndr, NDR_SCALARS, r->info1033));
2393                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1033_0, 0);
2394                                 }
2395                         break;
2396
2397                         case 1041:
2398                                 if (r->info1041) {
2399                                         _mem_save_info1041_0 = NDR_PULL_GET_MEM_CTX(ndr);
2400                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1041, 0);
2401                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1041(ndr, NDR_SCALARS, r->info1041));
2402                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1041_0, 0);
2403                                 }
2404                         break;
2405
2406                         case 1042:
2407                                 if (r->info1042) {
2408                                         _mem_save_info1042_0 = NDR_PULL_GET_MEM_CTX(ndr);
2409                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1042, 0);
2410                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1042(ndr, NDR_SCALARS, r->info1042));
2411                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1042_0, 0);
2412                                 }
2413                         break;
2414
2415                         case 1043:
2416                                 if (r->info1043) {
2417                                         _mem_save_info1043_0 = NDR_PULL_GET_MEM_CTX(ndr);
2418                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1043, 0);
2419                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1043(ndr, NDR_SCALARS, r->info1043));
2420                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1043_0, 0);
2421                                 }
2422                         break;
2423
2424                         case 1044:
2425                                 if (r->info1044) {
2426                                         _mem_save_info1044_0 = NDR_PULL_GET_MEM_CTX(ndr);
2427                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1044, 0);
2428                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1044(ndr, NDR_SCALARS, r->info1044));
2429                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1044_0, 0);
2430                                 }
2431                         break;
2432
2433                         case 1045:
2434                                 if (r->info1045) {
2435                                         _mem_save_info1045_0 = NDR_PULL_GET_MEM_CTX(ndr);
2436                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1045, 0);
2437                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1045(ndr, NDR_SCALARS, r->info1045));
2438                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1045_0, 0);
2439                                 }
2440                         break;
2441
2442                         case 1046:
2443                                 if (r->info1046) {
2444                                         _mem_save_info1046_0 = NDR_PULL_GET_MEM_CTX(ndr);
2445                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1046, 0);
2446                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1046(ndr, NDR_SCALARS, r->info1046));
2447                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1046_0, 0);
2448                                 }
2449                         break;
2450
2451                         case 1047:
2452                                 if (r->info1047) {
2453                                         _mem_save_info1047_0 = NDR_PULL_GET_MEM_CTX(ndr);
2454                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1047, 0);
2455                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1047(ndr, NDR_SCALARS, r->info1047));
2456                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1047_0, 0);
2457                                 }
2458                         break;
2459
2460                         case 1048:
2461                                 if (r->info1048) {
2462                                         _mem_save_info1048_0 = NDR_PULL_GET_MEM_CTX(ndr);
2463                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1048, 0);
2464                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1048(ndr, NDR_SCALARS, r->info1048));
2465                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1048_0, 0);
2466                                 }
2467                         break;
2468
2469                         case 1049:
2470                                 if (r->info1049) {
2471                                         _mem_save_info1049_0 = NDR_PULL_GET_MEM_CTX(ndr);
2472                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1049, 0);
2473                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1049(ndr, NDR_SCALARS, r->info1049));
2474                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1049_0, 0);
2475                                 }
2476                         break;
2477
2478                         case 1050:
2479                                 if (r->info1050) {
2480                                         _mem_save_info1050_0 = NDR_PULL_GET_MEM_CTX(ndr);
2481                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1050, 0);
2482                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1050(ndr, NDR_SCALARS, r->info1050));
2483                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1050_0, 0);
2484                                 }
2485                         break;
2486
2487                         case 1051:
2488                                 if (r->info1051) {
2489                                         _mem_save_info1051_0 = NDR_PULL_GET_MEM_CTX(ndr);
2490                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1051, 0);
2491                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1051(ndr, NDR_SCALARS, r->info1051));
2492                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1051_0, 0);
2493                                 }
2494                         break;
2495
2496                         case 1052:
2497                                 if (r->info1052) {
2498                                         _mem_save_info1052_0 = NDR_PULL_GET_MEM_CTX(ndr);
2499                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1052, 0);
2500                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1052(ndr, NDR_SCALARS, r->info1052));
2501                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1052_0, 0);
2502                                 }
2503                         break;
2504
2505                         case 1053:
2506                                 if (r->info1053) {
2507                                         _mem_save_info1053_0 = NDR_PULL_GET_MEM_CTX(ndr);
2508                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1053, 0);
2509                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1053(ndr, NDR_SCALARS, r->info1053));
2510                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1053_0, 0);
2511                                 }
2512                         break;
2513
2514                         case 1054:
2515                                 if (r->info1054) {
2516                                         _mem_save_info1054_0 = NDR_PULL_GET_MEM_CTX(ndr);
2517                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1054, 0);
2518                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1054(ndr, NDR_SCALARS, r->info1054));
2519                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1054_0, 0);
2520                                 }
2521                         break;
2522
2523                         case 1055:
2524                                 if (r->info1055) {
2525                                         _mem_save_info1055_0 = NDR_PULL_GET_MEM_CTX(ndr);
2526                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1055, 0);
2527                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1055(ndr, NDR_SCALARS, r->info1055));
2528                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1055_0, 0);
2529                                 }
2530                         break;
2531
2532                         case 1056:
2533                                 if (r->info1056) {
2534                                         _mem_save_info1056_0 = NDR_PULL_GET_MEM_CTX(ndr);
2535                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1056, 0);
2536                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1056(ndr, NDR_SCALARS, r->info1056));
2537                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1056_0, 0);
2538                                 }
2539                         break;
2540
2541                         case 1057:
2542                                 if (r->info1057) {
2543                                         _mem_save_info1057_0 = NDR_PULL_GET_MEM_CTX(ndr);
2544                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1057, 0);
2545                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1057(ndr, NDR_SCALARS, r->info1057));
2546                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1057_0, 0);
2547                                 }
2548                         break;
2549
2550                         case 1058:
2551                                 if (r->info1058) {
2552                                         _mem_save_info1058_0 = NDR_PULL_GET_MEM_CTX(ndr);
2553                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1058, 0);
2554                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1058(ndr, NDR_SCALARS, r->info1058));
2555                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1058_0, 0);
2556                                 }
2557                         break;
2558
2559                         case 1059:
2560                                 if (r->info1059) {
2561                                         _mem_save_info1059_0 = NDR_PULL_GET_MEM_CTX(ndr);
2562                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1059, 0);
2563                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1059(ndr, NDR_SCALARS, r->info1059));
2564                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1059_0, 0);
2565                                 }
2566                         break;
2567
2568                         case 1060:
2569                                 if (r->info1060) {
2570                                         _mem_save_info1060_0 = NDR_PULL_GET_MEM_CTX(ndr);
2571                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1060, 0);
2572                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1060(ndr, NDR_SCALARS, r->info1060));
2573                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1060_0, 0);
2574                                 }
2575                         break;
2576
2577                         case 1061:
2578                                 if (r->info1061) {
2579                                         _mem_save_info1061_0 = NDR_PULL_GET_MEM_CTX(ndr);
2580                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1061, 0);
2581                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1061(ndr, NDR_SCALARS, r->info1061));
2582                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1061_0, 0);
2583                                 }
2584                         break;
2585
2586                         case 1062:
2587                                 if (r->info1062) {
2588                                         _mem_save_info1062_0 = NDR_PULL_GET_MEM_CTX(ndr);
2589                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1062, 0);
2590                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1062(ndr, NDR_SCALARS, r->info1062));
2591                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1062_0, 0);
2592                                 }
2593                         break;
2594
2595                         default:
2596                         break;
2597
2598                 }
2599         }
2600         return NDR_ERR_SUCCESS;
2601 }
2602
2603 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo(struct ndr_print *ndr, const char *name, const union wkssvc_NetWkstaInfo *r)
2604 {
2605         int level;
2606         level = ndr_print_get_switch_value(ndr, r);
2607         ndr_print_union(ndr, name, level, "wkssvc_NetWkstaInfo");
2608         switch (level) {
2609                 case 100:
2610                         ndr_print_ptr(ndr, "info100", r->info100);
2611                         ndr->depth++;
2612                         if (r->info100) {
2613                                 ndr_print_wkssvc_NetWkstaInfo100(ndr, "info100", r->info100);
2614                         }
2615                         ndr->depth--;
2616                 break;
2617
2618                 case 101:
2619                         ndr_print_ptr(ndr, "info101", r->info101);
2620                         ndr->depth++;
2621                         if (r->info101) {
2622                                 ndr_print_wkssvc_NetWkstaInfo101(ndr, "info101", r->info101);
2623                         }
2624                         ndr->depth--;
2625                 break;
2626
2627                 case 102:
2628                         ndr_print_ptr(ndr, "info102", r->info102);
2629                         ndr->depth++;
2630                         if (r->info102) {
2631                                 ndr_print_wkssvc_NetWkstaInfo102(ndr, "info102", r->info102);
2632                         }
2633                         ndr->depth--;
2634                 break;
2635
2636                 case 502:
2637                         ndr_print_ptr(ndr, "info502", r->info502);
2638                         ndr->depth++;
2639                         if (r->info502) {
2640                                 ndr_print_wkssvc_NetWkstaInfo502(ndr, "info502", r->info502);
2641                         }
2642                         ndr->depth--;
2643                 break;
2644
2645                 case 1010:
2646                         ndr_print_ptr(ndr, "info1010", r->info1010);
2647                         ndr->depth++;
2648                         if (r->info1010) {
2649                                 ndr_print_wkssvc_NetWkstaInfo1010(ndr, "info1010", r->info1010);
2650                         }
2651                         ndr->depth--;
2652                 break;
2653
2654                 case 1011:
2655                         ndr_print_ptr(ndr, "info1011", r->info1011);
2656                         ndr->depth++;
2657                         if (r->info1011) {
2658                                 ndr_print_wkssvc_NetWkstaInfo1011(ndr, "info1011", r->info1011);
2659                         }
2660                         ndr->depth--;
2661                 break;
2662
2663                 case 1012:
2664                         ndr_print_ptr(ndr, "info1012", r->info1012);
2665                         ndr->depth++;
2666                         if (r->info1012) {
2667                                 ndr_print_wkssvc_NetWkstaInfo1012(ndr, "info1012", r->info1012);
2668                         }
2669                         ndr->depth--;
2670                 break;
2671
2672                 case 1013:
2673                         ndr_print_ptr(ndr, "info1013", r->info1013);
2674                         ndr->depth++;
2675                         if (r->info1013) {
2676                                 ndr_print_wkssvc_NetWkstaInfo1013(ndr, "info1013", r->info1013);
2677                         }
2678                         ndr->depth--;
2679                 break;
2680
2681                 case 1018:
2682                         ndr_print_ptr(ndr, "info1018", r->info1018);
2683                         ndr->depth++;
2684                         if (r->info1018) {
2685                                 ndr_print_wkssvc_NetWkstaInfo1018(ndr, "info1018", r->info1018);
2686                         }
2687                         ndr->depth--;
2688                 break;
2689
2690                 case 1023:
2691                         ndr_print_ptr(ndr, "info1023", r->info1023);
2692                         ndr->depth++;
2693                         if (r->info1023) {
2694                                 ndr_print_wkssvc_NetWkstaInfo1023(ndr, "info1023", r->info1023);
2695                         }
2696                         ndr->depth--;
2697                 break;
2698
2699                 case 1027:
2700                         ndr_print_ptr(ndr, "info1027", r->info1027);
2701                         ndr->depth++;
2702                         if (r->info1027) {
2703                                 ndr_print_wkssvc_NetWkstaInfo1027(ndr, "info1027", r->info1027);
2704                         }
2705                         ndr->depth--;
2706                 break;
2707
2708                 case 1028:
2709                         ndr_print_ptr(ndr, "info1028", r->info1028);
2710                         ndr->depth++;
2711                         if (r->info1028) {
2712                                 ndr_print_wkssvc_NetWkstaInfo1028(ndr, "info1028", r->info1028);
2713                         }
2714                         ndr->depth--;
2715                 break;
2716
2717                 case 1032:
2718                         ndr_print_ptr(ndr, "info1032", r->info1032);
2719                         ndr->depth++;
2720                         if (r->info1032) {
2721                                 ndr_print_wkssvc_NetWkstaInfo1032(ndr, "info1032", r->info1032);
2722                         }
2723                         ndr->depth--;
2724                 break;
2725
2726                 case 1033:
2727                         ndr_print_ptr(ndr, "info1033", r->info1033);
2728                         ndr->depth++;
2729                         if (r->info1033) {
2730                                 ndr_print_wkssvc_NetWkstaInfo1033(ndr, "info1033", r->info1033);
2731                         }
2732                         ndr->depth--;
2733                 break;
2734
2735                 case 1041:
2736                         ndr_print_ptr(ndr, "info1041", r->info1041);
2737                         ndr->depth++;
2738                         if (r->info1041) {
2739                                 ndr_print_wkssvc_NetWkstaInfo1041(ndr, "info1041", r->info1041);
2740                         }
2741                         ndr->depth--;
2742                 break;
2743
2744                 case 1042:
2745                         ndr_print_ptr(ndr, "info1042", r->info1042);
2746                         ndr->depth++;
2747                         if (r->info1042) {
2748                                 ndr_print_wkssvc_NetWkstaInfo1042(ndr, "info1042", r->info1042);
2749                         }
2750                         ndr->depth--;
2751                 break;
2752
2753                 case 1043:
2754                         ndr_print_ptr(ndr, "info1043", r->info1043);
2755                         ndr->depth++;
2756                         if (r->info1043) {
2757                                 ndr_print_wkssvc_NetWkstaInfo1043(ndr, "info1043", r->info1043);
2758                         }
2759                         ndr->depth--;
2760                 break;
2761
2762                 case 1044:
2763                         ndr_print_ptr(ndr, "info1044", r->info1044);
2764                         ndr->depth++;
2765                         if (r->info1044) {
2766                                 ndr_print_wkssvc_NetWkstaInfo1044(ndr, "info1044", r->info1044);
2767                         }
2768                         ndr->depth--;
2769                 break;
2770
2771                 case 1045:
2772                         ndr_print_ptr(ndr, "info1045", r->info1045);
2773                         ndr->depth++;
2774                         if (r->info1045) {
2775                                 ndr_print_wkssvc_NetWkstaInfo1045(ndr, "info1045", r->info1045);
2776                         }
2777                         ndr->depth--;
2778                 break;
2779
2780                 case 1046:
2781                         ndr_print_ptr(ndr, "info1046", r->info1046);
2782                         ndr->depth++;
2783                         if (r->info1046) {
2784                                 ndr_print_wkssvc_NetWkstaInfo1046(ndr, "info1046", r->info1046);
2785                         }
2786                         ndr->depth--;
2787                 break;
2788
2789                 case 1047:
2790                         ndr_print_ptr(ndr, "info1047", r->info1047);
2791                         ndr->depth++;
2792                         if (r->info1047) {
2793                                 ndr_print_wkssvc_NetWkstaInfo1047(ndr, "info1047", r->info1047);
2794                         }
2795                         ndr->depth--;
2796                 break;
2797
2798                 case 1048:
2799                         ndr_print_ptr(ndr, "info1048", r->info1048);
2800                         ndr->depth++;
2801                         if (r->info1048) {
2802                                 ndr_print_wkssvc_NetWkstaInfo1048(ndr, "info1048", r->info1048);
2803                         }
2804                         ndr->depth--;
2805                 break;
2806
2807                 case 1049:
2808                         ndr_print_ptr(ndr, "info1049", r->info1049);
2809                         ndr->depth++;
2810                         if (r->info1049) {
2811                                 ndr_print_wkssvc_NetWkstaInfo1049(ndr, "info1049", r->info1049);
2812                         }
2813                         ndr->depth--;
2814                 break;
2815
2816                 case 1050:
2817                         ndr_print_ptr(ndr, "info1050", r->info1050);
2818                         ndr->depth++;
2819                         if (r->info1050) {
2820                                 ndr_print_wkssvc_NetWkstaInfo1050(ndr, "info1050", r->info1050);
2821                         }
2822                         ndr->depth--;
2823                 break;
2824
2825                 case 1051:
2826                         ndr_print_ptr(ndr, "info1051", r->info1051);
2827                         ndr->depth++;
2828                         if (r->info1051) {
2829                                 ndr_print_wkssvc_NetWkstaInfo1051(ndr, "info1051", r->info1051);
2830                         }
2831                         ndr->depth--;
2832                 break;
2833
2834                 case 1052:
2835                         ndr_print_ptr(ndr, "info1052", r->info1052);
2836                         ndr->depth++;
2837                         if (r->info1052) {
2838                                 ndr_print_wkssvc_NetWkstaInfo1052(ndr, "info1052", r->info1052);
2839                         }
2840                         ndr->depth--;
2841                 break;
2842
2843                 case 1053:
2844                         ndr_print_ptr(ndr, "info1053", r->info1053);
2845                         ndr->depth++;
2846                         if (r->info1053) {
2847                                 ndr_print_wkssvc_NetWkstaInfo1053(ndr, "info1053", r->info1053);
2848                         }
2849                         ndr->depth--;
2850                 break;
2851
2852                 case 1054:
2853                         ndr_print_ptr(ndr, "info1054", r->info1054);
2854                         ndr->depth++;
2855                         if (r->info1054) {
2856                                 ndr_print_wkssvc_NetWkstaInfo1054(ndr, "info1054", r->info1054);
2857                         }
2858                         ndr->depth--;
2859                 break;
2860
2861                 case 1055:
2862                         ndr_print_ptr(ndr, "info1055", r->info1055);
2863                         ndr->depth++;
2864                         if (r->info1055) {
2865                                 ndr_print_wkssvc_NetWkstaInfo1055(ndr, "info1055", r->info1055);
2866                         }
2867                         ndr->depth--;
2868                 break;
2869
2870                 case 1056:
2871                         ndr_print_ptr(ndr, "info1056", r->info1056);
2872                         ndr->depth++;
2873                         if (r->info1056) {
2874                                 ndr_print_wkssvc_NetWkstaInfo1056(ndr, "info1056", r->info1056);
2875                         }
2876                         ndr->depth--;
2877                 break;
2878
2879                 case 1057:
2880                         ndr_print_ptr(ndr, "info1057", r->info1057);
2881                         ndr->depth++;
2882                         if (r->info1057) {
2883                                 ndr_print_wkssvc_NetWkstaInfo1057(ndr, "info1057", r->info1057);
2884                         }
2885                         ndr->depth--;
2886                 break;
2887
2888                 case 1058:
2889                         ndr_print_ptr(ndr, "info1058", r->info1058);
2890                         ndr->depth++;
2891                         if (r->info1058) {
2892                                 ndr_print_wkssvc_NetWkstaInfo1058(ndr, "info1058", r->info1058);
2893                         }
2894                         ndr->depth--;
2895                 break;
2896
2897                 case 1059:
2898                         ndr_print_ptr(ndr, "info1059", r->info1059);
2899                         ndr->depth++;
2900                         if (r->info1059) {
2901                                 ndr_print_wkssvc_NetWkstaInfo1059(ndr, "info1059", r->info1059);
2902                         }
2903                         ndr->depth--;
2904                 break;
2905
2906                 case 1060:
2907                         ndr_print_ptr(ndr, "info1060", r->info1060);
2908                         ndr->depth++;
2909                         if (r->info1060) {
2910                                 ndr_print_wkssvc_NetWkstaInfo1060(ndr, "info1060", r->info1060);
2911                         }
2912                         ndr->depth--;
2913                 break;
2914
2915                 case 1061:
2916                         ndr_print_ptr(ndr, "info1061", r->info1061);
2917                         ndr->depth++;
2918                         if (r->info1061) {
2919                                 ndr_print_wkssvc_NetWkstaInfo1061(ndr, "info1061", r->info1061);
2920                         }
2921                         ndr->depth--;
2922                 break;
2923
2924                 case 1062:
2925                         ndr_print_ptr(ndr, "info1062", r->info1062);
2926                         ndr->depth++;
2927                         if (r->info1062) {
2928                                 ndr_print_wkssvc_NetWkstaInfo1062(ndr, "info1062", r->info1062);
2929                         }
2930                         ndr->depth--;
2931                 break;
2932
2933                 default:
2934                 break;
2935
2936         }
2937 }
2938
2939 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserInfo0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrWkstaUserInfo0 *r)
2940 {
2941         if (ndr_flags & NDR_SCALARS) {
2942                 NDR_CHECK(ndr_push_align(ndr, 4));
2943                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
2944         }
2945         if (ndr_flags & NDR_BUFFERS) {
2946                 if (r->user_name) {
2947                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
2948                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2949                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
2950                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2951                 }
2952         }
2953         return NDR_ERR_SUCCESS;
2954 }
2955
2956 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserInfo0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrWkstaUserInfo0 *r)
2957 {
2958         uint32_t _ptr_user_name;
2959         TALLOC_CTX *_mem_save_user_name_0;
2960         if (ndr_flags & NDR_SCALARS) {
2961                 NDR_CHECK(ndr_pull_align(ndr, 4));
2962                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
2963                 if (_ptr_user_name) {
2964                         NDR_PULL_ALLOC(ndr, r->user_name);
2965                 } else {
2966                         r->user_name = NULL;
2967                 }
2968         }
2969         if (ndr_flags & NDR_BUFFERS) {
2970                 if (r->user_name) {
2971                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2972                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
2973                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
2974                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
2975                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
2976                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
2977                         }
2978                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
2979                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
2980                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
2981                 }
2982         }
2983         return NDR_ERR_SUCCESS;
2984 }
2985
2986 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserInfo0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrWkstaUserInfo0 *r)
2987 {
2988         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaUserInfo0");
2989         ndr->depth++;
2990         ndr_print_ptr(ndr, "user_name", r->user_name);
2991         ndr->depth++;
2992         if (r->user_name) {
2993                 ndr_print_string(ndr, "user_name", r->user_name);
2994         }
2995         ndr->depth--;
2996         ndr->depth--;
2997 }
2998
2999 static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsersCtr0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaEnumUsersCtr0 *r)
3000 {
3001         uint32_t cntr_user0_1;
3002         if (ndr_flags & NDR_SCALARS) {
3003                 NDR_CHECK(ndr_push_align(ndr, 4));
3004                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->entries_read));
3005                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user0));
3006         }
3007         if (ndr_flags & NDR_BUFFERS) {
3008                 if (r->user0) {
3009                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->entries_read));
3010                         for (cntr_user0_1 = 0; cntr_user0_1 < r->entries_read; cntr_user0_1++) {
3011                                 NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo0(ndr, NDR_SCALARS, &r->user0[cntr_user0_1]));
3012                         }
3013                         for (cntr_user0_1 = 0; cntr_user0_1 < r->entries_read; cntr_user0_1++) {
3014                                 NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo0(ndr, NDR_BUFFERS, &r->user0[cntr_user0_1]));
3015                         }
3016                 }
3017         }
3018         return NDR_ERR_SUCCESS;
3019 }
3020
3021 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsersCtr0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaEnumUsersCtr0 *r)
3022 {
3023         uint32_t _ptr_user0;
3024         uint32_t cntr_user0_1;
3025         TALLOC_CTX *_mem_save_user0_0;
3026         TALLOC_CTX *_mem_save_user0_1;
3027         if (ndr_flags & NDR_SCALARS) {
3028                 NDR_CHECK(ndr_pull_align(ndr, 4));
3029                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->entries_read));
3030                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user0));
3031                 if (_ptr_user0) {
3032                         NDR_PULL_ALLOC(ndr, r->user0);
3033                 } else {
3034                         r->user0 = NULL;
3035                 }
3036         }
3037         if (ndr_flags & NDR_BUFFERS) {
3038                 if (r->user0) {
3039                         _mem_save_user0_0 = NDR_PULL_GET_MEM_CTX(ndr);
3040                         NDR_PULL_SET_MEM_CTX(ndr, r->user0, 0);
3041                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user0));
3042                         NDR_PULL_ALLOC_N(ndr, r->user0, ndr_get_array_size(ndr, &r->user0));
3043                         _mem_save_user0_1 = NDR_PULL_GET_MEM_CTX(ndr);
3044                         NDR_PULL_SET_MEM_CTX(ndr, r->user0, 0);
3045                         for (cntr_user0_1 = 0; cntr_user0_1 < r->entries_read; cntr_user0_1++) {
3046                                 NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo0(ndr, NDR_SCALARS, &r->user0[cntr_user0_1]));
3047                         }
3048                         for (cntr_user0_1 = 0; cntr_user0_1 < r->entries_read; cntr_user0_1++) {
3049                                 NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo0(ndr, NDR_BUFFERS, &r->user0[cntr_user0_1]));
3050                         }
3051                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user0_1, 0);
3052                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user0_0, 0);
3053                 }
3054                 if (r->user0) {
3055                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->user0, r->entries_read));
3056                 }
3057         }
3058         return NDR_ERR_SUCCESS;
3059 }
3060
3061 _PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsersCtr0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaEnumUsersCtr0 *r)
3062 {
3063         uint32_t cntr_user0_1;
3064         ndr_print_struct(ndr, name, "wkssvc_NetWkstaEnumUsersCtr0");
3065         ndr->depth++;
3066         ndr_print_uint32(ndr, "entries_read", r->entries_read);
3067         ndr_print_ptr(ndr, "user0", r->user0);
3068         ndr->depth++;
3069         if (r->user0) {
3070                 ndr->print(ndr, "%s: ARRAY(%d)", "user0", r->entries_read);
3071                 ndr->depth++;
3072                 for (cntr_user0_1=0;cntr_user0_1<r->entries_read;cntr_user0_1++) {
3073                         char *idx_1=NULL;
3074                         asprintf(&idx_1, "[%d]", cntr_user0_1);
3075                         if (idx_1) {
3076                                 ndr_print_wkssvc_NetrWkstaUserInfo0(ndr, "user0", &r->user0[cntr_user0_1]);
3077                                 free(idx_1);
3078                         }
3079                 }
3080                 ndr->depth--;
3081         }
3082         ndr->depth--;
3083         ndr->depth--;
3084 }
3085
3086 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserInfo1(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrWkstaUserInfo1 *r)
3087 {
3088         if (ndr_flags & NDR_SCALARS) {
3089                 NDR_CHECK(ndr_push_align(ndr, 4));
3090                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
3091                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->logon_domain));
3092                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->other_domains));
3093                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->logon_server));
3094         }
3095         if (ndr_flags & NDR_BUFFERS) {
3096                 if (r->user_name) {
3097                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
3098                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3099                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
3100                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3101                 }
3102                 if (r->logon_domain) {
3103                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->logon_domain, CH_UTF16)));
3104                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3105                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->logon_domain, CH_UTF16)));
3106                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->logon_domain, ndr_charset_length(r->logon_domain, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3107                 }
3108                 if (r->other_domains) {
3109                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->other_domains, CH_UTF16)));
3110                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3111                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->other_domains, CH_UTF16)));
3112                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->other_domains, ndr_charset_length(r->other_domains, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3113                 }
3114                 if (r->logon_server) {
3115                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->logon_server, CH_UTF16)));
3116                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3117                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->logon_server, CH_UTF16)));
3118                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->logon_server, ndr_charset_length(r->logon_server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3119                 }
3120         }
3121         return NDR_ERR_SUCCESS;
3122 }
3123
3124 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserInfo1(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrWkstaUserInfo1 *r)
3125 {
3126         uint32_t _ptr_user_name;
3127         TALLOC_CTX *_mem_save_user_name_0;
3128         uint32_t _ptr_logon_domain;
3129         TALLOC_CTX *_mem_save_logon_domain_0;
3130         uint32_t _ptr_other_domains;
3131         TALLOC_CTX *_mem_save_other_domains_0;
3132         uint32_t _ptr_logon_server;
3133         TALLOC_CTX *_mem_save_logon_server_0;
3134         if (ndr_flags & NDR_SCALARS) {
3135                 NDR_CHECK(ndr_pull_align(ndr, 4));
3136                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3137                 if (_ptr_user_name) {
3138                         NDR_PULL_ALLOC(ndr, r->user_name);
3139                 } else {
3140                         r->user_name = NULL;
3141                 }
3142                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_logon_domain));
3143                 if (_ptr_logon_domain) {
3144                         NDR_PULL_ALLOC(ndr, r->logon_domain);
3145                 } else {
3146                         r->logon_domain = NULL;
3147                 }
3148                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_other_domains));
3149                 if (_ptr_other_domains) {
3150                         NDR_PULL_ALLOC(ndr, r->other_domains);
3151                 } else {
3152                         r->other_domains = NULL;
3153                 }
3154                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_logon_server));
3155                 if (_ptr_logon_server) {
3156                         NDR_PULL_ALLOC(ndr, r->logon_server);
3157                 } else {
3158                         r->logon_server = NULL;
3159                 }
3160         }
3161         if (ndr_flags & NDR_BUFFERS) {
3162                 if (r->user_name) {
3163                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3164                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3165                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
3166                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
3167                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
3168                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
3169                         }
3170                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
3171                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
3172                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3173                 }
3174                 if (r->logon_domain) {
3175                         _mem_save_logon_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
3176                         NDR_PULL_SET_MEM_CTX(ndr, r->logon_domain, 0);
3177                         NDR_CHECK(ndr_pull_array_size(ndr, &r->logon_domain));
3178                         NDR_CHECK(ndr_pull_array_length(ndr, &r->logon_domain));
3179                         if (ndr_get_array_length(ndr, &r->logon_domain) > ndr_get_array_size(ndr, &r->logon_domain)) {
3180                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->logon_domain), ndr_get_array_length(ndr, &r->logon_domain));
3181                         }
3182                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->logon_domain), sizeof(uint16_t)));
3183                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->logon_domain, ndr_get_array_length(ndr, &r->logon_domain), sizeof(uint16_t), CH_UTF16));
3184                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_logon_domain_0, 0);
3185                 }
3186                 if (r->other_domains) {
3187                         _mem_save_other_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
3188                         NDR_PULL_SET_MEM_CTX(ndr, r->other_domains, 0);
3189                         NDR_CHECK(ndr_pull_array_size(ndr, &r->other_domains));
3190                         NDR_CHECK(ndr_pull_array_length(ndr, &r->other_domains));
3191                         if (ndr_get_array_length(ndr, &r->other_domains) > ndr_get_array_size(ndr, &r->other_domains)) {
3192                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->other_domains), ndr_get_array_length(ndr, &r->other_domains));
3193                         }
3194                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->other_domains), sizeof(uint16_t)));
3195                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->other_domains, ndr_get_array_length(ndr, &r->other_domains), sizeof(uint16_t), CH_UTF16));
3196                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_other_domains_0, 0);
3197                 }
3198                 if (r->logon_server) {
3199                         _mem_save_logon_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
3200                         NDR_PULL_SET_MEM_CTX(ndr, r->logon_server, 0);
3201                         NDR_CHECK(ndr_pull_array_size(ndr, &r->logon_server));
3202                         NDR_CHECK(ndr_pull_array_length(ndr, &r->logon_server));
3203                         if (ndr_get_array_length(ndr, &r->logon_server) > ndr_get_array_size(ndr, &r->logon_server)) {
3204                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->logon_server), ndr_get_array_length(ndr, &r->logon_server));
3205                         }
3206                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->logon_server), sizeof(uint16_t)));
3207                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->logon_server, ndr_get_array_length(ndr, &r->logon_server), sizeof(uint16_t), CH_UTF16));
3208                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_logon_server_0, 0);
3209                 }
3210         }
3211         return NDR_ERR_SUCCESS;
3212 }
3213
3214 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserInfo1(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrWkstaUserInfo1 *r)
3215 {
3216         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaUserInfo1");
3217         ndr->depth++;
3218         ndr_print_ptr(ndr, "user_name", r->user_name);
3219         ndr->depth++;
3220         if (r->user_name) {
3221                 ndr_print_string(ndr, "user_name", r->user_name);
3222         }
3223         ndr->depth--;
3224         ndr_print_ptr(ndr, "logon_domain", r->logon_domain);
3225         ndr->depth++;
3226         if (r->logon_domain) {
3227                 ndr_print_string(ndr, "logon_domain", r->logon_domain);
3228         }
3229         ndr->depth--;
3230         ndr_print_ptr(ndr, "other_domains", r->other_domains);
3231         ndr->depth++;
3232         if (r->other_domains) {
3233                 ndr_print_string(ndr, "other_domains", r->other_domains);
3234         }
3235         ndr->depth--;
3236         ndr_print_ptr(ndr, "logon_server", r->logon_server);
3237         ndr->depth++;
3238         if (r->logon_server) {
3239                 ndr_print_string(ndr, "logon_server", r->logon_server);
3240         }
3241         ndr->depth--;
3242         ndr->depth--;
3243 }
3244
3245 static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsersCtr1(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaEnumUsersCtr1 *r)
3246 {
3247         uint32_t cntr_user1_1;
3248         if (ndr_flags & NDR_SCALARS) {
3249                 NDR_CHECK(ndr_push_align(ndr, 4));
3250                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->entries_read));
3251                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user1));
3252         }
3253         if (ndr_flags & NDR_BUFFERS) {
3254                 if (r->user1) {
3255                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->entries_read));
3256                         for (cntr_user1_1 = 0; cntr_user1_1 < r->entries_read; cntr_user1_1++) {
3257                                 NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo1(ndr, NDR_SCALARS, &r->user1[cntr_user1_1]));
3258                         }
3259                         for (cntr_user1_1 = 0; cntr_user1_1 < r->entries_read; cntr_user1_1++) {
3260                                 NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo1(ndr, NDR_BUFFERS, &r->user1[cntr_user1_1]));
3261                         }
3262                 }
3263         }
3264         return NDR_ERR_SUCCESS;
3265 }
3266
3267 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsersCtr1(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaEnumUsersCtr1 *r)
3268 {
3269         uint32_t _ptr_user1;
3270         uint32_t cntr_user1_1;
3271         TALLOC_CTX *_mem_save_user1_0;
3272         TALLOC_CTX *_mem_save_user1_1;
3273         if (ndr_flags & NDR_SCALARS) {
3274                 NDR_CHECK(ndr_pull_align(ndr, 4));
3275                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->entries_read));
3276                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user1));
3277                 if (_ptr_user1) {
3278                         NDR_PULL_ALLOC(ndr, r->user1);
3279                 } else {
3280                         r->user1 = NULL;
3281                 }
3282         }
3283         if (ndr_flags & NDR_BUFFERS) {
3284                 if (r->user1) {
3285                         _mem_save_user1_0 = NDR_PULL_GET_MEM_CTX(ndr);
3286                         NDR_PULL_SET_MEM_CTX(ndr, r->user1, 0);
3287                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user1));
3288                         NDR_PULL_ALLOC_N(ndr, r->user1, ndr_get_array_size(ndr, &r->user1));
3289                         _mem_save_user1_1 = NDR_PULL_GET_MEM_CTX(ndr);
3290                         NDR_PULL_SET_MEM_CTX(ndr, r->user1, 0);
3291                         for (cntr_user1_1 = 0; cntr_user1_1 < r->entries_read; cntr_user1_1++) {
3292                                 NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo1(ndr, NDR_SCALARS, &r->user1[cntr_user1_1]));
3293                         }
3294                         for (cntr_user1_1 = 0; cntr_user1_1 < r->entries_read; cntr_user1_1++) {
3295                                 NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo1(ndr, NDR_BUFFERS, &r->user1[cntr_user1_1]));
3296                         }
3297                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user1_1, 0);
3298                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user1_0, 0);
3299                 }
3300                 if (r->user1) {
3301                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->user1, r->entries_read));
3302                 }
3303         }
3304         return NDR_ERR_SUCCESS;
3305 }
3306
3307 _PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsersCtr1(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaEnumUsersCtr1 *r)
3308 {
3309         uint32_t cntr_user1_1;
3310         ndr_print_struct(ndr, name, "wkssvc_NetWkstaEnumUsersCtr1");
3311         ndr->depth++;
3312         ndr_print_uint32(ndr, "entries_read", r->entries_read);
3313         ndr_print_ptr(ndr, "user1", r->user1);
3314         ndr->depth++;
3315         if (r->user1) {
3316                 ndr->print(ndr, "%s: ARRAY(%d)", "user1", r->entries_read);
3317                 ndr->depth++;
3318                 for (cntr_user1_1=0;cntr_user1_1<r->entries_read;cntr_user1_1++) {
3319                         char *idx_1=NULL;
3320                         asprintf(&idx_1, "[%d]", cntr_user1_1);
3321                         if (idx_1) {
3322                                 ndr_print_wkssvc_NetrWkstaUserInfo1(ndr, "user1", &r->user1[cntr_user1_1]);
3323                                 free(idx_1);
3324                         }
3325                 }
3326                 ndr->depth--;
3327         }
3328         ndr->depth--;
3329         ndr->depth--;
3330 }
3331
3332 static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsersCtr(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetWkstaEnumUsersCtr *r)
3333 {
3334         if (ndr_flags & NDR_SCALARS) {
3335                 int level = ndr_push_get_switch_value(ndr, r);
3336                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
3337                 switch (level) {
3338                         case 0:
3339                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user0));
3340                         break;
3341
3342                         case 1:
3343                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user1));
3344                         break;
3345
3346                         default:
3347                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3348                 }
3349         }
3350         if (ndr_flags & NDR_BUFFERS) {
3351                 int level = ndr_push_get_switch_value(ndr, r);
3352                 switch (level) {
3353                         case 0:
3354                                 if (r->user0) {
3355                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->user0));
3356                                 }
3357                         break;
3358
3359                         case 1:
3360                                 if (r->user1) {
3361                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->user1));
3362                                 }
3363                         break;
3364
3365                         default:
3366                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3367                 }
3368         }
3369         return NDR_ERR_SUCCESS;
3370 }
3371
3372 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsersCtr(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetWkstaEnumUsersCtr *r)
3373 {
3374         int level;
3375         uint32_t _level;
3376         TALLOC_CTX *_mem_save_user0_0;
3377         TALLOC_CTX *_mem_save_user1_0;
3378         level = ndr_pull_get_switch_value(ndr, r);
3379         if (ndr_flags & NDR_SCALARS) {
3380                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
3381                 if (_level != level) {
3382                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
3383                 }
3384                 switch (level) {
3385                         case 0: {
3386                                 uint32_t _ptr_user0;
3387                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user0));
3388                                 if (_ptr_user0) {
3389                                         NDR_PULL_ALLOC(ndr, r->user0);
3390                                 } else {
3391                                         r->user0 = NULL;
3392                                 }
3393                         break; }
3394
3395                         case 1: {
3396                                 uint32_t _ptr_user1;
3397                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user1));
3398                                 if (_ptr_user1) {
3399                                         NDR_PULL_ALLOC(ndr, r->user1);
3400                                 } else {
3401                                         r->user1 = NULL;
3402                                 }
3403                         break; }
3404
3405                         default:
3406                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3407                 }
3408         }
3409         if (ndr_flags & NDR_BUFFERS) {
3410                 switch (level) {
3411                         case 0:
3412                                 if (r->user0) {
3413                                         _mem_save_user0_0 = NDR_PULL_GET_MEM_CTX(ndr);
3414                                         NDR_PULL_SET_MEM_CTX(ndr, r->user0, 0);
3415                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->user0));
3416                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user0_0, 0);
3417                                 }
3418                         break;
3419
3420                         case 1:
3421                                 if (r->user1) {
3422                                         _mem_save_user1_0 = NDR_PULL_GET_MEM_CTX(ndr);
3423                                         NDR_PULL_SET_MEM_CTX(ndr, r->user1, 0);
3424                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->user1));
3425                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user1_0, 0);
3426                                 }
3427                         break;
3428
3429                         default:
3430                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3431                 }
3432         }
3433         return NDR_ERR_SUCCESS;
3434 }
3435
3436 _PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsersCtr(struct ndr_print *ndr, const char *name, const union wkssvc_NetWkstaEnumUsersCtr *r)
3437 {
3438         int level;
3439         level = ndr_print_get_switch_value(ndr, r);
3440         ndr_print_union(ndr, name, level, "wkssvc_NetWkstaEnumUsersCtr");
3441         switch (level) {
3442                 case 0:
3443                         ndr_print_ptr(ndr, "user0", r->user0);
3444                         ndr->depth++;
3445                         if (r->user0) {
3446                                 ndr_print_wkssvc_NetWkstaEnumUsersCtr0(ndr, "user0", r->user0);
3447                         }
3448                         ndr->depth--;
3449                 break;
3450
3451                 case 1:
3452                         ndr_print_ptr(ndr, "user1", r->user1);
3453                         ndr->depth++;
3454                         if (r->user1) {
3455                                 ndr_print_wkssvc_NetWkstaEnumUsersCtr1(ndr, "user1", r->user1);
3456                         }
3457                         ndr->depth--;
3458                 break;
3459
3460                 default:
3461                         ndr_print_bad_level(ndr, name, level);
3462         }
3463 }
3464
3465 static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsersInfo(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaEnumUsersInfo *r)
3466 {
3467         if (ndr_flags & NDR_SCALARS) {
3468                 NDR_CHECK(ndr_push_align(ndr, 4));
3469                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
3470                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
3471                 NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersCtr(ndr, NDR_SCALARS, &r->ctr));
3472         }
3473         if (ndr_flags & NDR_BUFFERS) {
3474                 NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersCtr(ndr, NDR_BUFFERS, &r->ctr));
3475         }
3476         return NDR_ERR_SUCCESS;
3477 }
3478
3479 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsersInfo(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaEnumUsersInfo *r)
3480 {
3481         if (ndr_flags & NDR_SCALARS) {
3482                 NDR_CHECK(ndr_pull_align(ndr, 4));
3483                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
3484                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
3485                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersCtr(ndr, NDR_SCALARS, &r->ctr));
3486         }
3487         if (ndr_flags & NDR_BUFFERS) {
3488                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersCtr(ndr, NDR_BUFFERS, &r->ctr));
3489         }
3490         return NDR_ERR_SUCCESS;
3491 }
3492
3493 _PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsersInfo(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaEnumUsersInfo *r)
3494 {
3495         ndr_print_struct(ndr, name, "wkssvc_NetWkstaEnumUsersInfo");
3496         ndr->depth++;
3497         ndr_print_uint32(ndr, "level", r->level);
3498         ndr_print_set_switch_value(ndr, &r->ctr, r->level);
3499         ndr_print_wkssvc_NetWkstaEnumUsersCtr(ndr, "ctr", &r->ctr);
3500         ndr->depth--;
3501 }
3502
3503 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserInfo1101(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrWkstaUserInfo1101 *r)
3504 {
3505         if (ndr_flags & NDR_SCALARS) {
3506                 NDR_CHECK(ndr_push_align(ndr, 4));
3507                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->other_domains));
3508         }
3509         if (ndr_flags & NDR_BUFFERS) {
3510                 if (r->other_domains) {
3511                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->other_domains, CH_UTF16)));
3512                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3513                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->other_domains, CH_UTF16)));
3514                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->other_domains, ndr_charset_length(r->other_domains, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3515                 }
3516         }
3517         return NDR_ERR_SUCCESS;
3518 }
3519
3520 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserInfo1101(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrWkstaUserInfo1101 *r)
3521 {
3522         uint32_t _ptr_other_domains;
3523         TALLOC_CTX *_mem_save_other_domains_0;
3524         if (ndr_flags & NDR_SCALARS) {
3525                 NDR_CHECK(ndr_pull_align(ndr, 4));
3526                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_other_domains));
3527                 if (_ptr_other_domains) {
3528                         NDR_PULL_ALLOC(ndr, r->other_domains);
3529                 } else {
3530                         r->other_domains = NULL;
3531                 }
3532         }
3533         if (ndr_flags & NDR_BUFFERS) {
3534                 if (r->other_domains) {
3535                         _mem_save_other_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
3536                         NDR_PULL_SET_MEM_CTX(ndr, r->other_domains, 0);
3537                         NDR_CHECK(ndr_pull_array_size(ndr, &r->other_domains));
3538                         NDR_CHECK(ndr_pull_array_length(ndr, &r->other_domains));
3539                         if (ndr_get_array_length(ndr, &r->other_domains) > ndr_get_array_size(ndr, &r->other_domains)) {
3540                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->other_domains), ndr_get_array_length(ndr, &r->other_domains));
3541                         }
3542                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->other_domains), sizeof(uint16_t)));
3543                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->other_domains, ndr_get_array_length(ndr, &r->other_domains), sizeof(uint16_t), CH_UTF16));
3544                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_other_domains_0, 0);
3545                 }
3546         }
3547         return NDR_ERR_SUCCESS;
3548 }
3549
3550 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserInfo1101(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrWkstaUserInfo1101 *r)
3551 {
3552         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaUserInfo1101");
3553         ndr->depth++;
3554         ndr_print_ptr(ndr, "other_domains", r->other_domains);
3555         ndr->depth++;
3556         if (r->other_domains) {
3557                 ndr_print_string(ndr, "other_domains", r->other_domains);
3558         }
3559         ndr->depth--;
3560         ndr->depth--;
3561 }
3562
3563 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserInfo(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetrWkstaUserInfo *r)
3564 {
3565         if (ndr_flags & NDR_SCALARS) {
3566                 int level = ndr_push_get_switch_value(ndr, r);
3567                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
3568                 switch (level) {
3569                         case 0:
3570                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
3571                         break;
3572
3573                         case 1:
3574                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
3575                         break;
3576
3577                         case 1101:
3578                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1101));
3579                         break;
3580
3581                         default:
3582                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3583                 }
3584         }
3585         if (ndr_flags & NDR_BUFFERS) {
3586                 int level = ndr_push_get_switch_value(ndr, r);
3587                 switch (level) {
3588                         case 0:
3589                                 if (r->info0) {
3590                                         NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
3591                                 }
3592                         break;
3593
3594                         case 1:
3595                                 if (r->info1) {
3596                                         NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
3597                                 }
3598                         break;
3599
3600                         case 1101:
3601                                 if (r->info1101) {
3602                                         NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo1101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1101));
3603                                 }
3604                         break;
3605
3606                         default:
3607                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3608                 }
3609         }
3610         return NDR_ERR_SUCCESS;
3611 }
3612
3613 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserInfo(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetrWkstaUserInfo *r)
3614 {
3615         int level;
3616         uint32_t _level;
3617         TALLOC_CTX *_mem_save_info0_0;
3618         TALLOC_CTX *_mem_save_info1_0;
3619         TALLOC_CTX *_mem_save_info1101_0;
3620         level = ndr_pull_get_switch_value(ndr, r);
3621         if (ndr_flags & NDR_SCALARS) {
3622                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
3623                 if (_level != level) {
3624                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
3625                 }
3626                 switch (level) {
3627                         case 0: {
3628                                 uint32_t _ptr_info0;
3629                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
3630                                 if (_ptr_info0) {
3631                                         NDR_PULL_ALLOC(ndr, r->info0);
3632                                 } else {
3633                                         r->info0 = NULL;
3634                                 }
3635                         break; }
3636
3637                         case 1: {
3638                                 uint32_t _ptr_info1;
3639                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
3640                                 if (_ptr_info1) {
3641                                         NDR_PULL_ALLOC(ndr, r->info1);
3642                                 } else {
3643                                         r->info1 = NULL;
3644                                 }
3645                         break; }
3646
3647                         case 1101: {
3648                                 uint32_t _ptr_info1101;
3649                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1101));
3650                                 if (_ptr_info1101) {
3651                                         NDR_PULL_ALLOC(ndr, r->info1101);
3652                                 } else {
3653                                         r->info1101 = NULL;
3654                                 }
3655                         break; }
3656
3657                         default:
3658                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3659                 }
3660         }
3661         if (ndr_flags & NDR_BUFFERS) {
3662                 switch (level) {
3663                         case 0:
3664                                 if (r->info0) {
3665                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
3666                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
3667                                         NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
3668                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
3669                                 }
3670                         break;
3671
3672                         case 1:
3673                                 if (r->info1) {
3674                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
3675                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
3676                                         NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
3677                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
3678                                 }
3679                         break;
3680
3681                         case 1101:
3682                                 if (r->info1101) {
3683                                         _mem_save_info1101_0 = NDR_PULL_GET_MEM_CTX(ndr);
3684                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1101, 0);
3685                                         NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo1101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1101));
3686                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1101_0, 0);
3687                                 }
3688                         break;
3689
3690                         default:
3691                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3692                 }
3693         }
3694         return NDR_ERR_SUCCESS;
3695 }
3696
3697 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserInfo(struct ndr_print *ndr, const char *name, const union wkssvc_NetrWkstaUserInfo *r)
3698 {
3699         int level;
3700         level = ndr_print_get_switch_value(ndr, r);
3701         ndr_print_union(ndr, name, level, "wkssvc_NetrWkstaUserInfo");
3702         switch (level) {
3703                 case 0:
3704                         ndr_print_ptr(ndr, "info0", r->info0);
3705                         ndr->depth++;
3706                         if (r->info0) {
3707                                 ndr_print_wkssvc_NetrWkstaUserInfo0(ndr, "info0", r->info0);
3708                         }
3709                         ndr->depth--;
3710                 break;
3711
3712                 case 1:
3713                         ndr_print_ptr(ndr, "info1", r->info1);
3714                         ndr->depth++;
3715                         if (r->info1) {
3716                                 ndr_print_wkssvc_NetrWkstaUserInfo1(ndr, "info1", r->info1);
3717                         }
3718                         ndr->depth--;
3719                 break;
3720
3721                 case 1101:
3722                         ndr_print_ptr(ndr, "info1101", r->info1101);
3723                         ndr->depth++;
3724                         if (r->info1101) {
3725                                 ndr_print_wkssvc_NetrWkstaUserInfo1101(ndr, "info1101", r->info1101);
3726                         }
3727                         ndr->depth--;
3728                 break;
3729
3730                 default:
3731                         ndr_print_bad_level(ndr, name, level);
3732         }
3733 }
3734
3735 static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportInfo0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaTransportInfo0 *r)
3736 {
3737         if (ndr_flags & NDR_SCALARS) {
3738                 NDR_CHECK(ndr_push_align(ndr, 4));
3739                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->quality_of_service));
3740                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->vc_count));
3741                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
3742                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->address));
3743                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->wan_link));
3744         }
3745         if (ndr_flags & NDR_BUFFERS) {
3746                 if (r->name) {
3747                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
3748                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3749                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
3750                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3751                 }
3752                 if (r->address) {
3753                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->address, CH_UTF16)));
3754                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3755                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->address, CH_UTF16)));
3756                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->address, ndr_charset_length(r->address, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3757                 }
3758         }
3759         return NDR_ERR_SUCCESS;
3760 }
3761
3762 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportInfo0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaTransportInfo0 *r)
3763 {
3764         uint32_t _ptr_name;
3765         TALLOC_CTX *_mem_save_name_0;
3766         uint32_t _ptr_address;
3767         TALLOC_CTX *_mem_save_address_0;
3768         if (ndr_flags & NDR_SCALARS) {
3769                 NDR_CHECK(ndr_pull_align(ndr, 4));
3770                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->quality_of_service));
3771                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->vc_count));
3772                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
3773                 if (_ptr_name) {
3774                         NDR_PULL_ALLOC(ndr, r->name);
3775                 } else {
3776                         r->name = NULL;
3777                 }
3778                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_address));
3779                 if (_ptr_address) {
3780                         NDR_PULL_ALLOC(ndr, r->address);
3781                 } else {
3782                         r->address = NULL;
3783                 }
3784                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->wan_link));
3785         }
3786         if (ndr_flags & NDR_BUFFERS) {
3787                 if (r->name) {
3788                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3789                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
3790                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
3791                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
3792                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
3793                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));
3794                         }
3795                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
3796                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
3797                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
3798                 }
3799                 if (r->address) {
3800                         _mem_save_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
3801                         NDR_PULL_SET_MEM_CTX(ndr, r->address, 0);
3802                         NDR_CHECK(ndr_pull_array_size(ndr, &r->address));
3803                         NDR_CHECK(ndr_pull_array_length(ndr, &r->address));
3804                         if (ndr_get_array_length(ndr, &r->address) > ndr_get_array_size(ndr, &r->address)) {
3805                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->address), ndr_get_array_length(ndr, &r->address));
3806                         }
3807                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->address), sizeof(uint16_t)));
3808                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->address, ndr_get_array_length(ndr, &r->address), sizeof(uint16_t), CH_UTF16));
3809                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_address_0, 0);
3810                 }
3811         }
3812         return NDR_ERR_SUCCESS;
3813 }
3814
3815 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportInfo0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaTransportInfo0 *r)
3816 {
3817         ndr_print_struct(ndr, name, "wkssvc_NetWkstaTransportInfo0");
3818         ndr->depth++;
3819         ndr_print_uint32(ndr, "quality_of_service", r->quality_of_service);
3820         ndr_print_uint32(ndr, "vc_count", r->vc_count);
3821         ndr_print_ptr(ndr, "name", r->name);
3822         ndr->depth++;
3823         if (r->name) {
3824                 ndr_print_string(ndr, "name", r->name);
3825         }
3826         ndr->depth--;
3827         ndr_print_ptr(ndr, "address", r->address);
3828         ndr->depth++;
3829         if (r->address) {
3830                 ndr_print_string(ndr, "address", r->address);
3831         }
3832         ndr->depth--;
3833         ndr_print_uint32(ndr, "wan_link", r->wan_link);
3834         ndr->depth--;
3835 }
3836
3837 static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportCtr0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaTransportCtr0 *r)
3838 {
3839         uint32_t cntr_array_1;
3840         if (ndr_flags & NDR_SCALARS) {
3841                 NDR_CHECK(ndr_push_align(ndr, 4));
3842                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3843                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
3844         }
3845         if (ndr_flags & NDR_BUFFERS) {
3846                 if (r->array) {
3847                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3848                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3849                                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
3850                         }
3851                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3852                                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
3853                         }
3854                 }
3855         }
3856         return NDR_ERR_SUCCESS;
3857 }
3858
3859 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportCtr0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaTransportCtr0 *r)
3860 {
3861         uint32_t _ptr_array;
3862         uint32_t cntr_array_1;
3863         TALLOC_CTX *_mem_save_array_0;
3864         TALLOC_CTX *_mem_save_array_1;
3865         if (ndr_flags & NDR_SCALARS) {
3866                 NDR_CHECK(ndr_pull_align(ndr, 4));
3867                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3868                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
3869                 if (_ptr_array) {
3870                         NDR_PULL_ALLOC(ndr, r->array);
3871                 } else {
3872                         r->array = NULL;
3873                 }
3874         }
3875         if (ndr_flags & NDR_BUFFERS) {
3876                 if (r->array) {
3877                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
3878                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
3879                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
3880                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
3881                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
3882                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
3883                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3884                                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
3885                         }
3886                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3887                                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
3888                         }
3889                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
3890                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
3891                 }
3892                 if (r->array) {
3893                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
3894                 }
3895         }
3896         return NDR_ERR_SUCCESS;
3897 }
3898
3899 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportCtr0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaTransportCtr0 *r)
3900 {
3901         uint32_t cntr_array_1;
3902         ndr_print_struct(ndr, name, "wkssvc_NetWkstaTransportCtr0");
3903         ndr->depth++;
3904         ndr_print_uint32(ndr, "count", r->count);
3905         ndr_print_ptr(ndr, "array", r->array);
3906         ndr->depth++;
3907         if (r->array) {
3908                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
3909                 ndr->depth++;
3910                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
3911                         char *idx_1=NULL;
3912                         asprintf(&idx_1, "[%d]", cntr_array_1);
3913                         if (idx_1) {
3914                                 ndr_print_wkssvc_NetWkstaTransportInfo0(ndr, "array", &r->array[cntr_array_1]);
3915                                 free(idx_1);
3916                         }
3917                 }
3918                 ndr->depth--;
3919         }
3920         ndr->depth--;
3921         ndr->depth--;
3922 }
3923
3924 static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportCtr(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetWkstaTransportCtr *r)
3925 {
3926         if (ndr_flags & NDR_SCALARS) {
3927                 int level = ndr_push_get_switch_value(ndr, r);
3928                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
3929                 switch (level) {
3930                         case 0:
3931                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
3932                         break;
3933
3934                         default:
3935                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3936                 }
3937         }
3938         if (ndr_flags & NDR_BUFFERS) {
3939                 int level = ndr_push_get_switch_value(ndr, r);
3940                 switch (level) {
3941                         case 0:
3942                                 if (r->ctr0) {
3943                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
3944                                 }
3945                         break;
3946
3947                         default:
3948                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3949                 }
3950         }
3951         return NDR_ERR_SUCCESS;
3952 }
3953
3954 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportCtr(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetWkstaTransportCtr *r)
3955 {
3956         int level;
3957         uint32_t _level;
3958         TALLOC_CTX *_mem_save_ctr0_0;
3959         level = ndr_pull_get_switch_value(ndr, r);
3960         if (ndr_flags & NDR_SCALARS) {
3961                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
3962                 if (_level != level) {
3963                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
3964                 }
3965                 switch (level) {
3966                         case 0: {
3967                                 uint32_t _ptr_ctr0;
3968                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));
3969                                 if (_ptr_ctr0) {
3970                                         NDR_PULL_ALLOC(ndr, r->ctr0);
3971                                 } else {
3972                                         r->ctr0 = NULL;
3973                                 }
3974                         break; }
3975
3976                         default:
3977                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3978                 }
3979         }
3980         if (ndr_flags & NDR_BUFFERS) {
3981                 switch (level) {
3982                         case 0:
3983                                 if (r->ctr0) {
3984                                         _mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);
3985                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr0, 0);
3986                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
3987                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);
3988                                 }
3989                         break;
3990
3991                         default:
3992                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3993                 }
3994         }
3995         return NDR_ERR_SUCCESS;
3996 }
3997
3998 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportCtr(struct ndr_print *ndr, const char *name, const union wkssvc_NetWkstaTransportCtr *r)
3999 {
4000         int level;
4001         level = ndr_print_get_switch_value(ndr, r);
4002         ndr_print_union(ndr, name, level, "wkssvc_NetWkstaTransportCtr");
4003         switch (level) {
4004                 case 0:
4005                         ndr_print_ptr(ndr, "ctr0", r->ctr0);
4006                         ndr->depth++;
4007                         if (r->ctr0) {
4008                                 ndr_print_wkssvc_NetWkstaTransportCtr0(ndr, "ctr0", r->ctr0);
4009                         }
4010                         ndr->depth--;
4011                 break;
4012
4013                 default:
4014                         ndr_print_bad_level(ndr, name, level);
4015         }
4016 }
4017
4018 static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportInfo(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaTransportInfo *r)
4019 {
4020         if (ndr_flags & NDR_SCALARS) {
4021                 NDR_CHECK(ndr_push_align(ndr, 4));
4022                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
4023                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
4024                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportCtr(ndr, NDR_SCALARS, &r->ctr));
4025         }
4026         if (ndr_flags & NDR_BUFFERS) {
4027                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportCtr(ndr, NDR_BUFFERS, &r->ctr));
4028         }
4029         return NDR_ERR_SUCCESS;
4030 }
4031
4032 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportInfo(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaTransportInfo *r)
4033 {
4034         if (ndr_flags & NDR_SCALARS) {
4035                 NDR_CHECK(ndr_pull_align(ndr, 4));
4036                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
4037                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
4038                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportCtr(ndr, NDR_SCALARS, &r->ctr));
4039         }
4040         if (ndr_flags & NDR_BUFFERS) {
4041                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportCtr(ndr, NDR_BUFFERS, &r->ctr));
4042         }
4043         return NDR_ERR_SUCCESS;
4044 }
4045
4046 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportInfo(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaTransportInfo *r)
4047 {
4048         ndr_print_struct(ndr, name, "wkssvc_NetWkstaTransportInfo");
4049         ndr->depth++;
4050         ndr_print_uint32(ndr, "level", r->level);
4051         ndr_print_set_switch_value(ndr, &r->ctr, r->level);
4052         ndr_print_wkssvc_NetWkstaTransportCtr(ndr, "ctr", &r->ctr);
4053         ndr->depth--;
4054 }
4055
4056 static enum ndr_err_code ndr_push_wkssvc_NetrUseInfo3(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseInfo3 *r)
4057 {
4058         if (ndr_flags & NDR_SCALARS) {
4059                 NDR_CHECK(ndr_push_align(ndr, 4));
4060                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->unknown1));
4061                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->unknown2));
4062         }
4063         if (ndr_flags & NDR_BUFFERS) {
4064                 if (r->unknown1) {
4065                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->unknown1, CH_UTF16)));
4066                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4067                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->unknown1, CH_UTF16)));
4068                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->unknown1, ndr_charset_length(r->unknown1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4069                 }
4070                 if (r->unknown2) {
4071                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->unknown2, CH_UTF16)));
4072                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4073                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->unknown2, CH_UTF16)));
4074                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->unknown2, ndr_charset_length(r->unknown2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4075                 }
4076         }
4077         return NDR_ERR_SUCCESS;
4078 }
4079
4080 static enum ndr_err_code ndr_pull_wkssvc_NetrUseInfo3(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseInfo3 *r)
4081 {
4082         uint32_t _ptr_unknown1;
4083         TALLOC_CTX *_mem_save_unknown1_0;
4084         uint32_t _ptr_unknown2;
4085         TALLOC_CTX *_mem_save_unknown2_0;
4086         if (ndr_flags & NDR_SCALARS) {
4087                 NDR_CHECK(ndr_pull_align(ndr, 4));
4088                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown1));
4089                 if (_ptr_unknown1) {
4090                         NDR_PULL_ALLOC(ndr, r->unknown1);
4091                 } else {
4092                         r->unknown1 = NULL;
4093                 }
4094                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown2));
4095                 if (_ptr_unknown2) {
4096                         NDR_PULL_ALLOC(ndr, r->unknown2);
4097                 } else {
4098                         r->unknown2 = NULL;
4099                 }
4100         }
4101         if (ndr_flags & NDR_BUFFERS) {
4102                 if (r->unknown1) {
4103                         _mem_save_unknown1_0 = NDR_PULL_GET_MEM_CTX(ndr);
4104                         NDR_PULL_SET_MEM_CTX(ndr, r->unknown1, 0);
4105                         NDR_CHECK(ndr_pull_array_size(ndr, &r->unknown1));
4106                         NDR_CHECK(ndr_pull_array_length(ndr, &r->unknown1));
4107                         if (ndr_get_array_length(ndr, &r->unknown1) > ndr_get_array_size(ndr, &r->unknown1)) {
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->unknown1), ndr_get_array_length(ndr, &r->unknown1));
4109                         }
4110                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->unknown1), sizeof(uint16_t)));
4111                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->unknown1, ndr_get_array_length(ndr, &r->unknown1), sizeof(uint16_t), CH_UTF16));
4112                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown1_0, 0);
4113                 }
4114                 if (r->unknown2) {
4115                         _mem_save_unknown2_0 = NDR_PULL_GET_MEM_CTX(ndr);
4116                         NDR_PULL_SET_MEM_CTX(ndr, r->unknown2, 0);
4117                         NDR_CHECK(ndr_pull_array_size(ndr, &r->unknown2));
4118                         NDR_CHECK(ndr_pull_array_length(ndr, &r->unknown2));
4119                         if (ndr_get_array_length(ndr, &r->unknown2) > ndr_get_array_size(ndr, &r->unknown2)) {
4120                                 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));
4121                         }
4122                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->unknown2), sizeof(uint16_t)));
4123                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->unknown2, ndr_get_array_length(ndr, &r->unknown2), sizeof(uint16_t), CH_UTF16));
4124                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown2_0, 0);
4125                 }
4126         }
4127         return NDR_ERR_SUCCESS;
4128 }
4129
4130 _PUBLIC_ void ndr_print_wkssvc_NetrUseInfo3(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseInfo3 *r)
4131 {
4132         ndr_print_struct(ndr, name, "wkssvc_NetrUseInfo3");
4133         ndr->depth++;
4134         ndr_print_ptr(ndr, "unknown1", r->unknown1);
4135         ndr->depth++;
4136         if (r->unknown1) {
4137                 ndr_print_string(ndr, "unknown1", r->unknown1);
4138         }
4139         ndr->depth--;
4140         ndr_print_ptr(ndr, "unknown2", r->unknown2);
4141         ndr->depth++;
4142         if (r->unknown2) {
4143                 ndr_print_string(ndr, "unknown2", r->unknown2);
4144         }
4145         ndr->depth--;
4146         ndr->depth--;
4147 }
4148
4149 static enum ndr_err_code ndr_push_wkssvc_NetrUseInfo2(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseInfo2 *r)
4150 {
4151         if (ndr_flags & NDR_SCALARS) {
4152                 NDR_CHECK(ndr_push_align(ndr, 4));
4153                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->local));
4154                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote));
4155                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->password));
4156                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
4157                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->asg_type));
4158                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_count));
4159                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_count));
4160                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
4161                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
4162         }
4163         if (ndr_flags & NDR_BUFFERS) {
4164                 if (r->local) {
4165                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->local, CH_UTF16)));
4166                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4167                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->local, CH_UTF16)));
4168                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->local, ndr_charset_length(r->local, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4169                 }
4170                 if (r->remote) {
4171                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote, CH_UTF16)));
4172                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4173                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote, CH_UTF16)));
4174                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->remote, ndr_charset_length(r->remote, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4175                 }
4176                 if (r->password) {
4177                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));
4178                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4179                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));
4180                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->password, ndr_charset_length(r->password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4181                 }
4182                 if (r->user_name) {
4183                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4184                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4185                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4186                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4187                 }
4188                 if (r->domain_name) {
4189                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
4190                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4191                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
4192                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4193                 }
4194         }
4195         return NDR_ERR_SUCCESS;
4196 }
4197
4198 static enum ndr_err_code ndr_pull_wkssvc_NetrUseInfo2(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseInfo2 *r)
4199 {
4200         uint32_t _ptr_local;
4201         TALLOC_CTX *_mem_save_local_0;
4202         uint32_t _ptr_remote;
4203         TALLOC_CTX *_mem_save_remote_0;
4204         uint32_t _ptr_password;
4205         TALLOC_CTX *_mem_save_password_0;
4206         uint32_t _ptr_user_name;
4207         TALLOC_CTX *_mem_save_user_name_0;
4208         uint32_t _ptr_domain_name;
4209         TALLOC_CTX *_mem_save_domain_name_0;
4210         if (ndr_flags & NDR_SCALARS) {
4211                 NDR_CHECK(ndr_pull_align(ndr, 4));
4212                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local));
4213                 if (_ptr_local) {
4214                         NDR_PULL_ALLOC(ndr, r->local);
4215                 } else {
4216                         r->local = NULL;
4217                 }
4218                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote));
4219                 if (_ptr_remote) {
4220                         NDR_PULL_ALLOC(ndr, r->remote);
4221                 } else {
4222                         r->remote = NULL;
4223                 }
4224                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
4225                 if (_ptr_password) {
4226                         NDR_PULL_ALLOC(ndr, r->password);
4227                 } else {
4228                         r->password = NULL;
4229                 }
4230                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
4231                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->asg_type));
4232                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_count));
4233                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_count));
4234                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4235                 if (_ptr_user_name) {
4236                         NDR_PULL_ALLOC(ndr, r->user_name);
4237                 } else {
4238                         r->user_name = NULL;
4239                 }
4240                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
4241                 if (_ptr_domain_name) {
4242                         NDR_PULL_ALLOC(ndr, r->domain_name);
4243                 } else {
4244                         r->domain_name = NULL;
4245                 }
4246         }
4247         if (ndr_flags & NDR_BUFFERS) {
4248                 if (r->local) {
4249                         _mem_save_local_0 = NDR_PULL_GET_MEM_CTX(ndr);
4250                         NDR_PULL_SET_MEM_CTX(ndr, r->local, 0);
4251                         NDR_CHECK(ndr_pull_array_size(ndr, &r->local));
4252                         NDR_CHECK(ndr_pull_array_length(ndr, &r->local));
4253                         if (ndr_get_array_length(ndr, &r->local) > ndr_get_array_size(ndr, &r->local)) {
4254                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->local), ndr_get_array_length(ndr, &r->local));
4255                         }
4256                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->local), sizeof(uint16_t)));
4257                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->local, ndr_get_array_length(ndr, &r->local), sizeof(uint16_t), CH_UTF16));
4258                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_0, 0);
4259                 }
4260                 if (r->remote) {
4261                         _mem_save_remote_0 = NDR_PULL_GET_MEM_CTX(ndr);
4262                         NDR_PULL_SET_MEM_CTX(ndr, r->remote, 0);
4263                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote));
4264                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote));
4265                         if (ndr_get_array_length(ndr, &r->remote) > ndr_get_array_size(ndr, &r->remote)) {
4266                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->remote), ndr_get_array_length(ndr, &r->remote));
4267                         }
4268                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t)));
4269                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->remote, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t), CH_UTF16));
4270                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_0, 0);
4271                 }
4272                 if (r->password) {
4273                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
4274                         NDR_PULL_SET_MEM_CTX(ndr, r->password, 0);
4275                         NDR_CHECK(ndr_pull_array_size(ndr, &r->password));
4276                         NDR_CHECK(ndr_pull_array_length(ndr, &r->password));
4277                         if (ndr_get_array_length(ndr, &r->password) > ndr_get_array_size(ndr, &r->password)) {
4278                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->password), ndr_get_array_length(ndr, &r->password));
4279                         }
4280                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t)));
4281                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->password, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t), CH_UTF16));
4282                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
4283                 }
4284                 if (r->user_name) {
4285                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4286                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4287                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
4288                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
4289                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
4290                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
4291                         }
4292                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
4293                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
4294                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4295                 }
4296                 if (r->domain_name) {
4297                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4298                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
4299                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
4300                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
4301                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
4302                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->domain_name), ndr_get_array_length(ndr, &r->domain_name));
4303                         }
4304                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
4305                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
4306                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
4307                 }
4308         }
4309         return NDR_ERR_SUCCESS;
4310 }
4311
4312 _PUBLIC_ void ndr_print_wkssvc_NetrUseInfo2(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseInfo2 *r)
4313 {
4314         ndr_print_struct(ndr, name, "wkssvc_NetrUseInfo2");
4315         ndr->depth++;
4316         ndr_print_ptr(ndr, "local", r->local);
4317         ndr->depth++;
4318         if (r->local) {
4319                 ndr_print_string(ndr, "local", r->local);
4320         }
4321         ndr->depth--;
4322         ndr_print_ptr(ndr, "remote", r->remote);
4323         ndr->depth++;
4324         if (r->remote) {
4325                 ndr_print_string(ndr, "remote", r->remote);
4326         }
4327         ndr->depth--;
4328         ndr_print_ptr(ndr, "password", r->password);
4329         ndr->depth++;
4330         if (r->password) {
4331                 ndr_print_string(ndr, "password", r->password);
4332         }
4333         ndr->depth--;
4334         ndr_print_uint32(ndr, "status", r->status);
4335         ndr_print_uint32(ndr, "asg_type", r->asg_type);
4336         ndr_print_uint32(ndr, "ref_count", r->ref_count);
4337         ndr_print_uint32(ndr, "use_count", r->use_count);
4338         ndr_print_ptr(ndr, "user_name", r->user_name);
4339         ndr->depth++;
4340         if (r->user_name) {
4341                 ndr_print_string(ndr, "user_name", r->user_name);
4342         }
4343         ndr->depth--;
4344         ndr_print_ptr(ndr, "domain_name", r->domain_name);
4345         ndr->depth++;
4346         if (r->domain_name) {
4347                 ndr_print_string(ndr, "domain_name", r->domain_name);
4348         }
4349         ndr->depth--;
4350         ndr->depth--;
4351 }
4352
4353 static enum ndr_err_code ndr_push_wkssvc_NetrUseInfo1(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseInfo1 *r)
4354 {
4355         if (ndr_flags & NDR_SCALARS) {
4356                 NDR_CHECK(ndr_push_align(ndr, 4));
4357                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->local));
4358                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote));
4359                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->password));
4360                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
4361                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->asg_type));
4362                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_count));
4363                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_count));
4364         }
4365         if (ndr_flags & NDR_BUFFERS) {
4366                 if (r->local) {
4367                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->local, CH_UTF16)));
4368                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4369                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->local, CH_UTF16)));
4370                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->local, ndr_charset_length(r->local, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4371                 }
4372                 if (r->remote) {
4373                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote, CH_UTF16)));
4374                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4375                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote, CH_UTF16)));
4376                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->remote, ndr_charset_length(r->remote, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4377                 }
4378                 if (r->password) {
4379                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));
4380                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4381                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));
4382                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->password, ndr_charset_length(r->password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4383                 }
4384         }
4385         return NDR_ERR_SUCCESS;
4386 }
4387
4388 static enum ndr_err_code ndr_pull_wkssvc_NetrUseInfo1(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseInfo1 *r)
4389 {
4390         uint32_t _ptr_local;
4391         TALLOC_CTX *_mem_save_local_0;
4392         uint32_t _ptr_remote;
4393         TALLOC_CTX *_mem_save_remote_0;
4394         uint32_t _ptr_password;
4395         TALLOC_CTX *_mem_save_password_0;
4396         if (ndr_flags & NDR_SCALARS) {
4397                 NDR_CHECK(ndr_pull_align(ndr, 4));
4398                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local));
4399                 if (_ptr_local) {
4400                         NDR_PULL_ALLOC(ndr, r->local);
4401                 } else {
4402                         r->local = NULL;
4403                 }
4404                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote));
4405                 if (_ptr_remote) {
4406                         NDR_PULL_ALLOC(ndr, r->remote);
4407                 } else {
4408                         r->remote = NULL;
4409                 }
4410                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
4411                 if (_ptr_password) {
4412                         NDR_PULL_ALLOC(ndr, r->password);
4413                 } else {
4414                         r->password = NULL;
4415                 }
4416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
4417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->asg_type));
4418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_count));
4419                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_count));
4420         }
4421         if (ndr_flags & NDR_BUFFERS) {
4422                 if (r->local) {
4423                         _mem_save_local_0 = NDR_PULL_GET_MEM_CTX(ndr);
4424                         NDR_PULL_SET_MEM_CTX(ndr, r->local, 0);
4425                         NDR_CHECK(ndr_pull_array_size(ndr, &r->local));
4426                         NDR_CHECK(ndr_pull_array_length(ndr, &r->local));
4427                         if (ndr_get_array_length(ndr, &r->local) > ndr_get_array_size(ndr, &r->local)) {
4428                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->local), ndr_get_array_length(ndr, &r->local));
4429                         }
4430                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->local), sizeof(uint16_t)));
4431                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->local, ndr_get_array_length(ndr, &r->local), sizeof(uint16_t), CH_UTF16));
4432                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_0, 0);
4433                 }
4434                 if (r->remote) {
4435                         _mem_save_remote_0 = NDR_PULL_GET_MEM_CTX(ndr);
4436                         NDR_PULL_SET_MEM_CTX(ndr, r->remote, 0);
4437                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote));
4438                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote));
4439                         if (ndr_get_array_length(ndr, &r->remote) > ndr_get_array_size(ndr, &r->remote)) {
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->remote), ndr_get_array_length(ndr, &r->remote));
4441                         }
4442                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t)));
4443                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->remote, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t), CH_UTF16));
4444                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_0, 0);
4445                 }
4446                 if (r->password) {
4447                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
4448                         NDR_PULL_SET_MEM_CTX(ndr, r->password, 0);
4449                         NDR_CHECK(ndr_pull_array_size(ndr, &r->password));
4450                         NDR_CHECK(ndr_pull_array_length(ndr, &r->password));
4451                         if (ndr_get_array_length(ndr, &r->password) > ndr_get_array_size(ndr, &r->password)) {
4452                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->password), ndr_get_array_length(ndr, &r->password));
4453                         }
4454                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t)));
4455                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->password, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t), CH_UTF16));
4456                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
4457                 }
4458         }
4459         return NDR_ERR_SUCCESS;
4460 }
4461
4462 _PUBLIC_ void ndr_print_wkssvc_NetrUseInfo1(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseInfo1 *r)
4463 {
4464         ndr_print_struct(ndr, name, "wkssvc_NetrUseInfo1");
4465         ndr->depth++;
4466         ndr_print_ptr(ndr, "local", r->local);
4467         ndr->depth++;
4468         if (r->local) {
4469                 ndr_print_string(ndr, "local", r->local);
4470         }
4471         ndr->depth--;
4472         ndr_print_ptr(ndr, "remote", r->remote);
4473         ndr->depth++;
4474         if (r->remote) {
4475                 ndr_print_string(ndr, "remote", r->remote);
4476         }
4477         ndr->depth--;
4478         ndr_print_ptr(ndr, "password", r->password);
4479         ndr->depth++;
4480         if (r->password) {
4481                 ndr_print_string(ndr, "password", r->password);
4482         }
4483         ndr->depth--;
4484         ndr_print_uint32(ndr, "status", r->status);
4485         ndr_print_uint32(ndr, "asg_type", r->asg_type);
4486         ndr_print_uint32(ndr, "ref_count", r->ref_count);
4487         ndr_print_uint32(ndr, "use_count", r->use_count);
4488         ndr->depth--;
4489 }
4490
4491 static enum ndr_err_code ndr_push_wkssvc_NetrUseInfo0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseInfo0 *r)
4492 {
4493         if (ndr_flags & NDR_SCALARS) {
4494                 NDR_CHECK(ndr_push_align(ndr, 4));
4495                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->local));
4496                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote));
4497         }
4498         if (ndr_flags & NDR_BUFFERS) {
4499                 if (r->local) {
4500                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->local, CH_UTF16)));
4501                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4502                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->local, CH_UTF16)));
4503                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->local, ndr_charset_length(r->local, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4504                 }
4505                 if (r->remote) {
4506                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote, CH_UTF16)));
4507                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4508                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote, CH_UTF16)));
4509                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->remote, ndr_charset_length(r->remote, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4510                 }
4511         }
4512         return NDR_ERR_SUCCESS;
4513 }
4514
4515 static enum ndr_err_code ndr_pull_wkssvc_NetrUseInfo0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseInfo0 *r)
4516 {
4517         uint32_t _ptr_local;
4518         TALLOC_CTX *_mem_save_local_0;
4519         uint32_t _ptr_remote;
4520         TALLOC_CTX *_mem_save_remote_0;
4521         if (ndr_flags & NDR_SCALARS) {
4522                 NDR_CHECK(ndr_pull_align(ndr, 4));
4523                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local));
4524                 if (_ptr_local) {
4525                         NDR_PULL_ALLOC(ndr, r->local);
4526                 } else {
4527                         r->local = NULL;
4528                 }
4529                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote));
4530                 if (_ptr_remote) {
4531                         NDR_PULL_ALLOC(ndr, r->remote);
4532                 } else {
4533                         r->remote = NULL;
4534                 }
4535         }
4536         if (ndr_flags & NDR_BUFFERS) {
4537                 if (r->local) {
4538                         _mem_save_local_0 = NDR_PULL_GET_MEM_CTX(ndr);
4539                         NDR_PULL_SET_MEM_CTX(ndr, r->local, 0);
4540                         NDR_CHECK(ndr_pull_array_size(ndr, &r->local));
4541                         NDR_CHECK(ndr_pull_array_length(ndr, &r->local));
4542                         if (ndr_get_array_length(ndr, &r->local) > ndr_get_array_size(ndr, &r->local)) {
4543                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->local), ndr_get_array_length(ndr, &r->local));
4544                         }
4545                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->local), sizeof(uint16_t)));
4546                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->local, ndr_get_array_length(ndr, &r->local), sizeof(uint16_t), CH_UTF16));
4547                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_0, 0);
4548                 }
4549                 if (r->remote) {
4550                         _mem_save_remote_0 = NDR_PULL_GET_MEM_CTX(ndr);
4551                         NDR_PULL_SET_MEM_CTX(ndr, r->remote, 0);
4552                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote));
4553                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote));
4554                         if (ndr_get_array_length(ndr, &r->remote) > ndr_get_array_size(ndr, &r->remote)) {
4555                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->remote), ndr_get_array_length(ndr, &r->remote));
4556                         }
4557                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t)));
4558                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->remote, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t), CH_UTF16));
4559                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_0, 0);
4560                 }
4561         }
4562         return NDR_ERR_SUCCESS;
4563 }
4564
4565 _PUBLIC_ void ndr_print_wkssvc_NetrUseInfo0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseInfo0 *r)
4566 {
4567         ndr_print_struct(ndr, name, "wkssvc_NetrUseInfo0");
4568         ndr->depth++;
4569         ndr_print_ptr(ndr, "local", r->local);
4570         ndr->depth++;
4571         if (r->local) {
4572                 ndr_print_string(ndr, "local", r->local);
4573         }
4574         ndr->depth--;
4575         ndr_print_ptr(ndr, "remote", r->remote);
4576         ndr->depth++;
4577         if (r->remote) {
4578                 ndr_print_string(ndr, "remote", r->remote);
4579         }
4580         ndr->depth--;
4581         ndr->depth--;
4582 }
4583
4584 static enum ndr_err_code ndr_push_wkssvc_NetrUseGetInfoCtr(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetrUseGetInfoCtr *r)
4585 {
4586         if (ndr_flags & NDR_SCALARS) {
4587                 int level = ndr_push_get_switch_value(ndr, r);
4588                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
4589                 switch (level) {
4590                         case 0:
4591                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
4592                         break;
4593
4594                         case 1:
4595                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
4596                         break;
4597
4598                         case 2:
4599                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
4600                         break;
4601
4602                         case 3:
4603                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
4604                         break;
4605
4606                         default:
4607                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4608                 }
4609         }
4610         if (ndr_flags & NDR_BUFFERS) {
4611                 int level = ndr_push_get_switch_value(ndr, r);
4612                 switch (level) {
4613                         case 0:
4614                                 if (r->info0) {
4615                                         NDR_CHECK(ndr_push_wkssvc_NetrUseInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
4616                                 }
4617                         break;
4618
4619                         case 1:
4620                                 if (r->info1) {
4621                                         NDR_CHECK(ndr_push_wkssvc_NetrUseInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
4622                                 }
4623                         break;
4624
4625                         case 2:
4626                                 if (r->info2) {
4627                                         NDR_CHECK(ndr_push_wkssvc_NetrUseInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
4628                                 }
4629                         break;
4630
4631                         case 3:
4632                                 if (r->info3) {
4633                                         NDR_CHECK(ndr_push_wkssvc_NetrUseInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
4634                                 }
4635                         break;
4636
4637                         default:
4638                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4639                 }
4640         }
4641         return NDR_ERR_SUCCESS;
4642 }
4643
4644 static enum ndr_err_code ndr_pull_wkssvc_NetrUseGetInfoCtr(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetrUseGetInfoCtr *r)
4645 {
4646         int level;
4647         uint32_t _level;
4648         TALLOC_CTX *_mem_save_info0_0;
4649         TALLOC_CTX *_mem_save_info1_0;
4650         TALLOC_CTX *_mem_save_info2_0;
4651         TALLOC_CTX *_mem_save_info3_0;
4652         level = ndr_pull_get_switch_value(ndr, r);
4653         if (ndr_flags & NDR_SCALARS) {
4654                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
4655                 if (_level != level) {
4656                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
4657                 }
4658                 switch (level) {
4659                         case 0: {
4660                                 uint32_t _ptr_info0;
4661                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
4662                                 if (_ptr_info0) {
4663                                         NDR_PULL_ALLOC(ndr, r->info0);
4664                                 } else {
4665                                         r->info0 = NULL;
4666                                 }
4667                         break; }
4668
4669                         case 1: {
4670                                 uint32_t _ptr_info1;
4671                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
4672                                 if (_ptr_info1) {
4673                                         NDR_PULL_ALLOC(ndr, r->info1);
4674                                 } else {
4675                                         r->info1 = NULL;
4676                                 }
4677                         break; }
4678
4679                         case 2: {
4680                                 uint32_t _ptr_info2;
4681                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
4682                                 if (_ptr_info2) {
4683                                         NDR_PULL_ALLOC(ndr, r->info2);
4684                                 } else {
4685                                         r->info2 = NULL;
4686                                 }
4687                         break; }
4688
4689                         case 3: {
4690                                 uint32_t _ptr_info3;
4691                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
4692                                 if (_ptr_info3) {
4693                                         NDR_PULL_ALLOC(ndr, r->info3);
4694                                 } else {
4695                                         r->info3 = NULL;
4696                                 }
4697                         break; }
4698
4699                         default:
4700                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4701                 }
4702         }
4703         if (ndr_flags & NDR_BUFFERS) {
4704                 switch (level) {
4705                         case 0:
4706                                 if (r->info0) {
4707                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
4708                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
4709                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
4710                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
4711                                 }
4712                         break;
4713
4714                         case 1:
4715                                 if (r->info1) {
4716                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
4717                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
4718                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
4719                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
4720                                 }
4721                         break;
4722
4723                         case 2:
4724                                 if (r->info2) {
4725                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
4726                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
4727                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
4728                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
4729                                 }
4730                         break;
4731
4732                         case 3:
4733                                 if (r->info3) {
4734                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
4735                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
4736                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
4737                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
4738                                 }
4739                         break;
4740
4741                         default:
4742                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4743                 }
4744         }
4745         return NDR_ERR_SUCCESS;
4746 }
4747
4748 _PUBLIC_ void ndr_print_wkssvc_NetrUseGetInfoCtr(struct ndr_print *ndr, const char *name, const union wkssvc_NetrUseGetInfoCtr *r)
4749 {
4750         int level;
4751         level = ndr_print_get_switch_value(ndr, r);
4752         ndr_print_union(ndr, name, level, "wkssvc_NetrUseGetInfoCtr");
4753         switch (level) {
4754                 case 0:
4755                         ndr_print_ptr(ndr, "info0", r->info0);
4756                         ndr->depth++;
4757                         if (r->info0) {
4758                                 ndr_print_wkssvc_NetrUseInfo0(ndr, "info0", r->info0);
4759                         }
4760                         ndr->depth--;
4761                 break;
4762
4763                 case 1:
4764                         ndr_print_ptr(ndr, "info1", r->info1);
4765                         ndr->depth++;
4766                         if (r->info1) {
4767                                 ndr_print_wkssvc_NetrUseInfo1(ndr, "info1", r->info1);
4768                         }
4769                         ndr->depth--;
4770                 break;
4771
4772                 case 2:
4773                         ndr_print_ptr(ndr, "info2", r->info2);
4774                         ndr->depth++;
4775                         if (r->info2) {
4776                                 ndr_print_wkssvc_NetrUseInfo2(ndr, "info2", r->info2);
4777                         }
4778                         ndr->depth--;
4779                 break;
4780
4781                 case 3:
4782                         ndr_print_ptr(ndr, "info3", r->info3);
4783                         ndr->depth++;
4784                         if (r->info3) {
4785                                 ndr_print_wkssvc_NetrUseInfo3(ndr, "info3", r->info3);
4786                         }
4787                         ndr->depth--;
4788                 break;
4789
4790                 default:
4791                         ndr_print_bad_level(ndr, name, level);
4792         }
4793 }
4794
4795 static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumCtr2(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseEnumCtr2 *r)
4796 {
4797         uint32_t cntr_array_1;
4798         if (ndr_flags & NDR_SCALARS) {
4799                 NDR_CHECK(ndr_push_align(ndr, 4));
4800                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4801                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
4802         }
4803         if (ndr_flags & NDR_BUFFERS) {
4804                 if (r->array) {
4805                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4806                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4807                                 NDR_CHECK(ndr_push_wkssvc_NetrUseInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4808                         }
4809                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4810                                 NDR_CHECK(ndr_push_wkssvc_NetrUseInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4811                         }
4812                 }
4813         }
4814         return NDR_ERR_SUCCESS;
4815 }
4816
4817 static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumCtr2(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseEnumCtr2 *r)
4818 {
4819         uint32_t _ptr_array;
4820         uint32_t cntr_array_1;
4821         TALLOC_CTX *_mem_save_array_0;
4822         TALLOC_CTX *_mem_save_array_1;
4823         if (ndr_flags & NDR_SCALARS) {
4824                 NDR_CHECK(ndr_pull_align(ndr, 4));
4825                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4826                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
4827                 if (_ptr_array) {
4828                         NDR_PULL_ALLOC(ndr, r->array);
4829                 } else {
4830                         r->array = NULL;
4831                 }
4832         }
4833         if (ndr_flags & NDR_BUFFERS) {
4834                 if (r->array) {
4835                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4836                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4837                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
4838                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
4839                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4840                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4841                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4842                                 NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4843                         }
4844                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4845                                 NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4846                         }
4847                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
4848                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
4849                 }
4850                 if (r->array) {
4851                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
4852                 }
4853         }
4854         return NDR_ERR_SUCCESS;
4855 }
4856
4857 _PUBLIC_ void ndr_print_wkssvc_NetrUseEnumCtr2(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseEnumCtr2 *r)
4858 {
4859         uint32_t cntr_array_1;
4860         ndr_print_struct(ndr, name, "wkssvc_NetrUseEnumCtr2");
4861         ndr->depth++;
4862         ndr_print_uint32(ndr, "count", r->count);
4863         ndr_print_ptr(ndr, "array", r->array);
4864         ndr->depth++;
4865         if (r->array) {
4866                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
4867                 ndr->depth++;
4868                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
4869                         char *idx_1=NULL;
4870                         asprintf(&idx_1, "[%d]", cntr_array_1);
4871                         if (idx_1) {
4872                                 ndr_print_wkssvc_NetrUseInfo2(ndr, "array", &r->array[cntr_array_1]);
4873                                 free(idx_1);
4874                         }
4875                 }
4876                 ndr->depth--;
4877         }
4878         ndr->depth--;
4879         ndr->depth--;
4880 }
4881
4882 static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumCtr1(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseEnumCtr1 *r)
4883 {
4884         uint32_t cntr_array_1;
4885         if (ndr_flags & NDR_SCALARS) {
4886                 NDR_CHECK(ndr_push_align(ndr, 4));
4887                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4888                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
4889         }
4890         if (ndr_flags & NDR_BUFFERS) {
4891                 if (r->array) {
4892                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4893                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4894                                 NDR_CHECK(ndr_push_wkssvc_NetrUseInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4895                         }
4896                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4897                                 NDR_CHECK(ndr_push_wkssvc_NetrUseInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4898                         }
4899                 }
4900         }
4901         return NDR_ERR_SUCCESS;
4902 }
4903
4904 static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumCtr1(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseEnumCtr1 *r)
4905 {
4906         uint32_t _ptr_array;
4907         uint32_t cntr_array_1;
4908         TALLOC_CTX *_mem_save_array_0;
4909         TALLOC_CTX *_mem_save_array_1;
4910         if (ndr_flags & NDR_SCALARS) {
4911                 NDR_CHECK(ndr_pull_align(ndr, 4));
4912                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4913                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
4914                 if (_ptr_array) {
4915                         NDR_PULL_ALLOC(ndr, r->array);
4916                 } else {
4917                         r->array = NULL;
4918                 }
4919         }
4920         if (ndr_flags & NDR_BUFFERS) {
4921                 if (r->array) {
4922                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4923                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4924                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
4925                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
4926                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4927                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4928                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4929                                 NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4930                         }
4931                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4932                                 NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4933                         }
4934                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
4935                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
4936                 }
4937                 if (r->array) {
4938                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
4939                 }
4940         }
4941         return NDR_ERR_SUCCESS;
4942 }
4943
4944 _PUBLIC_ void ndr_print_wkssvc_NetrUseEnumCtr1(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseEnumCtr1 *r)
4945 {
4946         uint32_t cntr_array_1;
4947         ndr_print_struct(ndr, name, "wkssvc_NetrUseEnumCtr1");
4948         ndr->depth++;
4949         ndr_print_uint32(ndr, "count", r->count);
4950         ndr_print_ptr(ndr, "array", r->array);
4951         ndr->depth++;
4952         if (r->array) {
4953                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
4954                 ndr->depth++;
4955                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
4956                         char *idx_1=NULL;
4957                         asprintf(&idx_1, "[%d]", cntr_array_1);
4958                         if (idx_1) {
4959                                 ndr_print_wkssvc_NetrUseInfo1(ndr, "array", &r->array[cntr_array_1]);
4960                                 free(idx_1);
4961                         }
4962                 }
4963                 ndr->depth--;
4964         }
4965         ndr->depth--;
4966         ndr->depth--;
4967 }
4968
4969 static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumCtr0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseEnumCtr0 *r)
4970 {
4971         uint32_t cntr_array_1;
4972         if (ndr_flags & NDR_SCALARS) {
4973                 NDR_CHECK(ndr_push_align(ndr, 4));
4974                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4975                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
4976         }
4977         if (ndr_flags & NDR_BUFFERS) {
4978                 if (r->array) {
4979                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4980                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4981                                 NDR_CHECK(ndr_push_wkssvc_NetrUseInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4982                         }
4983                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4984                                 NDR_CHECK(ndr_push_wkssvc_NetrUseInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4985                         }
4986                 }
4987         }
4988         return NDR_ERR_SUCCESS;
4989 }
4990
4991 static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumCtr0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseEnumCtr0 *r)
4992 {
4993         uint32_t _ptr_array;
4994         uint32_t cntr_array_1;
4995         TALLOC_CTX *_mem_save_array_0;
4996         TALLOC_CTX *_mem_save_array_1;
4997         if (ndr_flags & NDR_SCALARS) {
4998                 NDR_CHECK(ndr_pull_align(ndr, 4));
4999                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5000                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
5001                 if (_ptr_array) {
5002                         NDR_PULL_ALLOC(ndr, r->array);
5003                 } else {
5004                         r->array = NULL;
5005                 }
5006         }
5007         if (ndr_flags & NDR_BUFFERS) {
5008                 if (r->array) {
5009                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5010                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5011                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
5012                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
5013                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5014                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5015                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5016                                 NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5017                         }
5018                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5019                                 NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5020                         }
5021                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
5022                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
5023                 }
5024                 if (r->array) {
5025                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
5026                 }
5027         }
5028         return NDR_ERR_SUCCESS;
5029 }
5030
5031 _PUBLIC_ void ndr_print_wkssvc_NetrUseEnumCtr0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseEnumCtr0 *r)
5032 {
5033         uint32_t cntr_array_1;
5034         ndr_print_struct(ndr, name, "wkssvc_NetrUseEnumCtr0");
5035         ndr->depth++;
5036         ndr_print_uint32(ndr, "count", r->count);
5037         ndr_print_ptr(ndr, "array", r->array);
5038         ndr->depth++;
5039         if (r->array) {
5040                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
5041                 ndr->depth++;
5042                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
5043                         char *idx_1=NULL;
5044                         asprintf(&idx_1, "[%d]", cntr_array_1);
5045                         if (idx_1) {
5046                                 ndr_print_wkssvc_NetrUseInfo0(ndr, "array", &r->array[cntr_array_1]);
5047                                 free(idx_1);
5048                         }
5049                 }
5050                 ndr->depth--;
5051         }
5052         ndr->depth--;
5053         ndr->depth--;
5054 }
5055
5056 static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumCtr(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetrUseEnumCtr *r)
5057 {
5058         if (ndr_flags & NDR_SCALARS) {
5059                 int level = ndr_push_get_switch_value(ndr, r);
5060                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5061                 switch (level) {
5062                         case 0:
5063                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
5064                         break;
5065
5066                         case 1:
5067                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
5068                         break;
5069
5070                         case 2:
5071                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr2));
5072                         break;
5073
5074                         default:
5075                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5076                 }
5077         }
5078         if (ndr_flags & NDR_BUFFERS) {
5079                 int level = ndr_push_get_switch_value(ndr, r);
5080                 switch (level) {
5081                         case 0:
5082                                 if (r->ctr0) {
5083                                         NDR_CHECK(ndr_push_wkssvc_NetrUseEnumCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
5084                                 }
5085                         break;
5086
5087                         case 1:
5088                                 if (r->ctr1) {
5089                                         NDR_CHECK(ndr_push_wkssvc_NetrUseEnumCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
5090                                 }
5091                         break;
5092
5093                         case 2:
5094                                 if (r->ctr2) {
5095                                         NDR_CHECK(ndr_push_wkssvc_NetrUseEnumCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
5096                                 }
5097                         break;
5098
5099                         default:
5100                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5101                 }
5102         }
5103         return NDR_ERR_SUCCESS;
5104 }
5105
5106 static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumCtr(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetrUseEnumCtr *r)
5107 {
5108         int level;
5109         uint32_t _level;
5110         TALLOC_CTX *_mem_save_ctr0_0;
5111         TALLOC_CTX *_mem_save_ctr1_0;
5112         TALLOC_CTX *_mem_save_ctr2_0;
5113         level = ndr_pull_get_switch_value(ndr, r);
5114         if (ndr_flags & NDR_SCALARS) {
5115                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5116                 if (_level != level) {
5117                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5118                 }
5119                 switch (level) {
5120                         case 0: {
5121                                 uint32_t _ptr_ctr0;
5122                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));
5123                                 if (_ptr_ctr0) {
5124                                         NDR_PULL_ALLOC(ndr, r->ctr0);
5125                                 } else {
5126                                         r->ctr0 = NULL;
5127                                 }
5128                         break; }
5129
5130                         case 1: {
5131                                 uint32_t _ptr_ctr1;
5132                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
5133                                 if (_ptr_ctr1) {
5134                                         NDR_PULL_ALLOC(ndr, r->ctr1);
5135                                 } else {
5136                                         r->ctr1 = NULL;
5137                                 }
5138                         break; }
5139
5140                         case 2: {
5141                                 uint32_t _ptr_ctr2;
5142                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr2));
5143                                 if (_ptr_ctr2) {
5144                                         NDR_PULL_ALLOC(ndr, r->ctr2);
5145                                 } else {
5146                                         r->ctr2 = NULL;
5147                                 }
5148                         break; }
5149
5150                         default:
5151                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5152                 }
5153         }
5154         if (ndr_flags & NDR_BUFFERS) {
5155                 switch (level) {
5156                         case 0:
5157                                 if (r->ctr0) {
5158                                         _mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);
5159                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr0, 0);
5160                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
5161                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);
5162                                 }
5163                         break;
5164
5165                         case 1:
5166                                 if (r->ctr1) {
5167                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5168                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
5169                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
5170                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
5171                                 }
5172                         break;
5173
5174                         case 2:
5175                                 if (r->ctr2) {
5176                                         _mem_save_ctr2_0 = NDR_PULL_GET_MEM_CTX(ndr);
5177                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr2, 0);
5178                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
5179                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr2_0, 0);
5180                                 }
5181                         break;
5182
5183                         default:
5184                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5185                 }
5186         }
5187         return NDR_ERR_SUCCESS;
5188 }
5189
5190 _PUBLIC_ void ndr_print_wkssvc_NetrUseEnumCtr(struct ndr_print *ndr, const char *name, const union wkssvc_NetrUseEnumCtr *r)
5191 {
5192         int level;
5193         level = ndr_print_get_switch_value(ndr, r);
5194         ndr_print_union(ndr, name, level, "wkssvc_NetrUseEnumCtr");
5195         switch (level) {
5196                 case 0:
5197                         ndr_print_ptr(ndr, "ctr0", r->ctr0);
5198                         ndr->depth++;
5199                         if (r->ctr0) {
5200                                 ndr_print_wkssvc_NetrUseEnumCtr0(ndr, "ctr0", r->ctr0);
5201                         }
5202                         ndr->depth--;
5203                 break;
5204
5205                 case 1:
5206                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
5207                         ndr->depth++;
5208                         if (r->ctr1) {
5209                                 ndr_print_wkssvc_NetrUseEnumCtr1(ndr, "ctr1", r->ctr1);
5210                         }
5211                         ndr->depth--;
5212                 break;
5213
5214                 case 2:
5215                         ndr_print_ptr(ndr, "ctr2", r->ctr2);
5216                         ndr->depth++;
5217                         if (r->ctr2) {
5218                                 ndr_print_wkssvc_NetrUseEnumCtr2(ndr, "ctr2", r->ctr2);
5219                         }
5220                         ndr->depth--;
5221                 break;
5222
5223                 default:
5224                         ndr_print_bad_level(ndr, name, level);
5225         }
5226 }
5227
5228 static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumInfo(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseEnumInfo *r)
5229 {
5230         if (ndr_flags & NDR_SCALARS) {
5231                 NDR_CHECK(ndr_push_align(ndr, 4));
5232                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
5233                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
5234                 NDR_CHECK(ndr_push_wkssvc_NetrUseEnumCtr(ndr, NDR_SCALARS, &r->ctr));
5235         }
5236         if (ndr_flags & NDR_BUFFERS) {
5237                 NDR_CHECK(ndr_push_wkssvc_NetrUseEnumCtr(ndr, NDR_BUFFERS, &r->ctr));
5238         }
5239         return NDR_ERR_SUCCESS;
5240 }
5241
5242 static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumInfo(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseEnumInfo *r)
5243 {
5244         if (ndr_flags & NDR_SCALARS) {
5245                 NDR_CHECK(ndr_pull_align(ndr, 4));
5246                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
5247                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
5248                 NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumCtr(ndr, NDR_SCALARS, &r->ctr));
5249         }
5250         if (ndr_flags & NDR_BUFFERS) {
5251                 NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumCtr(ndr, NDR_BUFFERS, &r->ctr));
5252         }
5253         return NDR_ERR_SUCCESS;
5254 }
5255
5256 _PUBLIC_ void ndr_print_wkssvc_NetrUseEnumInfo(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseEnumInfo *r)
5257 {
5258         ndr_print_struct(ndr, name, "wkssvc_NetrUseEnumInfo");
5259         ndr->depth++;
5260         ndr_print_uint32(ndr, "level", r->level);
5261         ndr_print_set_switch_value(ndr, &r->ctr, r->level);
5262         ndr_print_wkssvc_NetrUseEnumCtr(ndr, "ctr", &r->ctr);
5263         ndr->depth--;
5264 }
5265
5266 static enum ndr_err_code ndr_push_wkssvc_NetrWorkstationStatistics(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrWorkstationStatistics *r)
5267 {
5268         if (ndr_flags & NDR_SCALARS) {
5269                 NDR_CHECK(ndr_push_align(ndr, 8));
5270                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown1));
5271                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown2));
5272                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown3));
5273                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown4));
5274                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown5));
5275                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown6));
5276                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown7));
5277                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown8));
5278                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown9));
5279                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown10));
5280                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown11));
5281                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown12));
5282                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown13));
5283                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown14));
5284                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown15));
5285                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown16));
5286                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown17));
5287                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown18));
5288                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown19));
5289                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown20));
5290                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown21));
5291                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown22));
5292                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown23));
5293                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown24));
5294                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown25));
5295                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown26));
5296                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown27));
5297                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown28));
5298                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown29));
5299                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown30));
5300                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown31));
5301                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown32));
5302                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown33));
5303                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown34));
5304                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown35));
5305                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown36));
5306                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown37));
5307                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown38));
5308                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown39));
5309                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown40));
5310         }
5311         if (ndr_flags & NDR_BUFFERS) {
5312         }
5313         return NDR_ERR_SUCCESS;
5314 }
5315
5316 static enum ndr_err_code ndr_pull_wkssvc_NetrWorkstationStatistics(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrWorkstationStatistics *r)
5317 {
5318         if (ndr_flags & NDR_SCALARS) {
5319                 NDR_CHECK(ndr_pull_align(ndr, 8));
5320                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown1));
5321                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown2));
5322                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown3));
5323                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown4));
5324                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown5));
5325                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown6));
5326                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown7));
5327                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown8));
5328                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown9));
5329                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown10));
5330                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown11));
5331                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown12));
5332                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown13));
5333                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown14));
5334                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown15));
5335                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown16));
5336                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown17));
5337                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown18));
5338                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown19));
5339                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown20));
5340                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown21));
5341                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown22));
5342                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown23));
5343                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown24));
5344                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown25));
5345                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown26));
5346                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown27));
5347                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown28));
5348                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown29));
5349                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown30));
5350                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown31));
5351                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown32));
5352                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown33));
5353                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown34));
5354                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown35));
5355                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown36));
5356                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown37));
5357                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown38));
5358                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown39));
5359                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown40));
5360         }
5361         if (ndr_flags & NDR_BUFFERS) {
5362         }
5363         return NDR_ERR_SUCCESS;
5364 }
5365
5366 _PUBLIC_ void ndr_print_wkssvc_NetrWorkstationStatistics(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrWorkstationStatistics *r)
5367 {
5368         ndr_print_struct(ndr, name, "wkssvc_NetrWorkstationStatistics");
5369         ndr->depth++;
5370         ndr_print_hyper(ndr, "unknown1", r->unknown1);
5371         ndr_print_hyper(ndr, "unknown2", r->unknown2);
5372         ndr_print_hyper(ndr, "unknown3", r->unknown3);
5373         ndr_print_hyper(ndr, "unknown4", r->unknown4);
5374         ndr_print_hyper(ndr, "unknown5", r->unknown5);
5375         ndr_print_hyper(ndr, "unknown6", r->unknown6);
5376         ndr_print_hyper(ndr, "unknown7", r->unknown7);
5377         ndr_print_hyper(ndr, "unknown8", r->unknown8);
5378         ndr_print_hyper(ndr, "unknown9", r->unknown9);
5379         ndr_print_hyper(ndr, "unknown10", r->unknown10);
5380         ndr_print_hyper(ndr, "unknown11", r->unknown11);
5381         ndr_print_hyper(ndr, "unknown12", r->unknown12);
5382         ndr_print_hyper(ndr, "unknown13", r->unknown13);
5383         ndr_print_uint32(ndr, "unknown14", r->unknown14);
5384         ndr_print_uint32(ndr, "unknown15", r->unknown15);
5385         ndr_print_uint32(ndr, "unknown16", r->unknown16);
5386         ndr_print_uint32(ndr, "unknown17", r->unknown17);
5387         ndr_print_uint32(ndr, "unknown18", r->unknown18);
5388         ndr_print_uint32(ndr, "unknown19", r->unknown19);
5389         ndr_print_uint32(ndr, "unknown20", r->unknown20);
5390         ndr_print_uint32(ndr, "unknown21", r->unknown21);
5391         ndr_print_uint32(ndr, "unknown22", r->unknown22);
5392         ndr_print_uint32(ndr, "unknown23", r->unknown23);
5393         ndr_print_uint32(ndr, "unknown24", r->unknown24);
5394         ndr_print_uint32(ndr, "unknown25", r->unknown25);
5395         ndr_print_uint32(ndr, "unknown26", r->unknown26);
5396         ndr_print_uint32(ndr, "unknown27", r->unknown27);
5397         ndr_print_uint32(ndr, "unknown28", r->unknown28);
5398         ndr_print_uint32(ndr, "unknown29", r->unknown29);
5399         ndr_print_uint32(ndr, "unknown30", r->unknown30);
5400         ndr_print_uint32(ndr, "unknown31", r->unknown31);
5401         ndr_print_uint32(ndr, "unknown32", r->unknown32);
5402         ndr_print_uint32(ndr, "unknown33", r->unknown33);
5403         ndr_print_uint32(ndr, "unknown34", r->unknown34);
5404         ndr_print_uint32(ndr, "unknown35", r->unknown35);
5405         ndr_print_uint32(ndr, "unknown36", r->unknown36);
5406         ndr_print_uint32(ndr, "unknown37", r->unknown37);
5407         ndr_print_uint32(ndr, "unknown38", r->unknown38);
5408         ndr_print_uint32(ndr, "unknown39", r->unknown39);
5409         ndr_print_uint32(ndr, "unknown40", r->unknown40);
5410         ndr->depth--;
5411 }
5412
5413 static enum ndr_err_code ndr_push_wkssvc_renameflags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
5414 {
5415         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5416         return NDR_ERR_SUCCESS;
5417 }
5418
5419 static enum ndr_err_code ndr_pull_wkssvc_renameflags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
5420 {
5421         uint32_t v;
5422         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5423         *r = v;
5424         return NDR_ERR_SUCCESS;
5425 }
5426
5427 _PUBLIC_ void ndr_print_wkssvc_renameflags(struct ndr_print *ndr, const char *name, uint32_t r)
5428 {
5429         ndr_print_uint32(ndr, name, r);
5430         ndr->depth++;
5431         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE", WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE, r);
5432         ndr->depth--;
5433 }
5434
5435 static enum ndr_err_code ndr_push_wkssvc_NetValidateNameType(struct ndr_push *ndr, int ndr_flags, enum wkssvc_NetValidateNameType r)
5436 {
5437         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
5438         return NDR_ERR_SUCCESS;
5439 }
5440
5441 static enum ndr_err_code ndr_pull_wkssvc_NetValidateNameType(struct ndr_pull *ndr, int ndr_flags, enum wkssvc_NetValidateNameType *r)
5442 {
5443         uint16_t v;
5444         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
5445         *r = v;
5446         return NDR_ERR_SUCCESS;
5447 }
5448
5449 _PUBLIC_ void ndr_print_wkssvc_NetValidateNameType(struct ndr_print *ndr, const char *name, enum wkssvc_NetValidateNameType r)
5450 {
5451         const char *val = NULL;
5452
5453         switch (r) {
5454                 case NetSetupUnknown: val = "NetSetupUnknown"; break;
5455                 case NetSetupMachine: val = "NetSetupMachine"; break;
5456                 case NetSetupWorkgroup: val = "NetSetupWorkgroup"; break;
5457                 case NetSetupDomain: val = "NetSetupDomain"; break;
5458                 case NetSetupNonExistentDomain: val = "NetSetupNonExistentDomain"; break;
5459                 case NetSetupDnsMachine: val = "NetSetupDnsMachine"; break;
5460         }
5461         ndr_print_enum(ndr, name, "ENUM", val, r);
5462 }
5463
5464 static enum ndr_err_code ndr_push_wkssvc_NetJoinStatus(struct ndr_push *ndr, int ndr_flags, enum wkssvc_NetJoinStatus r)
5465 {
5466         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
5467         return NDR_ERR_SUCCESS;
5468 }
5469
5470 static enum ndr_err_code ndr_pull_wkssvc_NetJoinStatus(struct ndr_pull *ndr, int ndr_flags, enum wkssvc_NetJoinStatus *r)
5471 {
5472         uint16_t v;
5473         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
5474         *r = v;
5475         return NDR_ERR_SUCCESS;
5476 }
5477
5478 _PUBLIC_ void ndr_print_wkssvc_NetJoinStatus(struct ndr_print *ndr, const char *name, enum wkssvc_NetJoinStatus r)
5479 {
5480         const char *val = NULL;
5481
5482         switch (r) {
5483                 case NetSetupUnknownStatus: val = "NetSetupUnknownStatus"; break;
5484                 case NetSetupUnjoined: val = "NetSetupUnjoined"; break;
5485                 case NetSetupWorkgroupName: val = "NetSetupWorkgroupName"; break;
5486                 case NetSetupDomainName: val = "NetSetupDomainName"; break;
5487         }
5488         ndr_print_enum(ndr, name, "ENUM", val, r);
5489 }
5490
5491 static enum ndr_err_code ndr_push_wkssvc_PasswordBuffer(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_PasswordBuffer *r)
5492 {
5493         {
5494                 uint32_t _flags_save_STRUCT = ndr->flags;
5495                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
5496                 if (ndr_flags & NDR_SCALARS) {
5497                         NDR_CHECK(ndr_push_align(ndr, 1));
5498                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, 524));
5499                 }
5500                 if (ndr_flags & NDR_BUFFERS) {
5501                 }
5502                 ndr->flags = _flags_save_STRUCT;
5503         }
5504         return NDR_ERR_SUCCESS;
5505 }
5506
5507 static enum ndr_err_code ndr_pull_wkssvc_PasswordBuffer(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_PasswordBuffer *r)
5508 {
5509         {
5510                 uint32_t _flags_save_STRUCT = ndr->flags;
5511                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
5512                 if (ndr_flags & NDR_SCALARS) {
5513                         NDR_CHECK(ndr_pull_align(ndr, 1));
5514                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, 524));
5515                 }
5516                 if (ndr_flags & NDR_BUFFERS) {
5517                 }
5518                 ndr->flags = _flags_save_STRUCT;
5519         }
5520         return NDR_ERR_SUCCESS;
5521 }
5522
5523 _PUBLIC_ void ndr_print_wkssvc_PasswordBuffer(struct ndr_print *ndr, const char *name, const struct wkssvc_PasswordBuffer *r)
5524 {
5525         ndr_print_struct(ndr, name, "wkssvc_PasswordBuffer");
5526         {
5527                 uint32_t _flags_save_STRUCT = ndr->flags;
5528                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
5529                 ndr->depth++;
5530                 ndr_print_array_uint8(ndr, "data", r->data, 524);
5531                 ndr->depth--;
5532                 ndr->flags = _flags_save_STRUCT;
5533         }
5534 }
5535
5536 static enum ndr_err_code ndr_push_wkssvc_joinflags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
5537 {
5538         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5539         return NDR_ERR_SUCCESS;
5540 }
5541
5542 static enum ndr_err_code ndr_pull_wkssvc_joinflags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
5543 {
5544         uint32_t v;
5545         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5546         *r = v;
5547         return NDR_ERR_SUCCESS;
5548 }
5549
5550 _PUBLIC_ void ndr_print_wkssvc_joinflags(struct ndr_print *ndr, const char *name, uint32_t r)
5551 {
5552         ndr_print_uint32(ndr, name, r);
5553         ndr->depth++;
5554         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_JOIN_WITH_NEW_NAME", WKSSVC_JOIN_FLAGS_JOIN_WITH_NEW_NAME, r);
5555         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_JOIN_DC_ACCOUNT", WKSSVC_JOIN_FLAGS_JOIN_DC_ACCOUNT, r);
5556         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_DEFER_SPN", WKSSVC_JOIN_FLAGS_DEFER_SPN, r);
5557         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_MACHINE_PWD_PASSED", WKSSVC_JOIN_FLAGS_MACHINE_PWD_PASSED, r);
5558         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_JOIN_UNSECURE", WKSSVC_JOIN_FLAGS_JOIN_UNSECURE, r);
5559         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_DOMAIN_JOIN_IF_JOINED", WKSSVC_JOIN_FLAGS_DOMAIN_JOIN_IF_JOINED, r);
5560         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_WIN9X_UPGRADE", WKSSVC_JOIN_FLAGS_WIN9X_UPGRADE, r);
5561         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_ACCOUNT_DELETE", WKSSVC_JOIN_FLAGS_ACCOUNT_DELETE, r);
5562         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE", WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE, r);
5563         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_JOIN_TYPE", WKSSVC_JOIN_FLAGS_JOIN_TYPE, r);
5564         ndr->depth--;
5565 }
5566
5567 static enum ndr_err_code ndr_push_wkssvc_ComputerNameType(struct ndr_push *ndr, int ndr_flags, enum wkssvc_ComputerNameType r)
5568 {
5569         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
5570         return NDR_ERR_SUCCESS;
5571 }
5572
5573 static enum ndr_err_code ndr_pull_wkssvc_ComputerNameType(struct ndr_pull *ndr, int ndr_flags, enum wkssvc_ComputerNameType *r)
5574 {
5575         uint16_t v;
5576         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
5577         *r = v;
5578         return NDR_ERR_SUCCESS;
5579 }
5580
5581 _PUBLIC_ void ndr_print_wkssvc_ComputerNameType(struct ndr_print *ndr, const char *name, enum wkssvc_ComputerNameType r)
5582 {
5583         const char *val = NULL;
5584
5585         switch (r) {
5586                 case NetPrimaryComputerName: val = "NetPrimaryComputerName"; break;
5587                 case NetAlternateComputerNames: val = "NetAlternateComputerNames"; break;
5588                 case NetAllComputerNames: val = "NetAllComputerNames"; break;
5589                 case NetComputerNameTypeMax: val = "NetComputerNameTypeMax"; break;
5590         }
5591         ndr_print_enum(ndr, name, "ENUM", val, r);
5592 }
5593
5594 static enum ndr_err_code ndr_push_wkssvc_ComputerNamesCtr(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_ComputerNamesCtr *r)
5595 {
5596         uint32_t cntr_computer_name_1;
5597         if (ndr_flags & NDR_SCALARS) {
5598                 NDR_CHECK(ndr_push_align(ndr, 4));
5599                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5600                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_name));
5601         }
5602         if (ndr_flags & NDR_BUFFERS) {
5603                 if (r->computer_name) {
5604                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5605                         for (cntr_computer_name_1 = 0; cntr_computer_name_1 < r->count; cntr_computer_name_1++) {
5606                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->computer_name[cntr_computer_name_1]));
5607                         }
5608                         for (cntr_computer_name_1 = 0; cntr_computer_name_1 < r->count; cntr_computer_name_1++) {
5609                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->computer_name[cntr_computer_name_1]));
5610                         }
5611                 }
5612         }
5613         return NDR_ERR_SUCCESS;
5614 }
5615
5616 static enum ndr_err_code ndr_pull_wkssvc_ComputerNamesCtr(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_ComputerNamesCtr *r)
5617 {
5618         uint32_t _ptr_computer_name;
5619         uint32_t cntr_computer_name_1;
5620         TALLOC_CTX *_mem_save_computer_name_0;
5621         TALLOC_CTX *_mem_save_computer_name_1;
5622         if (ndr_flags & NDR_SCALARS) {
5623                 NDR_CHECK(ndr_pull_align(ndr, 4));
5624                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5625                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_name));
5626                 if (_ptr_computer_name) {
5627                         NDR_PULL_ALLOC(ndr, r->computer_name);
5628                 } else {
5629                         r->computer_name = NULL;
5630                 }
5631         }
5632         if (ndr_flags & NDR_BUFFERS) {
5633                 if (r->computer_name) {
5634                         _mem_save_computer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5635                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_name, 0);
5636                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_name));
5637                         NDR_PULL_ALLOC_N(ndr, r->computer_name, ndr_get_array_size(ndr, &r->computer_name));
5638                         _mem_save_computer_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
5639                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_name, 0);
5640                         for (cntr_computer_name_1 = 0; cntr_computer_name_1 < r->count; cntr_computer_name_1++) {
5641                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->computer_name[cntr_computer_name_1]));
5642                         }
5643                         for (cntr_computer_name_1 = 0; cntr_computer_name_1 < r->count; cntr_computer_name_1++) {
5644                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->computer_name[cntr_computer_name_1]));
5645                         }
5646                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_name_1, 0);
5647                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_name_0, 0);
5648                 }
5649                 if (r->computer_name) {
5650                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->computer_name, r->count));
5651                 }
5652         }
5653         return NDR_ERR_SUCCESS;
5654 }
5655
5656 _PUBLIC_ void ndr_print_wkssvc_ComputerNamesCtr(struct ndr_print *ndr, const char *name, const struct wkssvc_ComputerNamesCtr *r)
5657 {
5658         uint32_t cntr_computer_name_1;
5659         ndr_print_struct(ndr, name, "wkssvc_ComputerNamesCtr");
5660         ndr->depth++;
5661         ndr_print_uint32(ndr, "count", r->count);
5662         ndr_print_ptr(ndr, "computer_name", r->computer_name);
5663         ndr->depth++;
5664         if (r->computer_name) {
5665                 ndr->print(ndr, "%s: ARRAY(%d)", "computer_name", r->count);
5666                 ndr->depth++;
5667                 for (cntr_computer_name_1=0;cntr_computer_name_1<r->count;cntr_computer_name_1++) {
5668                         char *idx_1=NULL;
5669                         asprintf(&idx_1, "[%d]", cntr_computer_name_1);
5670                         if (idx_1) {
5671                                 ndr_print_lsa_String(ndr, "computer_name", &r->computer_name[cntr_computer_name_1]);
5672                                 free(idx_1);
5673                         }
5674                 }
5675                 ndr->depth--;
5676         }
5677         ndr->depth--;
5678         ndr->depth--;
5679 }
5680
5681 static enum ndr_err_code ndr_push_wkssvc_NetWkstaGetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaGetInfo *r)
5682 {
5683         if (flags & NDR_IN) {
5684                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
5685                 if (r->in.server_name) {
5686                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
5687                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5688                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
5689                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5690                 }
5691                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
5692         }
5693         if (flags & NDR_OUT) {
5694                 if (r->out.info == NULL) {
5695                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5696                 }
5697                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
5698                 NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
5699                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5700         }
5701         return NDR_ERR_SUCCESS;
5702 }
5703
5704 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaGetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaGetInfo *r)
5705 {
5706         uint32_t _ptr_server_name;
5707         TALLOC_CTX *_mem_save_server_name_0;
5708         TALLOC_CTX *_mem_save_info_0;
5709         if (flags & NDR_IN) {
5710                 ZERO_STRUCT(r->out);
5711
5712                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5713                 if (_ptr_server_name) {
5714                         NDR_PULL_ALLOC(ndr, r->in.server_name);
5715                 } else {
5716                         r->in.server_name = NULL;
5717                 }
5718                 if (r->in.server_name) {
5719                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5720                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
5721                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
5722                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
5723                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
5724                                 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_name), ndr_get_array_length(ndr, &r->in.server_name));
5725                         }
5726                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
5727                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
5728                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5729                 }
5730                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
5731                 NDR_PULL_ALLOC(ndr, r->out.info);
5732                 ZERO_STRUCTP(r->out.info);
5733         }
5734         if (flags & NDR_OUT) {
5735                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5736                         NDR_PULL_ALLOC(ndr, r->out.info);
5737                 }
5738                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
5739                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
5740                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
5741                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
5742                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
5743                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5744         }
5745         return NDR_ERR_SUCCESS;
5746 }
5747
5748 _PUBLIC_ void ndr_print_wkssvc_NetWkstaGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaGetInfo *r)
5749 {
5750         ndr_print_struct(ndr, name, "wkssvc_NetWkstaGetInfo");
5751         ndr->depth++;
5752         if (flags & NDR_SET_VALUES) {
5753                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5754         }
5755         if (flags & NDR_IN) {
5756                 ndr_print_struct(ndr, "in", "wkssvc_NetWkstaGetInfo");
5757                 ndr->depth++;
5758                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
5759                 ndr->depth++;
5760                 if (r->in.server_name) {
5761                         ndr_print_string(ndr, "server_name", r->in.server_name);
5762                 }
5763                 ndr->depth--;
5764                 ndr_print_uint32(ndr, "level", r->in.level);
5765                 ndr->depth--;
5766         }
5767         if (flags & NDR_OUT) {
5768                 ndr_print_struct(ndr, "out", "wkssvc_NetWkstaGetInfo");
5769                 ndr->depth++;
5770                 ndr_print_ptr(ndr, "info", r->out.info);
5771                 ndr->depth++;
5772                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
5773                 ndr_print_wkssvc_NetWkstaInfo(ndr, "info", r->out.info);
5774                 ndr->depth--;
5775                 ndr_print_WERROR(ndr, "result", r->out.result);
5776                 ndr->depth--;
5777         }
5778         ndr->depth--;
5779 }
5780
5781 static enum ndr_err_code ndr_push_wkssvc_NetWkstaSetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaSetInfo *r)
5782 {
5783         if (flags & NDR_IN) {
5784                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
5785                 if (r->in.server_name) {
5786                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
5787                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5788                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
5789                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5790                 }
5791                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
5792                 if (r->in.info == NULL) {
5793                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5794                 }
5795                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
5796                 NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
5797                 if (r->in.parm_error == NULL) {
5798                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5799                 }
5800                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_error));
5801         }
5802         if (flags & NDR_OUT) {
5803                 if (r->out.parm_error == NULL) {
5804                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5805                 }
5806                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_error));
5807                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5808         }
5809         return NDR_ERR_SUCCESS;
5810 }
5811
5812 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaSetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaSetInfo *r)
5813 {
5814         uint32_t _ptr_server_name;
5815         TALLOC_CTX *_mem_save_server_name_0;
5816         TALLOC_CTX *_mem_save_info_0;
5817         TALLOC_CTX *_mem_save_parm_error_0;
5818         if (flags & NDR_IN) {
5819                 ZERO_STRUCT(r->out);
5820
5821                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5822                 if (_ptr_server_name) {
5823                         NDR_PULL_ALLOC(ndr, r->in.server_name);
5824                 } else {
5825                         r->in.server_name = NULL;
5826                 }
5827                 if (r->in.server_name) {
5828                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5829                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
5830                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
5831                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
5832                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
5833                                 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_name), ndr_get_array_length(ndr, &r->in.server_name));
5834                         }
5835                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
5836                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
5837                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5838                 }
5839                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
5840                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5841                         NDR_PULL_ALLOC(ndr, r->in.info);
5842                 }
5843                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
5844                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
5845                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
5846                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
5847                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
5848                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5849                         NDR_PULL_ALLOC(ndr, r->in.parm_error);
5850                 }
5851                 _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
5852                 NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_error, LIBNDR_FLAG_REF_ALLOC);
5853                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_error));
5854                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, LIBNDR_FLAG_REF_ALLOC);
5855                 NDR_PULL_ALLOC(ndr, r->out.parm_error);
5856                 *r->out.parm_error = *r->in.parm_error;
5857         }
5858         if (flags & NDR_OUT) {
5859                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5860                         NDR_PULL_ALLOC(ndr, r->out.parm_error);
5861                 }
5862                 _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
5863                 NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_error, LIBNDR_FLAG_REF_ALLOC);
5864                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_error));
5865                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, LIBNDR_FLAG_REF_ALLOC);
5866                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5867         }
5868         return NDR_ERR_SUCCESS;
5869 }
5870
5871 _PUBLIC_ void ndr_print_wkssvc_NetWkstaSetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaSetInfo *r)
5872 {
5873         ndr_print_struct(ndr, name, "wkssvc_NetWkstaSetInfo");
5874         ndr->depth++;
5875         if (flags & NDR_SET_VALUES) {
5876                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5877         }
5878         if (flags & NDR_IN) {
5879                 ndr_print_struct(ndr, "in", "wkssvc_NetWkstaSetInfo");
5880                 ndr->depth++;
5881                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
5882                 ndr->depth++;
5883                 if (r->in.server_name) {
5884                         ndr_print_string(ndr, "server_name", r->in.server_name);
5885                 }
5886                 ndr->depth--;
5887                 ndr_print_uint32(ndr, "level", r->in.level);
5888                 ndr_print_ptr(ndr, "info", r->in.info);
5889                 ndr->depth++;
5890                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
5891                 ndr_print_wkssvc_NetWkstaInfo(ndr, "info", r->in.info);
5892                 ndr->depth--;
5893                 ndr_print_ptr(ndr, "parm_error", r->in.parm_error);
5894                 ndr->depth++;
5895                 ndr_print_uint32(ndr, "parm_error", *r->in.parm_error);
5896                 ndr->depth--;
5897                 ndr->depth--;
5898         }
5899         if (flags & NDR_OUT) {
5900                 ndr_print_struct(ndr, "out", "wkssvc_NetWkstaSetInfo");
5901                 ndr->depth++;
5902                 ndr_print_ptr(ndr, "parm_error", r->out.parm_error);
5903                 ndr->depth++;
5904                 ndr_print_uint32(ndr, "parm_error", *r->out.parm_error);
5905                 ndr->depth--;
5906                 ndr_print_WERROR(ndr, "result", r->out.result);
5907                 ndr->depth--;
5908         }
5909         ndr->depth--;
5910 }
5911
5912 static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsers(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaEnumUsers *r)
5913 {
5914         if (flags & NDR_IN) {
5915                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
5916                 if (r->in.server_name) {
5917                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
5918                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5919                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
5920                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5921                 }
5922                 if (r->in.info == NULL) {
5923                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5924                 }
5925                 NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
5926                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.prefmaxlen));
5927                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
5928                 if (r->in.resume_handle) {
5929                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
5930                 }
5931         }
5932         if (flags & NDR_OUT) {
5933                 if (r->out.info == NULL) {
5934                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5935                 }
5936                 NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
5937                 if (r->out.entries_read == NULL) {
5938                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5939                 }
5940                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.entries_read));
5941                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
5942                 if (r->out.resume_handle) {
5943                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
5944                 }
5945                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5946         }
5947         return NDR_ERR_SUCCESS;
5948 }
5949
5950 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsers(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaEnumUsers *r)
5951 {
5952         uint32_t _ptr_server_name;
5953         uint32_t _ptr_resume_handle;
5954         TALLOC_CTX *_mem_save_server_name_0;
5955         TALLOC_CTX *_mem_save_info_0;
5956         TALLOC_CTX *_mem_save_entries_read_0;
5957         TALLOC_CTX *_mem_save_resume_handle_0;
5958         if (flags & NDR_IN) {
5959                 ZERO_STRUCT(r->out);
5960
5961                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5962                 if (_ptr_server_name) {
5963                         NDR_PULL_ALLOC(ndr, r->in.server_name);
5964                 } else {
5965                         r->in.server_name = NULL;
5966                 }
5967                 if (r->in.server_name) {
5968                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5969                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
5970                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
5971                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
5972                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
5973                                 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_name), ndr_get_array_length(ndr, &r->in.server_name));
5974                         }
5975                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
5976                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
5977                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5978                 }
5979                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5980                         NDR_PULL_ALLOC(ndr, r->in.info);
5981                 }
5982                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
5983                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
5984                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
5985                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
5986                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.prefmaxlen));
5987                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
5988                 if (_ptr_resume_handle) {
5989                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
5990                 } else {
5991                         r->in.resume_handle = NULL;
5992                 }
5993                 if (r->in.resume_handle) {
5994                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5995                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
5996                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
5997                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
5998                 }
5999                 NDR_PULL_ALLOC(ndr, r->out.info);
6000                 *r->out.info = *r->in.info;
6001                 NDR_PULL_ALLOC(ndr, r->out.entries_read);
6002                 ZERO_STRUCTP(r->out.entries_read);
6003         }
6004         if (flags & NDR_OUT) {
6005                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6006                         NDR_PULL_ALLOC(ndr, r->out.info);
6007                 }
6008                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6009                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
6010                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
6011                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6012                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6013                         NDR_PULL_ALLOC(ndr, r->out.entries_read);
6014                 }
6015                 _mem_save_entries_read_0 = NDR_PULL_GET_MEM_CTX(ndr);
6016                 NDR_PULL_SET_MEM_CTX(ndr, r->out.entries_read, LIBNDR_FLAG_REF_ALLOC);
6017                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.entries_read));
6018                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_read_0, LIBNDR_FLAG_REF_ALLOC);
6019                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
6020                 if (_ptr_resume_handle) {
6021                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6022                 } else {
6023                         r->out.resume_handle = NULL;
6024                 }
6025                 if (r->out.resume_handle) {
6026                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6027                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
6028                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
6029                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
6030                 }
6031                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6032         }
6033         return NDR_ERR_SUCCESS;
6034 }
6035
6036 _PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsers(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaEnumUsers *r)
6037 {
6038         ndr_print_struct(ndr, name, "wkssvc_NetWkstaEnumUsers");
6039         ndr->depth++;
6040         if (flags & NDR_SET_VALUES) {
6041                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6042         }
6043         if (flags & NDR_IN) {
6044                 ndr_print_struct(ndr, "in", "wkssvc_NetWkstaEnumUsers");
6045                 ndr->depth++;
6046                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
6047                 ndr->depth++;
6048                 if (r->in.server_name) {
6049                         ndr_print_string(ndr, "server_name", r->in.server_name);
6050                 }
6051                 ndr->depth--;
6052                 ndr_print_ptr(ndr, "info", r->in.info);
6053                 ndr->depth++;
6054                 ndr_print_wkssvc_NetWkstaEnumUsersInfo(ndr, "info", r->in.info);
6055                 ndr->depth--;
6056                 ndr_print_uint32(ndr, "prefmaxlen", r->in.prefmaxlen);
6057                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
6058                 ndr->depth++;
6059                 if (r->in.resume_handle) {
6060                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
6061                 }
6062                 ndr->depth--;
6063                 ndr->depth--;
6064         }
6065         if (flags & NDR_OUT) {
6066                 ndr_print_struct(ndr, "out", "wkssvc_NetWkstaEnumUsers");
6067                 ndr->depth++;
6068                 ndr_print_ptr(ndr, "info", r->out.info);
6069                 ndr->depth++;
6070                 ndr_print_wkssvc_NetWkstaEnumUsersInfo(ndr, "info", r->out.info);
6071                 ndr->depth--;
6072                 ndr_print_ptr(ndr, "entries_read", r->out.entries_read);
6073                 ndr->depth++;
6074                 ndr_print_uint32(ndr, "entries_read", *r->out.entries_read);
6075                 ndr->depth--;
6076                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
6077                 ndr->depth++;
6078                 if (r->out.resume_handle) {
6079                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
6080                 }
6081                 ndr->depth--;
6082                 ndr_print_WERROR(ndr, "result", r->out.result);
6083                 ndr->depth--;
6084         }
6085         ndr->depth--;
6086 }
6087
6088 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserGetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetrWkstaUserGetInfo *r)
6089 {
6090         if (flags & NDR_IN) {
6091                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown));
6092                 if (r->in.unknown) {
6093                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));
6094                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6095                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));
6096                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.unknown, ndr_charset_length(r->in.unknown, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6097                 }
6098                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
6099         }
6100         if (flags & NDR_OUT) {
6101                 if (r->out.info == NULL) {
6102                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6103                 }
6104                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
6105                 NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
6106                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6107         }
6108         return NDR_ERR_SUCCESS;
6109 }
6110
6111 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserGetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetrWkstaUserGetInfo *r)
6112 {
6113         uint32_t _ptr_unknown;
6114         TALLOC_CTX *_mem_save_unknown_0;
6115         TALLOC_CTX *_mem_save_info_0;
6116         if (flags & NDR_IN) {
6117                 ZERO_STRUCT(r->out);
6118
6119                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown));
6120                 if (_ptr_unknown) {
6121                         NDR_PULL_ALLOC(ndr, r->in.unknown);
6122                 } else {
6123                         r->in.unknown = NULL;
6124                 }
6125                 if (r->in.unknown) {
6126                         _mem_save_unknown_0 = NDR_PULL_GET_MEM_CTX(ndr);
6127                         NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown, 0);
6128                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.unknown));
6129                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.unknown));
6130                         if (ndr_get_array_length(ndr, &r->in.unknown) > ndr_get_array_size(ndr, &r->in.unknown)) {
6131                                 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.unknown), ndr_get_array_length(ndr, &r->in.unknown));
6132                         }
6133                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t)));
6134                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.unknown, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t), CH_UTF16));
6135                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown_0, 0);
6136                 }
6137                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
6138                 NDR_PULL_ALLOC(ndr, r->out.info);
6139                 ZERO_STRUCTP(r->out.info);
6140         }
6141         if (flags & NDR_OUT) {
6142                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6143                         NDR_PULL_ALLOC(ndr, r->out.info);
6144                 }
6145                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6146                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
6147                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
6148                 NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
6149                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6150                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6151         }
6152         return NDR_ERR_SUCCESS;
6153 }
6154
6155 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrWkstaUserGetInfo *r)
6156 {
6157         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaUserGetInfo");
6158         ndr->depth++;
6159         if (flags & NDR_SET_VALUES) {
6160                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6161         }
6162         if (flags & NDR_IN) {
6163                 ndr_print_struct(ndr, "in", "wkssvc_NetrWkstaUserGetInfo");
6164                 ndr->depth++;
6165                 ndr_print_ptr(ndr, "unknown", r->in.unknown);
6166                 ndr->depth++;
6167                 if (r->in.unknown) {
6168                         ndr_print_string(ndr, "unknown", r->in.unknown);
6169                 }
6170                 ndr->depth--;
6171                 ndr_print_uint32(ndr, "level", r->in.level);
6172                 ndr->depth--;
6173         }
6174         if (flags & NDR_OUT) {
6175                 ndr_print_struct(ndr, "out", "wkssvc_NetrWkstaUserGetInfo");
6176                 ndr->depth++;
6177                 ndr_print_ptr(ndr, "info", r->out.info);
6178                 ndr->depth++;
6179                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
6180                 ndr_print_wkssvc_NetrWkstaUserInfo(ndr, "info", r->out.info);
6181                 ndr->depth--;
6182                 ndr_print_WERROR(ndr, "result", r->out.result);
6183                 ndr->depth--;
6184         }
6185         ndr->depth--;
6186 }
6187
6188 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserSetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetrWkstaUserSetInfo *r)
6189 {
6190         if (flags & NDR_IN) {
6191                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown));
6192                 if (r->in.unknown) {
6193                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));
6194                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6195                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));
6196                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.unknown, ndr_charset_length(r->in.unknown, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6197                 }
6198                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
6199                 if (r->in.info == NULL) {
6200                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6201                 }
6202                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
6203                 NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6204                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_err));
6205                 if (r->in.parm_err) {
6206                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_err));
6207                 }
6208         }
6209         if (flags & NDR_OUT) {
6210                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_err));
6211                 if (r->out.parm_err) {
6212                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_err));
6213                 }
6214                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6215         }
6216         return NDR_ERR_SUCCESS;
6217 }
6218
6219 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserSetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetrWkstaUserSetInfo *r)
6220 {
6221         uint32_t _ptr_unknown;
6222         uint32_t _ptr_parm_err;
6223         TALLOC_CTX *_mem_save_unknown_0;
6224         TALLOC_CTX *_mem_save_info_0;
6225         TALLOC_CTX *_mem_save_parm_err_0;
6226         if (flags & NDR_IN) {
6227                 ZERO_STRUCT(r->out);
6228
6229                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown));
6230                 if (_ptr_unknown) {
6231                         NDR_PULL_ALLOC(ndr, r->in.unknown);
6232                 } else {
6233                         r->in.unknown = NULL;
6234                 }
6235                 if (r->in.unknown) {
6236                         _mem_save_unknown_0 = NDR_PULL_GET_MEM_CTX(ndr);
6237                         NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown, 0);
6238                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.unknown));
6239                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.unknown));
6240                         if (ndr_get_array_length(ndr, &r->in.unknown) > ndr_get_array_size(ndr, &r->in.unknown)) {
6241                                 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.unknown), ndr_get_array_length(ndr, &r->in.unknown));
6242                         }
6243                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t)));
6244                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.unknown, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t), CH_UTF16));
6245                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown_0, 0);
6246                 }
6247                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
6248                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6249                         NDR_PULL_ALLOC(ndr, r->in.info);
6250                 }
6251                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6252                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
6253                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
6254                 NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6255                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6256                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));
6257                 if (_ptr_parm_err) {
6258                         NDR_PULL_ALLOC(ndr, r->in.parm_err);
6259                 } else {
6260                         r->in.parm_err = NULL;
6261                 }
6262                 if (r->in.parm_err) {
6263                         _mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);
6264                         NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_err, 0);
6265                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_err));
6266                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);
6267                 }
6268         }
6269         if (flags & NDR_OUT) {
6270                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));
6271                 if (_ptr_parm_err) {
6272                         NDR_PULL_ALLOC(ndr, r->out.parm_err);
6273                 } else {
6274                         r->out.parm_err = NULL;
6275                 }
6276                 if (r->out.parm_err) {
6277                         _mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);
6278                         NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_err, 0);
6279                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_err));
6280                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);
6281                 }
6282                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6283         }
6284         return NDR_ERR_SUCCESS;
6285 }
6286
6287 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserSetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrWkstaUserSetInfo *r)
6288 {
6289         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaUserSetInfo");
6290         ndr->depth++;
6291         if (flags & NDR_SET_VALUES) {
6292                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6293         }
6294         if (flags & NDR_IN) {
6295                 ndr_print_struct(ndr, "in", "wkssvc_NetrWkstaUserSetInfo");
6296                 ndr->depth++;
6297                 ndr_print_ptr(ndr, "unknown", r->in.unknown);
6298                 ndr->depth++;
6299                 if (r->in.unknown) {
6300                         ndr_print_string(ndr, "unknown", r->in.unknown);
6301                 }
6302                 ndr->depth--;
6303                 ndr_print_uint32(ndr, "level", r->in.level);
6304                 ndr_print_ptr(ndr, "info", r->in.info);
6305                 ndr->depth++;
6306                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
6307                 ndr_print_wkssvc_NetrWkstaUserInfo(ndr, "info", r->in.info);
6308                 ndr->depth--;
6309                 ndr_print_ptr(ndr, "parm_err", r->in.parm_err);
6310                 ndr->depth++;
6311                 if (r->in.parm_err) {
6312                         ndr_print_uint32(ndr, "parm_err", *r->in.parm_err);
6313                 }
6314                 ndr->depth--;
6315                 ndr->depth--;
6316         }
6317         if (flags & NDR_OUT) {
6318                 ndr_print_struct(ndr, "out", "wkssvc_NetrWkstaUserSetInfo");
6319                 ndr->depth++;
6320                 ndr_print_ptr(ndr, "parm_err", r->out.parm_err);
6321                 ndr->depth++;
6322                 if (r->out.parm_err) {
6323                         ndr_print_uint32(ndr, "parm_err", *r->out.parm_err);
6324                 }
6325                 ndr->depth--;
6326                 ndr_print_WERROR(ndr, "result", r->out.result);
6327                 ndr->depth--;
6328         }
6329         ndr->depth--;
6330 }
6331
6332 static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportEnum(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaTransportEnum *r)
6333 {
6334         if (flags & NDR_IN) {
6335                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
6336                 if (r->in.server_name) {
6337                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6338                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6339                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6340                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6341                 }
6342                 if (r->in.info == NULL) {
6343                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6344                 }
6345                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6346                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));
6347                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
6348                 if (r->in.resume_handle) {
6349                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
6350                 }
6351         }
6352         if (flags & NDR_OUT) {
6353                 if (r->out.info == NULL) {
6354                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6355                 }
6356                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
6357                 if (r->out.total_entries == NULL) {
6358                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6359                 }
6360                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_entries));
6361                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
6362                 if (r->out.resume_handle) {
6363                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
6364                 }
6365                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6366         }
6367         return NDR_ERR_SUCCESS;
6368 }
6369
6370 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportEnum(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaTransportEnum *r)
6371 {
6372         uint32_t _ptr_server_name;
6373         uint32_t _ptr_resume_handle;
6374         TALLOC_CTX *_mem_save_server_name_0;
6375         TALLOC_CTX *_mem_save_info_0;
6376         TALLOC_CTX *_mem_save_total_entries_0;
6377         TALLOC_CTX *_mem_save_resume_handle_0;
6378         if (flags & NDR_IN) {
6379                 ZERO_STRUCT(r->out);
6380
6381                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6382                 if (_ptr_server_name) {
6383                         NDR_PULL_ALLOC(ndr, r->in.server_name);
6384                 } else {
6385                         r->in.server_name = NULL;
6386                 }
6387                 if (r->in.server_name) {
6388                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6389                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
6390                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
6391                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
6392                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
6393                                 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_name), ndr_get_array_length(ndr, &r->in.server_name));
6394                         }
6395                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
6396                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
6397                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6398                 }
6399                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6400                         NDR_PULL_ALLOC(ndr, r->in.info);
6401                 }
6402                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6403                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
6404                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6405                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6406                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));
6407                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
6408                 if (_ptr_resume_handle) {
6409                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
6410                 } else {
6411                         r->in.resume_handle = NULL;
6412                 }
6413                 if (r->in.resume_handle) {
6414                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6415                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
6416                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
6417                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
6418                 }
6419                 NDR_PULL_ALLOC(ndr, r->out.info);
6420                 *r->out.info = *r->in.info;
6421                 NDR_PULL_ALLOC(ndr, r->out.total_entries);
6422                 ZERO_STRUCTP(r->out.total_entries);
6423         }
6424         if (flags & NDR_OUT) {
6425                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6426                         NDR_PULL_ALLOC(ndr, r->out.info);
6427                 }
6428                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6429                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
6430                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
6431                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6432                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6433                         NDR_PULL_ALLOC(ndr, r->out.total_entries);
6434                 }
6435                 _mem_save_total_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
6436                 NDR_PULL_SET_MEM_CTX(ndr, r->out.total_entries, LIBNDR_FLAG_REF_ALLOC);
6437                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_entries));
6438                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_entries_0, LIBNDR_FLAG_REF_ALLOC);
6439                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
6440                 if (_ptr_resume_handle) {
6441                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6442                 } else {
6443                         r->out.resume_handle = NULL;
6444                 }
6445                 if (r->out.resume_handle) {
6446                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6447                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
6448                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
6449                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
6450                 }
6451                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6452         }
6453         return NDR_ERR_SUCCESS;
6454 }
6455
6456 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportEnum(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaTransportEnum *r)
6457 {
6458         ndr_print_struct(ndr, name, "wkssvc_NetWkstaTransportEnum");
6459         ndr->depth++;
6460         if (flags & NDR_SET_VALUES) {
6461                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6462         }
6463         if (flags & NDR_IN) {
6464                 ndr_print_struct(ndr, "in", "wkssvc_NetWkstaTransportEnum");
6465                 ndr->depth++;
6466                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
6467                 ndr->depth++;
6468                 if (r->in.server_name) {
6469                         ndr_print_string(ndr, "server_name", r->in.server_name);
6470                 }
6471                 ndr->depth--;
6472                 ndr_print_ptr(ndr, "info", r->in.info);
6473                 ndr->depth++;
6474                 ndr_print_wkssvc_NetWkstaTransportInfo(ndr, "info", r->in.info);
6475                 ndr->depth--;
6476                 ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);
6477                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
6478                 ndr->depth++;
6479                 if (r->in.resume_handle) {
6480                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
6481                 }
6482                 ndr->depth--;
6483                 ndr->depth--;
6484         }
6485         if (flags & NDR_OUT) {
6486                 ndr_print_struct(ndr, "out", "wkssvc_NetWkstaTransportEnum");
6487                 ndr->depth++;
6488                 ndr_print_ptr(ndr, "info", r->out.info);
6489                 ndr->depth++;
6490                 ndr_print_wkssvc_NetWkstaTransportInfo(ndr, "info", r->out.info);
6491                 ndr->depth--;
6492                 ndr_print_ptr(ndr, "total_entries", r->out.total_entries);
6493                 ndr->depth++;
6494                 ndr_print_uint32(ndr, "total_entries", *r->out.total_entries);
6495                 ndr->depth--;
6496                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
6497                 ndr->depth++;
6498                 if (r->out.resume_handle) {
6499                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
6500                 }
6501                 ndr->depth--;
6502                 ndr_print_WERROR(ndr, "result", r->out.result);
6503                 ndr->depth--;
6504         }
6505         ndr->depth--;
6506 }
6507
6508 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaTransportAdd(struct ndr_push *ndr, int flags, const struct wkssvc_NetrWkstaTransportAdd *r)
6509 {
6510         if (flags & NDR_IN) {
6511                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
6512                 if (r->in.server_name) {
6513                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6514                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6515                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6516                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6517                 }
6518                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
6519                 if (r->in.info0 == NULL) {
6520                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6521                 }
6522                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info0));
6523                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_err));
6524                 if (r->in.parm_err) {
6525                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_err));
6526                 }
6527         }
6528         if (flags & NDR_OUT) {
6529                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_err));
6530                 if (r->out.parm_err) {
6531                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_err));
6532                 }
6533                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6534         }
6535         return NDR_ERR_SUCCESS;
6536 }
6537
6538 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaTransportAdd(struct ndr_pull *ndr, int flags, struct wkssvc_NetrWkstaTransportAdd *r)
6539 {
6540         uint32_t _ptr_server_name;
6541         uint32_t _ptr_parm_err;
6542         TALLOC_CTX *_mem_save_server_name_0;
6543         TALLOC_CTX *_mem_save_info0_0;
6544         TALLOC_CTX *_mem_save_parm_err_0;
6545         if (flags & NDR_IN) {
6546                 ZERO_STRUCT(r->out);
6547
6548                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6549                 if (_ptr_server_name) {
6550                         NDR_PULL_ALLOC(ndr, r->in.server_name);
6551                 } else {
6552                         r->in.server_name = NULL;
6553                 }
6554                 if (r->in.server_name) {
6555                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6556                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
6557                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
6558                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
6559                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
6560                                 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_name), ndr_get_array_length(ndr, &r->in.server_name));
6561                         }
6562                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
6563                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
6564                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6565                 }
6566                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
6567                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6568                         NDR_PULL_ALLOC(ndr, r->in.info0);
6569                 }
6570                 _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
6571                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info0, LIBNDR_FLAG_REF_ALLOC);
6572                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info0));
6573                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, LIBNDR_FLAG_REF_ALLOC);
6574                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));
6575                 if (_ptr_parm_err) {
6576                         NDR_PULL_ALLOC(ndr, r->in.parm_err);
6577                 } else {
6578                         r->in.parm_err = NULL;
6579                 }
6580                 if (r->in.parm_err) {
6581                         _mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);
6582                         NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_err, 0);
6583                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_err));
6584                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);
6585                 }
6586         }
6587         if (flags & NDR_OUT) {
6588                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));
6589                 if (_ptr_parm_err) {
6590                         NDR_PULL_ALLOC(ndr, r->out.parm_err);
6591                 } else {
6592                         r->out.parm_err = NULL;
6593                 }
6594                 if (r->out.parm_err) {
6595                         _mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);
6596                         NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_err, 0);
6597                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_err));
6598                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);
6599                 }
6600                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6601         }
6602         return NDR_ERR_SUCCESS;
6603 }
6604
6605 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaTransportAdd(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrWkstaTransportAdd *r)
6606 {
6607         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaTransportAdd");
6608         ndr->depth++;
6609         if (flags & NDR_SET_VALUES) {
6610                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6611         }
6612         if (flags & NDR_IN) {
6613                 ndr_print_struct(ndr, "in", "wkssvc_NetrWkstaTransportAdd");
6614                 ndr->depth++;
6615                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
6616                 ndr->depth++;
6617                 if (r->in.server_name) {
6618                         ndr_print_string(ndr, "server_name", r->in.server_name);
6619                 }
6620                 ndr->depth--;
6621                 ndr_print_uint32(ndr, "level", r->in.level);
6622                 ndr_print_ptr(ndr, "info0", r->in.info0);
6623                 ndr->depth++;
6624                 ndr_print_wkssvc_NetWkstaTransportInfo0(ndr, "info0", r->in.info0);
6625                 ndr->depth--;
6626                 ndr_print_ptr(ndr, "parm_err", r->in.parm_err);
6627                 ndr->depth++;
6628                 if (r->in.parm_err) {
6629                         ndr_print_uint32(ndr, "parm_err", *r->in.parm_err);
6630                 }
6631                 ndr->depth--;
6632                 ndr->depth--;
6633         }
6634         if (flags & NDR_OUT) {
6635                 ndr_print_struct(ndr, "out", "wkssvc_NetrWkstaTransportAdd");
6636                 ndr->depth++;
6637                 ndr_print_ptr(ndr, "parm_err", r->out.parm_err);
6638                 ndr->depth++;
6639                 if (r->out.parm_err) {
6640                         ndr_print_uint32(ndr, "parm_err", *r->out.parm_err);
6641                 }
6642                 ndr->depth--;
6643                 ndr_print_WERROR(ndr, "result", r->out.result);
6644                 ndr->depth--;
6645         }
6646         ndr->depth--;
6647 }
6648
6649 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaTransportDel(struct ndr_push *ndr, int flags, const struct wkssvc_NetrWkstaTransportDel *r)
6650 {
6651         if (flags & NDR_IN) {
6652                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
6653                 if (r->in.server_name) {
6654                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6655                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6656                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6657                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6658                 }
6659                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.transport_name));
6660                 if (r->in.transport_name) {
6661                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.transport_name, CH_UTF16)));
6662                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6663                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.transport_name, CH_UTF16)));
6664                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.transport_name, ndr_charset_length(r->in.transport_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6665                 }
6666                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown3));
6667         }
6668         if (flags & NDR_OUT) {
6669                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6670         }
6671         return NDR_ERR_SUCCESS;
6672 }
6673
6674 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaTransportDel(struct ndr_pull *ndr, int flags, struct wkssvc_NetrWkstaTransportDel *r)
6675 {
6676         uint32_t _ptr_server_name;
6677         uint32_t _ptr_transport_name;
6678         TALLOC_CTX *_mem_save_server_name_0;
6679         TALLOC_CTX *_mem_save_transport_name_0;
6680         if (flags & NDR_IN) {
6681                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6682                 if (_ptr_server_name) {
6683                         NDR_PULL_ALLOC(ndr, r->in.server_name);
6684                 } else {
6685                         r->in.server_name = NULL;
6686                 }
6687                 if (r->in.server_name) {
6688                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6689                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
6690                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
6691                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
6692                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
6693                                 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_name), ndr_get_array_length(ndr, &r->in.server_name));
6694                         }
6695                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
6696                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
6697                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6698                 }
6699                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_name));
6700                 if (_ptr_transport_name) {
6701                         NDR_PULL_ALLOC(ndr, r->in.transport_name);
6702                 } else {
6703                         r->in.transport_name = NULL;
6704                 }
6705                 if (r->in.transport_name) {
6706                         _mem_save_transport_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6707                         NDR_PULL_SET_MEM_CTX(ndr, r->in.transport_name, 0);
6708                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.transport_name));
6709                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.transport_name));
6710                         if (ndr_get_array_length(ndr, &r->in.transport_name) > ndr_get_array_size(ndr, &r->in.transport_name)) {
6711                                 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.transport_name), ndr_get_array_length(ndr, &r->in.transport_name));
6712                         }
6713                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.transport_name), sizeof(uint16_t)));
6714                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.transport_name, ndr_get_array_length(ndr, &r->in.transport_name), sizeof(uint16_t), CH_UTF16));
6715                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_name_0, 0);
6716                 }
6717                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown3));
6718         }
6719         if (flags & NDR_OUT) {
6720                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6721         }
6722         return NDR_ERR_SUCCESS;
6723 }
6724
6725 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaTransportDel(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrWkstaTransportDel *r)
6726 {
6727         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaTransportDel");
6728         ndr->depth++;
6729         if (flags & NDR_SET_VALUES) {
6730                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6731         }
6732         if (flags & NDR_IN) {
6733                 ndr_print_struct(ndr, "in", "wkssvc_NetrWkstaTransportDel");
6734                 ndr->depth++;
6735                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
6736                 ndr->depth++;
6737                 if (r->in.server_name) {
6738                         ndr_print_string(ndr, "server_name", r->in.server_name);
6739                 }
6740                 ndr->depth--;
6741                 ndr_print_ptr(ndr, "transport_name", r->in.transport_name);
6742                 ndr->depth++;
6743                 if (r->in.transport_name) {
6744                         ndr_print_string(ndr, "transport_name", r->in.transport_name);
6745                 }
6746                 ndr->depth--;
6747                 ndr_print_uint32(ndr, "unknown3", r->in.unknown3);
6748                 ndr->depth--;
6749         }
6750         if (flags & NDR_OUT) {
6751                 ndr_print_struct(ndr, "out", "wkssvc_NetrWkstaTransportDel");
6752                 ndr->depth++;
6753                 ndr_print_WERROR(ndr, "result", r->out.result);
6754                 ndr->depth--;
6755         }
6756         ndr->depth--;
6757 }
6758
6759 static enum ndr_err_code ndr_push_wkssvc_NetrUseAdd(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUseAdd *r)
6760 {
6761         if (flags & NDR_IN) {
6762                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
6763                 if (r->in.server_name) {
6764                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6765                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6766                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6767                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6768                 }
6769                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
6770                 if (r->in.ctr == NULL) {
6771                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6772                 }
6773                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.ctr, r->in.level));
6774                 NDR_CHECK(ndr_push_wkssvc_NetrUseGetInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
6775                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_err));
6776                 if (r->in.parm_err) {
6777                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_err));
6778                 }
6779         }
6780         if (flags & NDR_OUT) {
6781                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_err));
6782                 if (r->out.parm_err) {
6783                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_err));
6784                 }
6785                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6786         }
6787         return NDR_ERR_SUCCESS;
6788 }
6789
6790 static enum ndr_err_code ndr_pull_wkssvc_NetrUseAdd(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUseAdd *r)
6791 {
6792         uint32_t _ptr_server_name;
6793         uint32_t _ptr_parm_err;
6794         TALLOC_CTX *_mem_save_server_name_0;
6795         TALLOC_CTX *_mem_save_ctr_0;
6796         TALLOC_CTX *_mem_save_parm_err_0;
6797         if (flags & NDR_IN) {
6798                 ZERO_STRUCT(r->out);
6799
6800                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6801                 if (_ptr_server_name) {
6802                         NDR_PULL_ALLOC(ndr, r->in.server_name);
6803                 } else {
6804                         r->in.server_name = NULL;
6805                 }
6806                 if (r->in.server_name) {
6807                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6808                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
6809                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
6810                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
6811                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
6812                                 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_name), ndr_get_array_length(ndr, &r->in.server_name));
6813                         }
6814                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
6815                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
6816                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6817                 }
6818                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
6819                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6820                         NDR_PULL_ALLOC(ndr, r->in.ctr);
6821                 }
6822                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
6823                 NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, LIBNDR_FLAG_REF_ALLOC);
6824                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.ctr, r->in.level));
6825                 NDR_CHECK(ndr_pull_wkssvc_NetrUseGetInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
6826                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
6827                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));
6828                 if (_ptr_parm_err) {
6829                         NDR_PULL_ALLOC(ndr, r->in.parm_err);
6830                 } else {
6831                         r->in.parm_err = NULL;
6832                 }
6833                 if (r->in.parm_err) {
6834                         _mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);
6835                         NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_err, 0);
6836                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_err));
6837                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);
6838                 }
6839         }
6840         if (flags & NDR_OUT) {
6841                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));
6842                 if (_ptr_parm_err) {
6843                         NDR_PULL_ALLOC(ndr, r->out.parm_err);
6844                 } else {
6845                         r->out.parm_err = NULL;
6846                 }
6847                 if (r->out.parm_err) {
6848                         _mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);
6849                         NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_err, 0);
6850                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_err));
6851                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);
6852                 }
6853                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6854         }
6855         return NDR_ERR_SUCCESS;
6856 }
6857
6858 _PUBLIC_ void ndr_print_wkssvc_NetrUseAdd(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUseAdd *r)
6859 {
6860         ndr_print_struct(ndr, name, "wkssvc_NetrUseAdd");
6861         ndr->depth++;
6862         if (flags & NDR_SET_VALUES) {
6863                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6864         }
6865         if (flags & NDR_IN) {
6866                 ndr_print_struct(ndr, "in", "wkssvc_NetrUseAdd");
6867                 ndr->depth++;
6868                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
6869                 ndr->depth++;
6870                 if (r->in.server_name) {
6871                         ndr_print_string(ndr, "server_name", r->in.server_name);
6872                 }
6873                 ndr->depth--;
6874                 ndr_print_uint32(ndr, "level", r->in.level);
6875                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
6876                 ndr->depth++;
6877                 ndr_print_set_switch_value(ndr, r->in.ctr, r->in.level);
6878                 ndr_print_wkssvc_NetrUseGetInfoCtr(ndr, "ctr", r->in.ctr);
6879                 ndr->depth--;
6880                 ndr_print_ptr(ndr, "parm_err", r->in.parm_err);
6881                 ndr->depth++;
6882                 if (r->in.parm_err) {
6883                         ndr_print_uint32(ndr, "parm_err", *r->in.parm_err);
6884                 }
6885                 ndr->depth--;
6886                 ndr->depth--;
6887         }
6888         if (flags & NDR_OUT) {
6889                 ndr_print_struct(ndr, "out", "wkssvc_NetrUseAdd");
6890                 ndr->depth++;
6891                 ndr_print_ptr(ndr, "parm_err", r->out.parm_err);
6892                 ndr->depth++;
6893                 if (r->out.parm_err) {
6894                         ndr_print_uint32(ndr, "parm_err", *r->out.parm_err);
6895                 }
6896                 ndr->depth--;
6897                 ndr_print_WERROR(ndr, "result", r->out.result);
6898                 ndr->depth--;
6899         }
6900         ndr->depth--;
6901 }
6902
6903 static enum ndr_err_code ndr_push_wkssvc_NetrUseGetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUseGetInfo *r)
6904 {
6905         if (flags & NDR_IN) {
6906                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
6907                 if (r->in.server_name) {
6908                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6909                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6910                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6911                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6912                 }
6913                 if (r->in.use_name == NULL) {
6914                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6915                 }
6916                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.use_name, CH_UTF16)));
6917                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6918                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.use_name, CH_UTF16)));
6919                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.use_name, ndr_charset_length(r->in.use_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6920                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
6921         }
6922         if (flags & NDR_OUT) {
6923                 if (r->out.ctr == NULL) {
6924                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6925                 }
6926                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, r->in.level));
6927                 NDR_CHECK(ndr_push_wkssvc_NetrUseGetInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
6928                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6929         }
6930         return NDR_ERR_SUCCESS;
6931 }
6932
6933 static enum ndr_err_code ndr_pull_wkssvc_NetrUseGetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUseGetInfo *r)
6934 {
6935         uint32_t _ptr_server_name;
6936         TALLOC_CTX *_mem_save_server_name_0;
6937         TALLOC_CTX *_mem_save_ctr_0;
6938         if (flags & NDR_IN) {
6939                 ZERO_STRUCT(r->out);
6940
6941                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6942                 if (_ptr_server_name) {
6943                         NDR_PULL_ALLOC(ndr, r->in.server_name);
6944                 } else {
6945                         r->in.server_name = NULL;
6946                 }
6947                 if (r->in.server_name) {
6948                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6949                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
6950                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
6951                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
6952                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
6953                                 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_name), ndr_get_array_length(ndr, &r->in.server_name));
6954                         }
6955                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
6956                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
6957                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6958                 }
6959                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.use_name));
6960                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.use_name));
6961                 if (ndr_get_array_length(ndr, &r->in.use_name) > ndr_get_array_size(ndr, &r->in.use_name)) {
6962                         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.use_name), ndr_get_array_length(ndr, &r->in.use_name));
6963                 }
6964                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.use_name), sizeof(uint16_t)));
6965                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.use_name, ndr_get_array_length(ndr, &r->in.use_name), sizeof(uint16_t), CH_UTF16));
6966                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
6967                 NDR_PULL_ALLOC(ndr, r->out.ctr);
6968                 ZERO_STRUCTP(r->out.ctr);
6969         }
6970         if (flags & NDR_OUT) {
6971                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6972                         NDR_PULL_ALLOC(ndr, r->out.ctr);
6973                 }
6974                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
6975                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
6976                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, r->in.level));
6977                 NDR_CHECK(ndr_pull_wkssvc_NetrUseGetInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
6978                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
6979                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6980         }
6981         return NDR_ERR_SUCCESS;
6982 }
6983
6984 _PUBLIC_ void ndr_print_wkssvc_NetrUseGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUseGetInfo *r)
6985 {
6986         ndr_print_struct(ndr, name, "wkssvc_NetrUseGetInfo");
6987         ndr->depth++;
6988         if (flags & NDR_SET_VALUES) {
6989                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6990         }
6991         if (flags & NDR_IN) {
6992                 ndr_print_struct(ndr, "in", "wkssvc_NetrUseGetInfo");
6993                 ndr->depth++;
6994                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
6995                 ndr->depth++;
6996                 if (r->in.server_name) {
6997                         ndr_print_string(ndr, "server_name", r->in.server_name);
6998                 }
6999                 ndr->depth--;
7000                 ndr_print_ptr(ndr, "use_name", r->in.use_name);
7001                 ndr->depth++;
7002                 ndr_print_string(ndr, "use_name", r->in.use_name);
7003                 ndr->depth--;
7004                 ndr_print_uint32(ndr, "level", r->in.level);
7005                 ndr->depth--;
7006         }
7007         if (flags & NDR_OUT) {
7008                 ndr_print_struct(ndr, "out", "wkssvc_NetrUseGetInfo");
7009                 ndr->depth++;
7010                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
7011                 ndr->depth++;
7012                 ndr_print_set_switch_value(ndr, r->out.ctr, r->in.level);
7013                 ndr_print_wkssvc_NetrUseGetInfoCtr(ndr, "ctr", r->out.ctr);
7014                 ndr->depth--;
7015                 ndr_print_WERROR(ndr, "result", r->out.result);
7016                 ndr->depth--;
7017         }
7018         ndr->depth--;
7019 }
7020
7021 static enum ndr_err_code ndr_push_wkssvc_NetrUseDel(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUseDel *r)
7022 {
7023         if (flags & NDR_IN) {
7024                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
7025                 if (r->in.server_name) {
7026                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7027                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7028                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7029                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7030                 }
7031                 if (r->in.use_name == NULL) {
7032                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7033                 }
7034                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.use_name, CH_UTF16)));
7035                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7036                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.use_name, CH_UTF16)));
7037                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.use_name, ndr_charset_length(r->in.use_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7038                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.force_cond));
7039         }
7040         if (flags & NDR_OUT) {
7041                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7042         }
7043         return NDR_ERR_SUCCESS;
7044 }
7045
7046 static enum ndr_err_code ndr_pull_wkssvc_NetrUseDel(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUseDel *r)
7047 {
7048         uint32_t _ptr_server_name;
7049         TALLOC_CTX *_mem_save_server_name_0;
7050         if (flags & NDR_IN) {
7051                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
7052                 if (_ptr_server_name) {
7053                         NDR_PULL_ALLOC(ndr, r->in.server_name);
7054                 } else {
7055                         r->in.server_name = NULL;
7056                 }
7057                 if (r->in.server_name) {
7058                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7059                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
7060                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
7061                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
7062                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
7063                                 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_name), ndr_get_array_length(ndr, &r->in.server_name));
7064                         }
7065                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
7066                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
7067                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
7068                 }
7069                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.use_name));
7070                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.use_name));
7071                 if (ndr_get_array_length(ndr, &r->in.use_name) > ndr_get_array_size(ndr, &r->in.use_name)) {
7072                         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.use_name), ndr_get_array_length(ndr, &r->in.use_name));
7073                 }
7074                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.use_name), sizeof(uint16_t)));
7075                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.use_name, ndr_get_array_length(ndr, &r->in.use_name), sizeof(uint16_t), CH_UTF16));
7076                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.force_cond));
7077         }
7078         if (flags & NDR_OUT) {
7079                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7080         }
7081         return NDR_ERR_SUCCESS;
7082 }
7083
7084 _PUBLIC_ void ndr_print_wkssvc_NetrUseDel(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUseDel *r)
7085 {
7086         ndr_print_struct(ndr, name, "wkssvc_NetrUseDel");
7087         ndr->depth++;
7088         if (flags & NDR_SET_VALUES) {
7089                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7090         }
7091         if (flags & NDR_IN) {
7092                 ndr_print_struct(ndr, "in", "wkssvc_NetrUseDel");
7093                 ndr->depth++;
7094                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
7095                 ndr->depth++;
7096                 if (r->in.server_name) {
7097                         ndr_print_string(ndr, "server_name", r->in.server_name);
7098                 }
7099                 ndr->depth--;
7100                 ndr_print_ptr(ndr, "use_name", r->in.use_name);
7101                 ndr->depth++;
7102                 ndr_print_string(ndr, "use_name", r->in.use_name);
7103                 ndr->depth--;
7104                 ndr_print_uint32(ndr, "force_cond", r->in.force_cond);
7105                 ndr->depth--;
7106         }
7107         if (flags & NDR_OUT) {
7108                 ndr_print_struct(ndr, "out", "wkssvc_NetrUseDel");
7109                 ndr->depth++;
7110                 ndr_print_WERROR(ndr, "result", r->out.result);
7111                 ndr->depth--;
7112         }
7113         ndr->depth--;
7114 }
7115
7116 static enum ndr_err_code ndr_push_wkssvc_NetrUseEnum(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUseEnum *r)
7117 {
7118         if (flags & NDR_IN) {
7119                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
7120                 if (r->in.server_name) {
7121                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7122                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7123                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7124                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7125                 }
7126                 if (r->in.info == NULL) {
7127                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7128                 }
7129                 NDR_CHECK(ndr_push_wkssvc_NetrUseEnumInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
7130                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.prefmaxlen));
7131                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
7132                 if (r->in.resume_handle) {
7133                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
7134                 }
7135         }
7136         if (flags & NDR_OUT) {
7137                 if (r->out.info == NULL) {
7138                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7139                 }
7140                 NDR_CHECK(ndr_push_wkssvc_NetrUseEnumInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
7141                 if (r->out.entries_read == NULL) {
7142                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7143                 }
7144                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.entries_read));
7145                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
7146                 if (r->out.resume_handle) {
7147                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
7148                 }
7149                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7150         }
7151         return NDR_ERR_SUCCESS;
7152 }
7153
7154 static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnum(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUseEnum *r)
7155 {
7156         uint32_t _ptr_server_name;
7157         uint32_t _ptr_resume_handle;
7158         TALLOC_CTX *_mem_save_server_name_0;
7159         TALLOC_CTX *_mem_save_info_0;
7160         TALLOC_CTX *_mem_save_entries_read_0;
7161         TALLOC_CTX *_mem_save_resume_handle_0;
7162         if (flags & NDR_IN) {
7163                 ZERO_STRUCT(r->out);
7164
7165                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
7166                 if (_ptr_server_name) {
7167                         NDR_PULL_ALLOC(ndr, r->in.server_name);
7168                 } else {
7169                         r->in.server_name = NULL;
7170                 }
7171                 if (r->in.server_name) {
7172                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7173                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
7174                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
7175                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
7176                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
7177                                 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_name), ndr_get_array_length(ndr, &r->in.server_name));
7178                         }
7179                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
7180                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
7181                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
7182                 }
7183                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7184                         NDR_PULL_ALLOC(ndr, r->in.info);
7185                 }
7186                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
7187                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
7188                 NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
7189                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
7190                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.prefmaxlen));
7191                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
7192                 if (_ptr_resume_handle) {
7193                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
7194                 } else {
7195                         r->in.resume_handle = NULL;
7196                 }
7197                 if (r->in.resume_handle) {
7198                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7199                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
7200                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
7201                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
7202                 }
7203                 NDR_PULL_ALLOC(ndr, r->out.info);
7204                 *r->out.info = *r->in.info;
7205                 NDR_PULL_ALLOC(ndr, r->out.entries_read);
7206                 ZERO_STRUCTP(r->out.entries_read);
7207         }
7208         if (flags & NDR_OUT) {
7209                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7210                         NDR_PULL_ALLOC(ndr, r->out.info);
7211                 }
7212                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
7213                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
7214                 NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
7215                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
7216                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7217                         NDR_PULL_ALLOC(ndr, r->out.entries_read);
7218                 }
7219                 _mem_save_entries_read_0 = NDR_PULL_GET_MEM_CTX(ndr);
7220                 NDR_PULL_SET_MEM_CTX(ndr, r->out.entries_read, LIBNDR_FLAG_REF_ALLOC);
7221                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.entries_read));
7222                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_read_0, LIBNDR_FLAG_REF_ALLOC);
7223                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
7224                 if (_ptr_resume_handle) {
7225                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
7226                 } else {
7227                         r->out.resume_handle = NULL;
7228                 }
7229                 if (r->out.resume_handle) {
7230                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7231                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
7232                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
7233                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
7234                 }
7235                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7236         }
7237         return NDR_ERR_SUCCESS;
7238 }
7239
7240 _PUBLIC_ void ndr_print_wkssvc_NetrUseEnum(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUseEnum *r)
7241 {
7242         ndr_print_struct(ndr, name, "wkssvc_NetrUseEnum");
7243         ndr->depth++;
7244         if (flags & NDR_SET_VALUES) {
7245                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7246         }
7247         if (flags & NDR_IN) {
7248                 ndr_print_struct(ndr, "in", "wkssvc_NetrUseEnum");
7249                 ndr->depth++;
7250                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
7251                 ndr->depth++;
7252                 if (r->in.server_name) {
7253                         ndr_print_string(ndr, "server_name", r->in.server_name);
7254                 }
7255                 ndr->depth--;
7256                 ndr_print_ptr(ndr, "info", r->in.info);
7257                 ndr->depth++;
7258                 ndr_print_wkssvc_NetrUseEnumInfo(ndr, "info", r->in.info);
7259                 ndr->depth--;
7260                 ndr_print_uint32(ndr, "prefmaxlen", r->in.prefmaxlen);
7261                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
7262                 ndr->depth++;
7263                 if (r->in.resume_handle) {
7264                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
7265                 }
7266                 ndr->depth--;
7267                 ndr->depth--;
7268         }
7269         if (flags & NDR_OUT) {
7270                 ndr_print_struct(ndr, "out", "wkssvc_NetrUseEnum");
7271                 ndr->depth++;
7272                 ndr_print_ptr(ndr, "info", r->out.info);
7273                 ndr->depth++;
7274                 ndr_print_wkssvc_NetrUseEnumInfo(ndr, "info", r->out.info);
7275                 ndr->depth--;
7276                 ndr_print_ptr(ndr, "entries_read", r->out.entries_read);
7277                 ndr->depth++;
7278                 ndr_print_uint32(ndr, "entries_read", *r->out.entries_read);
7279                 ndr->depth--;
7280                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
7281                 ndr->depth++;
7282                 if (r->out.resume_handle) {
7283                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
7284                 }
7285                 ndr->depth--;
7286                 ndr_print_WERROR(ndr, "result", r->out.result);
7287                 ndr->depth--;
7288         }
7289         ndr->depth--;
7290 }
7291
7292 static enum ndr_err_code ndr_push_wkssvc_NetrMessageBufferSend(struct ndr_push *ndr, int flags, const struct wkssvc_NetrMessageBufferSend *r)
7293 {
7294         if (flags & NDR_IN) {
7295                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
7296                 if (r->in.server_name) {
7297                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7298                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7299                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7300                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7301                 }
7302                 if (r->in.message_name == NULL) {
7303                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7304                 }
7305                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.message_name, CH_UTF16)));
7306                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7307                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.message_name, CH_UTF16)));
7308                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.message_name, ndr_charset_length(r->in.message_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7309                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.message_sender_name));
7310                 if (r->in.message_sender_name) {
7311                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.message_sender_name, CH_UTF16)));
7312                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7313                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.message_sender_name, CH_UTF16)));
7314                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.message_sender_name, ndr_charset_length(r->in.message_sender_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7315                 }
7316                 if (r->in.message_buffer == NULL) {
7317                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7318                 }
7319                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.message_size));
7320                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.message_buffer, r->in.message_size));
7321                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.message_size));
7322         }
7323         if (flags & NDR_OUT) {
7324                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7325         }
7326         return NDR_ERR_SUCCESS;
7327 }
7328
7329 static enum ndr_err_code ndr_pull_wkssvc_NetrMessageBufferSend(struct ndr_pull *ndr, int flags, struct wkssvc_NetrMessageBufferSend *r)
7330 {
7331         uint32_t _ptr_server_name;
7332         uint32_t _ptr_message_sender_name;
7333         TALLOC_CTX *_mem_save_server_name_0;
7334         TALLOC_CTX *_mem_save_message_sender_name_0;
7335         if (flags & NDR_IN) {
7336                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
7337                 if (_ptr_server_name) {
7338                         NDR_PULL_ALLOC(ndr, r->in.server_name);
7339                 } else {
7340                         r->in.server_name = NULL;
7341                 }
7342                 if (r->in.server_name) {
7343                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7344                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
7345                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
7346                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
7347                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
7348                                 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_name), ndr_get_array_length(ndr, &r->in.server_name));
7349                         }
7350                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
7351                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
7352                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
7353                 }
7354                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.message_name));
7355                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.message_name));
7356                 if (ndr_get_array_length(ndr, &r->in.message_name) > ndr_get_array_size(ndr, &r->in.message_name)) {
7357                         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.message_name), ndr_get_array_length(ndr, &r->in.message_name));
7358                 }
7359                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.message_name), sizeof(uint16_t)));
7360                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.message_name, ndr_get_array_length(ndr, &r->in.message_name), sizeof(uint16_t), CH_UTF16));
7361                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_message_sender_name));
7362                 if (_ptr_message_sender_name) {
7363                         NDR_PULL_ALLOC(ndr, r->in.message_sender_name);
7364                 } else {
7365                         r->in.message_sender_name = NULL;
7366                 }
7367                 if (r->in.message_sender_name) {
7368                         _mem_save_message_sender_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7369                         NDR_PULL_SET_MEM_CTX(ndr, r->in.message_sender_name, 0);
7370                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.message_sender_name));
7371                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.message_sender_name));
7372                         if (ndr_get_array_length(ndr, &r->in.message_sender_name) > ndr_get_array_size(ndr, &r->in.message_sender_name)) {
7373                                 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.message_sender_name), ndr_get_array_length(ndr, &r->in.message_sender_name));
7374                         }
7375                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.message_sender_name), sizeof(uint16_t)));
7376                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.message_sender_name, ndr_get_array_length(ndr, &r->in.message_sender_name), sizeof(uint16_t), CH_UTF16));
7377                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_message_sender_name_0, 0);
7378                 }
7379                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.message_buffer));
7380                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7381                         NDR_PULL_ALLOC_N(ndr, r->in.message_buffer, ndr_get_array_size(ndr, &r->in.message_buffer));
7382                 }
7383                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.message_buffer, ndr_get_array_size(ndr, &r->in.message_buffer)));
7384                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.message_size));
7385                 if (r->in.message_buffer) {
7386                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.message_buffer, r->in.message_size));
7387                 }
7388         }
7389         if (flags & NDR_OUT) {
7390                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7391         }
7392         return NDR_ERR_SUCCESS;
7393 }
7394
7395 _PUBLIC_ void ndr_print_wkssvc_NetrMessageBufferSend(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrMessageBufferSend *r)
7396 {
7397         ndr_print_struct(ndr, name, "wkssvc_NetrMessageBufferSend");
7398         ndr->depth++;
7399         if (flags & NDR_SET_VALUES) {
7400                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7401         }
7402         if (flags & NDR_IN) {
7403                 ndr_print_struct(ndr, "in", "wkssvc_NetrMessageBufferSend");
7404                 ndr->depth++;
7405                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
7406                 ndr->depth++;
7407                 if (r->in.server_name) {
7408                         ndr_print_string(ndr, "server_name", r->in.server_name);
7409                 }
7410                 ndr->depth--;
7411                 ndr_print_ptr(ndr, "message_name", r->in.message_name);
7412                 ndr->depth++;
7413                 ndr_print_string(ndr, "message_name", r->in.message_name);
7414                 ndr->depth--;
7415                 ndr_print_ptr(ndr, "message_sender_name", r->in.message_sender_name);
7416                 ndr->depth++;
7417                 if (r->in.message_sender_name) {
7418                         ndr_print_string(ndr, "message_sender_name", r->in.message_sender_name);
7419                 }
7420                 ndr->depth--;
7421                 ndr_print_ptr(ndr, "message_buffer", r->in.message_buffer);
7422                 ndr->depth++;
7423                 ndr_print_array_uint8(ndr, "message_buffer", r->in.message_buffer, r->in.message_size);
7424                 ndr->depth--;
7425                 ndr_print_uint32(ndr, "message_size", r->in.message_size);
7426                 ndr->depth--;
7427         }
7428         if (flags & NDR_OUT) {
7429                 ndr_print_struct(ndr, "out", "wkssvc_NetrMessageBufferSend");
7430                 ndr->depth++;
7431                 ndr_print_WERROR(ndr, "result", r->out.result);
7432                 ndr->depth--;
7433         }
7434         ndr->depth--;
7435 }
7436
7437 static enum ndr_err_code ndr_push_wkssvc_NetrWorkstationStatisticsGet(struct ndr_push *ndr, int flags, const struct wkssvc_NetrWorkstationStatisticsGet *r)
7438 {
7439         if (flags & NDR_IN) {
7440                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
7441                 if (r->in.server_name) {
7442                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7443                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7444                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7445                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7446                 }
7447                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown2));
7448                 if (r->in.unknown2) {
7449                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown2, CH_UTF16)));
7450                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7451                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown2, CH_UTF16)));
7452                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.unknown2, ndr_charset_length(r->in.unknown2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7453                 }
7454                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown3));
7455                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown4));
7456         }
7457         if (flags & NDR_OUT) {
7458                 if (r->out.info == NULL) {
7459                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7460                 }
7461                 if (*r->out.info == NULL) {
7462                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7463                 }
7464                 NDR_CHECK(ndr_push_ref_ptr(ndr));
7465                 NDR_CHECK(ndr_push_wkssvc_NetrWorkstationStatistics(ndr, NDR_SCALARS, *r->out.info));
7466                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7467         }
7468         return NDR_ERR_SUCCESS;
7469 }
7470
7471 static enum ndr_err_code ndr_pull_wkssvc_NetrWorkstationStatisticsGet(struct ndr_pull *ndr, int flags, struct wkssvc_NetrWorkstationStatisticsGet *r)
7472 {
7473         uint32_t _ptr_server_name;
7474         uint32_t _ptr_unknown2;
7475         uint32_t _ptr_info;
7476         TALLOC_CTX *_mem_save_server_name_0;
7477         TALLOC_CTX *_mem_save_unknown2_0;
7478         TALLOC_CTX *_mem_save_info_0;
7479         TALLOC_CTX *_mem_save_info_1;
7480         if (flags & NDR_IN) {
7481                 ZERO_STRUCT(r->out);
7482
7483                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
7484                 if (_ptr_server_name) {
7485                         NDR_PULL_ALLOC(ndr, r->in.server_name);
7486                 } else {
7487                         r->in.server_name = NULL;
7488                 }
7489                 if (r->in.server_name) {
7490                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7491                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
7492                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
7493                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
7494                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
7495                                 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_name), ndr_get_array_length(ndr, &r->in.server_name));
7496                         }
7497                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
7498                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
7499                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
7500                 }
7501                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown2));
7502                 if (_ptr_unknown2) {
7503                         NDR_PULL_ALLOC(ndr, r->in.unknown2);
7504                 } else {
7505                         r->in.unknown2 = NULL;
7506                 }
7507                 if (r->in.unknown2) {
7508                         _mem_save_unknown2_0 = NDR_PULL_GET_MEM_CTX(ndr);
7509                         NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown2, 0);
7510                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.unknown2));
7511                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.unknown2));
7512                         if (ndr_get_array_length(ndr, &r->in.unknown2) > ndr_get_array_size(ndr, &r->in.unknown2)) {
7513                                 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.unknown2), ndr_get_array_length(ndr, &r->in.unknown2));
7514                         }
7515                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.unknown2), sizeof(uint16_t)));
7516                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.unknown2, ndr_get_array_length(ndr, &r->in.unknown2), sizeof(uint16_t), CH_UTF16));
7517                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown2_0, 0);
7518                 }
7519                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown3));
7520                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown4));
7521                 NDR_PULL_ALLOC(ndr, r->out.info);
7522                 ZERO_STRUCTP(r->out.info);
7523         }
7524         if (flags & NDR_OUT) {
7525                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7526                         NDR_PULL_ALLOC(ndr, r->out.info);
7527                 }
7528                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
7529                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
7530                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_info));
7531                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7532                         NDR_PULL_ALLOC(ndr, *r->out.info);
7533                 }
7534                 _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
7535                 NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, LIBNDR_FLAG_REF_ALLOC);
7536                 NDR_CHECK(ndr_pull_wkssvc_NetrWorkstationStatistics(ndr, NDR_SCALARS, *r->out.info));
7537                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, LIBNDR_FLAG_REF_ALLOC);
7538                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
7539                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7540         }
7541         return NDR_ERR_SUCCESS;
7542 }
7543
7544 _PUBLIC_ void ndr_print_wkssvc_NetrWorkstationStatisticsGet(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrWorkstationStatisticsGet *r)
7545 {
7546         ndr_print_struct(ndr, name, "wkssvc_NetrWorkstationStatisticsGet");
7547         ndr->depth++;
7548         if (flags & NDR_SET_VALUES) {
7549                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7550         }
7551         if (flags & NDR_IN) {
7552                 ndr_print_struct(ndr, "in", "wkssvc_NetrWorkstationStatisticsGet");
7553                 ndr->depth++;
7554                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
7555                 ndr->depth++;
7556                 if (r->in.server_name) {
7557                         ndr_print_string(ndr, "server_name", r->in.server_name);
7558                 }
7559                 ndr->depth--;
7560                 ndr_print_ptr(ndr, "unknown2", r->in.unknown2);
7561                 ndr->depth++;
7562                 if (r->in.unknown2) {
7563                         ndr_print_string(ndr, "unknown2", r->in.unknown2);
7564                 }
7565                 ndr->depth--;
7566                 ndr_print_uint32(ndr, "unknown3", r->in.unknown3);
7567                 ndr_print_uint32(ndr, "unknown4", r->in.unknown4);
7568                 ndr->depth--;
7569         }
7570         if (flags & NDR_OUT) {
7571                 ndr_print_struct(ndr, "out", "wkssvc_NetrWorkstationStatisticsGet");
7572                 ndr->depth++;
7573                 ndr_print_ptr(ndr, "info", r->out.info);
7574                 ndr->depth++;
7575                 ndr_print_ptr(ndr, "info", *r->out.info);
7576                 ndr->depth++;
7577                 ndr_print_wkssvc_NetrWorkstationStatistics(ndr, "info", *r->out.info);
7578                 ndr->depth--;
7579                 ndr->depth--;
7580                 ndr_print_WERROR(ndr, "result", r->out.result);
7581                 ndr->depth--;
7582         }
7583         ndr->depth--;
7584 }
7585
7586 static enum ndr_err_code ndr_push_wkssvc_NetrLogonDomainNameAdd(struct ndr_push *ndr, int flags, const struct wkssvc_NetrLogonDomainNameAdd *r)
7587 {
7588         if (flags & NDR_IN) {
7589                 if (r->in.domain_name == NULL) {
7590                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7591                 }
7592                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
7593                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7594                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
7595                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.domain_name, ndr_charset_length(r->in.domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7596         }
7597         if (flags & NDR_OUT) {
7598                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7599         }
7600         return NDR_ERR_SUCCESS;
7601 }
7602
7603 static enum ndr_err_code ndr_pull_wkssvc_NetrLogonDomainNameAdd(struct ndr_pull *ndr, int flags, struct wkssvc_NetrLogonDomainNameAdd *r)
7604 {
7605         if (flags & NDR_IN) {
7606                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
7607                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
7608                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
7609                         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.domain_name), ndr_get_array_length(ndr, &r->in.domain_name));
7610                 }
7611                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
7612                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.domain_name, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t), CH_UTF16));
7613         }
7614         if (flags & NDR_OUT) {
7615                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7616         }
7617         return NDR_ERR_SUCCESS;
7618 }
7619
7620 _PUBLIC_ void ndr_print_wkssvc_NetrLogonDomainNameAdd(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrLogonDomainNameAdd *r)
7621 {
7622         ndr_print_struct(ndr, name, "wkssvc_NetrLogonDomainNameAdd");
7623         ndr->depth++;
7624         if (flags & NDR_SET_VALUES) {
7625                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7626         }
7627         if (flags & NDR_IN) {
7628                 ndr_print_struct(ndr, "in", "wkssvc_NetrLogonDomainNameAdd");
7629                 ndr->depth++;
7630                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
7631                 ndr->depth++;
7632                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
7633                 ndr->depth--;
7634                 ndr->depth--;
7635         }
7636         if (flags & NDR_OUT) {
7637                 ndr_print_struct(ndr, "out", "wkssvc_NetrLogonDomainNameAdd");
7638                 ndr->depth++;
7639                 ndr_print_WERROR(ndr, "result", r->out.result);
7640                 ndr->depth--;
7641         }
7642         ndr->depth--;
7643 }
7644
7645 static enum ndr_err_code ndr_push_wkssvc_NetrLogonDomainNameDel(struct ndr_push *ndr, int flags, const struct wkssvc_NetrLogonDomainNameDel *r)
7646 {
7647         if (flags & NDR_IN) {
7648                 if (r->in.domain_name == NULL) {
7649                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7650                 }
7651                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
7652                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7653                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
7654                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.domain_name, ndr_charset_length(r->in.domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7655         }
7656         if (flags & NDR_OUT) {
7657                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7658         }
7659         return NDR_ERR_SUCCESS;
7660 }
7661
7662 static enum ndr_err_code ndr_pull_wkssvc_NetrLogonDomainNameDel(struct ndr_pull *ndr, int flags, struct wkssvc_NetrLogonDomainNameDel *r)
7663 {
7664         if (flags & NDR_IN) {
7665                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
7666                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
7667                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
7668                         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.domain_name), ndr_get_array_length(ndr, &r->in.domain_name));
7669                 }
7670                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
7671                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.domain_name, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t), CH_UTF16));
7672         }
7673         if (flags & NDR_OUT) {
7674                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7675         }
7676         return NDR_ERR_SUCCESS;
7677 }
7678
7679 _PUBLIC_ void ndr_print_wkssvc_NetrLogonDomainNameDel(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrLogonDomainNameDel *r)
7680 {
7681         ndr_print_struct(ndr, name, "wkssvc_NetrLogonDomainNameDel");
7682         ndr->depth++;
7683         if (flags & NDR_SET_VALUES) {
7684                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7685         }
7686         if (flags & NDR_IN) {
7687                 ndr_print_struct(ndr, "in", "wkssvc_NetrLogonDomainNameDel");
7688                 ndr->depth++;
7689                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
7690                 ndr->depth++;
7691                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
7692                 ndr->depth--;
7693                 ndr->depth--;
7694         }
7695         if (flags & NDR_OUT) {
7696                 ndr_print_struct(ndr, "out", "wkssvc_NetrLogonDomainNameDel");
7697                 ndr->depth++;
7698                 ndr_print_WERROR(ndr, "result", r->out.result);
7699                 ndr->depth--;
7700         }
7701         ndr->depth--;
7702 }
7703
7704 static enum ndr_err_code ndr_push_wkssvc_NetrJoinDomain(struct ndr_push *ndr, int flags, const struct wkssvc_NetrJoinDomain *r)
7705 {
7706         if (flags & NDR_IN) {
7707                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
7708                 if (r->in.server_name) {
7709                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7710                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7711                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7712                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7713                 }
7714                 if (r->in.domain_name == NULL) {
7715                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7716                 }
7717                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
7718                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7719                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
7720                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.domain_name, ndr_charset_length(r->in.domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7721                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.account_ou));
7722                 if (r->in.account_ou) {
7723                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account_ou, CH_UTF16)));
7724                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7725                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account_ou, CH_UTF16)));
7726                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.account_ou, ndr_charset_length(r->in.account_ou, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7727                 }
7728                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
7729                 if (r->in.Account) {
7730                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
7731                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7732                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
7733                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7734                 }
7735                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
7736                 if (r->in.password) {
7737                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
7738                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7739                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
7740                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7741                 }
7742                 NDR_CHECK(ndr_push_wkssvc_joinflags(ndr, NDR_SCALARS, r->in.join_flags));
7743         }
7744         if (flags & NDR_OUT) {
7745                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7746         }
7747         return NDR_ERR_SUCCESS;
7748 }
7749
7750 static enum ndr_err_code ndr_pull_wkssvc_NetrJoinDomain(struct ndr_pull *ndr, int flags, struct wkssvc_NetrJoinDomain *r)
7751 {
7752         uint32_t _ptr_server_name;
7753         uint32_t _ptr_account_ou;
7754         uint32_t _ptr_Account;
7755         uint32_t _ptr_password;
7756         TALLOC_CTX *_mem_save_server_name_0;
7757         TALLOC_CTX *_mem_save_account_ou_0;
7758         TALLOC_CTX *_mem_save_Account_0;
7759         TALLOC_CTX *_mem_save_password_0;
7760         if (flags & NDR_IN) {
7761                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
7762                 if (_ptr_server_name) {
7763                         NDR_PULL_ALLOC(ndr, r->in.server_name);
7764                 } else {
7765                         r->in.server_name = NULL;
7766                 }
7767                 if (r->in.server_name) {
7768                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7769                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
7770                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
7771                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
7772                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
7773                                 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_name), ndr_get_array_length(ndr, &r->in.server_name));
7774                         }
7775                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
7776                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
7777                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
7778                 }
7779                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
7780                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
7781                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
7782                         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.domain_name), ndr_get_array_length(ndr, &r->in.domain_name));
7783                 }
7784                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
7785                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.domain_name, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t), CH_UTF16));
7786                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account_ou));
7787                 if (_ptr_account_ou) {
7788                         NDR_PULL_ALLOC(ndr, r->in.account_ou);
7789                 } else {
7790                         r->in.account_ou = NULL;
7791                 }
7792                 if (r->in.account_ou) {
7793                         _mem_save_account_ou_0 = NDR_PULL_GET_MEM_CTX(ndr);
7794                         NDR_PULL_SET_MEM_CTX(ndr, r->in.account_ou, 0);
7795                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.account_ou));
7796                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.account_ou));
7797                         if (ndr_get_array_length(ndr, &r->in.account_ou) > ndr_get_array_size(ndr, &r->in.account_ou)) {
7798                                 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.account_ou), ndr_get_array_length(ndr, &r->in.account_ou));
7799                         }
7800                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.account_ou), sizeof(uint16_t)));
7801                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.account_ou, ndr_get_array_length(ndr, &r->in.account_ou), sizeof(uint16_t), CH_UTF16));
7802                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_ou_0, 0);
7803                 }
7804                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
7805                 if (_ptr_Account) {
7806                         NDR_PULL_ALLOC(ndr, r->in.Account);
7807                 } else {
7808                         r->in.Account = NULL;
7809                 }
7810                 if (r->in.Account) {
7811                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
7812                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
7813                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
7814                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
7815                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
7816                                 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.Account), ndr_get_array_length(ndr, &r->in.Account));
7817                         }
7818                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
7819                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
7820                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
7821                 }
7822                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
7823                 if (_ptr_password) {
7824                         NDR_PULL_ALLOC(ndr, r->in.password);
7825                 } else {
7826                         r->in.password = NULL;
7827                 }
7828                 if (r->in.password) {
7829                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
7830                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
7831                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.password));
7832                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.password));
7833                         if (ndr_get_array_length(ndr, &r->in.password) > ndr_get_array_size(ndr, &r->in.password)) {
7834                                 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.password), ndr_get_array_length(ndr, &r->in.password));
7835                         }
7836                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t)));
7837                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.password, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t), CH_UTF16));
7838                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
7839                 }
7840                 NDR_CHECK(ndr_pull_wkssvc_joinflags(ndr, NDR_SCALARS, &r->in.join_flags));
7841         }
7842         if (flags & NDR_OUT) {
7843                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7844         }
7845         return NDR_ERR_SUCCESS;
7846 }
7847
7848 _PUBLIC_ void ndr_print_wkssvc_NetrJoinDomain(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrJoinDomain *r)
7849 {
7850         ndr_print_struct(ndr, name, "wkssvc_NetrJoinDomain");
7851         ndr->depth++;
7852         if (flags & NDR_SET_VALUES) {
7853                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7854         }
7855         if (flags & NDR_IN) {
7856                 ndr_print_struct(ndr, "in", "wkssvc_NetrJoinDomain");
7857                 ndr->depth++;
7858                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
7859                 ndr->depth++;
7860                 if (r->in.server_name) {
7861                         ndr_print_string(ndr, "server_name", r->in.server_name);
7862                 }
7863                 ndr->depth--;
7864                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
7865                 ndr->depth++;
7866                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
7867                 ndr->depth--;
7868                 ndr_print_ptr(ndr, "account_ou", r->in.account_ou);
7869                 ndr->depth++;
7870                 if (r->in.account_ou) {
7871                         ndr_print_string(ndr, "account_ou", r->in.account_ou);
7872                 }
7873                 ndr->depth--;
7874                 ndr_print_ptr(ndr, "Account", r->in.Account);
7875                 ndr->depth++;
7876                 if (r->in.Account) {
7877                         ndr_print_string(ndr, "Account", r->in.Account);
7878                 }
7879                 ndr->depth--;
7880                 ndr_print_ptr(ndr, "password", r->in.password);
7881                 ndr->depth++;
7882                 if (r->in.password) {
7883                         ndr_print_string(ndr, "password", r->in.password);
7884                 }
7885                 ndr->depth--;
7886                 ndr_print_wkssvc_joinflags(ndr, "join_flags", r->in.join_flags);
7887                 ndr->depth--;
7888         }
7889         if (flags & NDR_OUT) {
7890                 ndr_print_struct(ndr, "out", "wkssvc_NetrJoinDomain");
7891                 ndr->depth++;
7892                 ndr_print_WERROR(ndr, "result", r->out.result);
7893                 ndr->depth--;
7894         }
7895         ndr->depth--;
7896 }
7897
7898 static enum ndr_err_code ndr_push_wkssvc_NetrUnjoinDomain(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUnjoinDomain *r)
7899 {
7900         if (flags & NDR_IN) {
7901                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
7902                 if (r->in.server_name) {
7903                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7904                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7905                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7906                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7907                 }
7908                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
7909                 if (r->in.Account) {
7910                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
7911                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7912                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
7913                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7914                 }
7915                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
7916                 if (r->in.password) {
7917                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
7918                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7919                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
7920                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7921                 }
7922                 NDR_CHECK(ndr_push_wkssvc_joinflags(ndr, NDR_SCALARS, r->in.unjoin_flags));
7923         }
7924         if (flags & NDR_OUT) {
7925                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7926         }
7927         return NDR_ERR_SUCCESS;
7928 }
7929
7930 static enum ndr_err_code ndr_pull_wkssvc_NetrUnjoinDomain(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUnjoinDomain *r)
7931 {
7932         uint32_t _ptr_server_name;
7933         uint32_t _ptr_Account;
7934         uint32_t _ptr_password;
7935         TALLOC_CTX *_mem_save_server_name_0;
7936         TALLOC_CTX *_mem_save_Account_0;
7937         TALLOC_CTX *_mem_save_password_0;
7938         if (flags & NDR_IN) {
7939                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
7940                 if (_ptr_server_name) {
7941                         NDR_PULL_ALLOC(ndr, r->in.server_name);
7942                 } else {
7943                         r->in.server_name = NULL;
7944                 }
7945                 if (r->in.server_name) {
7946                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7947                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
7948                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
7949                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
7950                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
7951                                 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_name), ndr_get_array_length(ndr, &r->in.server_name));
7952                         }
7953                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
7954                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
7955                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
7956                 }
7957                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
7958                 if (_ptr_Account) {
7959                         NDR_PULL_ALLOC(ndr, r->in.Account);
7960                 } else {
7961                         r->in.Account = NULL;
7962                 }
7963                 if (r->in.Account) {
7964                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
7965                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
7966                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
7967                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
7968                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
7969                                 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.Account), ndr_get_array_length(ndr, &r->in.Account));
7970                         }
7971                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
7972                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
7973                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
7974                 }
7975                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
7976                 if (_ptr_password) {
7977                         NDR_PULL_ALLOC(ndr, r->in.password);
7978                 } else {
7979                         r->in.password = NULL;
7980                 }
7981                 if (r->in.password) {
7982                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
7983                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
7984                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.password));
7985                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.password));
7986                         if (ndr_get_array_length(ndr, &r->in.password) > ndr_get_array_size(ndr, &r->in.password)) {
7987                                 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.password), ndr_get_array_length(ndr, &r->in.password));
7988                         }
7989                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t)));
7990                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.password, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t), CH_UTF16));
7991                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
7992                 }
7993                 NDR_CHECK(ndr_pull_wkssvc_joinflags(ndr, NDR_SCALARS, &r->in.unjoin_flags));
7994         }
7995         if (flags & NDR_OUT) {
7996                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7997         }
7998         return NDR_ERR_SUCCESS;
7999 }
8000
8001 _PUBLIC_ void ndr_print_wkssvc_NetrUnjoinDomain(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUnjoinDomain *r)
8002 {
8003         ndr_print_struct(ndr, name, "wkssvc_NetrUnjoinDomain");
8004         ndr->depth++;
8005         if (flags & NDR_SET_VALUES) {
8006                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8007         }
8008         if (flags & NDR_IN) {
8009                 ndr_print_struct(ndr, "in", "wkssvc_NetrUnjoinDomain");
8010                 ndr->depth++;
8011                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
8012                 ndr->depth++;
8013                 if (r->in.server_name) {
8014                         ndr_print_string(ndr, "server_name", r->in.server_name);
8015                 }
8016                 ndr->depth--;
8017                 ndr_print_ptr(ndr, "Account", r->in.Account);
8018                 ndr->depth++;
8019                 if (r->in.Account) {
8020                         ndr_print_string(ndr, "Account", r->in.Account);
8021                 }
8022                 ndr->depth--;
8023                 ndr_print_ptr(ndr, "password", r->in.password);
8024                 ndr->depth++;
8025                 if (r->in.password) {
8026                         ndr_print_string(ndr, "password", r->in.password);
8027                 }
8028                 ndr->depth--;
8029                 ndr_print_wkssvc_joinflags(ndr, "unjoin_flags", r->in.unjoin_flags);
8030                 ndr->depth--;
8031         }
8032         if (flags & NDR_OUT) {
8033                 ndr_print_struct(ndr, "out", "wkssvc_NetrUnjoinDomain");
8034                 ndr->depth++;
8035                 ndr_print_WERROR(ndr, "result", r->out.result);
8036                 ndr->depth--;
8037         }
8038         ndr->depth--;
8039 }
8040
8041 static enum ndr_err_code ndr_push_wkssvc_NetrRenameMachineInDomain(struct ndr_push *ndr, int flags, const struct wkssvc_NetrRenameMachineInDomain *r)
8042 {
8043         if (flags & NDR_IN) {
8044                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
8045                 if (r->in.server_name) {
8046                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8047                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8048                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8049                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8050                 }
8051                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.NewMachineName));
8052                 if (r->in.NewMachineName) {
8053                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewMachineName, CH_UTF16)));
8054                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8055                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewMachineName, CH_UTF16)));
8056                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.NewMachineName, ndr_charset_length(r->in.NewMachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8057                 }
8058                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
8059                 if (r->in.Account) {
8060                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
8061                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8062                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
8063                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8064                 }
8065                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
8066                 if (r->in.password) {
8067                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
8068                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8069                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
8070                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8071                 }
8072                 NDR_CHECK(ndr_push_wkssvc_renameflags(ndr, NDR_SCALARS, r->in.RenameOptions));
8073         }
8074         if (flags & NDR_OUT) {
8075                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
8076         }
8077         return NDR_ERR_SUCCESS;
8078 }
8079
8080 static enum ndr_err_code ndr_pull_wkssvc_NetrRenameMachineInDomain(struct ndr_pull *ndr, int flags, struct wkssvc_NetrRenameMachineInDomain *r)
8081 {
8082         uint32_t _ptr_server_name;
8083         uint32_t _ptr_NewMachineName;
8084         uint32_t _ptr_Account;
8085         uint32_t _ptr_password;
8086         TALLOC_CTX *_mem_save_server_name_0;
8087         TALLOC_CTX *_mem_save_NewMachineName_0;
8088         TALLOC_CTX *_mem_save_Account_0;
8089         TALLOC_CTX *_mem_save_password_0;
8090         if (flags & NDR_IN) {
8091                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
8092                 if (_ptr_server_name) {
8093                         NDR_PULL_ALLOC(ndr, r->in.server_name);
8094                 } else {
8095                         r->in.server_name = NULL;
8096                 }
8097                 if (r->in.server_name) {
8098                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8099                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
8100                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
8101                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
8102                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
8103                                 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_name), ndr_get_array_length(ndr, &r->in.server_name));
8104                         }
8105                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
8106                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
8107                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
8108                 }
8109                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_NewMachineName));
8110                 if (_ptr_NewMachineName) {
8111                         NDR_PULL_ALLOC(ndr, r->in.NewMachineName);
8112                 } else {
8113                         r->in.NewMachineName = NULL;
8114                 }
8115                 if (r->in.NewMachineName) {
8116                         _mem_save_NewMachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);
8117                         NDR_PULL_SET_MEM_CTX(ndr, r->in.NewMachineName, 0);
8118                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.NewMachineName));
8119                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.NewMachineName));
8120                         if (ndr_get_array_length(ndr, &r->in.NewMachineName) > ndr_get_array_size(ndr, &r->in.NewMachineName)) {
8121                                 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.NewMachineName), ndr_get_array_length(ndr, &r->in.NewMachineName));
8122                         }
8123                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.NewMachineName), sizeof(uint16_t)));
8124                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.NewMachineName, ndr_get_array_length(ndr, &r->in.NewMachineName), sizeof(uint16_t), CH_UTF16));
8125                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_NewMachineName_0, 0);
8126                 }
8127                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
8128                 if (_ptr_Account) {
8129                         NDR_PULL_ALLOC(ndr, r->in.Account);
8130                 } else {
8131                         r->in.Account = NULL;
8132                 }
8133                 if (r->in.Account) {
8134                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
8135                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
8136                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
8137                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
8138                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
8139                                 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.Account), ndr_get_array_length(ndr, &r->in.Account));
8140                         }
8141                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
8142                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
8143                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
8144                 }
8145                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
8146                 if (_ptr_password) {
8147                         NDR_PULL_ALLOC(ndr, r->in.password);
8148                 } else {
8149                         r->in.password = NULL;
8150                 }
8151                 if (r->in.password) {
8152                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
8153                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
8154                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.password));
8155                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.password));
8156                         if (ndr_get_array_length(ndr, &r->in.password) > ndr_get_array_size(ndr, &r->in.password)) {
8157                                 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.password), ndr_get_array_length(ndr, &r->in.password));
8158                         }
8159                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t)));
8160                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.password, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t), CH_UTF16));
8161                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
8162                 }
8163                 NDR_CHECK(ndr_pull_wkssvc_renameflags(ndr, NDR_SCALARS, &r->in.RenameOptions));
8164         }
8165         if (flags & NDR_OUT) {
8166                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
8167         }
8168         return NDR_ERR_SUCCESS;
8169 }
8170
8171 _PUBLIC_ void ndr_print_wkssvc_NetrRenameMachineInDomain(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrRenameMachineInDomain *r)
8172 {
8173         ndr_print_struct(ndr, name, "wkssvc_NetrRenameMachineInDomain");
8174         ndr->depth++;
8175         if (flags & NDR_SET_VALUES) {
8176                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8177         }
8178         if (flags & NDR_IN) {
8179                 ndr_print_struct(ndr, "in", "wkssvc_NetrRenameMachineInDomain");
8180                 ndr->depth++;
8181                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
8182                 ndr->depth++;
8183                 if (r->in.server_name) {
8184                         ndr_print_string(ndr, "server_name", r->in.server_name);
8185                 }
8186                 ndr->depth--;
8187                 ndr_print_ptr(ndr, "NewMachineName", r->in.NewMachineName);
8188                 ndr->depth++;
8189                 if (r->in.NewMachineName) {
8190                         ndr_print_string(ndr, "NewMachineName", r->in.NewMachineName);
8191                 }
8192                 ndr->depth--;
8193                 ndr_print_ptr(ndr, "Account", r->in.Account);
8194                 ndr->depth++;
8195                 if (r->in.Account) {
8196                         ndr_print_string(ndr, "Account", r->in.Account);
8197                 }
8198                 ndr->depth--;
8199                 ndr_print_ptr(ndr, "password", r->in.password);
8200                 ndr->depth++;
8201                 if (r->in.password) {
8202                         ndr_print_string(ndr, "password", r->in.password);
8203                 }
8204                 ndr->depth--;
8205                 ndr_print_wkssvc_renameflags(ndr, "RenameOptions", r->in.RenameOptions);
8206                 ndr->depth--;
8207         }
8208         if (flags & NDR_OUT) {
8209                 ndr_print_struct(ndr, "out", "wkssvc_NetrRenameMachineInDomain");
8210                 ndr->depth++;
8211                 ndr_print_WERROR(ndr, "result", r->out.result);
8212                 ndr->depth--;
8213         }
8214         ndr->depth--;
8215 }
8216
8217 static enum ndr_err_code ndr_push_wkssvc_NetrValidateName(struct ndr_push *ndr, int flags, const struct wkssvc_NetrValidateName *r)
8218 {
8219         if (flags & NDR_IN) {
8220                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
8221                 if (r->in.server_name) {
8222                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8223                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8224                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8225                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8226                 }
8227                 if (r->in.name == NULL) {
8228                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8229                 }
8230                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF16)));
8231                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8232                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF16)));
8233                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.name, ndr_charset_length(r->in.name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8234                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
8235                 if (r->in.Account) {
8236                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
8237                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8238                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
8239                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8240                 }
8241                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Password));
8242                 if (r->in.Password) {
8243                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Password, CH_UTF16)));
8244                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8245                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Password, CH_UTF16)));
8246                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Password, ndr_charset_length(r->in.Password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8247                 }
8248                 NDR_CHECK(ndr_push_wkssvc_NetValidateNameType(ndr, NDR_SCALARS, r->in.name_type));
8249         }
8250         if (flags & NDR_OUT) {
8251                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
8252         }
8253         return NDR_ERR_SUCCESS;
8254 }
8255
8256 static enum ndr_err_code ndr_pull_wkssvc_NetrValidateName(struct ndr_pull *ndr, int flags, struct wkssvc_NetrValidateName *r)
8257 {
8258         uint32_t _ptr_server_name;
8259         uint32_t _ptr_Account;
8260         uint32_t _ptr_Password;
8261         TALLOC_CTX *_mem_save_server_name_0;
8262         TALLOC_CTX *_mem_save_Account_0;
8263         TALLOC_CTX *_mem_save_Password_0;
8264         if (flags & NDR_IN) {
8265                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
8266                 if (_ptr_server_name) {
8267                         NDR_PULL_ALLOC(ndr, r->in.server_name);
8268                 } else {
8269                         r->in.server_name = NULL;
8270                 }
8271                 if (r->in.server_name) {
8272                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8273                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
8274                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
8275                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
8276                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
8277                                 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_name), ndr_get_array_length(ndr, &r->in.server_name));
8278                         }
8279                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
8280                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
8281                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
8282                 }
8283                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.name));
8284                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.name));
8285                 if (ndr_get_array_length(ndr, &r->in.name) > ndr_get_array_size(ndr, &r->in.name)) {
8286                         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.name), ndr_get_array_length(ndr, &r->in.name));
8287                 }
8288                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.name), sizeof(uint16_t)));
8289                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.name, ndr_get_array_length(ndr, &r->in.name), sizeof(uint16_t), CH_UTF16));
8290                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
8291                 if (_ptr_Account) {
8292                         NDR_PULL_ALLOC(ndr, r->in.Account);
8293                 } else {
8294                         r->in.Account = NULL;
8295                 }
8296                 if (r->in.Account) {
8297                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
8298                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
8299                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
8300                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
8301                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
8302                                 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.Account), ndr_get_array_length(ndr, &r->in.Account));
8303                         }
8304                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
8305                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
8306                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
8307                 }
8308                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Password));
8309                 if (_ptr_Password) {
8310                         NDR_PULL_ALLOC(ndr, r->in.Password);
8311                 } else {
8312                         r->in.Password = NULL;
8313                 }
8314                 if (r->in.Password) {
8315                         _mem_save_Password_0 = NDR_PULL_GET_MEM_CTX(ndr);
8316                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Password, 0);
8317                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Password));
8318                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Password));
8319                         if (ndr_get_array_length(ndr, &r->in.Password) > ndr_get_array_size(ndr, &r->in.Password)) {
8320                                 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.Password), ndr_get_array_length(ndr, &r->in.Password));
8321                         }
8322                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Password), sizeof(uint16_t)));
8323                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Password, ndr_get_array_length(ndr, &r->in.Password), sizeof(uint16_t), CH_UTF16));
8324                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Password_0, 0);
8325                 }
8326                 NDR_CHECK(ndr_pull_wkssvc_NetValidateNameType(ndr, NDR_SCALARS, &r->in.name_type));
8327         }
8328         if (flags & NDR_OUT) {
8329                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
8330         }
8331         return NDR_ERR_SUCCESS;
8332 }
8333
8334 _PUBLIC_ void ndr_print_wkssvc_NetrValidateName(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrValidateName *r)
8335 {
8336         ndr_print_struct(ndr, name, "wkssvc_NetrValidateName");
8337         ndr->depth++;
8338         if (flags & NDR_SET_VALUES) {
8339                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8340         }
8341         if (flags & NDR_IN) {
8342                 ndr_print_struct(ndr, "in", "wkssvc_NetrValidateName");
8343                 ndr->depth++;
8344                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
8345                 ndr->depth++;
8346                 if (r->in.server_name) {
8347                         ndr_print_string(ndr, "server_name", r->in.server_name);
8348                 }
8349                 ndr->depth--;
8350                 ndr_print_ptr(ndr, "name", r->in.name);
8351                 ndr->depth++;
8352                 ndr_print_string(ndr, "name", r->in.name);
8353                 ndr->depth--;
8354                 ndr_print_ptr(ndr, "Account", r->in.Account);
8355                 ndr->depth++;
8356                 if (r->in.Account) {
8357                         ndr_print_string(ndr, "Account", r->in.Account);
8358                 }
8359                 ndr->depth--;
8360                 ndr_print_ptr(ndr, "Password", r->in.Password);
8361                 ndr->depth++;
8362                 if (r->in.Password) {
8363                         ndr_print_string(ndr, "Password", r->in.Password);
8364                 }
8365                 ndr->depth--;
8366                 ndr_print_wkssvc_NetValidateNameType(ndr, "name_type", r->in.name_type);
8367                 ndr->depth--;
8368         }
8369         if (flags & NDR_OUT) {
8370                 ndr_print_struct(ndr, "out", "wkssvc_NetrValidateName");
8371                 ndr->depth++;
8372                 ndr_print_WERROR(ndr, "result", r->out.result);
8373                 ndr->depth--;
8374         }
8375         ndr->depth--;
8376 }
8377
8378 static enum ndr_err_code ndr_push_wkssvc_NetrGetJoinInformation(struct ndr_push *ndr, int flags, const struct wkssvc_NetrGetJoinInformation *r)
8379 {
8380         if (flags & NDR_IN) {
8381                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
8382                 if (r->in.server_name) {
8383                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8384                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8385                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8386                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8387                 }
8388                 if (r->in.name_buffer == NULL) {
8389                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8390                 }
8391                 if (*r->in.name_buffer == NULL) {
8392                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8393                 }
8394                 NDR_CHECK(ndr_push_ref_ptr(ndr));
8395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->in.name_buffer, CH_UTF16)));
8396                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8397                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->in.name_buffer, CH_UTF16)));
8398                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->in.name_buffer, ndr_charset_length(*r->in.name_buffer, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8399         }
8400         if (flags & NDR_OUT) {
8401                 if (r->out.name_buffer == NULL) {
8402                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8403                 }
8404                 if (*r->out.name_buffer == NULL) {
8405                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8406                 }
8407                 NDR_CHECK(ndr_push_ref_ptr(ndr));
8408                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.name_buffer, CH_UTF16)));
8409                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8410                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.name_buffer, CH_UTF16)));
8411                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.name_buffer, ndr_charset_length(*r->out.name_buffer, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8412                 if (r->out.name_type == NULL) {
8413                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8414                 }
8415                 NDR_CHECK(ndr_push_wkssvc_NetJoinStatus(ndr, NDR_SCALARS, *r->out.name_type));
8416                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
8417         }
8418         return NDR_ERR_SUCCESS;
8419 }
8420
8421 static enum ndr_err_code ndr_pull_wkssvc_NetrGetJoinInformation(struct ndr_pull *ndr, int flags, struct wkssvc_NetrGetJoinInformation *r)
8422 {
8423         uint32_t _ptr_server_name;
8424         uint32_t _ptr_name_buffer;
8425         TALLOC_CTX *_mem_save_server_name_0;
8426         TALLOC_CTX *_mem_save_name_buffer_0;
8427         TALLOC_CTX *_mem_save_name_type_0;
8428         if (flags & NDR_IN) {
8429                 ZERO_STRUCT(r->out);
8430
8431                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
8432                 if (_ptr_server_name) {
8433                         NDR_PULL_ALLOC(ndr, r->in.server_name);
8434                 } else {
8435                         r->in.server_name = NULL;
8436                 }
8437                 if (r->in.server_name) {
8438                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8439                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
8440                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
8441                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
8442                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
8443                                 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_name), ndr_get_array_length(ndr, &r->in.server_name));
8444                         }
8445                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
8446                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
8447                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
8448                 }
8449                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8450                         NDR_PULL_ALLOC(ndr, r->in.name_buffer);
8451                 }
8452                 _mem_save_name_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
8453                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name_buffer, LIBNDR_FLAG_REF_ALLOC);
8454                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_name_buffer));
8455                 NDR_CHECK(ndr_pull_array_size(ndr, r->in.name_buffer));
8456                 NDR_CHECK(ndr_pull_array_length(ndr, r->in.name_buffer));
8457                 if (ndr_get_array_length(ndr, r->in.name_buffer) > ndr_get_array_size(ndr, r->in.name_buffer)) {
8458                         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.name_buffer), ndr_get_array_length(ndr, r->in.name_buffer));
8459                 }
8460                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->in.name_buffer), sizeof(uint16_t)));
8461                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->in.name_buffer, ndr_get_array_length(ndr, r->in.name_buffer), sizeof(uint16_t), CH_UTF16));
8462                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_buffer_0, LIBNDR_FLAG_REF_ALLOC);
8463                 NDR_PULL_ALLOC(ndr, r->out.name_buffer);
8464                 *r->out.name_buffer = *r->in.name_buffer;
8465                 NDR_PULL_ALLOC(ndr, r->out.name_type);
8466                 ZERO_STRUCTP(r->out.name_type);
8467         }
8468         if (flags & NDR_OUT) {
8469                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8470                         NDR_PULL_ALLOC(ndr, r->out.name_buffer);
8471                 }
8472                 _mem_save_name_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
8473                 NDR_PULL_SET_MEM_CTX(ndr, r->out.name_buffer, LIBNDR_FLAG_REF_ALLOC);
8474                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_name_buffer));
8475                 NDR_CHECK(ndr_pull_array_size(ndr, r->out.name_buffer));
8476                 NDR_CHECK(ndr_pull_array_length(ndr, r->out.name_buffer));
8477                 if (ndr_get_array_length(ndr, r->out.name_buffer) > ndr_get_array_size(ndr, r->out.name_buffer)) {
8478                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, r->out.name_buffer), ndr_get_array_length(ndr, r->out.name_buffer));
8479                 }
8480                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->out.name_buffer), sizeof(uint16_t)));
8481                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.name_buffer, ndr_get_array_length(ndr, r->out.name_buffer), sizeof(uint16_t), CH_UTF16));
8482                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_buffer_0, LIBNDR_FLAG_REF_ALLOC);
8483                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8484                         NDR_PULL_ALLOC(ndr, r->out.name_type);
8485                 }
8486                 _mem_save_name_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
8487                 NDR_PULL_SET_MEM_CTX(ndr, r->out.name_type, LIBNDR_FLAG_REF_ALLOC);
8488                 NDR_CHECK(ndr_pull_wkssvc_NetJoinStatus(ndr, NDR_SCALARS, r->out.name_type));
8489                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_type_0, LIBNDR_FLAG_REF_ALLOC);
8490                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
8491         }
8492         return NDR_ERR_SUCCESS;
8493 }
8494
8495 _PUBLIC_ void ndr_print_wkssvc_NetrGetJoinInformation(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrGetJoinInformation *r)
8496 {
8497         ndr_print_struct(ndr, name, "wkssvc_NetrGetJoinInformation");
8498         ndr->depth++;
8499         if (flags & NDR_SET_VALUES) {
8500                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8501         }
8502         if (flags & NDR_IN) {
8503                 ndr_print_struct(ndr, "in", "wkssvc_NetrGetJoinInformation");
8504                 ndr->depth++;
8505                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
8506                 ndr->depth++;
8507                 if (r->in.server_name) {
8508                         ndr_print_string(ndr, "server_name", r->in.server_name);
8509                 }
8510                 ndr->depth--;
8511                 ndr_print_ptr(ndr, "name_buffer", r->in.name_buffer);
8512                 ndr->depth++;
8513                 ndr_print_ptr(ndr, "name_buffer", *r->in.name_buffer);
8514                 ndr->depth++;
8515                 ndr_print_string(ndr, "name_buffer", *r->in.name_buffer);
8516                 ndr->depth--;
8517                 ndr->depth--;
8518                 ndr->depth--;
8519         }
8520         if (flags & NDR_OUT) {
8521                 ndr_print_struct(ndr, "out", "wkssvc_NetrGetJoinInformation");
8522                 ndr->depth++;
8523                 ndr_print_ptr(ndr, "name_buffer", r->out.name_buffer);
8524                 ndr->depth++;
8525                 ndr_print_ptr(ndr, "name_buffer", *r->out.name_buffer);
8526                 ndr->depth++;
8527                 ndr_print_string(ndr, "name_buffer", *r->out.name_buffer);
8528                 ndr->depth--;
8529                 ndr->depth--;
8530                 ndr_print_ptr(ndr, "name_type", r->out.name_type);
8531                 ndr->depth++;
8532                 ndr_print_wkssvc_NetJoinStatus(ndr, "name_type", *r->out.name_type);
8533                 ndr->depth--;
8534                 ndr_print_WERROR(ndr, "result", r->out.result);
8535                 ndr->depth--;
8536         }
8537         ndr->depth--;
8538 }
8539
8540 static enum ndr_err_code ndr_push_wkssvc_NetrGetJoinableOus(struct ndr_push *ndr, int flags, const struct wkssvc_NetrGetJoinableOus *r)
8541 {
8542         uint32_t cntr_ous_1;
8543         if (flags & NDR_IN) {
8544                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
8545                 if (r->in.server_name) {
8546                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8547                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8548                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8549                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8550                 }
8551                 if (r->in.domain_name == NULL) {
8552                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8553                 }
8554                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
8555                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8556                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
8557                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.domain_name, ndr_charset_length(r->in.domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8558                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
8559                 if (r->in.Account) {
8560                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
8561                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8562                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
8563                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8564                 }
8565                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown));
8566                 if (r->in.unknown) {
8567                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));
8568                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8569                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));
8570                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.unknown, ndr_charset_length(r->in.unknown, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8571                 }
8572                 if (r->in.num_ous == NULL) {
8573                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8574                 }
8575                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.num_ous));
8576         }
8577         if (flags & NDR_OUT) {
8578                 if (r->out.num_ous == NULL) {
8579                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8580                 }
8581                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_ous));
8582                 if (r->out.ous == NULL) {
8583                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8584                 }
8585                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_ous));
8586                 for (cntr_ous_1 = 0; cntr_ous_1 < *r->out.num_ous; cntr_ous_1++) {
8587                         if (r->out.ous[cntr_ous_1] == NULL) {
8588                                 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8589                         }
8590                         NDR_CHECK(ndr_push_ref_ptr(ndr));
8591                 }
8592                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
8593         }
8594         return NDR_ERR_SUCCESS;
8595 }
8596
8597 static enum ndr_err_code ndr_pull_wkssvc_NetrGetJoinableOus(struct ndr_pull *ndr, int flags, struct wkssvc_NetrGetJoinableOus *r)
8598 {
8599         uint32_t _ptr_server_name;
8600         uint32_t _ptr_Account;
8601         uint32_t _ptr_unknown;
8602         uint32_t _ptr_ous;
8603         uint32_t cntr_ous_1;
8604         TALLOC_CTX *_mem_save_server_name_0;
8605         TALLOC_CTX *_mem_save_Account_0;
8606         TALLOC_CTX *_mem_save_unknown_0;
8607         TALLOC_CTX *_mem_save_num_ous_0;
8608         TALLOC_CTX *_mem_save_ous_1;
8609         TALLOC_CTX *_mem_save_ous_2;
8610         if (flags & NDR_IN) {
8611                 ZERO_STRUCT(r->out);
8612
8613                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
8614                 if (_ptr_server_name) {
8615                         NDR_PULL_ALLOC(ndr, r->in.server_name);
8616                 } else {
8617                         r->in.server_name = NULL;
8618                 }
8619                 if (r->in.server_name) {
8620                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8621                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
8622                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
8623                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
8624                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
8625                                 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_name), ndr_get_array_length(ndr, &r->in.server_name));
8626                         }
8627                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
8628                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
8629                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
8630                 }
8631                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
8632                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
8633                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
8634                         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.domain_name), ndr_get_array_length(ndr, &r->in.domain_name));
8635                 }
8636                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
8637                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.domain_name, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t), CH_UTF16));
8638                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
8639                 if (_ptr_Account) {
8640                         NDR_PULL_ALLOC(ndr, r->in.Account);
8641                 } else {
8642                         r->in.Account = NULL;
8643                 }
8644                 if (r->in.Account) {
8645                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
8646                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
8647                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
8648                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
8649                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
8650                                 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.Account), ndr_get_array_length(ndr, &r->in.Account));
8651                         }
8652                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
8653                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
8654                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
8655                 }
8656                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown));
8657                 if (_ptr_unknown) {
8658                         NDR_PULL_ALLOC(ndr, r->in.unknown);
8659                 } else {
8660                         r->in.unknown = NULL;
8661                 }
8662                 if (r->in.unknown) {
8663                         _mem_save_unknown_0 = NDR_PULL_GET_MEM_CTX(ndr);
8664                         NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown, 0);
8665                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.unknown));
8666                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.unknown));
8667                         if (ndr_get_array_length(ndr, &r->in.unknown) > ndr_get_array_size(ndr, &r->in.unknown)) {
8668                                 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.unknown), ndr_get_array_length(ndr, &r->in.unknown));
8669                         }
8670                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t)));
8671                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.unknown, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t), CH_UTF16));
8672                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown_0, 0);
8673                 }
8674                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8675                         NDR_PULL_ALLOC(ndr, r->in.num_ous);
8676                 }
8677                 _mem_save_num_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);
8678                 NDR_PULL_SET_MEM_CTX(ndr, r->in.num_ous, LIBNDR_FLAG_REF_ALLOC);
8679                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.num_ous));
8680                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_ous_0, LIBNDR_FLAG_REF_ALLOC);
8681                 NDR_PULL_ALLOC(ndr, r->out.num_ous);
8682                 *r->out.num_ous = *r->in.num_ous;
8683                 NDR_PULL_ALLOC_N(ndr, r->out.ous, *r->in.num_ous);
8684                 memset(r->out.ous, 0, *r->in.num_ous * sizeof(*r->out.ous));
8685         }
8686         if (flags & NDR_OUT) {
8687                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8688                         NDR_PULL_ALLOC(ndr, r->out.num_ous);
8689                 }
8690                 _mem_save_num_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);
8691                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_ous, LIBNDR_FLAG_REF_ALLOC);
8692                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_ous));
8693                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_ous_0, LIBNDR_FLAG_REF_ALLOC);
8694                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.ous));
8695                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8696                         NDR_PULL_ALLOC_N(ndr, r->out.ous, ndr_get_array_size(ndr, &r->out.ous));
8697                 }
8698                 _mem_save_ous_1 = NDR_PULL_GET_MEM_CTX(ndr);
8699                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ous, 0);
8700                 for (cntr_ous_1 = 0; cntr_ous_1 < *r->out.num_ous; cntr_ous_1++) {
8701                         NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_ous));
8702                         if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8703                                 NDR_PULL_ALLOC(ndr, r->out.ous[cntr_ous_1]);
8704                         }
8705                 }
8706                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_1, 0);
8707                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
8708                 if (r->out.ous) {
8709                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.ous, *r->out.num_ous));
8710                 }
8711         }
8712         return NDR_ERR_SUCCESS;
8713 }
8714
8715 _PUBLIC_ void ndr_print_wkssvc_NetrGetJoinableOus(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrGetJoinableOus *r)
8716 {
8717         uint32_t cntr_ous_1;
8718         ndr_print_struct(ndr, name, "wkssvc_NetrGetJoinableOus");
8719         ndr->depth++;
8720         if (flags & NDR_SET_VALUES) {
8721                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8722         }
8723         if (flags & NDR_IN) {
8724                 ndr_print_struct(ndr, "in", "wkssvc_NetrGetJoinableOus");
8725                 ndr->depth++;
8726                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
8727                 ndr->depth++;
8728                 if (r->in.server_name) {
8729                         ndr_print_string(ndr, "server_name", r->in.server_name);
8730                 }
8731                 ndr->depth--;
8732                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
8733                 ndr->depth++;
8734                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
8735                 ndr->depth--;
8736                 ndr_print_ptr(ndr, "Account", r->in.Account);
8737                 ndr->depth++;
8738                 if (r->in.Account) {
8739                         ndr_print_string(ndr, "Account", r->in.Account);
8740                 }
8741                 ndr->depth--;
8742                 ndr_print_ptr(ndr, "unknown", r->in.unknown);
8743                 ndr->depth++;
8744                 if (r->in.unknown) {
8745                         ndr_print_string(ndr, "unknown", r->in.unknown);
8746                 }
8747                 ndr->depth--;
8748                 ndr_print_ptr(ndr, "num_ous", r->in.num_ous);
8749                 ndr->depth++;
8750                 ndr_print_uint32(ndr, "num_ous", *r->in.num_ous);
8751                 ndr->depth--;
8752                 ndr->depth--;
8753         }
8754         if (flags & NDR_OUT) {
8755                 ndr_print_struct(ndr, "out", "wkssvc_NetrGetJoinableOus");
8756                 ndr->depth++;
8757                 ndr_print_ptr(ndr, "num_ous", r->out.num_ous);
8758                 ndr->depth++;
8759                 ndr_print_uint32(ndr, "num_ous", *r->out.num_ous);
8760                 ndr->depth--;
8761                 ndr_print_ptr(ndr, "ous", r->out.ous);
8762                 ndr->depth++;
8763                 ndr->print(ndr, "%s: ARRAY(%d)", "ous", *r->out.num_ous);
8764                 ndr->depth++;
8765                 for (cntr_ous_1=0;cntr_ous_1<*r->out.num_ous;cntr_ous_1++) {
8766                         char *idx_1=NULL;
8767                         asprintf(&idx_1, "[%d]", cntr_ous_1);
8768                         if (idx_1) {
8769                                 ndr_print_ptr(ndr, "ous", r->out.ous[cntr_ous_1]);
8770                                 ndr->depth++;
8771                                 ndr_print_ptr(ndr, "ous", *r->out.ous[cntr_ous_1]);
8772                                 ndr->depth++;
8773                                 ndr_print_string(ndr, "ous", *r->out.ous[cntr_ous_1]);
8774                                 ndr->depth--;
8775                                 ndr->depth--;
8776                                 free(idx_1);
8777                         }
8778                 }
8779                 ndr->depth--;
8780                 ndr->depth--;
8781                 ndr_print_WERROR(ndr, "result", r->out.result);
8782                 ndr->depth--;
8783         }
8784         ndr->depth--;
8785 }
8786
8787 static enum ndr_err_code ndr_push_wkssvc_NetrJoinDomain2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrJoinDomain2 *r)
8788 {
8789         if (flags & NDR_IN) {
8790                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
8791                 if (r->in.server_name) {
8792                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8793                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8794                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8795                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8796                 }
8797                 if (r->in.domain_name == NULL) {
8798                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8799                 }
8800                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
8801                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8802                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
8803                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.domain_name, ndr_charset_length(r->in.domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8804                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.account_ou));
8805                 if (r->in.account_ou) {
8806                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account_ou, CH_UTF16)));
8807                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8808                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account_ou, CH_UTF16)));
8809                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.account_ou, ndr_charset_length(r->in.account_ou, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8810                 }
8811                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.admin_account));
8812                 if (r->in.admin_account) {
8813                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.admin_account, CH_UTF16)));
8814                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8815                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.admin_account, CH_UTF16)));
8816                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.admin_account, ndr_charset_length(r->in.admin_account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8817                 }
8818                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.encrypted_password));
8819                 if (r->in.encrypted_password) {
8820                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));
8821                 }
8822                 NDR_CHECK(ndr_push_wkssvc_joinflags(ndr, NDR_SCALARS, r->in.join_flags));
8823         }
8824         if (flags & NDR_OUT) {
8825                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
8826         }
8827         return NDR_ERR_SUCCESS;
8828 }
8829
8830 static enum ndr_err_code ndr_pull_wkssvc_NetrJoinDomain2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrJoinDomain2 *r)
8831 {
8832         uint32_t _ptr_server_name;
8833         uint32_t _ptr_account_ou;
8834         uint32_t _ptr_admin_account;
8835         uint32_t _ptr_encrypted_password;
8836         TALLOC_CTX *_mem_save_server_name_0;
8837         TALLOC_CTX *_mem_save_account_ou_0;
8838         TALLOC_CTX *_mem_save_admin_account_0;
8839         TALLOC_CTX *_mem_save_encrypted_password_0;
8840         if (flags & NDR_IN) {
8841                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
8842                 if (_ptr_server_name) {
8843                         NDR_PULL_ALLOC(ndr, r->in.server_name);
8844                 } else {
8845                         r->in.server_name = NULL;
8846                 }
8847                 if (r->in.server_name) {
8848                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8849                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
8850                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
8851                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
8852                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
8853                                 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_name), ndr_get_array_length(ndr, &r->in.server_name));
8854                         }
8855                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
8856                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
8857                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
8858                 }
8859                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
8860                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
8861                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
8862                         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.domain_name), ndr_get_array_length(ndr, &r->in.domain_name));
8863                 }
8864                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
8865                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.domain_name, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t), CH_UTF16));
8866                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account_ou));
8867                 if (_ptr_account_ou) {
8868                         NDR_PULL_ALLOC(ndr, r->in.account_ou);
8869                 } else {
8870                         r->in.account_ou = NULL;
8871                 }
8872                 if (r->in.account_ou) {
8873                         _mem_save_account_ou_0 = NDR_PULL_GET_MEM_CTX(ndr);
8874                         NDR_PULL_SET_MEM_CTX(ndr, r->in.account_ou, 0);
8875                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.account_ou));
8876                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.account_ou));
8877                         if (ndr_get_array_length(ndr, &r->in.account_ou) > ndr_get_array_size(ndr, &r->in.account_ou)) {
8878                                 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.account_ou), ndr_get_array_length(ndr, &r->in.account_ou));
8879                         }
8880                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.account_ou), sizeof(uint16_t)));
8881                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.account_ou, ndr_get_array_length(ndr, &r->in.account_ou), sizeof(uint16_t), CH_UTF16));
8882                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_ou_0, 0);
8883                 }
8884                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_admin_account));
8885                 if (_ptr_admin_account) {
8886                         NDR_PULL_ALLOC(ndr, r->in.admin_account);
8887                 } else {
8888                         r->in.admin_account = NULL;
8889                 }
8890                 if (r->in.admin_account) {
8891                         _mem_save_admin_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
8892                         NDR_PULL_SET_MEM_CTX(ndr, r->in.admin_account, 0);
8893                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.admin_account));
8894                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.admin_account));
8895                         if (ndr_get_array_length(ndr, &r->in.admin_account) > ndr_get_array_size(ndr, &r->in.admin_account)) {
8896                                 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.admin_account), ndr_get_array_length(ndr, &r->in.admin_account));
8897                         }
8898                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.admin_account), sizeof(uint16_t)));
8899                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.admin_account, ndr_get_array_length(ndr, &r->in.admin_account), sizeof(uint16_t), CH_UTF16));
8900                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_admin_account_0, 0);
8901                 }
8902                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_encrypted_password));
8903                 if (_ptr_encrypted_password) {
8904                         NDR_PULL_ALLOC(ndr, r->in.encrypted_password);
8905                 } else {
8906                         r->in.encrypted_password = NULL;
8907                 }
8908                 if (r->in.encrypted_password) {
8909                         _mem_save_encrypted_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
8910                         NDR_PULL_SET_MEM_CTX(ndr, r->in.encrypted_password, 0);
8911                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));
8912                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_encrypted_password_0, 0);
8913                 }
8914                 NDR_CHECK(ndr_pull_wkssvc_joinflags(ndr, NDR_SCALARS, &r->in.join_flags));
8915         }
8916         if (flags & NDR_OUT) {
8917                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
8918         }
8919         return NDR_ERR_SUCCESS;
8920 }
8921
8922 _PUBLIC_ void ndr_print_wkssvc_NetrJoinDomain2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrJoinDomain2 *r)
8923 {
8924         ndr_print_struct(ndr, name, "wkssvc_NetrJoinDomain2");
8925         ndr->depth++;
8926         if (flags & NDR_SET_VALUES) {
8927                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8928         }
8929         if (flags & NDR_IN) {
8930                 ndr_print_struct(ndr, "in", "wkssvc_NetrJoinDomain2");
8931                 ndr->depth++;
8932                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
8933                 ndr->depth++;
8934                 if (r->in.server_name) {
8935                         ndr_print_string(ndr, "server_name", r->in.server_name);
8936                 }
8937                 ndr->depth--;
8938                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
8939                 ndr->depth++;
8940                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
8941                 ndr->depth--;
8942                 ndr_print_ptr(ndr, "account_ou", r->in.account_ou);
8943                 ndr->depth++;
8944                 if (r->in.account_ou) {
8945                         ndr_print_string(ndr, "account_ou", r->in.account_ou);
8946                 }
8947                 ndr->depth--;
8948                 ndr_print_ptr(ndr, "admin_account", r->in.admin_account);
8949                 ndr->depth++;
8950                 if (r->in.admin_account) {
8951                         ndr_print_string(ndr, "admin_account", r->in.admin_account);
8952                 }
8953                 ndr->depth--;
8954                 ndr_print_ptr(ndr, "encrypted_password", r->in.encrypted_password);
8955                 ndr->depth++;
8956                 if (r->in.encrypted_password) {
8957                         ndr_print_wkssvc_PasswordBuffer(ndr, "encrypted_password", r->in.encrypted_password);
8958                 }
8959                 ndr->depth--;
8960                 ndr_print_wkssvc_joinflags(ndr, "join_flags", r->in.join_flags);
8961                 ndr->depth--;
8962         }
8963         if (flags & NDR_OUT) {
8964                 ndr_print_struct(ndr, "out", "wkssvc_NetrJoinDomain2");
8965                 ndr->depth++;
8966                 ndr_print_WERROR(ndr, "result", r->out.result);
8967                 ndr->depth--;
8968         }
8969         ndr->depth--;
8970 }
8971
8972 static enum ndr_err_code ndr_push_wkssvc_NetrUnjoinDomain2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUnjoinDomain2 *r)
8973 {
8974         if (flags & NDR_IN) {
8975                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
8976                 if (r->in.server_name) {
8977                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8978                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8979                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8980                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8981                 }
8982                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.account));
8983                 if (r->in.account) {
8984                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account, CH_UTF16)));
8985                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8986                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account, CH_UTF16)));
8987                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.account, ndr_charset_length(r->in.account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8988                 }
8989                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.encrypted_password));
8990                 if (r->in.encrypted_password) {
8991                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));
8992                 }
8993                 NDR_CHECK(ndr_push_wkssvc_joinflags(ndr, NDR_SCALARS, r->in.unjoin_flags));
8994         }
8995         if (flags & NDR_OUT) {
8996                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
8997         }
8998         return NDR_ERR_SUCCESS;
8999 }
9000
9001 static enum ndr_err_code ndr_pull_wkssvc_NetrUnjoinDomain2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUnjoinDomain2 *r)
9002 {
9003         uint32_t _ptr_server_name;
9004         uint32_t _ptr_account;
9005         uint32_t _ptr_encrypted_password;
9006         TALLOC_CTX *_mem_save_server_name_0;
9007         TALLOC_CTX *_mem_save_account_0;
9008         TALLOC_CTX *_mem_save_encrypted_password_0;
9009         if (flags & NDR_IN) {
9010                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
9011                 if (_ptr_server_name) {
9012                         NDR_PULL_ALLOC(ndr, r->in.server_name);
9013                 } else {
9014                         r->in.server_name = NULL;
9015                 }
9016                 if (r->in.server_name) {
9017                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9018                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
9019                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
9020                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
9021                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
9022                                 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_name), ndr_get_array_length(ndr, &r->in.server_name));
9023                         }
9024                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
9025                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
9026                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
9027                 }
9028                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account));
9029                 if (_ptr_account) {
9030                         NDR_PULL_ALLOC(ndr, r->in.account);
9031                 } else {
9032                         r->in.account = NULL;
9033                 }
9034                 if (r->in.account) {
9035                         _mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
9036                         NDR_PULL_SET_MEM_CTX(ndr, r->in.account, 0);
9037                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.account));
9038                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.account));
9039                         if (ndr_get_array_length(ndr, &r->in.account) > ndr_get_array_size(ndr, &r->in.account)) {
9040                                 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.account), ndr_get_array_length(ndr, &r->in.account));
9041                         }
9042                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.account), sizeof(uint16_t)));
9043                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.account, ndr_get_array_length(ndr, &r->in.account), sizeof(uint16_t), CH_UTF16));
9044                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, 0);
9045                 }
9046                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_encrypted_password));
9047                 if (_ptr_encrypted_password) {
9048                         NDR_PULL_ALLOC(ndr, r->in.encrypted_password);
9049                 } else {
9050                         r->in.encrypted_password = NULL;
9051                 }
9052                 if (r->in.encrypted_password) {
9053                         _mem_save_encrypted_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
9054                         NDR_PULL_SET_MEM_CTX(ndr, r->in.encrypted_password, 0);
9055                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));
9056                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_encrypted_password_0, 0);
9057                 }
9058                 NDR_CHECK(ndr_pull_wkssvc_joinflags(ndr, NDR_SCALARS, &r->in.unjoin_flags));
9059         }
9060         if (flags & NDR_OUT) {
9061                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9062         }
9063         return NDR_ERR_SUCCESS;
9064 }
9065
9066 _PUBLIC_ void ndr_print_wkssvc_NetrUnjoinDomain2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUnjoinDomain2 *r)
9067 {
9068         ndr_print_struct(ndr, name, "wkssvc_NetrUnjoinDomain2");
9069         ndr->depth++;
9070         if (flags & NDR_SET_VALUES) {
9071                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9072         }
9073         if (flags & NDR_IN) {
9074                 ndr_print_struct(ndr, "in", "wkssvc_NetrUnjoinDomain2");
9075                 ndr->depth++;
9076                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
9077                 ndr->depth++;
9078                 if (r->in.server_name) {
9079                         ndr_print_string(ndr, "server_name", r->in.server_name);
9080                 }
9081                 ndr->depth--;
9082                 ndr_print_ptr(ndr, "account", r->in.account);
9083                 ndr->depth++;
9084                 if (r->in.account) {
9085                         ndr_print_string(ndr, "account", r->in.account);
9086                 }
9087                 ndr->depth--;
9088                 ndr_print_ptr(ndr, "encrypted_password", r->in.encrypted_password);
9089                 ndr->depth++;
9090                 if (r->in.encrypted_password) {
9091                         ndr_print_wkssvc_PasswordBuffer(ndr, "encrypted_password", r->in.encrypted_password);
9092                 }
9093                 ndr->depth--;
9094                 ndr_print_wkssvc_joinflags(ndr, "unjoin_flags", r->in.unjoin_flags);
9095                 ndr->depth--;
9096         }
9097         if (flags & NDR_OUT) {
9098                 ndr_print_struct(ndr, "out", "wkssvc_NetrUnjoinDomain2");
9099                 ndr->depth++;
9100                 ndr_print_WERROR(ndr, "result", r->out.result);
9101                 ndr->depth--;
9102         }
9103         ndr->depth--;
9104 }
9105
9106 static enum ndr_err_code ndr_push_wkssvc_NetrRenameMachineInDomain2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrRenameMachineInDomain2 *r)
9107 {
9108         if (flags & NDR_IN) {
9109                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
9110                 if (r->in.server_name) {
9111                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9112                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9113                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9114                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9115                 }
9116                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.NewMachineName));
9117                 if (r->in.NewMachineName) {
9118                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewMachineName, CH_UTF16)));
9119                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9120                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewMachineName, CH_UTF16)));
9121                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.NewMachineName, ndr_charset_length(r->in.NewMachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9122                 }
9123                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
9124                 if (r->in.Account) {
9125                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9126                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9127                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9128                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9129                 }
9130                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
9131                 if (r->in.EncryptedPassword) {
9132                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9133                 }
9134                 NDR_CHECK(ndr_push_wkssvc_renameflags(ndr, NDR_SCALARS, r->in.RenameOptions));
9135         }
9136         if (flags & NDR_OUT) {
9137                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9138         }
9139         return NDR_ERR_SUCCESS;
9140 }
9141
9142 static enum ndr_err_code ndr_pull_wkssvc_NetrRenameMachineInDomain2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrRenameMachineInDomain2 *r)
9143 {
9144         uint32_t _ptr_server_name;
9145         uint32_t _ptr_NewMachineName;
9146         uint32_t _ptr_Account;
9147         uint32_t _ptr_EncryptedPassword;
9148         TALLOC_CTX *_mem_save_server_name_0;
9149         TALLOC_CTX *_mem_save_NewMachineName_0;
9150         TALLOC_CTX *_mem_save_Account_0;
9151         TALLOC_CTX *_mem_save_EncryptedPassword_0;
9152         if (flags & NDR_IN) {
9153                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
9154                 if (_ptr_server_name) {
9155                         NDR_PULL_ALLOC(ndr, r->in.server_name);
9156                 } else {
9157                         r->in.server_name = NULL;
9158                 }
9159                 if (r->in.server_name) {
9160                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9161                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
9162                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
9163                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
9164                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
9165                                 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_name), ndr_get_array_length(ndr, &r->in.server_name));
9166                         }
9167                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
9168                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
9169                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
9170                 }
9171                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_NewMachineName));
9172                 if (_ptr_NewMachineName) {
9173                         NDR_PULL_ALLOC(ndr, r->in.NewMachineName);
9174                 } else {
9175                         r->in.NewMachineName = NULL;
9176                 }
9177                 if (r->in.NewMachineName) {
9178                         _mem_save_NewMachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);
9179                         NDR_PULL_SET_MEM_CTX(ndr, r->in.NewMachineName, 0);
9180                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.NewMachineName));
9181                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.NewMachineName));
9182                         if (ndr_get_array_length(ndr, &r->in.NewMachineName) > ndr_get_array_size(ndr, &r->in.NewMachineName)) {
9183                                 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.NewMachineName), ndr_get_array_length(ndr, &r->in.NewMachineName));
9184                         }
9185                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.NewMachineName), sizeof(uint16_t)));
9186                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.NewMachineName, ndr_get_array_length(ndr, &r->in.NewMachineName), sizeof(uint16_t), CH_UTF16));
9187                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_NewMachineName_0, 0);
9188                 }
9189                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
9190                 if (_ptr_Account) {
9191                         NDR_PULL_ALLOC(ndr, r->in.Account);
9192                 } else {
9193                         r->in.Account = NULL;
9194                 }
9195                 if (r->in.Account) {
9196                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
9197                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
9198                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
9199                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
9200                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
9201                                 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.Account), ndr_get_array_length(ndr, &r->in.Account));
9202                         }
9203                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
9204                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
9205                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
9206                 }
9207                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
9208                 if (_ptr_EncryptedPassword) {
9209                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
9210                 } else {
9211                         r->in.EncryptedPassword = NULL;
9212                 }
9213                 if (r->in.EncryptedPassword) {
9214                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
9215                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
9216                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9217                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
9218                 }
9219                 NDR_CHECK(ndr_pull_wkssvc_renameflags(ndr, NDR_SCALARS, &r->in.RenameOptions));
9220         }
9221         if (flags & NDR_OUT) {
9222                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9223         }
9224         return NDR_ERR_SUCCESS;
9225 }
9226
9227 _PUBLIC_ void ndr_print_wkssvc_NetrRenameMachineInDomain2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrRenameMachineInDomain2 *r)
9228 {
9229         ndr_print_struct(ndr, name, "wkssvc_NetrRenameMachineInDomain2");
9230         ndr->depth++;
9231         if (flags & NDR_SET_VALUES) {
9232                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9233         }
9234         if (flags & NDR_IN) {
9235                 ndr_print_struct(ndr, "in", "wkssvc_NetrRenameMachineInDomain2");
9236                 ndr->depth++;
9237                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
9238                 ndr->depth++;
9239                 if (r->in.server_name) {
9240                         ndr_print_string(ndr, "server_name", r->in.server_name);
9241                 }
9242                 ndr->depth--;
9243                 ndr_print_ptr(ndr, "NewMachineName", r->in.NewMachineName);
9244                 ndr->depth++;
9245                 if (r->in.NewMachineName) {
9246                         ndr_print_string(ndr, "NewMachineName", r->in.NewMachineName);
9247                 }
9248                 ndr->depth--;
9249                 ndr_print_ptr(ndr, "Account", r->in.Account);
9250                 ndr->depth++;
9251                 if (r->in.Account) {
9252                         ndr_print_string(ndr, "Account", r->in.Account);
9253                 }
9254                 ndr->depth--;
9255                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9256                 ndr->depth++;
9257                 if (r->in.EncryptedPassword) {
9258                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9259                 }
9260                 ndr->depth--;
9261                 ndr_print_wkssvc_renameflags(ndr, "RenameOptions", r->in.RenameOptions);
9262                 ndr->depth--;
9263         }
9264         if (flags & NDR_OUT) {
9265                 ndr_print_struct(ndr, "out", "wkssvc_NetrRenameMachineInDomain2");
9266                 ndr->depth++;
9267                 ndr_print_WERROR(ndr, "result", r->out.result);
9268                 ndr->depth--;
9269         }
9270         ndr->depth--;
9271 }
9272
9273 static enum ndr_err_code ndr_push_wkssvc_NetrValidateName2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrValidateName2 *r)
9274 {
9275         if (flags & NDR_IN) {
9276                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
9277                 if (r->in.server_name) {
9278                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9279                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9280                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9281                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9282                 }
9283                 if (r->in.name == NULL) {
9284                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9285                 }
9286                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF16)));
9287                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9288                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF16)));
9289                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.name, ndr_charset_length(r->in.name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9290                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
9291                 if (r->in.Account) {
9292                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9293                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9294                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9295                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9296                 }
9297                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
9298                 if (r->in.EncryptedPassword) {
9299                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9300                 }
9301                 NDR_CHECK(ndr_push_wkssvc_NetValidateNameType(ndr, NDR_SCALARS, r->in.name_type));
9302         }
9303         if (flags & NDR_OUT) {
9304                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9305         }
9306         return NDR_ERR_SUCCESS;
9307 }
9308
9309 static enum ndr_err_code ndr_pull_wkssvc_NetrValidateName2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrValidateName2 *r)
9310 {
9311         uint32_t _ptr_server_name;
9312         uint32_t _ptr_Account;
9313         uint32_t _ptr_EncryptedPassword;
9314         TALLOC_CTX *_mem_save_server_name_0;
9315         TALLOC_CTX *_mem_save_Account_0;
9316         TALLOC_CTX *_mem_save_EncryptedPassword_0;
9317         if (flags & NDR_IN) {
9318                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
9319                 if (_ptr_server_name) {
9320                         NDR_PULL_ALLOC(ndr, r->in.server_name);
9321                 } else {
9322                         r->in.server_name = NULL;
9323                 }
9324                 if (r->in.server_name) {
9325                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9326                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
9327                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
9328                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
9329                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
9330                                 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_name), ndr_get_array_length(ndr, &r->in.server_name));
9331                         }
9332                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
9333                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
9334                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
9335                 }
9336                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.name));
9337                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.name));
9338                 if (ndr_get_array_length(ndr, &r->in.name) > ndr_get_array_size(ndr, &r->in.name)) {
9339                         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.name), ndr_get_array_length(ndr, &r->in.name));
9340                 }
9341                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.name), sizeof(uint16_t)));
9342                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.name, ndr_get_array_length(ndr, &r->in.name), sizeof(uint16_t), CH_UTF16));
9343                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
9344                 if (_ptr_Account) {
9345                         NDR_PULL_ALLOC(ndr, r->in.Account);
9346                 } else {
9347                         r->in.Account = NULL;
9348                 }
9349                 if (r->in.Account) {
9350                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
9351                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
9352                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
9353                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
9354                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
9355                                 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.Account), ndr_get_array_length(ndr, &r->in.Account));
9356                         }
9357                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
9358                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
9359                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
9360                 }
9361                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
9362                 if (_ptr_EncryptedPassword) {
9363                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
9364                 } else {
9365                         r->in.EncryptedPassword = NULL;
9366                 }
9367                 if (r->in.EncryptedPassword) {
9368                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
9369                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
9370                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9371                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
9372                 }
9373                 NDR_CHECK(ndr_pull_wkssvc_NetValidateNameType(ndr, NDR_SCALARS, &r->in.name_type));
9374         }
9375         if (flags & NDR_OUT) {
9376                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9377         }
9378         return NDR_ERR_SUCCESS;
9379 }
9380
9381 _PUBLIC_ void ndr_print_wkssvc_NetrValidateName2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrValidateName2 *r)
9382 {
9383         ndr_print_struct(ndr, name, "wkssvc_NetrValidateName2");
9384         ndr->depth++;
9385         if (flags & NDR_SET_VALUES) {
9386                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9387         }
9388         if (flags & NDR_IN) {
9389                 ndr_print_struct(ndr, "in", "wkssvc_NetrValidateName2");
9390                 ndr->depth++;
9391                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
9392                 ndr->depth++;
9393                 if (r->in.server_name) {
9394                         ndr_print_string(ndr, "server_name", r->in.server_name);
9395                 }
9396                 ndr->depth--;
9397                 ndr_print_ptr(ndr, "name", r->in.name);
9398                 ndr->depth++;
9399                 ndr_print_string(ndr, "name", r->in.name);
9400                 ndr->depth--;
9401                 ndr_print_ptr(ndr, "Account", r->in.Account);
9402                 ndr->depth++;
9403                 if (r->in.Account) {
9404                         ndr_print_string(ndr, "Account", r->in.Account);
9405                 }
9406                 ndr->depth--;
9407                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9408                 ndr->depth++;
9409                 if (r->in.EncryptedPassword) {
9410                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9411                 }
9412                 ndr->depth--;
9413                 ndr_print_wkssvc_NetValidateNameType(ndr, "name_type", r->in.name_type);
9414                 ndr->depth--;
9415         }
9416         if (flags & NDR_OUT) {
9417                 ndr_print_struct(ndr, "out", "wkssvc_NetrValidateName2");
9418                 ndr->depth++;
9419                 ndr_print_WERROR(ndr, "result", r->out.result);
9420                 ndr->depth--;
9421         }
9422         ndr->depth--;
9423 }
9424
9425 static enum ndr_err_code ndr_push_wkssvc_NetrGetJoinableOus2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrGetJoinableOus2 *r)
9426 {
9427         uint32_t cntr_ous_1;
9428         if (flags & NDR_IN) {
9429                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
9430                 if (r->in.server_name) {
9431                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9432                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9433                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9434                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9435                 }
9436                 if (r->in.domain_name == NULL) {
9437                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9438                 }
9439                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
9440                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9441                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
9442                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.domain_name, ndr_charset_length(r->in.domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9443                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
9444                 if (r->in.Account) {
9445                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9446                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9447                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9448                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9449                 }
9450                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
9451                 if (r->in.EncryptedPassword) {
9452                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9453                 }
9454                 if (r->in.num_ous == NULL) {
9455                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9456                 }
9457                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.num_ous));
9458         }
9459         if (flags & NDR_OUT) {
9460                 if (r->out.num_ous == NULL) {
9461                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9462                 }
9463                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_ous));
9464                 if (r->out.ous == NULL) {
9465                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9466                 }
9467                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_ous));
9468                 for (cntr_ous_1 = 0; cntr_ous_1 < *r->out.num_ous; cntr_ous_1++) {
9469                         if (r->out.ous[cntr_ous_1] == NULL) {
9470                                 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9471                         }
9472                         NDR_CHECK(ndr_push_ref_ptr(ndr));
9473                 }
9474                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9475         }
9476         return NDR_ERR_SUCCESS;
9477 }
9478
9479 static enum ndr_err_code ndr_pull_wkssvc_NetrGetJoinableOus2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrGetJoinableOus2 *r)
9480 {
9481         uint32_t _ptr_server_name;
9482         uint32_t _ptr_Account;
9483         uint32_t _ptr_EncryptedPassword;
9484         uint32_t _ptr_ous;
9485         uint32_t cntr_ous_1;
9486         TALLOC_CTX *_mem_save_server_name_0;
9487         TALLOC_CTX *_mem_save_Account_0;
9488         TALLOC_CTX *_mem_save_EncryptedPassword_0;
9489         TALLOC_CTX *_mem_save_num_ous_0;
9490         TALLOC_CTX *_mem_save_ous_1;
9491         TALLOC_CTX *_mem_save_ous_2;
9492         if (flags & NDR_IN) {
9493                 ZERO_STRUCT(r->out);
9494
9495                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
9496                 if (_ptr_server_name) {
9497                         NDR_PULL_ALLOC(ndr, r->in.server_name);
9498                 } else {
9499                         r->in.server_name = NULL;
9500                 }
9501                 if (r->in.server_name) {
9502                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9503                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
9504                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
9505                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
9506                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
9507                                 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_name), ndr_get_array_length(ndr, &r->in.server_name));
9508                         }
9509                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
9510                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
9511                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
9512                 }
9513                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
9514                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
9515                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
9516                         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.domain_name), ndr_get_array_length(ndr, &r->in.domain_name));
9517                 }
9518                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
9519                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.domain_name, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t), CH_UTF16));
9520                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
9521                 if (_ptr_Account) {
9522                         NDR_PULL_ALLOC(ndr, r->in.Account);
9523                 } else {
9524                         r->in.Account = NULL;
9525                 }
9526                 if (r->in.Account) {
9527                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
9528                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
9529                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
9530                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
9531                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
9532                                 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.Account), ndr_get_array_length(ndr, &r->in.Account));
9533                         }
9534                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
9535                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
9536                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
9537                 }
9538                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
9539                 if (_ptr_EncryptedPassword) {
9540                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
9541                 } else {
9542                         r->in.EncryptedPassword = NULL;
9543                 }
9544                 if (r->in.EncryptedPassword) {
9545                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
9546                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
9547                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9548                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
9549                 }
9550                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9551                         NDR_PULL_ALLOC(ndr, r->in.num_ous);
9552                 }
9553                 _mem_save_num_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);
9554                 NDR_PULL_SET_MEM_CTX(ndr, r->in.num_ous, LIBNDR_FLAG_REF_ALLOC);
9555                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.num_ous));
9556                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_ous_0, LIBNDR_FLAG_REF_ALLOC);
9557                 NDR_PULL_ALLOC(ndr, r->out.num_ous);
9558                 *r->out.num_ous = *r->in.num_ous;
9559                 NDR_PULL_ALLOC_N(ndr, r->out.ous, *r->in.num_ous);
9560                 memset(r->out.ous, 0, *r->in.num_ous * sizeof(*r->out.ous));
9561         }
9562         if (flags & NDR_OUT) {
9563                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9564                         NDR_PULL_ALLOC(ndr, r->out.num_ous);
9565                 }
9566                 _mem_save_num_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);
9567                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_ous, LIBNDR_FLAG_REF_ALLOC);
9568                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_ous));
9569                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_ous_0, LIBNDR_FLAG_REF_ALLOC);
9570                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.ous));
9571                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9572                         NDR_PULL_ALLOC_N(ndr, r->out.ous, ndr_get_array_size(ndr, &r->out.ous));
9573                 }
9574                 _mem_save_ous_1 = NDR_PULL_GET_MEM_CTX(ndr);
9575                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ous, 0);
9576                 for (cntr_ous_1 = 0; cntr_ous_1 < *r->out.num_ous; cntr_ous_1++) {
9577                         NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_ous));
9578                         if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9579                                 NDR_PULL_ALLOC(ndr, r->out.ous[cntr_ous_1]);
9580                         }
9581                 }
9582                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_1, 0);
9583                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9584                 if (r->out.ous) {
9585                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.ous, *r->out.num_ous));
9586                 }
9587         }
9588         return NDR_ERR_SUCCESS;
9589 }
9590
9591 _PUBLIC_ void ndr_print_wkssvc_NetrGetJoinableOus2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrGetJoinableOus2 *r)
9592 {
9593         uint32_t cntr_ous_1;
9594         ndr_print_struct(ndr, name, "wkssvc_NetrGetJoinableOus2");
9595         ndr->depth++;
9596         if (flags & NDR_SET_VALUES) {
9597                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9598         }
9599         if (flags & NDR_IN) {
9600                 ndr_print_struct(ndr, "in", "wkssvc_NetrGetJoinableOus2");
9601                 ndr->depth++;
9602                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
9603                 ndr->depth++;
9604                 if (r->in.server_name) {
9605                         ndr_print_string(ndr, "server_name", r->in.server_name);
9606                 }
9607                 ndr->depth--;
9608                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
9609                 ndr->depth++;
9610                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
9611                 ndr->depth--;
9612                 ndr_print_ptr(ndr, "Account", r->in.Account);
9613                 ndr->depth++;
9614                 if (r->in.Account) {
9615                         ndr_print_string(ndr, "Account", r->in.Account);
9616                 }
9617                 ndr->depth--;
9618                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9619                 ndr->depth++;
9620                 if (r->in.EncryptedPassword) {
9621                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9622                 }
9623                 ndr->depth--;
9624                 ndr_print_ptr(ndr, "num_ous", r->in.num_ous);
9625                 ndr->depth++;
9626                 ndr_print_uint32(ndr, "num_ous", *r->in.num_ous);
9627                 ndr->depth--;
9628                 ndr->depth--;
9629         }
9630         if (flags & NDR_OUT) {
9631                 ndr_print_struct(ndr, "out", "wkssvc_NetrGetJoinableOus2");
9632                 ndr->depth++;
9633                 ndr_print_ptr(ndr, "num_ous", r->out.num_ous);
9634                 ndr->depth++;
9635                 ndr_print_uint32(ndr, "num_ous", *r->out.num_ous);
9636                 ndr->depth--;
9637                 ndr_print_ptr(ndr, "ous", r->out.ous);
9638                 ndr->depth++;
9639                 ndr->print(ndr, "%s: ARRAY(%d)", "ous", *r->out.num_ous);
9640                 ndr->depth++;
9641                 for (cntr_ous_1=0;cntr_ous_1<*r->out.num_ous;cntr_ous_1++) {
9642                         char *idx_1=NULL;
9643                         asprintf(&idx_1, "[%d]", cntr_ous_1);
9644                         if (idx_1) {
9645                                 ndr_print_ptr(ndr, "ous", r->out.ous[cntr_ous_1]);
9646                                 ndr->depth++;
9647                                 ndr_print_ptr(ndr, "ous", *r->out.ous[cntr_ous_1]);
9648                                 ndr->depth++;
9649                                 ndr_print_string(ndr, "ous", *r->out.ous[cntr_ous_1]);
9650                                 ndr->depth--;
9651                                 ndr->depth--;
9652                                 free(idx_1);
9653                         }
9654                 }
9655                 ndr->depth--;
9656                 ndr->depth--;
9657                 ndr_print_WERROR(ndr, "result", r->out.result);
9658                 ndr->depth--;
9659         }
9660         ndr->depth--;
9661 }
9662
9663 static enum ndr_err_code ndr_push_wkssvc_NetrAddAlternateComputerName(struct ndr_push *ndr, int flags, const struct wkssvc_NetrAddAlternateComputerName *r)
9664 {
9665         if (flags & NDR_IN) {
9666                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
9667                 if (r->in.server_name) {
9668                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9669                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9670                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9671                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9672                 }
9673                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.NewAlternateMachineName));
9674                 if (r->in.NewAlternateMachineName) {
9675                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewAlternateMachineName, CH_UTF16)));
9676                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9677                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewAlternateMachineName, CH_UTF16)));
9678                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.NewAlternateMachineName, ndr_charset_length(r->in.NewAlternateMachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9679                 }
9680                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
9681                 if (r->in.Account) {
9682                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9683                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9684                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9685                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9686                 }
9687                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
9688                 if (r->in.EncryptedPassword) {
9689                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9690                 }
9691                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Reserved));
9692         }
9693         if (flags & NDR_OUT) {
9694                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9695         }
9696         return NDR_ERR_SUCCESS;
9697 }
9698
9699 static enum ndr_err_code ndr_pull_wkssvc_NetrAddAlternateComputerName(struct ndr_pull *ndr, int flags, struct wkssvc_NetrAddAlternateComputerName *r)
9700 {
9701         uint32_t _ptr_server_name;
9702         uint32_t _ptr_NewAlternateMachineName;
9703         uint32_t _ptr_Account;
9704         uint32_t _ptr_EncryptedPassword;
9705         TALLOC_CTX *_mem_save_server_name_0;
9706         TALLOC_CTX *_mem_save_NewAlternateMachineName_0;
9707         TALLOC_CTX *_mem_save_Account_0;
9708         TALLOC_CTX *_mem_save_EncryptedPassword_0;
9709         if (flags & NDR_IN) {
9710                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
9711                 if (_ptr_server_name) {
9712                         NDR_PULL_ALLOC(ndr, r->in.server_name);
9713                 } else {
9714                         r->in.server_name = NULL;
9715                 }
9716                 if (r->in.server_name) {
9717                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9718                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
9719                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
9720                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
9721                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
9722                                 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_name), ndr_get_array_length(ndr, &r->in.server_name));
9723                         }
9724                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
9725                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
9726                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
9727                 }
9728                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_NewAlternateMachineName));
9729                 if (_ptr_NewAlternateMachineName) {
9730                         NDR_PULL_ALLOC(ndr, r->in.NewAlternateMachineName);
9731                 } else {
9732                         r->in.NewAlternateMachineName = NULL;
9733                 }
9734                 if (r->in.NewAlternateMachineName) {
9735                         _mem_save_NewAlternateMachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);
9736                         NDR_PULL_SET_MEM_CTX(ndr, r->in.NewAlternateMachineName, 0);
9737                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.NewAlternateMachineName));
9738                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.NewAlternateMachineName));
9739                         if (ndr_get_array_length(ndr, &r->in.NewAlternateMachineName) > ndr_get_array_size(ndr, &r->in.NewAlternateMachineName)) {
9740                                 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.NewAlternateMachineName), ndr_get_array_length(ndr, &r->in.NewAlternateMachineName));
9741                         }
9742                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.NewAlternateMachineName), sizeof(uint16_t)));
9743                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.NewAlternateMachineName, ndr_get_array_length(ndr, &r->in.NewAlternateMachineName), sizeof(uint16_t), CH_UTF16));
9744                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_NewAlternateMachineName_0, 0);
9745                 }
9746                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
9747                 if (_ptr_Account) {
9748                         NDR_PULL_ALLOC(ndr, r->in.Account);
9749                 } else {
9750                         r->in.Account = NULL;
9751                 }
9752                 if (r->in.Account) {
9753                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
9754                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
9755                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
9756                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
9757                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
9758                                 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.Account), ndr_get_array_length(ndr, &r->in.Account));
9759                         }
9760                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
9761                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
9762                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
9763                 }
9764                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
9765                 if (_ptr_EncryptedPassword) {
9766                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
9767                 } else {
9768                         r->in.EncryptedPassword = NULL;
9769                 }
9770                 if (r->in.EncryptedPassword) {
9771                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
9772                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
9773                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9774                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
9775                 }
9776                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Reserved));
9777         }
9778         if (flags & NDR_OUT) {
9779                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9780         }
9781         return NDR_ERR_SUCCESS;
9782 }
9783
9784 _PUBLIC_ void ndr_print_wkssvc_NetrAddAlternateComputerName(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrAddAlternateComputerName *r)
9785 {
9786         ndr_print_struct(ndr, name, "wkssvc_NetrAddAlternateComputerName");
9787         ndr->depth++;
9788         if (flags & NDR_SET_VALUES) {
9789                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9790         }
9791         if (flags & NDR_IN) {
9792                 ndr_print_struct(ndr, "in", "wkssvc_NetrAddAlternateComputerName");
9793                 ndr->depth++;
9794                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
9795                 ndr->depth++;
9796                 if (r->in.server_name) {
9797                         ndr_print_string(ndr, "server_name", r->in.server_name);
9798                 }
9799                 ndr->depth--;
9800                 ndr_print_ptr(ndr, "NewAlternateMachineName", r->in.NewAlternateMachineName);
9801                 ndr->depth++;
9802                 if (r->in.NewAlternateMachineName) {
9803                         ndr_print_string(ndr, "NewAlternateMachineName", r->in.NewAlternateMachineName);
9804                 }
9805                 ndr->depth--;
9806                 ndr_print_ptr(ndr, "Account", r->in.Account);
9807                 ndr->depth++;
9808                 if (r->in.Account) {
9809                         ndr_print_string(ndr, "Account", r->in.Account);
9810                 }
9811                 ndr->depth--;
9812                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9813                 ndr->depth++;
9814                 if (r->in.EncryptedPassword) {
9815                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9816                 }
9817                 ndr->depth--;
9818                 ndr_print_uint32(ndr, "Reserved", r->in.Reserved);
9819                 ndr->depth--;
9820         }
9821         if (flags & NDR_OUT) {
9822                 ndr_print_struct(ndr, "out", "wkssvc_NetrAddAlternateComputerName");
9823                 ndr->depth++;
9824                 ndr_print_WERROR(ndr, "result", r->out.result);
9825                 ndr->depth--;
9826         }
9827         ndr->depth--;
9828 }
9829
9830 static enum ndr_err_code ndr_push_wkssvc_NetrRemoveAlternateComputerName(struct ndr_push *ndr, int flags, const struct wkssvc_NetrRemoveAlternateComputerName *r)
9831 {
9832         if (flags & NDR_IN) {
9833                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
9834                 if (r->in.server_name) {
9835                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9836                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9837                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9838                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9839                 }
9840                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.AlternateMachineNameToRemove));
9841                 if (r->in.AlternateMachineNameToRemove) {
9842                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.AlternateMachineNameToRemove, CH_UTF16)));
9843                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9844                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.AlternateMachineNameToRemove, CH_UTF16)));
9845                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.AlternateMachineNameToRemove, ndr_charset_length(r->in.AlternateMachineNameToRemove, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9846                 }
9847                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
9848                 if (r->in.Account) {
9849                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9850                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9851                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9852                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9853                 }
9854                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
9855                 if (r->in.EncryptedPassword) {
9856                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9857                 }
9858                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Reserved));
9859         }
9860         if (flags & NDR_OUT) {
9861                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9862         }
9863         return NDR_ERR_SUCCESS;
9864 }
9865
9866 static enum ndr_err_code ndr_pull_wkssvc_NetrRemoveAlternateComputerName(struct ndr_pull *ndr, int flags, struct wkssvc_NetrRemoveAlternateComputerName *r)
9867 {
9868         uint32_t _ptr_server_name;
9869         uint32_t _ptr_AlternateMachineNameToRemove;
9870         uint32_t _ptr_Account;
9871         uint32_t _ptr_EncryptedPassword;
9872         TALLOC_CTX *_mem_save_server_name_0;
9873         TALLOC_CTX *_mem_save_AlternateMachineNameToRemove_0;
9874         TALLOC_CTX *_mem_save_Account_0;
9875         TALLOC_CTX *_mem_save_EncryptedPassword_0;
9876         if (flags & NDR_IN) {
9877                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
9878                 if (_ptr_server_name) {
9879                         NDR_PULL_ALLOC(ndr, r->in.server_name);
9880                 } else {
9881                         r->in.server_name = NULL;
9882                 }
9883                 if (r->in.server_name) {
9884                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9885                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
9886                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
9887                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
9888                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
9889                                 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_name), ndr_get_array_length(ndr, &r->in.server_name));
9890                         }
9891                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
9892                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
9893                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
9894                 }
9895                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_AlternateMachineNameToRemove));
9896                 if (_ptr_AlternateMachineNameToRemove) {
9897                         NDR_PULL_ALLOC(ndr, r->in.AlternateMachineNameToRemove);
9898                 } else {
9899                         r->in.AlternateMachineNameToRemove = NULL;
9900                 }
9901                 if (r->in.AlternateMachineNameToRemove) {
9902                         _mem_save_AlternateMachineNameToRemove_0 = NDR_PULL_GET_MEM_CTX(ndr);
9903                         NDR_PULL_SET_MEM_CTX(ndr, r->in.AlternateMachineNameToRemove, 0);
9904                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.AlternateMachineNameToRemove));
9905                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.AlternateMachineNameToRemove));
9906                         if (ndr_get_array_length(ndr, &r->in.AlternateMachineNameToRemove) > ndr_get_array_size(ndr, &r->in.AlternateMachineNameToRemove)) {
9907                                 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.AlternateMachineNameToRemove), ndr_get_array_length(ndr, &r->in.AlternateMachineNameToRemove));
9908                         }
9909                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.AlternateMachineNameToRemove), sizeof(uint16_t)));
9910                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.AlternateMachineNameToRemove, ndr_get_array_length(ndr, &r->in.AlternateMachineNameToRemove), sizeof(uint16_t), CH_UTF16));
9911                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_AlternateMachineNameToRemove_0, 0);
9912                 }
9913                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
9914                 if (_ptr_Account) {
9915                         NDR_PULL_ALLOC(ndr, r->in.Account);
9916                 } else {
9917                         r->in.Account = NULL;
9918                 }
9919                 if (r->in.Account) {
9920                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
9921                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
9922                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
9923                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
9924                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
9925                                 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.Account), ndr_get_array_length(ndr, &r->in.Account));
9926                         }
9927                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
9928                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
9929                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
9930                 }
9931                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
9932                 if (_ptr_EncryptedPassword) {
9933                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
9934                 } else {
9935                         r->in.EncryptedPassword = NULL;
9936                 }
9937                 if (r->in.EncryptedPassword) {
9938                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
9939                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
9940                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9941                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
9942                 }
9943                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Reserved));
9944         }
9945         if (flags & NDR_OUT) {
9946                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9947         }
9948         return NDR_ERR_SUCCESS;
9949 }
9950
9951 _PUBLIC_ void ndr_print_wkssvc_NetrRemoveAlternateComputerName(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrRemoveAlternateComputerName *r)
9952 {
9953         ndr_print_struct(ndr, name, "wkssvc_NetrRemoveAlternateComputerName");
9954         ndr->depth++;
9955         if (flags & NDR_SET_VALUES) {
9956                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9957         }
9958         if (flags & NDR_IN) {
9959                 ndr_print_struct(ndr, "in", "wkssvc_NetrRemoveAlternateComputerName");
9960                 ndr->depth++;
9961                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
9962                 ndr->depth++;
9963                 if (r->in.server_name) {
9964                         ndr_print_string(ndr, "server_name", r->in.server_name);
9965                 }
9966                 ndr->depth--;
9967                 ndr_print_ptr(ndr, "AlternateMachineNameToRemove", r->in.AlternateMachineNameToRemove);
9968                 ndr->depth++;
9969                 if (r->in.AlternateMachineNameToRemove) {
9970                         ndr_print_string(ndr, "AlternateMachineNameToRemove", r->in.AlternateMachineNameToRemove);
9971                 }
9972                 ndr->depth--;
9973                 ndr_print_ptr(ndr, "Account", r->in.Account);
9974                 ndr->depth++;
9975                 if (r->in.Account) {
9976                         ndr_print_string(ndr, "Account", r->in.Account);
9977                 }
9978                 ndr->depth--;
9979                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9980                 ndr->depth++;
9981                 if (r->in.EncryptedPassword) {
9982                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9983                 }
9984                 ndr->depth--;
9985                 ndr_print_uint32(ndr, "Reserved", r->in.Reserved);
9986                 ndr->depth--;
9987         }
9988         if (flags & NDR_OUT) {
9989                 ndr_print_struct(ndr, "out", "wkssvc_NetrRemoveAlternateComputerName");
9990                 ndr->depth++;
9991                 ndr_print_WERROR(ndr, "result", r->out.result);
9992                 ndr->depth--;
9993         }
9994         ndr->depth--;
9995 }
9996
9997 static enum ndr_err_code ndr_push_wkssvc_NetrSetPrimaryComputername(struct ndr_push *ndr, int flags, const struct wkssvc_NetrSetPrimaryComputername *r)
9998 {
9999         if (flags & NDR_IN) {
10000                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
10001                 if (r->in.server_name) {
10002                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
10003                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10004                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
10005                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10006                 }
10007                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.primary_name));
10008                 if (r->in.primary_name) {
10009                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.primary_name, CH_UTF16)));
10010                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10011                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.primary_name, CH_UTF16)));
10012                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.primary_name, ndr_charset_length(r->in.primary_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10013                 }
10014                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
10015                 if (r->in.Account) {
10016                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
10017                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10018                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
10019                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10020                 }
10021                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
10022                 if (r->in.EncryptedPassword) {
10023                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
10024                 }
10025                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Reserved));
10026         }
10027         if (flags & NDR_OUT) {
10028                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
10029         }
10030         return NDR_ERR_SUCCESS;
10031 }
10032
10033 static enum ndr_err_code ndr_pull_wkssvc_NetrSetPrimaryComputername(struct ndr_pull *ndr, int flags, struct wkssvc_NetrSetPrimaryComputername *r)
10034 {
10035         uint32_t _ptr_server_name;
10036         uint32_t _ptr_primary_name;
10037         uint32_t _ptr_Account;
10038         uint32_t _ptr_EncryptedPassword;
10039         TALLOC_CTX *_mem_save_server_name_0;
10040         TALLOC_CTX *_mem_save_primary_name_0;
10041         TALLOC_CTX *_mem_save_Account_0;
10042         TALLOC_CTX *_mem_save_EncryptedPassword_0;
10043         if (flags & NDR_IN) {
10044                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
10045                 if (_ptr_server_name) {
10046                         NDR_PULL_ALLOC(ndr, r->in.server_name);
10047                 } else {
10048                         r->in.server_name = NULL;
10049                 }
10050                 if (r->in.server_name) {
10051                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10052                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
10053                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
10054                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
10055                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
10056                                 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_name), ndr_get_array_length(ndr, &r->in.server_name));
10057                         }
10058                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
10059                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
10060                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
10061                 }
10062                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_primary_name));
10063                 if (_ptr_primary_name) {
10064                         NDR_PULL_ALLOC(ndr, r->in.primary_name);
10065                 } else {
10066                         r->in.primary_name = NULL;
10067                 }
10068                 if (r->in.primary_name) {
10069                         _mem_save_primary_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10070                         NDR_PULL_SET_MEM_CTX(ndr, r->in.primary_name, 0);
10071                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.primary_name));
10072                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.primary_name));
10073                         if (ndr_get_array_length(ndr, &r->in.primary_name) > ndr_get_array_size(ndr, &r->in.primary_name)) {
10074                                 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.primary_name), ndr_get_array_length(ndr, &r->in.primary_name));
10075                         }
10076                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.primary_name), sizeof(uint16_t)));
10077                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.primary_name, ndr_get_array_length(ndr, &r->in.primary_name), sizeof(uint16_t), CH_UTF16));
10078                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_primary_name_0, 0);
10079                 }
10080                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
10081                 if (_ptr_Account) {
10082                         NDR_PULL_ALLOC(ndr, r->in.Account);
10083                 } else {
10084                         r->in.Account = NULL;
10085                 }
10086                 if (r->in.Account) {
10087                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
10088                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
10089                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
10090                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
10091                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
10092                                 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.Account), ndr_get_array_length(ndr, &r->in.Account));
10093                         }
10094                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
10095                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
10096                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
10097                 }
10098                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
10099                 if (_ptr_EncryptedPassword) {
10100                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
10101                 } else {
10102                         r->in.EncryptedPassword = NULL;
10103                 }
10104                 if (r->in.EncryptedPassword) {
10105                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
10106                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
10107                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
10108                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
10109                 }
10110                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Reserved));
10111         }
10112         if (flags & NDR_OUT) {
10113                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
10114         }
10115         return NDR_ERR_SUCCESS;
10116 }
10117
10118 _PUBLIC_ void ndr_print_wkssvc_NetrSetPrimaryComputername(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrSetPrimaryComputername *r)
10119 {
10120         ndr_print_struct(ndr, name, "wkssvc_NetrSetPrimaryComputername");
10121         ndr->depth++;
10122         if (flags & NDR_SET_VALUES) {
10123                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10124         }
10125         if (flags & NDR_IN) {
10126                 ndr_print_struct(ndr, "in", "wkssvc_NetrSetPrimaryComputername");
10127                 ndr->depth++;
10128                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
10129                 ndr->depth++;
10130                 if (r->in.server_name) {
10131                         ndr_print_string(ndr, "server_name", r->in.server_name);
10132                 }
10133                 ndr->depth--;
10134                 ndr_print_ptr(ndr, "primary_name", r->in.primary_name);
10135                 ndr->depth++;
10136                 if (r->in.primary_name) {
10137                         ndr_print_string(ndr, "primary_name", r->in.primary_name);
10138                 }
10139                 ndr->depth--;
10140                 ndr_print_ptr(ndr, "Account", r->in.Account);
10141                 ndr->depth++;
10142                 if (r->in.Account) {
10143                         ndr_print_string(ndr, "Account", r->in.Account);
10144                 }
10145                 ndr->depth--;
10146                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
10147                 ndr->depth++;
10148                 if (r->in.EncryptedPassword) {
10149                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
10150                 }
10151                 ndr->depth--;
10152                 ndr_print_uint32(ndr, "Reserved", r->in.Reserved);
10153                 ndr->depth--;
10154         }
10155         if (flags & NDR_OUT) {
10156                 ndr_print_struct(ndr, "out", "wkssvc_NetrSetPrimaryComputername");
10157                 ndr->depth++;
10158                 ndr_print_WERROR(ndr, "result", r->out.result);
10159                 ndr->depth--;
10160         }
10161         ndr->depth--;
10162 }
10163
10164 static enum ndr_err_code ndr_push_wkssvc_NetrEnumerateComputerNames(struct ndr_push *ndr, int flags, const struct wkssvc_NetrEnumerateComputerNames *r)
10165 {
10166         if (flags & NDR_IN) {
10167                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
10168                 if (r->in.server_name) {
10169                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
10170                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10171                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
10172                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10173                 }
10174                 NDR_CHECK(ndr_push_wkssvc_ComputerNameType(ndr, NDR_SCALARS, r->in.name_type));
10175                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Reserved));
10176         }
10177         if (flags & NDR_OUT) {
10178                 if (r->out.ctr == NULL) {
10179                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10180                 }
10181                 if (*r->out.ctr == NULL) {
10182                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10183                 }
10184                 NDR_CHECK(ndr_push_ref_ptr(ndr));
10185                 NDR_CHECK(ndr_push_wkssvc_ComputerNamesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.ctr));
10186                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
10187         }
10188         return NDR_ERR_SUCCESS;
10189 }
10190
10191 static enum ndr_err_code ndr_pull_wkssvc_NetrEnumerateComputerNames(struct ndr_pull *ndr, int flags, struct wkssvc_NetrEnumerateComputerNames *r)
10192 {
10193         uint32_t _ptr_server_name;
10194         uint32_t _ptr_ctr;
10195         TALLOC_CTX *_mem_save_server_name_0;
10196         TALLOC_CTX *_mem_save_ctr_0;
10197         TALLOC_CTX *_mem_save_ctr_1;
10198         if (flags & NDR_IN) {
10199                 ZERO_STRUCT(r->out);
10200
10201                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
10202                 if (_ptr_server_name) {
10203                         NDR_PULL_ALLOC(ndr, r->in.server_name);
10204                 } else {
10205                         r->in.server_name = NULL;
10206                 }
10207                 if (r->in.server_name) {
10208                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10209                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
10210                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
10211                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
10212                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
10213                                 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_name), ndr_get_array_length(ndr, &r->in.server_name));
10214                         }
10215                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
10216                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
10217                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
10218                 }
10219                 NDR_CHECK(ndr_pull_wkssvc_ComputerNameType(ndr, NDR_SCALARS, &r->in.name_type));
10220                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Reserved));
10221                 NDR_PULL_ALLOC(ndr, r->out.ctr);
10222                 ZERO_STRUCTP(r->out.ctr);
10223         }
10224         if (flags & NDR_OUT) {
10225                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10226                         NDR_PULL_ALLOC(ndr, r->out.ctr);
10227                 }
10228                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
10229                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
10230                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_ctr));
10231                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10232                         NDR_PULL_ALLOC(ndr, *r->out.ctr);
10233                 }
10234                 _mem_save_ctr_1 = NDR_PULL_GET_MEM_CTX(ndr);
10235                 NDR_PULL_SET_MEM_CTX(ndr, *r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
10236                 NDR_CHECK(ndr_pull_wkssvc_ComputerNamesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.ctr));
10237                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_1, LIBNDR_FLAG_REF_ALLOC);
10238                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
10239                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
10240         }
10241         return NDR_ERR_SUCCESS;
10242 }
10243
10244 _PUBLIC_ void ndr_print_wkssvc_NetrEnumerateComputerNames(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrEnumerateComputerNames *r)
10245 {
10246         ndr_print_struct(ndr, name, "wkssvc_NetrEnumerateComputerNames");
10247         ndr->depth++;
10248         if (flags & NDR_SET_VALUES) {
10249                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10250         }
10251         if (flags & NDR_IN) {
10252                 ndr_print_struct(ndr, "in", "wkssvc_NetrEnumerateComputerNames");
10253                 ndr->depth++;
10254                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
10255                 ndr->depth++;
10256                 if (r->in.server_name) {
10257                         ndr_print_string(ndr, "server_name", r->in.server_name);
10258                 }
10259                 ndr->depth--;
10260                 ndr_print_wkssvc_ComputerNameType(ndr, "name_type", r->in.name_type);
10261                 ndr_print_uint32(ndr, "Reserved", r->in.Reserved);
10262                 ndr->depth--;
10263         }
10264         if (flags & NDR_OUT) {
10265                 ndr_print_struct(ndr, "out", "wkssvc_NetrEnumerateComputerNames");
10266                 ndr->depth++;
10267                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
10268                 ndr->depth++;
10269                 ndr_print_ptr(ndr, "ctr", *r->out.ctr);
10270                 ndr->depth++;
10271                 ndr_print_wkssvc_ComputerNamesCtr(ndr, "ctr", *r->out.ctr);
10272                 ndr->depth--;
10273                 ndr->depth--;
10274                 ndr_print_WERROR(ndr, "result", r->out.result);
10275                 ndr->depth--;
10276         }
10277         ndr->depth--;
10278 }
10279
10280 static const struct ndr_interface_call wkssvc_calls[] = {
10281         {
10282                 "wkssvc_NetWkstaGetInfo",
10283                 sizeof(struct wkssvc_NetWkstaGetInfo),
10284                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaGetInfo,
10285                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaGetInfo,
10286                 (ndr_print_function_t) ndr_print_wkssvc_NetWkstaGetInfo,
10287                 false,
10288         },
10289         {
10290                 "wkssvc_NetWkstaSetInfo",
10291                 sizeof(struct wkssvc_NetWkstaSetInfo),
10292                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaSetInfo,
10293                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaSetInfo,
10294                 (ndr_print_function_t) ndr_print_wkssvc_NetWkstaSetInfo,
10295                 false,
10296         },
10297         {
10298                 "wkssvc_NetWkstaEnumUsers",
10299                 sizeof(struct wkssvc_NetWkstaEnumUsers),
10300                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaEnumUsers,
10301                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaEnumUsers,
10302                 (ndr_print_function_t) ndr_print_wkssvc_NetWkstaEnumUsers,
10303                 false,
10304         },
10305         {
10306                 "wkssvc_NetrWkstaUserGetInfo",
10307                 sizeof(struct wkssvc_NetrWkstaUserGetInfo),
10308                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrWkstaUserGetInfo,
10309                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrWkstaUserGetInfo,
10310                 (ndr_print_function_t) ndr_print_wkssvc_NetrWkstaUserGetInfo,
10311                 false,
10312         },
10313         {
10314                 "wkssvc_NetrWkstaUserSetInfo",
10315                 sizeof(struct wkssvc_NetrWkstaUserSetInfo),
10316                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrWkstaUserSetInfo,
10317                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrWkstaUserSetInfo,
10318                 (ndr_print_function_t) ndr_print_wkssvc_NetrWkstaUserSetInfo,
10319                 false,
10320         },
10321         {
10322                 "wkssvc_NetWkstaTransportEnum",
10323                 sizeof(struct wkssvc_NetWkstaTransportEnum),
10324                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaTransportEnum,
10325                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaTransportEnum,
10326                 (ndr_print_function_t) ndr_print_wkssvc_NetWkstaTransportEnum,
10327                 false,
10328         },
10329         {
10330                 "wkssvc_NetrWkstaTransportAdd",
10331                 sizeof(struct wkssvc_NetrWkstaTransportAdd),
10332                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrWkstaTransportAdd,
10333                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrWkstaTransportAdd,
10334                 (ndr_print_function_t) ndr_print_wkssvc_NetrWkstaTransportAdd,
10335                 false,
10336         },
10337         {
10338                 "wkssvc_NetrWkstaTransportDel",
10339                 sizeof(struct wkssvc_NetrWkstaTransportDel),
10340                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrWkstaTransportDel,
10341                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrWkstaTransportDel,
10342                 (ndr_print_function_t) ndr_print_wkssvc_NetrWkstaTransportDel,
10343                 false,
10344         },
10345         {
10346                 "wkssvc_NetrUseAdd",
10347                 sizeof(struct wkssvc_NetrUseAdd),
10348                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUseAdd,
10349                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUseAdd,
10350                 (ndr_print_function_t) ndr_print_wkssvc_NetrUseAdd,
10351                 false,
10352         },
10353         {
10354                 "wkssvc_NetrUseGetInfo",
10355                 sizeof(struct wkssvc_NetrUseGetInfo),
10356                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUseGetInfo,
10357                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUseGetInfo,
10358                 (ndr_print_function_t) ndr_print_wkssvc_NetrUseGetInfo,
10359                 false,
10360         },
10361         {
10362                 "wkssvc_NetrUseDel",
10363                 sizeof(struct wkssvc_NetrUseDel),
10364                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUseDel,
10365                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUseDel,
10366                 (ndr_print_function_t) ndr_print_wkssvc_NetrUseDel,
10367                 false,
10368         },
10369         {
10370                 "wkssvc_NetrUseEnum",
10371                 sizeof(struct wkssvc_NetrUseEnum),
10372                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUseEnum,
10373                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUseEnum,
10374                 (ndr_print_function_t) ndr_print_wkssvc_NetrUseEnum,
10375                 false,
10376         },
10377         {
10378                 "wkssvc_NetrMessageBufferSend",
10379                 sizeof(struct wkssvc_NetrMessageBufferSend),
10380                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrMessageBufferSend,
10381                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrMessageBufferSend,
10382                 (ndr_print_function_t) ndr_print_wkssvc_NetrMessageBufferSend,
10383                 false,
10384         },
10385         {
10386                 "wkssvc_NetrWorkstationStatisticsGet",
10387                 sizeof(struct wkssvc_NetrWorkstationStatisticsGet),
10388                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrWorkstationStatisticsGet,
10389                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrWorkstationStatisticsGet,
10390                 (ndr_print_function_t) ndr_print_wkssvc_NetrWorkstationStatisticsGet,
10391                 false,
10392         },
10393         {
10394                 "wkssvc_NetrLogonDomainNameAdd",
10395                 sizeof(struct wkssvc_NetrLogonDomainNameAdd),
10396                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrLogonDomainNameAdd,
10397                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrLogonDomainNameAdd,
10398                 (ndr_print_function_t) ndr_print_wkssvc_NetrLogonDomainNameAdd,
10399                 false,
10400         },
10401         {
10402                 "wkssvc_NetrLogonDomainNameDel",
10403                 sizeof(struct wkssvc_NetrLogonDomainNameDel),
10404                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrLogonDomainNameDel,
10405                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrLogonDomainNameDel,
10406                 (ndr_print_function_t) ndr_print_wkssvc_NetrLogonDomainNameDel,
10407                 false,
10408         },
10409         {
10410                 "wkssvc_NetrJoinDomain",
10411                 sizeof(struct wkssvc_NetrJoinDomain),
10412                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrJoinDomain,
10413                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrJoinDomain,
10414                 (ndr_print_function_t) ndr_print_wkssvc_NetrJoinDomain,
10415                 false,
10416         },
10417         {
10418                 "wkssvc_NetrUnjoinDomain",
10419                 sizeof(struct wkssvc_NetrUnjoinDomain),
10420                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUnjoinDomain,
10421                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUnjoinDomain,
10422                 (ndr_print_function_t) ndr_print_wkssvc_NetrUnjoinDomain,
10423                 false,
10424         },
10425         {
10426                 "wkssvc_NetrRenameMachineInDomain",
10427                 sizeof(struct wkssvc_NetrRenameMachineInDomain),
10428                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrRenameMachineInDomain,
10429                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrRenameMachineInDomain,
10430                 (ndr_print_function_t) ndr_print_wkssvc_NetrRenameMachineInDomain,
10431                 false,
10432         },
10433         {
10434                 "wkssvc_NetrValidateName",
10435                 sizeof(struct wkssvc_NetrValidateName),
10436                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrValidateName,
10437                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrValidateName,
10438                 (ndr_print_function_t) ndr_print_wkssvc_NetrValidateName,
10439                 false,
10440         },
10441         {
10442                 "wkssvc_NetrGetJoinInformation",
10443                 sizeof(struct wkssvc_NetrGetJoinInformation),
10444                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrGetJoinInformation,
10445                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrGetJoinInformation,
10446                 (ndr_print_function_t) ndr_print_wkssvc_NetrGetJoinInformation,
10447                 false,
10448         },
10449         {
10450                 "wkssvc_NetrGetJoinableOus",
10451                 sizeof(struct wkssvc_NetrGetJoinableOus),
10452                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrGetJoinableOus,
10453                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrGetJoinableOus,
10454                 (ndr_print_function_t) ndr_print_wkssvc_NetrGetJoinableOus,
10455                 false,
10456         },
10457         {
10458                 "wkssvc_NetrJoinDomain2",
10459                 sizeof(struct wkssvc_NetrJoinDomain2),
10460                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrJoinDomain2,
10461                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrJoinDomain2,
10462                 (ndr_print_function_t) ndr_print_wkssvc_NetrJoinDomain2,
10463                 false,
10464         },
10465         {
10466                 "wkssvc_NetrUnjoinDomain2",
10467                 sizeof(struct wkssvc_NetrUnjoinDomain2),
10468                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUnjoinDomain2,
10469                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUnjoinDomain2,
10470                 (ndr_print_function_t) ndr_print_wkssvc_NetrUnjoinDomain2,
10471                 false,
10472         },
10473         {
10474                 "wkssvc_NetrRenameMachineInDomain2",
10475                 sizeof(struct wkssvc_NetrRenameMachineInDomain2),
10476                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrRenameMachineInDomain2,
10477                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrRenameMachineInDomain2,
10478                 (ndr_print_function_t) ndr_print_wkssvc_NetrRenameMachineInDomain2,
10479                 false,
10480         },
10481         {
10482                 "wkssvc_NetrValidateName2",
10483                 sizeof(struct wkssvc_NetrValidateName2),
10484                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrValidateName2,
10485                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrValidateName2,
10486                 (ndr_print_function_t) ndr_print_wkssvc_NetrValidateName2,
10487                 false,
10488         },
10489         {
10490                 "wkssvc_NetrGetJoinableOus2",
10491                 sizeof(struct wkssvc_NetrGetJoinableOus2),
10492                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrGetJoinableOus2,
10493                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrGetJoinableOus2,
10494                 (ndr_print_function_t) ndr_print_wkssvc_NetrGetJoinableOus2,
10495                 false,
10496         },
10497         {
10498                 "wkssvc_NetrAddAlternateComputerName",
10499                 sizeof(struct wkssvc_NetrAddAlternateComputerName),
10500                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrAddAlternateComputerName,
10501                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrAddAlternateComputerName,
10502                 (ndr_print_function_t) ndr_print_wkssvc_NetrAddAlternateComputerName,
10503                 false,
10504         },
10505         {
10506                 "wkssvc_NetrRemoveAlternateComputerName",
10507                 sizeof(struct wkssvc_NetrRemoveAlternateComputerName),
10508                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrRemoveAlternateComputerName,
10509                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrRemoveAlternateComputerName,
10510                 (ndr_print_function_t) ndr_print_wkssvc_NetrRemoveAlternateComputerName,
10511                 false,
10512         },
10513         {
10514                 "wkssvc_NetrSetPrimaryComputername",
10515                 sizeof(struct wkssvc_NetrSetPrimaryComputername),
10516                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrSetPrimaryComputername,
10517                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrSetPrimaryComputername,
10518                 (ndr_print_function_t) ndr_print_wkssvc_NetrSetPrimaryComputername,
10519                 false,
10520         },
10521         {
10522                 "wkssvc_NetrEnumerateComputerNames",
10523                 sizeof(struct wkssvc_NetrEnumerateComputerNames),
10524                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrEnumerateComputerNames,
10525                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrEnumerateComputerNames,
10526                 (ndr_print_function_t) ndr_print_wkssvc_NetrEnumerateComputerNames,
10527                 false,
10528         },
10529         { NULL, 0, NULL, NULL, NULL, false }
10530 };
10531
10532 static const char * const wkssvc_endpoint_strings[] = {
10533         "ncacn_np:[\\pipe\\wkssvc]",
10534         "ncacn_ip_tcp:",
10535         "ncalrpc:",
10536 };
10537
10538 static const struct ndr_interface_string_array wkssvc_endpoints = {
10539         .count  = 3,
10540         .names  = wkssvc_endpoint_strings
10541 };
10542
10543 static const char * const wkssvc_authservice_strings[] = {
10544         "host",
10545 };
10546
10547 static const struct ndr_interface_string_array wkssvc_authservices = {
10548         .count  = 3,
10549         .names  = wkssvc_authservice_strings
10550 };
10551
10552
10553 const struct ndr_interface_table ndr_table_wkssvc = {
10554         .name           = "wkssvc",
10555         .syntax_id      = {
10556                 {0x6bffd098,0xa112,0x3610,{0x98,0x33},{0x46,0xc3,0xf8,0x7e,0x34,0x5a}},
10557                 NDR_WKSSVC_VERSION
10558         },
10559         .helpstring     = NDR_WKSSVC_HELPSTRING,
10560         .num_calls      = 31,
10561         .calls          = wkssvc_calls,
10562         .endpoints      = &wkssvc_endpoints,
10563         .authservices   = &wkssvc_authservices
10564 };
10565