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, 5));
  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                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
  18         }
  19         if (ndr_flags & NDR_BUFFERS) {
  20                 if (r->server_name) {
  21                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
  22                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
  23                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
  24                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
  25                 }
  26                 if (r->domain_name) {
  27                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
  28                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
  29                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
  30                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
  31                 }
  32         }
  33         return NDR_ERR_SUCCESS;
  34 }
  35
  36 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo100(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo100 *r)
  37 {
  38         uint32_t _ptr_server_name;
  39         TALLOC_CTX *_mem_save_server_name_0;
  40         uint32_t _ptr_domain_name;
  41         TALLOC_CTX *_mem_save_domain_name_0;
  42         if (ndr_flags & NDR_SCALARS) {
  43                 NDR_CHECK(ndr_pull_align(ndr, 5));
  44                 NDR_CHECK(ndr_pull_srvsvc_PlatformId(ndr, NDR_SCALARS, &r->platform_id));
  45                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
  46                 if (_ptr_server_name) {
  47                         NDR_PULL_ALLOC(ndr, r->server_name);
  48                 } else {
  49                         r->server_name = NULL;
  50                 }
  51                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
  52                 if (_ptr_domain_name) {
  53                         NDR_PULL_ALLOC(ndr, r->domain_name);
  54                 } else {
  55                         r->domain_name = NULL;
  56                 }
  57                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_major));
  58                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_minor));
  59                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
  60         }
  61         if (ndr_flags & NDR_BUFFERS) {
  62                 if (r->server_name) {
  63                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
  64                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
  65                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
  66                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
  67                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
  68                                 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));
  69                         }
  70                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
  71                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
  72                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
  73                 }
  74                 if (r->domain_name) {
  75                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
  76                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
  77                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
  78                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
  79                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
  80                                 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));
  81                         }
  82                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
  83                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
  84                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
  85                 }
  86         }
  87         return NDR_ERR_SUCCESS;
  88 }
  89
  90 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo100(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo100 *r)
  91 {
  92         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo100");
  93         ndr->depth++;
  94         ndr_print_srvsvc_PlatformId(ndr, "platform_id", r->platform_id);
  95         ndr_print_ptr(ndr, "server_name", r->server_name);
  96         ndr->depth++;
  97         if (r->server_name) {
  98                 ndr_print_string(ndr, "server_name", r->server_name);
  99         }
 100         ndr->depth--;
 101         ndr_print_ptr(ndr, "domain_name", r->domain_name);
 102         ndr->depth++;
 103         if (r->domain_name) {
 104                 ndr_print_string(ndr, "domain_name", r->domain_name);
 105         }
 106         ndr->depth--;
 107         ndr_print_uint32(ndr, "version_major", r->version_major);
 108         ndr_print_uint32(ndr, "version_minor", r->version_minor);
 109         ndr->depth--;
 110 }
 111
 112 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo101(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo101 *r)
 113 {
 114         if (ndr_flags & NDR_SCALARS) {
 115                 NDR_CHECK(ndr_push_align(ndr, 5));
 116                 NDR_CHECK(ndr_push_srvsvc_PlatformId(ndr, NDR_SCALARS, r->platform_id));
 117                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
 118                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
 119                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_major));
 120                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_minor));
 121                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->lan_root));
 122                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 123         }
 124         if (ndr_flags & NDR_BUFFERS) {
 125                 if (r->server_name) {
 126                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
 127                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 128                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
 129                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 130                 }
 131                 if (r->domain_name) {
 132                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
 133                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 134                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
 135                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 136                 }
 137                 if (r->lan_root) {
 138                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lan_root, CH_UTF16)));
 139                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 140                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lan_root, CH_UTF16)));
 141                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->lan_root, ndr_charset_length(r->lan_root, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 142                 }
 143         }
 144         return NDR_ERR_SUCCESS;
 145 }
 146
 147 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo101(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo101 *r)
 148 {
 149         uint32_t _ptr_server_name;
 150         TALLOC_CTX *_mem_save_server_name_0;
 151         uint32_t _ptr_domain_name;
 152         TALLOC_CTX *_mem_save_domain_name_0;
 153         uint32_t _ptr_lan_root;
 154         TALLOC_CTX *_mem_save_lan_root_0;
 155         if (ndr_flags & NDR_SCALARS) {
 156                 NDR_CHECK(ndr_pull_align(ndr, 5));
 157                 NDR_CHECK(ndr_pull_srvsvc_PlatformId(ndr, NDR_SCALARS, &r->platform_id));
 158                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
 159                 if (_ptr_server_name) {
 160                         NDR_PULL_ALLOC(ndr, r->server_name);
 161                 } else {
 162                         r->server_name = NULL;
 163                 }
 164                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
 165                 if (_ptr_domain_name) {
 166                         NDR_PULL_ALLOC(ndr, r->domain_name);
 167                 } else {
 168                         r->domain_name = NULL;
 169                 }
 170                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_major));
 171                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_minor));
 172                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lan_root));
 173                 if (_ptr_lan_root) {
 174                         NDR_PULL_ALLOC(ndr, r->lan_root);
 175                 } else {
 176                         r->lan_root = NULL;
 177                 }
 178                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 179         }
 180         if (ndr_flags & NDR_BUFFERS) {
 181                 if (r->server_name) {
 182                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 183                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
 184                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
 185                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
 186                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
 187                                 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));
 188                         }
 189                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
 190                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
 191                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
 192                 }
 193                 if (r->domain_name) {
 194                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 195                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
 196                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
 197                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
 198                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
 199                                 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));
 200                         }
 201                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
 202                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
 203                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
 204                 }
 205                 if (r->lan_root) {
 206                         _mem_save_lan_root_0 = NDR_PULL_GET_MEM_CTX(ndr);
 207                         NDR_PULL_SET_MEM_CTX(ndr, r->lan_root, 0);
 208                         NDR_CHECK(ndr_pull_array_size(ndr, &r->lan_root));
 209                         NDR_CHECK(ndr_pull_array_length(ndr, &r->lan_root));
 210                         if (ndr_get_array_length(ndr, &r->lan_root) > ndr_get_array_size(ndr, &r->lan_root)) {
 211                                 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));
 212                         }
 213                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->lan_root), sizeof(uint16_t)));
 214                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->lan_root, ndr_get_array_length(ndr, &r->lan_root), sizeof(uint16_t), CH_UTF16));
 215                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lan_root_0, 0);
 216                 }
 217         }
 218         return NDR_ERR_SUCCESS;
 219 }
 220
 221 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo101(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo101 *r)
 222 {
 223         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo101");
 224         ndr->depth++;
 225         ndr_print_srvsvc_PlatformId(ndr, "platform_id", r->platform_id);
 226         ndr_print_ptr(ndr, "server_name", r->server_name);
 227         ndr->depth++;
 228         if (r->server_name) {
 229                 ndr_print_string(ndr, "server_name", r->server_name);
 230         }
 231         ndr->depth--;
 232         ndr_print_ptr(ndr, "domain_name", r->domain_name);
 233         ndr->depth++;
 234         if (r->domain_name) {
 235                 ndr_print_string(ndr, "domain_name", r->domain_name);
 236         }
 237         ndr->depth--;
 238         ndr_print_uint32(ndr, "version_major", r->version_major);
 239         ndr_print_uint32(ndr, "version_minor", r->version_minor);
 240         ndr_print_ptr(ndr, "lan_root", r->lan_root);
 241         ndr->depth++;
 242         if (r->lan_root) {
 243                 ndr_print_string(ndr, "lan_root", r->lan_root);
 244         }
 245         ndr->depth--;
 246         ndr->depth--;
 247 }
 248
 249 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo102(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo102 *r)
 250 {
 251         if (ndr_flags & NDR_SCALARS) {
 252                 NDR_CHECK(ndr_push_align(ndr, 5));
 253                 NDR_CHECK(ndr_push_srvsvc_PlatformId(ndr, NDR_SCALARS, r->platform_id));
 254                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
 255                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
 256                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_major));
 257                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_minor));
 258                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->lan_root));
 259                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->logged_on_users));
 260                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 261         }
 262         if (ndr_flags & NDR_BUFFERS) {
 263                 if (r->server_name) {
 264                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
 265                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 266                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
 267                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 268                 }
 269                 if (r->domain_name) {
 270                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
 271                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 272                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
 273                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 274                 }
 275                 if (r->lan_root) {
 276                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lan_root, CH_UTF16)));
 277                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 278                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lan_root, CH_UTF16)));
 279                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->lan_root, ndr_charset_length(r->lan_root, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 280                 }
 281         }
 282         return NDR_ERR_SUCCESS;
 283 }
 284
 285 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo102(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo102 *r)
 286 {
 287         uint32_t _ptr_server_name;
 288         TALLOC_CTX *_mem_save_server_name_0;
 289         uint32_t _ptr_domain_name;
 290         TALLOC_CTX *_mem_save_domain_name_0;
 291         uint32_t _ptr_lan_root;
 292         TALLOC_CTX *_mem_save_lan_root_0;
 293         if (ndr_flags & NDR_SCALARS) {
 294                 NDR_CHECK(ndr_pull_align(ndr, 5));
 295                 NDR_CHECK(ndr_pull_srvsvc_PlatformId(ndr, NDR_SCALARS, &r->platform_id));
 296                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
 297                 if (_ptr_server_name) {
 298                         NDR_PULL_ALLOC(ndr, r->server_name);
 299                 } else {
 300                         r->server_name = NULL;
 301                 }
 302                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
 303                 if (_ptr_domain_name) {
 304                         NDR_PULL_ALLOC(ndr, r->domain_name);
 305                 } else {
 306                         r->domain_name = NULL;
 307                 }
 308                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_major));
 309                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_minor));
 310                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lan_root));
 311                 if (_ptr_lan_root) {
 312                         NDR_PULL_ALLOC(ndr, r->lan_root);
 313                 } else {
 314                         r->lan_root = NULL;
 315                 }
 316                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->logged_on_users));
 317                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 318         }
 319         if (ndr_flags & NDR_BUFFERS) {
 320                 if (r->server_name) {
 321                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 322                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
 323                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
 324                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
 325                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
 326                                 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));
 327                         }
 328                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
 329                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
 330                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
 331                 }
 332                 if (r->domain_name) {
 333                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 334                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
 335                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
 336                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
 337                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
 338                                 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));
 339                         }
 340                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
 341                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
 342                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
 343                 }
 344                 if (r->lan_root) {
 345                         _mem_save_lan_root_0 = NDR_PULL_GET_MEM_CTX(ndr);
 346                         NDR_PULL_SET_MEM_CTX(ndr, r->lan_root, 0);
 347                         NDR_CHECK(ndr_pull_array_size(ndr, &r->lan_root));
 348                         NDR_CHECK(ndr_pull_array_length(ndr, &r->lan_root));
 349                         if (ndr_get_array_length(ndr, &r->lan_root) > ndr_get_array_size(ndr, &r->lan_root)) {
 350                                 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));
 351                         }
 352                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->lan_root), sizeof(uint16_t)));
 353                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->lan_root, ndr_get_array_length(ndr, &r->lan_root), sizeof(uint16_t), CH_UTF16));
 354                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lan_root_0, 0);
 355                 }
 356         }
 357         return NDR_ERR_SUCCESS;
 358 }
 359
 360 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo102(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo102 *r)
 361 {
 362         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo102");
 363         ndr->depth++;
 364         ndr_print_srvsvc_PlatformId(ndr, "platform_id", r->platform_id);
 365         ndr_print_ptr(ndr, "server_name", r->server_name);
 366         ndr->depth++;
 367         if (r->server_name) {
 368                 ndr_print_string(ndr, "server_name", r->server_name);
 369         }
 370         ndr->depth--;
 371         ndr_print_ptr(ndr, "domain_name", r->domain_name);
 372         ndr->depth++;
 373         if (r->domain_name) {
 374                 ndr_print_string(ndr, "domain_name", r->domain_name);
 375         }
 376         ndr->depth--;
 377         ndr_print_uint32(ndr, "version_major", r->version_major);
 378         ndr_print_uint32(ndr, "version_minor", r->version_minor);
 379         ndr_print_ptr(ndr, "lan_root", r->lan_root);
 380         ndr->depth++;
 381         if (r->lan_root) {
 382                 ndr_print_string(ndr, "lan_root", r->lan_root);
 383         }
 384         ndr->depth--;
 385         ndr_print_uint32(ndr, "logged_on_users", r->logged_on_users);
 386         ndr->depth--;
 387 }
 388
 389 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo502(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo502 *r)
 390 {
 391         if (ndr_flags & NDR_SCALARS) {
 392                 NDR_CHECK(ndr_push_align(ndr, 4));
 393                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->char_wait));
 394                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->collection_time));
 395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maximum_collection_count));
 396                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->keep_connection));
 397                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_commands));
 398                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_timeout));
 399                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_char_buf));
 400                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_threads));
 401                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_quota));
 402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_increment));
 403                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_maximum));
 404                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pipe_increment));
 405                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pipe_maximum));
 406                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cache_file_timeout));
 407                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dormant_file_limit));
 408                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->read_ahead_throughput));
 409                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_mailslot_buffers));
 410                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_srv_announce_buffers));
 411                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_illegal_dgram_events));
 412                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dgram_event_reset_freq));
 413                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->log_election_packets));
 414                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_opportunistic_locking));
 415                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_unlock_behind));
 416                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_close_behind));
 417                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_named_pipes));
 418                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_lock_read_unlock));
 419                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->utilize_nt_caching));
 420                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_raw_read));
 421                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_raw_write));
 422                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_write_raw_data));
 423                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_encryption));
 424                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_files_deny_write));
 425                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_read_only_files));
 426                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->force_core_create_mode));
 427                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_512_byte_max_transfer));
 428                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 429         }
 430         if (ndr_flags & NDR_BUFFERS) {
 431         }
 432         return NDR_ERR_SUCCESS;
 433 }
 434
 435 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo502(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo502 *r)
 436 {
 437         if (ndr_flags & NDR_SCALARS) {
 438                 NDR_CHECK(ndr_pull_align(ndr, 4));
 439                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->char_wait));
 440                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->collection_time));
 441                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maximum_collection_count));
 442                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->keep_connection));
 443                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_commands));
 444                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_timeout));
 445                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_char_buf));
 446                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_threads));
 447                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_quota));
 448                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_increment));
 449                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_maximum));
 450                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pipe_increment));
 451                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pipe_maximum));
 452                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cache_file_timeout));
 453                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dormant_file_limit));
 454                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->read_ahead_throughput));
 455                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_mailslot_buffers));
 456                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_srv_announce_buffers));
 457                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_illegal_dgram_events));
 458                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dgram_event_reset_freq));
 459                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->log_election_packets));
 460                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_opportunistic_locking));
 461                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_unlock_behind));
 462                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_close_behind));
 463                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_named_pipes));
 464                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_lock_read_unlock));
 465                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->utilize_nt_caching));
 466                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_raw_read));
 467                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_raw_write));
 468                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_write_raw_data));
 469                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_encryption));
 470                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_files_deny_write));
 471                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_read_only_files));
 472                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->force_core_create_mode));
 473                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_512_byte_max_transfer));
 474                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 475         }
 476         if (ndr_flags & NDR_BUFFERS) {
 477         }
 478         return NDR_ERR_SUCCESS;
 479 }
 480
 481 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo502(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo502 *r)
 482 {
 483         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo502");
 484         ndr->depth++;
 485         ndr_print_uint32(ndr, "char_wait", r->char_wait);
 486         ndr_print_uint32(ndr, "collection_time", r->collection_time);
 487         ndr_print_uint32(ndr, "maximum_collection_count", r->maximum_collection_count);
 488         ndr_print_uint32(ndr, "keep_connection", r->keep_connection);
 489         ndr_print_uint32(ndr, "max_commands", r->max_commands);
 490         ndr_print_uint32(ndr, "session_timeout", r->session_timeout);
 491         ndr_print_uint32(ndr, "size_char_buf", r->size_char_buf);
 492         ndr_print_uint32(ndr, "max_threads", r->max_threads);
 493         ndr_print_uint32(ndr, "lock_quota", r->lock_quota);
 494         ndr_print_uint32(ndr, "lock_increment", r->lock_increment);
 495         ndr_print_uint32(ndr, "lock_maximum", r->lock_maximum);
 496         ndr_print_uint32(ndr, "pipe_increment", r->pipe_increment);
 497         ndr_print_uint32(ndr, "pipe_maximum", r->pipe_maximum);
 498         ndr_print_uint32(ndr, "cache_file_timeout", r->cache_file_timeout);
 499         ndr_print_uint32(ndr, "dormant_file_limit", r->dormant_file_limit);
 500         ndr_print_uint32(ndr, "read_ahead_throughput", r->read_ahead_throughput);
 501         ndr_print_uint32(ndr, "num_mailslot_buffers", r->num_mailslot_buffers);
 502         ndr_print_uint32(ndr, "num_srv_announce_buffers", r->num_srv_announce_buffers);
 503         ndr_print_uint32(ndr, "max_illegal_dgram_events", r->max_illegal_dgram_events);
 504         ndr_print_uint32(ndr, "dgram_event_reset_freq", r->dgram_event_reset_freq);
 505         ndr_print_uint32(ndr, "log_election_packets", r->log_election_packets);
 506         ndr_print_uint32(ndr, "use_opportunistic_locking", r->use_opportunistic_locking);
 507         ndr_print_uint32(ndr, "use_unlock_behind", r->use_unlock_behind);
 508         ndr_print_uint32(ndr, "use_close_behind", r->use_close_behind);
 509         ndr_print_uint32(ndr, "buf_named_pipes", r->buf_named_pipes);
 510         ndr_print_uint32(ndr, "use_lock_read_unlock", r->use_lock_read_unlock);
 511         ndr_print_uint32(ndr, "utilize_nt_caching", r->utilize_nt_caching);
 512         ndr_print_uint32(ndr, "use_raw_read", r->use_raw_read);
 513         ndr_print_uint32(ndr, "use_raw_write", r->use_raw_write);
 514         ndr_print_uint32(ndr, "use_write_raw_data", r->use_write_raw_data);
 515         ndr_print_uint32(ndr, "use_encryption", r->use_encryption);
 516         ndr_print_uint32(ndr, "buf_files_deny_write", r->buf_files_deny_write);
 517         ndr_print_uint32(ndr, "buf_read_only_files", r->buf_read_only_files);
 518         ndr_print_uint32(ndr, "force_core_create_mode", r->force_core_create_mode);
 519         ndr_print_uint32(ndr, "use_512_byte_max_transfer", r->use_512_byte_max_transfer);
 520         ndr->depth--;
 521 }
 522
 523 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1010(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1010 *r)
 524 {
 525         if (ndr_flags & NDR_SCALARS) {
 526                 NDR_CHECK(ndr_push_align(ndr, 4));
 527                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->char_wait));
 528                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 529         }
 530         if (ndr_flags & NDR_BUFFERS) {
 531         }
 532         return NDR_ERR_SUCCESS;
 533 }
 534
 535 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1010(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1010 *r)
 536 {
 537         if (ndr_flags & NDR_SCALARS) {
 538                 NDR_CHECK(ndr_pull_align(ndr, 4));
 539                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->char_wait));
 540                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 541         }
 542         if (ndr_flags & NDR_BUFFERS) {
 543         }
 544         return NDR_ERR_SUCCESS;
 545 }
 546
 547 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1010(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1010 *r)
 548 {
 549         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1010");
 550         ndr->depth++;
 551         ndr_print_uint32(ndr, "char_wait", r->char_wait);
 552         ndr->depth--;
 553 }
 554
 555 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1011(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1011 *r)
 556 {
 557         if (ndr_flags & NDR_SCALARS) {
 558                 NDR_CHECK(ndr_push_align(ndr, 4));
 559                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->collection_time));
 560                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 561         }
 562         if (ndr_flags & NDR_BUFFERS) {
 563         }
 564         return NDR_ERR_SUCCESS;
 565 }
 566
 567 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1011(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1011 *r)
 568 {
 569         if (ndr_flags & NDR_SCALARS) {
 570                 NDR_CHECK(ndr_pull_align(ndr, 4));
 571                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->collection_time));
 572                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 573         }
 574         if (ndr_flags & NDR_BUFFERS) {
 575         }
 576         return NDR_ERR_SUCCESS;
 577 }
 578
 579 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1011(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1011 *r)
 580 {
 581         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1011");
 582         ndr->depth++;
 583         ndr_print_uint32(ndr, "collection_time", r->collection_time);
 584         ndr->depth--;
 585 }
 586
 587 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1012(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1012 *r)
 588 {
 589         if (ndr_flags & NDR_SCALARS) {
 590                 NDR_CHECK(ndr_push_align(ndr, 4));
 591                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maximum_collection_count));
 592                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 593         }
 594         if (ndr_flags & NDR_BUFFERS) {
 595         }
 596         return NDR_ERR_SUCCESS;
 597 }
 598
 599 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1012(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1012 *r)
 600 {
 601         if (ndr_flags & NDR_SCALARS) {
 602                 NDR_CHECK(ndr_pull_align(ndr, 4));
 603                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maximum_collection_count));
 604                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 605         }
 606         if (ndr_flags & NDR_BUFFERS) {
 607         }
 608         return NDR_ERR_SUCCESS;
 609 }
 610
 611 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1012(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1012 *r)
 612 {
 613         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1012");
 614         ndr->depth++;
 615         ndr_print_uint32(ndr, "maximum_collection_count", r->maximum_collection_count);
 616         ndr->depth--;
 617 }
 618
 619 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1013(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1013 *r)
 620 {
 621         if (ndr_flags & NDR_SCALARS) {
 622                 NDR_CHECK(ndr_push_align(ndr, 4));
 623                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->keep_connection));
 624                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 625         }
 626         if (ndr_flags & NDR_BUFFERS) {
 627         }
 628         return NDR_ERR_SUCCESS;
 629 }
 630
 631 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1013(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1013 *r)
 632 {
 633         if (ndr_flags & NDR_SCALARS) {
 634                 NDR_CHECK(ndr_pull_align(ndr, 4));
 635                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->keep_connection));
 636                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 637         }
 638         if (ndr_flags & NDR_BUFFERS) {
 639         }
 640         return NDR_ERR_SUCCESS;
 641 }
 642
 643 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1013(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1013 *r)
 644 {
 645         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1013");
 646         ndr->depth++;
 647         ndr_print_uint32(ndr, "keep_connection", r->keep_connection);
 648         ndr->depth--;
 649 }
 650
 651 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1018(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1018 *r)
 652 {
 653         if (ndr_flags & NDR_SCALARS) {
 654                 NDR_CHECK(ndr_push_align(ndr, 4));
 655                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_timeout));
 656                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 657         }
 658         if (ndr_flags & NDR_BUFFERS) {
 659         }
 660         return NDR_ERR_SUCCESS;
 661 }
 662
 663 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1018(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1018 *r)
 664 {
 665         if (ndr_flags & NDR_SCALARS) {
 666                 NDR_CHECK(ndr_pull_align(ndr, 4));
 667                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_timeout));
 668                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 669         }
 670         if (ndr_flags & NDR_BUFFERS) {
 671         }
 672         return NDR_ERR_SUCCESS;
 673 }
 674
 675 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1018(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1018 *r)
 676 {
 677         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1018");
 678         ndr->depth++;
 679         ndr_print_uint32(ndr, "session_timeout", r->session_timeout);
 680         ndr->depth--;
 681 }
 682
 683 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1023(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1023 *r)
 684 {
 685         if (ndr_flags & NDR_SCALARS) {
 686                 NDR_CHECK(ndr_push_align(ndr, 4));
 687                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_char_buf));
 688                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 689         }
 690         if (ndr_flags & NDR_BUFFERS) {
 691         }
 692         return NDR_ERR_SUCCESS;
 693 }
 694
 695 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1023(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1023 *r)
 696 {
 697         if (ndr_flags & NDR_SCALARS) {
 698                 NDR_CHECK(ndr_pull_align(ndr, 4));
 699                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_char_buf));
 700                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 701         }
 702         if (ndr_flags & NDR_BUFFERS) {
 703         }
 704         return NDR_ERR_SUCCESS;
 705 }
 706
 707 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1023(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1023 *r)
 708 {
 709         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1023");
 710         ndr->depth++;
 711         ndr_print_uint32(ndr, "size_char_buf", r->size_char_buf);
 712         ndr->depth--;
 713 }
 714
 715 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1027(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1027 *r)
 716 {
 717         if (ndr_flags & NDR_SCALARS) {
 718                 NDR_CHECK(ndr_push_align(ndr, 4));
 719                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->errorlog_sz));
 720                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 721         }
 722         if (ndr_flags & NDR_BUFFERS) {
 723         }
 724         return NDR_ERR_SUCCESS;
 725 }
 726
 727 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1027(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1027 *r)
 728 {
 729         if (ndr_flags & NDR_SCALARS) {
 730                 NDR_CHECK(ndr_pull_align(ndr, 4));
 731                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->errorlog_sz));
 732                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 733         }
 734         if (ndr_flags & NDR_BUFFERS) {
 735         }
 736         return NDR_ERR_SUCCESS;
 737 }
 738
 739 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1027(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1027 *r)
 740 {
 741         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1027");
 742         ndr->depth++;
 743         ndr_print_uint32(ndr, "errorlog_sz", r->errorlog_sz);
 744         ndr->depth--;
 745 }
 746
 747 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1028(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1028 *r)
 748 {
 749         if (ndr_flags & NDR_SCALARS) {
 750                 NDR_CHECK(ndr_push_align(ndr, 4));
 751                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->print_buf_time));
 752                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 753         }
 754         if (ndr_flags & NDR_BUFFERS) {
 755         }
 756         return NDR_ERR_SUCCESS;
 757 }
 758
 759 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1028(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1028 *r)
 760 {
 761         if (ndr_flags & NDR_SCALARS) {
 762                 NDR_CHECK(ndr_pull_align(ndr, 4));
 763                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->print_buf_time));
 764                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 765         }
 766         if (ndr_flags & NDR_BUFFERS) {
 767         }
 768         return NDR_ERR_SUCCESS;
 769 }
 770
 771 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1028(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1028 *r)
 772 {
 773         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1028");
 774         ndr->depth++;
 775         ndr_print_uint32(ndr, "print_buf_time", r->print_buf_time);
 776         ndr->depth--;
 777 }
 778
 779 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1032(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1032 *r)
 780 {
 781         if (ndr_flags & NDR_SCALARS) {
 782                 NDR_CHECK(ndr_push_align(ndr, 4));
 783                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->wrk_heuristics));
 784                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 785         }
 786         if (ndr_flags & NDR_BUFFERS) {
 787         }
 788         return NDR_ERR_SUCCESS;
 789 }
 790
 791 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1032(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1032 *r)
 792 {
 793         if (ndr_flags & NDR_SCALARS) {
 794                 NDR_CHECK(ndr_pull_align(ndr, 4));
 795                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->wrk_heuristics));
 796                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 797         }
 798         if (ndr_flags & NDR_BUFFERS) {
 799         }
 800         return NDR_ERR_SUCCESS;
 801 }
 802
 803 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1032(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1032 *r)
 804 {
 805         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1032");
 806         ndr->depth++;
 807         ndr_print_uint32(ndr, "wrk_heuristics", r->wrk_heuristics);
 808         ndr->depth--;
 809 }
 810
 811 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1033(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1033 *r)
 812 {
 813         if (ndr_flags & NDR_SCALARS) {
 814                 NDR_CHECK(ndr_push_align(ndr, 4));
 815                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_threads));
 816                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 817         }
 818         if (ndr_flags & NDR_BUFFERS) {
 819         }
 820         return NDR_ERR_SUCCESS;
 821 }
 822
 823 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1033(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1033 *r)
 824 {
 825         if (ndr_flags & NDR_SCALARS) {
 826                 NDR_CHECK(ndr_pull_align(ndr, 4));
 827                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_threads));
 828                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 829         }
 830         if (ndr_flags & NDR_BUFFERS) {
 831         }
 832         return NDR_ERR_SUCCESS;
 833 }
 834
 835 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1033(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1033 *r)
 836 {
 837         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1033");
 838         ndr->depth++;
 839         ndr_print_uint32(ndr, "max_threads", r->max_threads);
 840         ndr->depth--;
 841 }
 842
 843 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1041(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1041 *r)
 844 {
 845         if (ndr_flags & NDR_SCALARS) {
 846                 NDR_CHECK(ndr_push_align(ndr, 4));
 847                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_quota));
 848                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 849         }
 850         if (ndr_flags & NDR_BUFFERS) {
 851         }
 852         return NDR_ERR_SUCCESS;
 853 }
 854
 855 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1041(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1041 *r)
 856 {
 857         if (ndr_flags & NDR_SCALARS) {
 858                 NDR_CHECK(ndr_pull_align(ndr, 4));
 859                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_quota));
 860                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 861         }
 862         if (ndr_flags & NDR_BUFFERS) {
 863         }
 864         return NDR_ERR_SUCCESS;
 865 }
 866
 867 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1041(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1041 *r)
 868 {
 869         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1041");
 870         ndr->depth++;
 871         ndr_print_uint32(ndr, "lock_quota", r->lock_quota);
 872         ndr->depth--;
 873 }
 874
 875 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1042(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1042 *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_increment));
 880                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 881         }
 882         if (ndr_flags & NDR_BUFFERS) {
 883         }
 884         return NDR_ERR_SUCCESS;
 885 }
 886
 887 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1042(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1042 *r)
 888 {
 889         if (ndr_flags & NDR_SCALARS) {
 890                 NDR_CHECK(ndr_pull_align(ndr, 4));
 891                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_increment));
 892                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 893         }
 894         if (ndr_flags & NDR_BUFFERS) {
 895         }
 896         return NDR_ERR_SUCCESS;
 897 }
 898
 899 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1042(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1042 *r)
 900 {
 901         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1042");
 902         ndr->depth++;
 903         ndr_print_uint32(ndr, "lock_increment", r->lock_increment);
 904         ndr->depth--;
 905 }
 906
 907 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1043(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1043 *r)
 908 {
 909         if (ndr_flags & NDR_SCALARS) {
 910                 NDR_CHECK(ndr_push_align(ndr, 4));
 911                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_maximum));
 912                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 913         }
 914         if (ndr_flags & NDR_BUFFERS) {
 915         }
 916         return NDR_ERR_SUCCESS;
 917 }
 918
 919 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1043(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1043 *r)
 920 {
 921         if (ndr_flags & NDR_SCALARS) {
 922                 NDR_CHECK(ndr_pull_align(ndr, 4));
 923                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_maximum));
 924                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 925         }
 926         if (ndr_flags & NDR_BUFFERS) {
 927         }
 928         return NDR_ERR_SUCCESS;
 929 }
 930
 931 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1043(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1043 *r)
 932 {
 933         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1043");
 934         ndr->depth++;
 935         ndr_print_uint32(ndr, "lock_maximum", r->lock_maximum);
 936         ndr->depth--;
 937 }
 938
 939 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1044(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1044 *r)
 940 {
 941         if (ndr_flags & NDR_SCALARS) {
 942                 NDR_CHECK(ndr_push_align(ndr, 4));
 943                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pipe_increment));
 944                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 945         }
 946         if (ndr_flags & NDR_BUFFERS) {
 947         }
 948         return NDR_ERR_SUCCESS;
 949 }
 950
 951 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1044(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1044 *r)
 952 {
 953         if (ndr_flags & NDR_SCALARS) {
 954                 NDR_CHECK(ndr_pull_align(ndr, 4));
 955                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pipe_increment));
 956                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 957         }
 958         if (ndr_flags & NDR_BUFFERS) {
 959         }
 960         return NDR_ERR_SUCCESS;
 961 }
 962
 963 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1044(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1044 *r)
 964 {
 965         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1044");
 966         ndr->depth++;
 967         ndr_print_uint32(ndr, "pipe_increment", r->pipe_increment);
 968         ndr->depth--;
 969 }
 970
 971 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1045(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1045 *r)
 972 {
 973         if (ndr_flags & NDR_SCALARS) {
 974                 NDR_CHECK(ndr_push_align(ndr, 4));
 975                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pipe_maximum));
 976                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 977         }
 978         if (ndr_flags & NDR_BUFFERS) {
 979         }
 980         return NDR_ERR_SUCCESS;
 981 }
 982
 983 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1045(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1045 *r)
 984 {
 985         if (ndr_flags & NDR_SCALARS) {
 986                 NDR_CHECK(ndr_pull_align(ndr, 4));
 987                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pipe_maximum));
 988                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 989         }
 990         if (ndr_flags & NDR_BUFFERS) {
 991         }
 992         return NDR_ERR_SUCCESS;
 993 }
 994
 995 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1045(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1045 *r)
 996 {
 997         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1045");
 998         ndr->depth++;
 999         ndr_print_uint32(ndr, "pipe_maximum", r->pipe_maximum);
1000         ndr->depth--;
1001 }
1002
1003 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1046(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1046 *r)
1004 {
1005         if (ndr_flags & NDR_SCALARS) {
1006                 NDR_CHECK(ndr_push_align(ndr, 4));
1007                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dormant_file_limit));
1008                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1009         }
1010         if (ndr_flags & NDR_BUFFERS) {
1011         }
1012         return NDR_ERR_SUCCESS;
1013 }
1014
1015 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1046(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1046 *r)
1016 {
1017         if (ndr_flags & NDR_SCALARS) {
1018                 NDR_CHECK(ndr_pull_align(ndr, 4));
1019                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dormant_file_limit));
1020                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1021         }
1022         if (ndr_flags & NDR_BUFFERS) {
1023         }
1024         return NDR_ERR_SUCCESS;
1025 }
1026
1027 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1046(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1046 *r)
1028 {
1029         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1046");
1030         ndr->depth++;
1031         ndr_print_uint32(ndr, "dormant_file_limit", r->dormant_file_limit);
1032         ndr->depth--;
1033 }
1034
1035 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1047(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1047 *r)
1036 {
1037         if (ndr_flags & NDR_SCALARS) {
1038                 NDR_CHECK(ndr_push_align(ndr, 4));
1039                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cache_file_timeout));
1040                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1041         }
1042         if (ndr_flags & NDR_BUFFERS) {
1043         }
1044         return NDR_ERR_SUCCESS;
1045 }
1046
1047 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1047(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1047 *r)
1048 {
1049         if (ndr_flags & NDR_SCALARS) {
1050                 NDR_CHECK(ndr_pull_align(ndr, 4));
1051                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cache_file_timeout));
1052                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1053         }
1054         if (ndr_flags & NDR_BUFFERS) {
1055         }
1056         return NDR_ERR_SUCCESS;
1057 }
1058
1059 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1047(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1047 *r)
1060 {
1061         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1047");
1062         ndr->depth++;
1063         ndr_print_uint32(ndr, "cache_file_timeout", r->cache_file_timeout);
1064         ndr->depth--;
1065 }
1066
1067 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1048(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1048 *r)
1068 {
1069         if (ndr_flags & NDR_SCALARS) {
1070                 NDR_CHECK(ndr_push_align(ndr, 4));
1071                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_opportunistic_locking));
1072                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1073         }
1074         if (ndr_flags & NDR_BUFFERS) {
1075         }
1076         return NDR_ERR_SUCCESS;
1077 }
1078
1079 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1048(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1048 *r)
1080 {
1081         if (ndr_flags & NDR_SCALARS) {
1082                 NDR_CHECK(ndr_pull_align(ndr, 4));
1083                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_opportunistic_locking));
1084                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1085         }
1086         if (ndr_flags & NDR_BUFFERS) {
1087         }
1088         return NDR_ERR_SUCCESS;
1089 }
1090
1091 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1048(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1048 *r)
1092 {
1093         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1048");
1094         ndr->depth++;
1095         ndr_print_uint32(ndr, "use_opportunistic_locking", r->use_opportunistic_locking);
1096         ndr->depth--;
1097 }
1098
1099 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1049(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1049 *r)
1100 {
1101         if (ndr_flags & NDR_SCALARS) {
1102                 NDR_CHECK(ndr_push_align(ndr, 4));
1103                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_unlock_behind));
1104                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1105         }
1106         if (ndr_flags & NDR_BUFFERS) {
1107         }
1108         return NDR_ERR_SUCCESS;
1109 }
1110
1111 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1049(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1049 *r)
1112 {
1113         if (ndr_flags & NDR_SCALARS) {
1114                 NDR_CHECK(ndr_pull_align(ndr, 4));
1115                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_unlock_behind));
1116                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1117         }
1118         if (ndr_flags & NDR_BUFFERS) {
1119         }
1120         return NDR_ERR_SUCCESS;
1121 }
1122
1123 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1049(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1049 *r)
1124 {
1125         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1049");
1126         ndr->depth++;
1127         ndr_print_uint32(ndr, "use_unlock_behind", r->use_unlock_behind);
1128         ndr->depth--;
1129 }
1130
1131 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1050(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1050 *r)
1132 {
1133         if (ndr_flags & NDR_SCALARS) {
1134                 NDR_CHECK(ndr_push_align(ndr, 4));
1135                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_close_behind));
1136                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1137         }
1138         if (ndr_flags & NDR_BUFFERS) {
1139         }
1140         return NDR_ERR_SUCCESS;
1141 }
1142
1143 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1050(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1050 *r)
1144 {
1145         if (ndr_flags & NDR_SCALARS) {
1146                 NDR_CHECK(ndr_pull_align(ndr, 4));
1147                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_close_behind));
1148                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1149         }
1150         if (ndr_flags & NDR_BUFFERS) {
1151         }
1152         return NDR_ERR_SUCCESS;
1153 }
1154
1155 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1050(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1050 *r)
1156 {
1157         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1050");
1158         ndr->depth++;
1159         ndr_print_uint32(ndr, "use_close_behind", r->use_close_behind);
1160         ndr->depth--;
1161 }
1162
1163 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1051(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1051 *r)
1164 {
1165         if (ndr_flags & NDR_SCALARS) {
1166                 NDR_CHECK(ndr_push_align(ndr, 4));
1167                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_named_pipes));
1168                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1169         }
1170         if (ndr_flags & NDR_BUFFERS) {
1171         }
1172         return NDR_ERR_SUCCESS;
1173 }
1174
1175 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1051(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1051 *r)
1176 {
1177         if (ndr_flags & NDR_SCALARS) {
1178                 NDR_CHECK(ndr_pull_align(ndr, 4));
1179                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_named_pipes));
1180                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1181         }
1182         if (ndr_flags & NDR_BUFFERS) {
1183         }
1184         return NDR_ERR_SUCCESS;
1185 }
1186
1187 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1051(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1051 *r)
1188 {
1189         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1051");
1190         ndr->depth++;
1191         ndr_print_uint32(ndr, "buf_named_pipes", r->buf_named_pipes);
1192         ndr->depth--;
1193 }
1194
1195 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1052(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1052 *r)
1196 {
1197         if (ndr_flags & NDR_SCALARS) {
1198                 NDR_CHECK(ndr_push_align(ndr, 4));
1199                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_lock_read_unlock));
1200                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1201         }
1202         if (ndr_flags & NDR_BUFFERS) {
1203         }
1204         return NDR_ERR_SUCCESS;
1205 }
1206
1207 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1052(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1052 *r)
1208 {
1209         if (ndr_flags & NDR_SCALARS) {
1210                 NDR_CHECK(ndr_pull_align(ndr, 4));
1211                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_lock_read_unlock));
1212                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1213         }
1214         if (ndr_flags & NDR_BUFFERS) {
1215         }
1216         return NDR_ERR_SUCCESS;
1217 }
1218
1219 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1052(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1052 *r)
1220 {
1221         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1052");
1222         ndr->depth++;
1223         ndr_print_uint32(ndr, "use_lock_read_unlock", r->use_lock_read_unlock);
1224         ndr->depth--;
1225 }
1226
1227 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1053(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1053 *r)
1228 {
1229         if (ndr_flags & NDR_SCALARS) {
1230                 NDR_CHECK(ndr_push_align(ndr, 4));
1231                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->utilize_nt_caching));
1232                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1233         }
1234         if (ndr_flags & NDR_BUFFERS) {
1235         }
1236         return NDR_ERR_SUCCESS;
1237 }
1238
1239 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1053(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1053 *r)
1240 {
1241         if (ndr_flags & NDR_SCALARS) {
1242                 NDR_CHECK(ndr_pull_align(ndr, 4));
1243                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->utilize_nt_caching));
1244                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1245         }
1246         if (ndr_flags & NDR_BUFFERS) {
1247         }
1248         return NDR_ERR_SUCCESS;
1249 }
1250
1251 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1053(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1053 *r)
1252 {
1253         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1053");
1254         ndr->depth++;
1255         ndr_print_uint32(ndr, "utilize_nt_caching", r->utilize_nt_caching);
1256         ndr->depth--;
1257 }
1258
1259 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1054(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1054 *r)
1260 {
1261         if (ndr_flags & NDR_SCALARS) {
1262                 NDR_CHECK(ndr_push_align(ndr, 4));
1263                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_raw_read));
1264                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1265         }
1266         if (ndr_flags & NDR_BUFFERS) {
1267         }
1268         return NDR_ERR_SUCCESS;
1269 }
1270
1271 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1054(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1054 *r)
1272 {
1273         if (ndr_flags & NDR_SCALARS) {
1274                 NDR_CHECK(ndr_pull_align(ndr, 4));
1275                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_raw_read));
1276                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1277         }
1278         if (ndr_flags & NDR_BUFFERS) {
1279         }
1280         return NDR_ERR_SUCCESS;
1281 }
1282
1283 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1054(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1054 *r)
1284 {
1285         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1054");
1286         ndr->depth++;
1287         ndr_print_uint32(ndr, "use_raw_read", r->use_raw_read);
1288         ndr->depth--;
1289 }
1290
1291 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1055(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1055 *r)
1292 {
1293         if (ndr_flags & NDR_SCALARS) {
1294                 NDR_CHECK(ndr_push_align(ndr, 4));
1295                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_raw_write));
1296                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1297         }
1298         if (ndr_flags & NDR_BUFFERS) {
1299         }
1300         return NDR_ERR_SUCCESS;
1301 }
1302
1303 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1055(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1055 *r)
1304 {
1305         if (ndr_flags & NDR_SCALARS) {
1306                 NDR_CHECK(ndr_pull_align(ndr, 4));
1307                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_raw_write));
1308                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1309         }
1310         if (ndr_flags & NDR_BUFFERS) {
1311         }
1312         return NDR_ERR_SUCCESS;
1313 }
1314
1315 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1055(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1055 *r)
1316 {
1317         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1055");
1318         ndr->depth++;
1319         ndr_print_uint32(ndr, "use_raw_write", r->use_raw_write);
1320         ndr->depth--;
1321 }
1322
1323 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1056(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1056 *r)
1324 {
1325         if (ndr_flags & NDR_SCALARS) {
1326                 NDR_CHECK(ndr_push_align(ndr, 4));
1327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_write_raw_data));
1328                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1329         }
1330         if (ndr_flags & NDR_BUFFERS) {
1331         }
1332         return NDR_ERR_SUCCESS;
1333 }
1334
1335 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1056(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1056 *r)
1336 {
1337         if (ndr_flags & NDR_SCALARS) {
1338                 NDR_CHECK(ndr_pull_align(ndr, 4));
1339                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_write_raw_data));
1340                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1341         }
1342         if (ndr_flags & NDR_BUFFERS) {
1343         }
1344         return NDR_ERR_SUCCESS;
1345 }
1346
1347 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1056(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1056 *r)
1348 {
1349         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1056");
1350         ndr->depth++;
1351         ndr_print_uint32(ndr, "use_write_raw_data", r->use_write_raw_data);
1352         ndr->depth--;
1353 }
1354
1355 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1057(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1057 *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->use_encryption));
1360                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1361         }
1362         if (ndr_flags & NDR_BUFFERS) {
1363         }
1364         return NDR_ERR_SUCCESS;
1365 }
1366
1367 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1057(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1057 *r)
1368 {
1369         if (ndr_flags & NDR_SCALARS) {
1370                 NDR_CHECK(ndr_pull_align(ndr, 4));
1371                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_encryption));
1372                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1373         }
1374         if (ndr_flags & NDR_BUFFERS) {
1375         }
1376         return NDR_ERR_SUCCESS;
1377 }
1378
1379 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1057(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1057 *r)
1380 {
1381         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1057");
1382         ndr->depth++;
1383         ndr_print_uint32(ndr, "use_encryption", r->use_encryption);
1384         ndr->depth--;
1385 }
1386
1387 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1058(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1058 *r)
1388 {
1389         if (ndr_flags & NDR_SCALARS) {
1390                 NDR_CHECK(ndr_push_align(ndr, 4));
1391                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_files_deny_write));
1392                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1393         }
1394         if (ndr_flags & NDR_BUFFERS) {
1395         }
1396         return NDR_ERR_SUCCESS;
1397 }
1398
1399 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1058(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1058 *r)
1400 {
1401         if (ndr_flags & NDR_SCALARS) {
1402                 NDR_CHECK(ndr_pull_align(ndr, 4));
1403                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_files_deny_write));
1404                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1405         }
1406         if (ndr_flags & NDR_BUFFERS) {
1407         }
1408         return NDR_ERR_SUCCESS;
1409 }
1410
1411 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1058(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1058 *r)
1412 {
1413         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1058");
1414         ndr->depth++;
1415         ndr_print_uint32(ndr, "buf_files_deny_write", r->buf_files_deny_write);
1416         ndr->depth--;
1417 }
1418
1419 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1059(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1059 *r)
1420 {
1421         if (ndr_flags & NDR_SCALARS) {
1422                 NDR_CHECK(ndr_push_align(ndr, 4));
1423                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_read_only_files));
1424                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1425         }
1426         if (ndr_flags & NDR_BUFFERS) {
1427         }
1428         return NDR_ERR_SUCCESS;
1429 }
1430
1431 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1059(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1059 *r)
1432 {
1433         if (ndr_flags & NDR_SCALARS) {
1434                 NDR_CHECK(ndr_pull_align(ndr, 4));
1435                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_read_only_files));
1436                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1437         }
1438         if (ndr_flags & NDR_BUFFERS) {
1439         }
1440         return NDR_ERR_SUCCESS;
1441 }
1442
1443 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1059(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1059 *r)
1444 {
1445         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1059");
1446         ndr->depth++;
1447         ndr_print_uint32(ndr, "buf_read_only_files", r->buf_read_only_files);
1448         ndr->depth--;
1449 }
1450
1451 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1060(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1060 *r)
1452 {
1453         if (ndr_flags & NDR_SCALARS) {
1454                 NDR_CHECK(ndr_push_align(ndr, 4));
1455                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->force_core_create_mode));
1456                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1457         }
1458         if (ndr_flags & NDR_BUFFERS) {
1459         }
1460         return NDR_ERR_SUCCESS;
1461 }
1462
1463 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1060(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1060 *r)
1464 {
1465         if (ndr_flags & NDR_SCALARS) {
1466                 NDR_CHECK(ndr_pull_align(ndr, 4));
1467                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->force_core_create_mode));
1468                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1469         }
1470         if (ndr_flags & NDR_BUFFERS) {
1471         }
1472         return NDR_ERR_SUCCESS;
1473 }
1474
1475 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1060(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1060 *r)
1476 {
1477         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1060");
1478         ndr->depth++;
1479         ndr_print_uint32(ndr, "force_core_create_mode", r->force_core_create_mode);
1480         ndr->depth--;
1481 }
1482
1483 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1061(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1061 *r)
1484 {
1485         if (ndr_flags & NDR_SCALARS) {
1486                 NDR_CHECK(ndr_push_align(ndr, 4));
1487                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_512_byte_max_transfer));
1488                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1489         }
1490         if (ndr_flags & NDR_BUFFERS) {
1491         }
1492         return NDR_ERR_SUCCESS;
1493 }
1494
1495 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1061(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1061 *r)
1496 {
1497         if (ndr_flags & NDR_SCALARS) {
1498                 NDR_CHECK(ndr_pull_align(ndr, 4));
1499                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_512_byte_max_transfer));
1500                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1501         }
1502         if (ndr_flags & NDR_BUFFERS) {
1503         }
1504         return NDR_ERR_SUCCESS;
1505 }
1506
1507 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1061(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1061 *r)
1508 {
1509         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1061");
1510         ndr->depth++;
1511         ndr_print_uint32(ndr, "use_512_byte_max_transfer", r->use_512_byte_max_transfer);
1512         ndr->depth--;
1513 }
1514
1515 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1062(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1062 *r)
1516 {
1517         if (ndr_flags & NDR_SCALARS) {
1518                 NDR_CHECK(ndr_push_align(ndr, 4));
1519                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->read_ahead_throughput));
1520                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1521         }
1522         if (ndr_flags & NDR_BUFFERS) {
1523         }
1524         return NDR_ERR_SUCCESS;
1525 }
1526
1527 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1062(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1062 *r)
1528 {
1529         if (ndr_flags & NDR_SCALARS) {
1530                 NDR_CHECK(ndr_pull_align(ndr, 4));
1531                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->read_ahead_throughput));
1532                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1533         }
1534         if (ndr_flags & NDR_BUFFERS) {
1535         }
1536         return NDR_ERR_SUCCESS;
1537 }
1538
1539 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1062(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1062 *r)
1540 {
1541         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1062");
1542         ndr->depth++;
1543         ndr_print_uint32(ndr, "read_ahead_throughput", r->read_ahead_throughput);
1544         ndr->depth--;
1545 }
1546
1547 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetWkstaInfo *r)
1548 {
1549         if (ndr_flags & NDR_SCALARS) {
1550                 int level = ndr_push_get_switch_value(ndr, r);
1551                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
1552                 NDR_CHECK(ndr_push_union_align(ndr, 5));
1553                 switch (level) {
1554                         case 100: {
1555                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info100));
1556                         break; }
1557
1558                         case 101: {
1559                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info101));
1560                         break; }
1561
1562                         case 102: {
1563                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info102));
1564                         break; }
1565
1566                         case 502: {
1567                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info502));
1568                         break; }
1569
1570                         case 1010: {
1571                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1010));
1572                         break; }
1573
1574                         case 1011: {
1575                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1011));
1576                         break; }
1577
1578                         case 1012: {
1579                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1012));
1580                         break; }
1581
1582                         case 1013: {
1583                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1013));
1584                         break; }
1585
1586                         case 1018: {
1587                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1018));
1588                         break; }
1589
1590                         case 1023: {
1591                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1023));
1592                         break; }
1593
1594                         case 1027: {
1595                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1027));
1596                         break; }
1597
1598                         case 1028: {
1599                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1028));
1600                         break; }
1601
1602                         case 1032: {
1603                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1032));
1604                         break; }
1605
1606                         case 1033: {
1607                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1033));
1608                         break; }
1609
1610                         case 1041: {
1611                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1041));
1612                         break; }
1613
1614                         case 1042: {
1615                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1042));
1616                         break; }
1617
1618                         case 1043: {
1619                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1043));
1620                         break; }
1621
1622                         case 1044: {
1623                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1044));
1624                         break; }
1625
1626                         case 1045: {
1627                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1045));
1628                         break; }
1629
1630                         case 1046: {
1631                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1046));
1632                         break; }
1633
1634                         case 1047: {
1635                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1047));
1636                         break; }
1637
1638                         case 1048: {
1639                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1048));
1640                         break; }
1641
1642                         case 1049: {
1643                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1049));
1644                         break; }
1645
1646                         case 1050: {
1647                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1050));
1648                         break; }
1649
1650                         case 1051: {
1651                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1051));
1652                         break; }
1653
1654                         case 1052: {
1655                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1052));
1656                         break; }
1657
1658                         case 1053: {
1659                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1053));
1660                         break; }
1661
1662                         case 1054: {
1663                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1054));
1664                         break; }
1665
1666                         case 1055: {
1667                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1055));
1668                         break; }
1669
1670                         case 1056: {
1671                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1056));
1672                         break; }
1673
1674                         case 1057: {
1675                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1057));
1676                         break; }
1677
1678                         case 1058: {
1679                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1058));
1680                         break; }
1681
1682                         case 1059: {
1683                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1059));
1684                         break; }
1685
1686                         case 1060: {
1687                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1060));
1688                         break; }
1689
1690                         case 1061: {
1691                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1061));
1692                         break; }
1693
1694                         case 1062: {
1695                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1062));
1696                         break; }
1697
1698                         default: {
1699                         break; }
1700
1701                 }
1702         }
1703         if (ndr_flags & NDR_BUFFERS) {
1704                 int level = ndr_push_get_switch_value(ndr, r);
1705                 switch (level) {
1706                         case 100:
1707                                 if (r->info100) {
1708                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo100(ndr, NDR_SCALARS|NDR_BUFFERS, r->info100));
1709                                 }
1710                         break;
1711
1712                         case 101:
1713                                 if (r->info101) {
1714                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info101));
1715                                 }
1716                         break;
1717
1718                         case 102:
1719                                 if (r->info102) {
1720                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo102(ndr, NDR_SCALARS|NDR_BUFFERS, r->info102));
1721                                 }
1722                         break;
1723
1724                         case 502:
1725                                 if (r->info502) {
1726                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo502(ndr, NDR_SCALARS, r->info502));
1727                                 }
1728                         break;
1729
1730                         case 1010:
1731                                 if (r->info1010) {
1732                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1010(ndr, NDR_SCALARS, r->info1010));
1733                                 }
1734                         break;
1735
1736                         case 1011:
1737                                 if (r->info1011) {
1738                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1011(ndr, NDR_SCALARS, r->info1011));
1739                                 }
1740                         break;
1741
1742                         case 1012:
1743                                 if (r->info1012) {
1744                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1012(ndr, NDR_SCALARS, r->info1012));
1745                                 }
1746                         break;
1747
1748                         case 1013:
1749                                 if (r->info1013) {
1750                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1013(ndr, NDR_SCALARS, r->info1013));
1751                                 }
1752                         break;
1753
1754                         case 1018:
1755                                 if (r->info1018) {
1756                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1018(ndr, NDR_SCALARS, r->info1018));
1757                                 }
1758                         break;
1759
1760                         case 1023:
1761                                 if (r->info1023) {
1762                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1023(ndr, NDR_SCALARS, r->info1023));
1763                                 }
1764                         break;
1765
1766                         case 1027:
1767                                 if (r->info1027) {
1768                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1027(ndr, NDR_SCALARS, r->info1027));
1769                                 }
1770                         break;
1771
1772                         case 1028:
1773                                 if (r->info1028) {
1774                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1028(ndr, NDR_SCALARS, r->info1028));
1775                                 }
1776                         break;
1777
1778                         case 1032:
1779                                 if (r->info1032) {
1780                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1032(ndr, NDR_SCALARS, r->info1032));
1781                                 }
1782                         break;
1783
1784                         case 1033:
1785                                 if (r->info1033) {
1786                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1033(ndr, NDR_SCALARS, r->info1033));
1787                                 }
1788                         break;
1789
1790                         case 1041:
1791                                 if (r->info1041) {
1792                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1041(ndr, NDR_SCALARS, r->info1041));
1793                                 }
1794                         break;
1795
1796                         case 1042:
1797                                 if (r->info1042) {
1798                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1042(ndr, NDR_SCALARS, r->info1042));
1799                                 }
1800                         break;
1801
1802                         case 1043:
1803                                 if (r->info1043) {
1804                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1043(ndr, NDR_SCALARS, r->info1043));
1805                                 }
1806                         break;
1807
1808                         case 1044:
1809                                 if (r->info1044) {
1810                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1044(ndr, NDR_SCALARS, r->info1044));
1811                                 }
1812                         break;
1813
1814                         case 1045:
1815                                 if (r->info1045) {
1816                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1045(ndr, NDR_SCALARS, r->info1045));
1817                                 }
1818                         break;
1819
1820                         case 1046:
1821                                 if (r->info1046) {
1822                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1046(ndr, NDR_SCALARS, r->info1046));
1823                                 }
1824                         break;
1825
1826                         case 1047:
1827                                 if (r->info1047) {
1828                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1047(ndr, NDR_SCALARS, r->info1047));
1829                                 }
1830                         break;
1831
1832                         case 1048:
1833                                 if (r->info1048) {
1834                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1048(ndr, NDR_SCALARS, r->info1048));
1835                                 }
1836                         break;
1837
1838                         case 1049:
1839                                 if (r->info1049) {
1840                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1049(ndr, NDR_SCALARS, r->info1049));
1841                                 }
1842                         break;
1843
1844                         case 1050:
1845                                 if (r->info1050) {
1846                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1050(ndr, NDR_SCALARS, r->info1050));
1847                                 }
1848                         break;
1849
1850                         case 1051:
1851                                 if (r->info1051) {
1852                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1051(ndr, NDR_SCALARS, r->info1051));
1853                                 }
1854                         break;
1855
1856                         case 1052:
1857                                 if (r->info1052) {
1858                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1052(ndr, NDR_SCALARS, r->info1052));
1859                                 }
1860                         break;
1861
1862                         case 1053:
1863                                 if (r->info1053) {
1864                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1053(ndr, NDR_SCALARS, r->info1053));
1865                                 }
1866                         break;
1867
1868                         case 1054:
1869                                 if (r->info1054) {
1870                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1054(ndr, NDR_SCALARS, r->info1054));
1871                                 }
1872                         break;
1873
1874                         case 1055:
1875                                 if (r->info1055) {
1876                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1055(ndr, NDR_SCALARS, r->info1055));
1877                                 }
1878                         break;
1879
1880                         case 1056:
1881                                 if (r->info1056) {
1882                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1056(ndr, NDR_SCALARS, r->info1056));
1883                                 }
1884                         break;
1885
1886                         case 1057:
1887                                 if (r->info1057) {
1888                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1057(ndr, NDR_SCALARS, r->info1057));
1889                                 }
1890                         break;
1891
1892                         case 1058:
1893                                 if (r->info1058) {
1894                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1058(ndr, NDR_SCALARS, r->info1058));
1895                                 }
1896                         break;
1897
1898                         case 1059:
1899                                 if (r->info1059) {
1900                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1059(ndr, NDR_SCALARS, r->info1059));
1901                                 }
1902                         break;
1903
1904                         case 1060:
1905                                 if (r->info1060) {
1906                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1060(ndr, NDR_SCALARS, r->info1060));
1907                                 }
1908                         break;
1909
1910                         case 1061:
1911                                 if (r->info1061) {
1912                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1061(ndr, NDR_SCALARS, r->info1061));
1913                                 }
1914                         break;
1915
1916                         case 1062:
1917                                 if (r->info1062) {
1918                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1062(ndr, NDR_SCALARS, r->info1062));
1919                                 }
1920                         break;
1921
1922                         default:
1923                         break;
1924
1925                 }
1926         }
1927         return NDR_ERR_SUCCESS;
1928 }
1929
1930 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetWkstaInfo *r)
1931 {
1932         int level;
1933         uint32_t _level;
1934         TALLOC_CTX *_mem_save_info100_0;
1935         TALLOC_CTX *_mem_save_info101_0;
1936         TALLOC_CTX *_mem_save_info102_0;
1937         TALLOC_CTX *_mem_save_info502_0;
1938         TALLOC_CTX *_mem_save_info1010_0;
1939         TALLOC_CTX *_mem_save_info1011_0;
1940         TALLOC_CTX *_mem_save_info1012_0;
1941         TALLOC_CTX *_mem_save_info1013_0;
1942         TALLOC_CTX *_mem_save_info1018_0;
1943         TALLOC_CTX *_mem_save_info1023_0;
1944         TALLOC_CTX *_mem_save_info1027_0;
1945         TALLOC_CTX *_mem_save_info1028_0;
1946         TALLOC_CTX *_mem_save_info1032_0;
1947         TALLOC_CTX *_mem_save_info1033_0;
1948         TALLOC_CTX *_mem_save_info1041_0;
1949         TALLOC_CTX *_mem_save_info1042_0;
1950         TALLOC_CTX *_mem_save_info1043_0;
1951         TALLOC_CTX *_mem_save_info1044_0;
1952         TALLOC_CTX *_mem_save_info1045_0;
1953         TALLOC_CTX *_mem_save_info1046_0;
1954         TALLOC_CTX *_mem_save_info1047_0;
1955         TALLOC_CTX *_mem_save_info1048_0;
1956         TALLOC_CTX *_mem_save_info1049_0;
1957         TALLOC_CTX *_mem_save_info1050_0;
1958         TALLOC_CTX *_mem_save_info1051_0;
1959         TALLOC_CTX *_mem_save_info1052_0;
1960         TALLOC_CTX *_mem_save_info1053_0;
1961         TALLOC_CTX *_mem_save_info1054_0;
1962         TALLOC_CTX *_mem_save_info1055_0;
1963         TALLOC_CTX *_mem_save_info1056_0;
1964         TALLOC_CTX *_mem_save_info1057_0;
1965         TALLOC_CTX *_mem_save_info1058_0;
1966         TALLOC_CTX *_mem_save_info1059_0;
1967         TALLOC_CTX *_mem_save_info1060_0;
1968         TALLOC_CTX *_mem_save_info1061_0;
1969         TALLOC_CTX *_mem_save_info1062_0;
1970         level = ndr_pull_get_switch_value(ndr, r);
1971         if (ndr_flags & NDR_SCALARS) {
1972                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
1973                 if (_level != level) {
1974                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
1975                 }
1976                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
1977                 switch (level) {
1978                         case 100: {
1979                                 uint32_t _ptr_info100;
1980                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info100));
1981                                 if (_ptr_info100) {
1982                                         NDR_PULL_ALLOC(ndr, r->info100);
1983                                 } else {
1984                                         r->info100 = NULL;
1985                                 }
1986                         break; }
1987
1988                         case 101: {
1989                                 uint32_t _ptr_info101;
1990                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info101));
1991                                 if (_ptr_info101) {
1992                                         NDR_PULL_ALLOC(ndr, r->info101);
1993                                 } else {
1994                                         r->info101 = NULL;
1995                                 }
1996                         break; }
1997
1998                         case 102: {
1999                                 uint32_t _ptr_info102;
2000                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info102));
2001                                 if (_ptr_info102) {
2002                                         NDR_PULL_ALLOC(ndr, r->info102);
2003                                 } else {
2004                                         r->info102 = NULL;
2005                                 }
2006                         break; }
2007
2008                         case 502: {
2009                                 uint32_t _ptr_info502;
2010                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info502));
2011                                 if (_ptr_info502) {
2012                                         NDR_PULL_ALLOC(ndr, r->info502);
2013                                 } else {
2014                                         r->info502 = NULL;
2015                                 }
2016                         break; }
2017
2018                         case 1010: {
2019                                 uint32_t _ptr_info1010;
2020                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1010));
2021                                 if (_ptr_info1010) {
2022                                         NDR_PULL_ALLOC(ndr, r->info1010);
2023                                 } else {
2024                                         r->info1010 = NULL;
2025                                 }
2026                         break; }
2027
2028                         case 1011: {
2029                                 uint32_t _ptr_info1011;
2030                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1011));
2031                                 if (_ptr_info1011) {
2032                                         NDR_PULL_ALLOC(ndr, r->info1011);
2033                                 } else {
2034                                         r->info1011 = NULL;
2035                                 }
2036                         break; }
2037
2038                         case 1012: {
2039                                 uint32_t _ptr_info1012;
2040                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1012));
2041                                 if (_ptr_info1012) {
2042                                         NDR_PULL_ALLOC(ndr, r->info1012);
2043                                 } else {
2044                                         r->info1012 = NULL;
2045                                 }
2046                         break; }
2047
2048                         case 1013: {
2049                                 uint32_t _ptr_info1013;
2050                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1013));
2051                                 if (_ptr_info1013) {
2052                                         NDR_PULL_ALLOC(ndr, r->info1013);
2053                                 } else {
2054                                         r->info1013 = NULL;
2055                                 }
2056                         break; }
2057
2058                         case 1018: {
2059                                 uint32_t _ptr_info1018;
2060                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1018));
2061                                 if (_ptr_info1018) {
2062                                         NDR_PULL_ALLOC(ndr, r->info1018);
2063                                 } else {
2064                                         r->info1018 = NULL;
2065                                 }
2066                         break; }
2067
2068                         case 1023: {
2069                                 uint32_t _ptr_info1023;
2070                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1023));
2071                                 if (_ptr_info1023) {
2072                                         NDR_PULL_ALLOC(ndr, r->info1023);
2073                                 } else {
2074                                         r->info1023 = NULL;
2075                                 }
2076                         break; }
2077
2078                         case 1027: {
2079                                 uint32_t _ptr_info1027;
2080                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1027));
2081                                 if (_ptr_info1027) {
2082                                         NDR_PULL_ALLOC(ndr, r->info1027);
2083                                 } else {
2084                                         r->info1027 = NULL;
2085                                 }
2086                         break; }
2087
2088                         case 1028: {
2089                                 uint32_t _ptr_info1028;
2090                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1028));
2091                                 if (_ptr_info1028) {
2092                                         NDR_PULL_ALLOC(ndr, r->info1028);
2093                                 } else {
2094                                         r->info1028 = NULL;
2095                                 }
2096                         break; }
2097
2098                         case 1032: {
2099                                 uint32_t _ptr_info1032;
2100                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1032));
2101                                 if (_ptr_info1032) {
2102                                         NDR_PULL_ALLOC(ndr, r->info1032);
2103                                 } else {
2104                                         r->info1032 = NULL;
2105                                 }
2106                         break; }
2107
2108                         case 1033: {
2109                                 uint32_t _ptr_info1033;
2110                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1033));
2111                                 if (_ptr_info1033) {
2112                                         NDR_PULL_ALLOC(ndr, r->info1033);
2113                                 } else {
2114                                         r->info1033 = NULL;
2115                                 }
2116                         break; }
2117
2118                         case 1041: {
2119                                 uint32_t _ptr_info1041;
2120                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1041));
2121                                 if (_ptr_info1041) {
2122                                         NDR_PULL_ALLOC(ndr, r->info1041);
2123                                 } else {
2124                                         r->info1041 = NULL;
2125                                 }
2126                         break; }
2127
2128                         case 1042: {
2129                                 uint32_t _ptr_info1042;
2130                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1042));
2131                                 if (_ptr_info1042) {
2132                                         NDR_PULL_ALLOC(ndr, r->info1042);
2133                                 } else {
2134                                         r->info1042 = NULL;
2135                                 }
2136                         break; }
2137
2138                         case 1043: {
2139                                 uint32_t _ptr_info1043;
2140                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1043));
2141                                 if (_ptr_info1043) {
2142                                         NDR_PULL_ALLOC(ndr, r->info1043);
2143                                 } else {
2144                                         r->info1043 = NULL;
2145                                 }
2146                         break; }
2147
2148                         case 1044: {
2149                                 uint32_t _ptr_info1044;
2150                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1044));
2151                                 if (_ptr_info1044) {
2152                                         NDR_PULL_ALLOC(ndr, r->info1044);
2153                                 } else {
2154                                         r->info1044 = NULL;
2155                                 }
2156                         break; }
2157
2158                         case 1045: {
2159                                 uint32_t _ptr_info1045;
2160                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1045));
2161                                 if (_ptr_info1045) {
2162                                         NDR_PULL_ALLOC(ndr, r->info1045);
2163                                 } else {
2164                                         r->info1045 = NULL;
2165                                 }
2166                         break; }
2167
2168                         case 1046: {
2169                                 uint32_t _ptr_info1046;
2170                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1046));
2171                                 if (_ptr_info1046) {
2172                                         NDR_PULL_ALLOC(ndr, r->info1046);
2173                                 } else {
2174                                         r->info1046 = NULL;
2175                                 }
2176                         break; }
2177
2178                         case 1047: {
2179                                 uint32_t _ptr_info1047;
2180                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1047));
2181                                 if (_ptr_info1047) {
2182                                         NDR_PULL_ALLOC(ndr, r->info1047);
2183                                 } else {
2184                                         r->info1047 = NULL;
2185                                 }
2186                         break; }
2187
2188                         case 1048: {
2189                                 uint32_t _ptr_info1048;
2190                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1048));
2191                                 if (_ptr_info1048) {
2192                                         NDR_PULL_ALLOC(ndr, r->info1048);
2193                                 } else {
2194                                         r->info1048 = NULL;
2195                                 }
2196                         break; }
2197
2198                         case 1049: {
2199                                 uint32_t _ptr_info1049;
2200                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1049));
2201                                 if (_ptr_info1049) {
2202                                         NDR_PULL_ALLOC(ndr, r->info1049);
2203                                 } else {
2204                                         r->info1049 = NULL;
2205                                 }
2206                         break; }
2207
2208                         case 1050: {
2209                                 uint32_t _ptr_info1050;
2210                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1050));
2211                                 if (_ptr_info1050) {
2212                                         NDR_PULL_ALLOC(ndr, r->info1050);
2213                                 } else {
2214                                         r->info1050 = NULL;
2215                                 }
2216                         break; }
2217
2218                         case 1051: {
2219                                 uint32_t _ptr_info1051;
2220                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1051));
2221                                 if (_ptr_info1051) {
2222                                         NDR_PULL_ALLOC(ndr, r->info1051);
2223                                 } else {
2224                                         r->info1051 = NULL;
2225                                 }
2226                         break; }
2227
2228                         case 1052: {
2229                                 uint32_t _ptr_info1052;
2230                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1052));
2231                                 if (_ptr_info1052) {
2232                                         NDR_PULL_ALLOC(ndr, r->info1052);
2233                                 } else {
2234                                         r->info1052 = NULL;
2235                                 }
2236                         break; }
2237
2238                         case 1053: {
2239                                 uint32_t _ptr_info1053;
2240                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1053));
2241                                 if (_ptr_info1053) {
2242                                         NDR_PULL_ALLOC(ndr, r->info1053);
2243                                 } else {
2244                                         r->info1053 = NULL;
2245                                 }
2246                         break; }
2247
2248                         case 1054: {
2249                                 uint32_t _ptr_info1054;
2250                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1054));
2251                                 if (_ptr_info1054) {
2252                                         NDR_PULL_ALLOC(ndr, r->info1054);
2253                                 } else {
2254                                         r->info1054 = NULL;
2255                                 }
2256                         break; }
2257
2258                         case 1055: {
2259                                 uint32_t _ptr_info1055;
2260                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1055));
2261                                 if (_ptr_info1055) {
2262                                         NDR_PULL_ALLOC(ndr, r->info1055);
2263                                 } else {
2264                                         r->info1055 = NULL;
2265                                 }
2266                         break; }
2267
2268                         case 1056: {
2269                                 uint32_t _ptr_info1056;
2270                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1056));
2271                                 if (_ptr_info1056) {
2272                                         NDR_PULL_ALLOC(ndr, r->info1056);
2273                                 } else {
2274                                         r->info1056 = NULL;
2275                                 }
2276                         break; }
2277
2278                         case 1057: {
2279                                 uint32_t _ptr_info1057;
2280                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1057));
2281                                 if (_ptr_info1057) {
2282                                         NDR_PULL_ALLOC(ndr, r->info1057);
2283                                 } else {
2284                                         r->info1057 = NULL;
2285                                 }
2286                         break; }
2287
2288                         case 1058: {
2289                                 uint32_t _ptr_info1058;
2290                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1058));
2291                                 if (_ptr_info1058) {
2292                                         NDR_PULL_ALLOC(ndr, r->info1058);
2293                                 } else {
2294                                         r->info1058 = NULL;
2295                                 }
2296                         break; }
2297
2298                         case 1059: {
2299                                 uint32_t _ptr_info1059;
2300                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1059));
2301                                 if (_ptr_info1059) {
2302                                         NDR_PULL_ALLOC(ndr, r->info1059);
2303                                 } else {
2304                                         r->info1059 = NULL;
2305                                 }
2306                         break; }
2307
2308                         case 1060: {
2309                                 uint32_t _ptr_info1060;
2310                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1060));
2311                                 if (_ptr_info1060) {
2312                                         NDR_PULL_ALLOC(ndr, r->info1060);
2313                                 } else {
2314                                         r->info1060 = NULL;
2315                                 }
2316                         break; }
2317
2318                         case 1061: {
2319                                 uint32_t _ptr_info1061;
2320                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1061));
2321                                 if (_ptr_info1061) {
2322                                         NDR_PULL_ALLOC(ndr, r->info1061);
2323                                 } else {
2324                                         r->info1061 = NULL;
2325                                 }
2326                         break; }
2327
2328                         case 1062: {
2329                                 uint32_t _ptr_info1062;
2330                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1062));
2331                                 if (_ptr_info1062) {
2332                                         NDR_PULL_ALLOC(ndr, r->info1062);
2333                                 } else {
2334                                         r->info1062 = NULL;
2335                                 }
2336                         break; }
2337
2338                         default: {
2339                         break; }
2340
2341                 }
2342         }
2343         if (ndr_flags & NDR_BUFFERS) {
2344                 switch (level) {
2345                         case 100:
2346                                 if (r->info100) {
2347                                         _mem_save_info100_0 = NDR_PULL_GET_MEM_CTX(ndr);
2348                                         NDR_PULL_SET_MEM_CTX(ndr, r->info100, 0);
2349                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo100(ndr, NDR_SCALARS|NDR_BUFFERS, r->info100));
2350                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info100_0, 0);
2351                                 }
2352                         break;
2353
2354                         case 101:
2355                                 if (r->info101) {
2356                                         _mem_save_info101_0 = NDR_PULL_GET_MEM_CTX(ndr);
2357                                         NDR_PULL_SET_MEM_CTX(ndr, r->info101, 0);
2358                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info101));
2359                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info101_0, 0);
2360                                 }
2361                         break;
2362
2363                         case 102:
2364                                 if (r->info102) {
2365                                         _mem_save_info102_0 = NDR_PULL_GET_MEM_CTX(ndr);
2366                                         NDR_PULL_SET_MEM_CTX(ndr, r->info102, 0);
2367                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo102(ndr, NDR_SCALARS|NDR_BUFFERS, r->info102));
2368                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info102_0, 0);
2369                                 }
2370                         break;
2371
2372                         case 502:
2373                                 if (r->info502) {
2374                                         _mem_save_info502_0 = NDR_PULL_GET_MEM_CTX(ndr);
2375                                         NDR_PULL_SET_MEM_CTX(ndr, r->info502, 0);
2376                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo502(ndr, NDR_SCALARS, r->info502));
2377                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info502_0, 0);
2378                                 }
2379                         break;
2380
2381                         case 1010:
2382                                 if (r->info1010) {
2383                                         _mem_save_info1010_0 = NDR_PULL_GET_MEM_CTX(ndr);
2384                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1010, 0);
2385                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1010(ndr, NDR_SCALARS, r->info1010));
2386                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1010_0, 0);
2387                                 }
2388                         break;
2389
2390                         case 1011:
2391                                 if (r->info1011) {
2392                                         _mem_save_info1011_0 = NDR_PULL_GET_MEM_CTX(ndr);
2393                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1011, 0);
2394                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1011(ndr, NDR_SCALARS, r->info1011));
2395                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1011_0, 0);
2396                                 }
2397                         break;
2398
2399                         case 1012:
2400                                 if (r->info1012) {
2401                                         _mem_save_info1012_0 = NDR_PULL_GET_MEM_CTX(ndr);
2402                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1012, 0);
2403                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1012(ndr, NDR_SCALARS, r->info1012));
2404                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1012_0, 0);
2405                                 }
2406                         break;
2407
2408                         case 1013:
2409                                 if (r->info1013) {
2410                                         _mem_save_info1013_0 = NDR_PULL_GET_MEM_CTX(ndr);
2411                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1013, 0);
2412                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1013(ndr, NDR_SCALARS, r->info1013));
2413                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1013_0, 0);
2414                                 }
2415                         break;
2416
2417                         case 1018:
2418                                 if (r->info1018) {
2419                                         _mem_save_info1018_0 = NDR_PULL_GET_MEM_CTX(ndr);
2420                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1018, 0);
2421                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1018(ndr, NDR_SCALARS, r->info1018));
2422                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1018_0, 0);
2423                                 }
2424                         break;
2425
2426                         case 1023:
2427                                 if (r->info1023) {
2428                                         _mem_save_info1023_0 = NDR_PULL_GET_MEM_CTX(ndr);
2429                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1023, 0);
2430                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1023(ndr, NDR_SCALARS, r->info1023));
2431                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1023_0, 0);
2432                                 }
2433                         break;
2434
2435                         case 1027:
2436                                 if (r->info1027) {
2437                                         _mem_save_info1027_0 = NDR_PULL_GET_MEM_CTX(ndr);
2438                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1027, 0);
2439                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1027(ndr, NDR_SCALARS, r->info1027));
2440                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1027_0, 0);
2441                                 }
2442                         break;
2443
2444                         case 1028:
2445                                 if (r->info1028) {
2446                                         _mem_save_info1028_0 = NDR_PULL_GET_MEM_CTX(ndr);
2447                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1028, 0);
2448                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1028(ndr, NDR_SCALARS, r->info1028));
2449                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1028_0, 0);
2450                                 }
2451                         break;
2452
2453                         case 1032:
2454                                 if (r->info1032) {
2455                                         _mem_save_info1032_0 = NDR_PULL_GET_MEM_CTX(ndr);
2456                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1032, 0);
2457                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1032(ndr, NDR_SCALARS, r->info1032));
2458                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1032_0, 0);
2459                                 }
2460                         break;
2461
2462                         case 1033:
2463                                 if (r->info1033) {
2464                                         _mem_save_info1033_0 = NDR_PULL_GET_MEM_CTX(ndr);
2465                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1033, 0);
2466                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1033(ndr, NDR_SCALARS, r->info1033));
2467                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1033_0, 0);
2468                                 }
2469                         break;
2470
2471                         case 1041:
2472                                 if (r->info1041) {
2473                                         _mem_save_info1041_0 = NDR_PULL_GET_MEM_CTX(ndr);
2474                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1041, 0);
2475                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1041(ndr, NDR_SCALARS, r->info1041));
2476                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1041_0, 0);
2477                                 }
2478                         break;
2479
2480                         case 1042:
2481                                 if (r->info1042) {
2482                                         _mem_save_info1042_0 = NDR_PULL_GET_MEM_CTX(ndr);
2483                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1042, 0);
2484                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1042(ndr, NDR_SCALARS, r->info1042));
2485                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1042_0, 0);
2486                                 }
2487                         break;
2488
2489                         case 1043:
2490                                 if (r->info1043) {
2491                                         _mem_save_info1043_0 = NDR_PULL_GET_MEM_CTX(ndr);
2492                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1043, 0);
2493                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1043(ndr, NDR_SCALARS, r->info1043));
2494                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1043_0, 0);
2495                                 }
2496                         break;
2497
2498                         case 1044:
2499                                 if (r->info1044) {
2500                                         _mem_save_info1044_0 = NDR_PULL_GET_MEM_CTX(ndr);
2501                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1044, 0);
2502                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1044(ndr, NDR_SCALARS, r->info1044));
2503                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1044_0, 0);
2504                                 }
2505                         break;
2506
2507                         case 1045:
2508                                 if (r->info1045) {
2509                                         _mem_save_info1045_0 = NDR_PULL_GET_MEM_CTX(ndr);
2510                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1045, 0);
2511                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1045(ndr, NDR_SCALARS, r->info1045));
2512                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1045_0, 0);
2513                                 }
2514                         break;
2515
2516                         case 1046:
2517                                 if (r->info1046) {
2518                                         _mem_save_info1046_0 = NDR_PULL_GET_MEM_CTX(ndr);
2519                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1046, 0);
2520                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1046(ndr, NDR_SCALARS, r->info1046));
2521                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1046_0, 0);
2522                                 }
2523                         break;
2524
2525                         case 1047:
2526                                 if (r->info1047) {
2527                                         _mem_save_info1047_0 = NDR_PULL_GET_MEM_CTX(ndr);
2528                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1047, 0);
2529                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1047(ndr, NDR_SCALARS, r->info1047));
2530                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1047_0, 0);
2531                                 }
2532                         break;
2533
2534                         case 1048:
2535                                 if (r->info1048) {
2536                                         _mem_save_info1048_0 = NDR_PULL_GET_MEM_CTX(ndr);
2537                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1048, 0);
2538                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1048(ndr, NDR_SCALARS, r->info1048));
2539                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1048_0, 0);
2540                                 }
2541                         break;
2542
2543                         case 1049:
2544                                 if (r->info1049) {
2545                                         _mem_save_info1049_0 = NDR_PULL_GET_MEM_CTX(ndr);
2546                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1049, 0);
2547                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1049(ndr, NDR_SCALARS, r->info1049));
2548                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1049_0, 0);
2549                                 }
2550                         break;
2551
2552                         case 1050:
2553                                 if (r->info1050) {
2554                                         _mem_save_info1050_0 = NDR_PULL_GET_MEM_CTX(ndr);
2555                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1050, 0);
2556                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1050(ndr, NDR_SCALARS, r->info1050));
2557                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1050_0, 0);
2558                                 }
2559                         break;
2560
2561                         case 1051:
2562                                 if (r->info1051) {
2563                                         _mem_save_info1051_0 = NDR_PULL_GET_MEM_CTX(ndr);
2564                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1051, 0);
2565                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1051(ndr, NDR_SCALARS, r->info1051));
2566                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1051_0, 0);
2567                                 }
2568                         break;
2569
2570                         case 1052:
2571                                 if (r->info1052) {
2572                                         _mem_save_info1052_0 = NDR_PULL_GET_MEM_CTX(ndr);
2573                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1052, 0);
2574                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1052(ndr, NDR_SCALARS, r->info1052));
2575                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1052_0, 0);
2576                                 }
2577                         break;
2578
2579                         case 1053:
2580                                 if (r->info1053) {
2581                                         _mem_save_info1053_0 = NDR_PULL_GET_MEM_CTX(ndr);
2582                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1053, 0);
2583                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1053(ndr, NDR_SCALARS, r->info1053));
2584                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1053_0, 0);
2585                                 }
2586                         break;
2587
2588                         case 1054:
2589                                 if (r->info1054) {
2590                                         _mem_save_info1054_0 = NDR_PULL_GET_MEM_CTX(ndr);
2591                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1054, 0);
2592                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1054(ndr, NDR_SCALARS, r->info1054));
2593                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1054_0, 0);
2594                                 }
2595                         break;
2596
2597                         case 1055:
2598                                 if (r->info1055) {
2599                                         _mem_save_info1055_0 = NDR_PULL_GET_MEM_CTX(ndr);
2600                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1055, 0);
2601                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1055(ndr, NDR_SCALARS, r->info1055));
2602                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1055_0, 0);
2603                                 }
2604                         break;
2605
2606                         case 1056:
2607                                 if (r->info1056) {
2608                                         _mem_save_info1056_0 = NDR_PULL_GET_MEM_CTX(ndr);
2609                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1056, 0);
2610                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1056(ndr, NDR_SCALARS, r->info1056));
2611                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1056_0, 0);
2612                                 }
2613                         break;
2614
2615                         case 1057:
2616                                 if (r->info1057) {
2617                                         _mem_save_info1057_0 = NDR_PULL_GET_MEM_CTX(ndr);
2618                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1057, 0);
2619                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1057(ndr, NDR_SCALARS, r->info1057));
2620                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1057_0, 0);
2621                                 }
2622                         break;
2623
2624                         case 1058:
2625                                 if (r->info1058) {
2626                                         _mem_save_info1058_0 = NDR_PULL_GET_MEM_CTX(ndr);
2627                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1058, 0);
2628                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1058(ndr, NDR_SCALARS, r->info1058));
2629                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1058_0, 0);
2630                                 }
2631                         break;
2632
2633                         case 1059:
2634                                 if (r->info1059) {
2635                                         _mem_save_info1059_0 = NDR_PULL_GET_MEM_CTX(ndr);
2636                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1059, 0);
2637                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1059(ndr, NDR_SCALARS, r->info1059));
2638                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1059_0, 0);
2639                                 }
2640                         break;
2641
2642                         case 1060:
2643                                 if (r->info1060) {
2644                                         _mem_save_info1060_0 = NDR_PULL_GET_MEM_CTX(ndr);
2645                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1060, 0);
2646                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1060(ndr, NDR_SCALARS, r->info1060));
2647                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1060_0, 0);
2648                                 }
2649                         break;
2650
2651                         case 1061:
2652                                 if (r->info1061) {
2653                                         _mem_save_info1061_0 = NDR_PULL_GET_MEM_CTX(ndr);
2654                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1061, 0);
2655                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1061(ndr, NDR_SCALARS, r->info1061));
2656                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1061_0, 0);
2657                                 }
2658                         break;
2659
2660                         case 1062:
2661                                 if (r->info1062) {
2662                                         _mem_save_info1062_0 = NDR_PULL_GET_MEM_CTX(ndr);
2663                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1062, 0);
2664                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1062(ndr, NDR_SCALARS, r->info1062));
2665                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1062_0, 0);
2666                                 }
2667                         break;
2668
2669                         default:
2670                         break;
2671
2672                 }
2673         }
2674         return NDR_ERR_SUCCESS;
2675 }
2676
2677 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo(struct ndr_print *ndr, const char *name, const union wkssvc_NetWkstaInfo *r)
2678 {
2679         int level;
2680         level = ndr_print_get_switch_value(ndr, r);
2681         ndr_print_union(ndr, name, level, "wkssvc_NetWkstaInfo");
2682         switch (level) {
2683                 case 100:
2684                         ndr_print_ptr(ndr, "info100", r->info100);
2685                         ndr->depth++;
2686                         if (r->info100) {
2687                                 ndr_print_wkssvc_NetWkstaInfo100(ndr, "info100", r->info100);
2688                         }
2689                         ndr->depth--;
2690                 break;
2691
2692                 case 101:
2693                         ndr_print_ptr(ndr, "info101", r->info101);
2694                         ndr->depth++;
2695                         if (r->info101) {
2696                                 ndr_print_wkssvc_NetWkstaInfo101(ndr, "info101", r->info101);
2697                         }
2698                         ndr->depth--;
2699                 break;
2700
2701                 case 102:
2702                         ndr_print_ptr(ndr, "info102", r->info102);
2703                         ndr->depth++;
2704                         if (r->info102) {
2705                                 ndr_print_wkssvc_NetWkstaInfo102(ndr, "info102", r->info102);
2706                         }
2707                         ndr->depth--;
2708                 break;
2709
2710                 case 502:
2711                         ndr_print_ptr(ndr, "info502", r->info502);
2712                         ndr->depth++;
2713                         if (r->info502) {
2714                                 ndr_print_wkssvc_NetWkstaInfo502(ndr, "info502", r->info502);
2715                         }
2716                         ndr->depth--;
2717                 break;
2718
2719                 case 1010:
2720                         ndr_print_ptr(ndr, "info1010", r->info1010);
2721                         ndr->depth++;
2722                         if (r->info1010) {
2723                                 ndr_print_wkssvc_NetWkstaInfo1010(ndr, "info1010", r->info1010);
2724                         }
2725                         ndr->depth--;
2726                 break;
2727
2728                 case 1011:
2729                         ndr_print_ptr(ndr, "info1011", r->info1011);
2730                         ndr->depth++;
2731                         if (r->info1011) {
2732                                 ndr_print_wkssvc_NetWkstaInfo1011(ndr, "info1011", r->info1011);
2733                         }
2734                         ndr->depth--;
2735                 break;
2736
2737                 case 1012:
2738                         ndr_print_ptr(ndr, "info1012", r->info1012);
2739                         ndr->depth++;
2740                         if (r->info1012) {
2741                                 ndr_print_wkssvc_NetWkstaInfo1012(ndr, "info1012", r->info1012);
2742                         }
2743                         ndr->depth--;
2744                 break;
2745
2746                 case 1013:
2747                         ndr_print_ptr(ndr, "info1013", r->info1013);
2748                         ndr->depth++;
2749                         if (r->info1013) {
2750                                 ndr_print_wkssvc_NetWkstaInfo1013(ndr, "info1013", r->info1013);
2751                         }
2752                         ndr->depth--;
2753                 break;
2754
2755                 case 1018:
2756                         ndr_print_ptr(ndr, "info1018", r->info1018);
2757                         ndr->depth++;
2758                         if (r->info1018) {
2759                                 ndr_print_wkssvc_NetWkstaInfo1018(ndr, "info1018", r->info1018);
2760                         }
2761                         ndr->depth--;
2762                 break;
2763
2764                 case 1023:
2765                         ndr_print_ptr(ndr, "info1023", r->info1023);
2766                         ndr->depth++;
2767                         if (r->info1023) {
2768                                 ndr_print_wkssvc_NetWkstaInfo1023(ndr, "info1023", r->info1023);
2769                         }
2770                         ndr->depth--;
2771                 break;
2772
2773                 case 1027:
2774                         ndr_print_ptr(ndr, "info1027", r->info1027);
2775                         ndr->depth++;
2776                         if (r->info1027) {
2777                                 ndr_print_wkssvc_NetWkstaInfo1027(ndr, "info1027", r->info1027);
2778                         }
2779                         ndr->depth--;
2780                 break;
2781
2782                 case 1028:
2783                         ndr_print_ptr(ndr, "info1028", r->info1028);
2784                         ndr->depth++;
2785                         if (r->info1028) {
2786                                 ndr_print_wkssvc_NetWkstaInfo1028(ndr, "info1028", r->info1028);
2787                         }
2788                         ndr->depth--;
2789                 break;
2790
2791                 case 1032:
2792                         ndr_print_ptr(ndr, "info1032", r->info1032);
2793                         ndr->depth++;
2794                         if (r->info1032) {
2795                                 ndr_print_wkssvc_NetWkstaInfo1032(ndr, "info1032", r->info1032);
2796                         }
2797                         ndr->depth--;
2798                 break;
2799
2800                 case 1033:
2801                         ndr_print_ptr(ndr, "info1033", r->info1033);
2802                         ndr->depth++;
2803                         if (r->info1033) {
2804                                 ndr_print_wkssvc_NetWkstaInfo1033(ndr, "info1033", r->info1033);
2805                         }
2806                         ndr->depth--;
2807                 break;
2808
2809                 case 1041:
2810                         ndr_print_ptr(ndr, "info1041", r->info1041);
2811                         ndr->depth++;
2812                         if (r->info1041) {
2813                                 ndr_print_wkssvc_NetWkstaInfo1041(ndr, "info1041", r->info1041);
2814                         }
2815                         ndr->depth--;
2816                 break;
2817
2818                 case 1042:
2819                         ndr_print_ptr(ndr, "info1042", r->info1042);
2820                         ndr->depth++;
2821                         if (r->info1042) {
2822                                 ndr_print_wkssvc_NetWkstaInfo1042(ndr, "info1042", r->info1042);
2823                         }
2824                         ndr->depth--;
2825                 break;
2826
2827                 case 1043:
2828                         ndr_print_ptr(ndr, "info1043", r->info1043);
2829                         ndr->depth++;
2830                         if (r->info1043) {
2831                                 ndr_print_wkssvc_NetWkstaInfo1043(ndr, "info1043", r->info1043);
2832                         }
2833                         ndr->depth--;
2834                 break;
2835
2836                 case 1044:
2837                         ndr_print_ptr(ndr, "info1044", r->info1044);
2838                         ndr->depth++;
2839                         if (r->info1044) {
2840                                 ndr_print_wkssvc_NetWkstaInfo1044(ndr, "info1044", r->info1044);
2841                         }
2842                         ndr->depth--;
2843                 break;
2844
2845                 case 1045:
2846                         ndr_print_ptr(ndr, "info1045", r->info1045);
2847                         ndr->depth++;
2848                         if (r->info1045) {
2849                                 ndr_print_wkssvc_NetWkstaInfo1045(ndr, "info1045", r->info1045);
2850                         }
2851                         ndr->depth--;
2852                 break;
2853
2854                 case 1046:
2855                         ndr_print_ptr(ndr, "info1046", r->info1046);
2856                         ndr->depth++;
2857                         if (r->info1046) {
2858                                 ndr_print_wkssvc_NetWkstaInfo1046(ndr, "info1046", r->info1046);
2859                         }
2860                         ndr->depth--;
2861                 break;
2862
2863                 case 1047:
2864                         ndr_print_ptr(ndr, "info1047", r->info1047);
2865                         ndr->depth++;
2866                         if (r->info1047) {
2867                                 ndr_print_wkssvc_NetWkstaInfo1047(ndr, "info1047", r->info1047);
2868                         }
2869                         ndr->depth--;
2870                 break;
2871
2872                 case 1048:
2873                         ndr_print_ptr(ndr, "info1048", r->info1048);
2874                         ndr->depth++;
2875                         if (r->info1048) {
2876                                 ndr_print_wkssvc_NetWkstaInfo1048(ndr, "info1048", r->info1048);
2877                         }
2878                         ndr->depth--;
2879                 break;
2880
2881                 case 1049:
2882                         ndr_print_ptr(ndr, "info1049", r->info1049);
2883                         ndr->depth++;
2884                         if (r->info1049) {
2885                                 ndr_print_wkssvc_NetWkstaInfo1049(ndr, "info1049", r->info1049);
2886                         }
2887                         ndr->depth--;
2888                 break;
2889
2890                 case 1050:
2891                         ndr_print_ptr(ndr, "info1050", r->info1050);
2892                         ndr->depth++;
2893                         if (r->info1050) {
2894                                 ndr_print_wkssvc_NetWkstaInfo1050(ndr, "info1050", r->info1050);
2895                         }
2896                         ndr->depth--;
2897                 break;
2898
2899                 case 1051:
2900                         ndr_print_ptr(ndr, "info1051", r->info1051);
2901                         ndr->depth++;
2902                         if (r->info1051) {
2903                                 ndr_print_wkssvc_NetWkstaInfo1051(ndr, "info1051", r->info1051);
2904                         }
2905                         ndr->depth--;
2906                 break;
2907
2908                 case 1052:
2909                         ndr_print_ptr(ndr, "info1052", r->info1052);
2910                         ndr->depth++;
2911                         if (r->info1052) {
2912                                 ndr_print_wkssvc_NetWkstaInfo1052(ndr, "info1052", r->info1052);
2913                         }
2914                         ndr->depth--;
2915                 break;
2916
2917                 case 1053:
2918                         ndr_print_ptr(ndr, "info1053", r->info1053);
2919                         ndr->depth++;
2920                         if (r->info1053) {
2921                                 ndr_print_wkssvc_NetWkstaInfo1053(ndr, "info1053", r->info1053);
2922                         }
2923                         ndr->depth--;
2924                 break;
2925
2926                 case 1054:
2927                         ndr_print_ptr(ndr, "info1054", r->info1054);
2928                         ndr->depth++;
2929                         if (r->info1054) {
2930                                 ndr_print_wkssvc_NetWkstaInfo1054(ndr, "info1054", r->info1054);
2931                         }
2932                         ndr->depth--;
2933                 break;
2934
2935                 case 1055:
2936                         ndr_print_ptr(ndr, "info1055", r->info1055);
2937                         ndr->depth++;
2938                         if (r->info1055) {
2939                                 ndr_print_wkssvc_NetWkstaInfo1055(ndr, "info1055", r->info1055);
2940                         }
2941                         ndr->depth--;
2942                 break;
2943
2944                 case 1056:
2945                         ndr_print_ptr(ndr, "info1056", r->info1056);
2946                         ndr->depth++;
2947                         if (r->info1056) {
2948                                 ndr_print_wkssvc_NetWkstaInfo1056(ndr, "info1056", r->info1056);
2949                         }
2950                         ndr->depth--;
2951                 break;
2952
2953                 case 1057:
2954                         ndr_print_ptr(ndr, "info1057", r->info1057);
2955                         ndr->depth++;
2956                         if (r->info1057) {
2957                                 ndr_print_wkssvc_NetWkstaInfo1057(ndr, "info1057", r->info1057);
2958                         }
2959                         ndr->depth--;
2960                 break;
2961
2962                 case 1058:
2963                         ndr_print_ptr(ndr, "info1058", r->info1058);
2964                         ndr->depth++;
2965                         if (r->info1058) {
2966                                 ndr_print_wkssvc_NetWkstaInfo1058(ndr, "info1058", r->info1058);
2967                         }
2968                         ndr->depth--;
2969                 break;
2970
2971                 case 1059:
2972                         ndr_print_ptr(ndr, "info1059", r->info1059);
2973                         ndr->depth++;
2974                         if (r->info1059) {
2975                                 ndr_print_wkssvc_NetWkstaInfo1059(ndr, "info1059", r->info1059);
2976                         }
2977                         ndr->depth--;
2978                 break;
2979
2980                 case 1060:
2981                         ndr_print_ptr(ndr, "info1060", r->info1060);
2982                         ndr->depth++;
2983                         if (r->info1060) {
2984                                 ndr_print_wkssvc_NetWkstaInfo1060(ndr, "info1060", r->info1060);
2985                         }
2986                         ndr->depth--;
2987                 break;
2988
2989                 case 1061:
2990                         ndr_print_ptr(ndr, "info1061", r->info1061);
2991                         ndr->depth++;
2992                         if (r->info1061) {
2993                                 ndr_print_wkssvc_NetWkstaInfo1061(ndr, "info1061", r->info1061);
2994                         }
2995                         ndr->depth--;
2996                 break;
2997
2998                 case 1062:
2999                         ndr_print_ptr(ndr, "info1062", r->info1062);
3000                         ndr->depth++;
3001                         if (r->info1062) {
3002                                 ndr_print_wkssvc_NetWkstaInfo1062(ndr, "info1062", r->info1062);
3003                         }
3004                         ndr->depth--;
3005                 break;
3006
3007                 default:
3008                 break;
3009
3010         }
3011 }
3012
3013 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserInfo0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrWkstaUserInfo0 *r)
3014 {
3015         if (ndr_flags & NDR_SCALARS) {
3016                 NDR_CHECK(ndr_push_align(ndr, 5));
3017                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
3018                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3019         }
3020         if (ndr_flags & NDR_BUFFERS) {
3021                 if (r->user_name) {
3022                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
3023                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3024                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
3025                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3026                 }
3027         }
3028         return NDR_ERR_SUCCESS;
3029 }
3030
3031 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserInfo0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrWkstaUserInfo0 *r)
3032 {
3033         uint32_t _ptr_user_name;
3034         TALLOC_CTX *_mem_save_user_name_0;
3035         if (ndr_flags & NDR_SCALARS) {
3036                 NDR_CHECK(ndr_pull_align(ndr, 5));
3037                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3038                 if (_ptr_user_name) {
3039                         NDR_PULL_ALLOC(ndr, r->user_name);
3040                 } else {
3041                         r->user_name = NULL;
3042                 }
3043                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3044         }
3045         if (ndr_flags & NDR_BUFFERS) {
3046                 if (r->user_name) {
3047                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3048                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3049                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
3050                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
3051                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
3052                                 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));
3053                         }
3054                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
3055                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
3056                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3057                 }
3058         }
3059         return NDR_ERR_SUCCESS;
3060 }
3061
3062 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserInfo0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrWkstaUserInfo0 *r)
3063 {
3064         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaUserInfo0");
3065         ndr->depth++;
3066         ndr_print_ptr(ndr, "user_name", r->user_name);
3067         ndr->depth++;
3068         if (r->user_name) {
3069                 ndr_print_string(ndr, "user_name", r->user_name);
3070         }
3071         ndr->depth--;
3072         ndr->depth--;
3073 }
3074
3075 static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsersCtr0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaEnumUsersCtr0 *r)
3076 {
3077         uint32_t cntr_user0_1;
3078         if (ndr_flags & NDR_SCALARS) {
3079                 NDR_CHECK(ndr_push_align(ndr, 5));
3080                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->entries_read));
3081                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user0));
3082                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3083         }
3084         if (ndr_flags & NDR_BUFFERS) {
3085                 if (r->user0) {
3086                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->entries_read));
3087                         for (cntr_user0_1 = 0; cntr_user0_1 < r->entries_read; cntr_user0_1++) {
3088                                 NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo0(ndr, NDR_SCALARS, &r->user0[cntr_user0_1]));
3089                         }
3090                         for (cntr_user0_1 = 0; cntr_user0_1 < r->entries_read; cntr_user0_1++) {
3091                                 NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo0(ndr, NDR_BUFFERS, &r->user0[cntr_user0_1]));
3092                         }
3093                 }
3094         }
3095         return NDR_ERR_SUCCESS;
3096 }
3097
3098 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsersCtr0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaEnumUsersCtr0 *r)
3099 {
3100         uint32_t _ptr_user0;
3101         uint32_t cntr_user0_1;
3102         TALLOC_CTX *_mem_save_user0_0;
3103         TALLOC_CTX *_mem_save_user0_1;
3104         if (ndr_flags & NDR_SCALARS) {
3105                 NDR_CHECK(ndr_pull_align(ndr, 5));
3106                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->entries_read));
3107                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user0));
3108                 if (_ptr_user0) {
3109                         NDR_PULL_ALLOC(ndr, r->user0);
3110                 } else {
3111                         r->user0 = NULL;
3112                 }
3113                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3114         }
3115         if (ndr_flags & NDR_BUFFERS) {
3116                 if (r->user0) {
3117                         _mem_save_user0_0 = NDR_PULL_GET_MEM_CTX(ndr);
3118                         NDR_PULL_SET_MEM_CTX(ndr, r->user0, 0);
3119                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user0));
3120                         NDR_PULL_ALLOC_N(ndr, r->user0, ndr_get_array_size(ndr, &r->user0));
3121                         _mem_save_user0_1 = NDR_PULL_GET_MEM_CTX(ndr);
3122                         NDR_PULL_SET_MEM_CTX(ndr, r->user0, 0);
3123                         for (cntr_user0_1 = 0; cntr_user0_1 < r->entries_read; cntr_user0_1++) {
3124                                 NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo0(ndr, NDR_SCALARS, &r->user0[cntr_user0_1]));
3125                         }
3126                         for (cntr_user0_1 = 0; cntr_user0_1 < r->entries_read; cntr_user0_1++) {
3127                                 NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo0(ndr, NDR_BUFFERS, &r->user0[cntr_user0_1]));
3128                         }
3129                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user0_1, 0);
3130                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user0_0, 0);
3131                 }
3132                 if (r->user0) {
3133                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->user0, r->entries_read));
3134                 }
3135         }
3136         return NDR_ERR_SUCCESS;
3137 }
3138
3139 _PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsersCtr0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaEnumUsersCtr0 *r)
3140 {
3141         uint32_t cntr_user0_1;
3142         ndr_print_struct(ndr, name, "wkssvc_NetWkstaEnumUsersCtr0");
3143         ndr->depth++;
3144         ndr_print_uint32(ndr, "entries_read", r->entries_read);
3145         ndr_print_ptr(ndr, "user0", r->user0);
3146         ndr->depth++;
3147         if (r->user0) {
3148                 ndr->print(ndr, "%s: ARRAY(%d)", "user0", (int)r->entries_read);
3149                 ndr->depth++;
3150                 for (cntr_user0_1=0;cntr_user0_1<r->entries_read;cntr_user0_1++) {
3151                         char *idx_1=NULL;
3152                         if (asprintf(&idx_1, "[%d]", cntr_user0_1) != -1) {
3153                                 ndr_print_wkssvc_NetrWkstaUserInfo0(ndr, "user0", &r->user0[cntr_user0_1]);
3154                                 free(idx_1);
3155                         }
3156                 }
3157                 ndr->depth--;
3158         }
3159         ndr->depth--;
3160         ndr->depth--;
3161 }
3162
3163 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserInfo1(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrWkstaUserInfo1 *r)
3164 {
3165         if (ndr_flags & NDR_SCALARS) {
3166                 NDR_CHECK(ndr_push_align(ndr, 5));
3167                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
3168                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->logon_domain));
3169                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->other_domains));
3170                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->logon_server));
3171                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3172         }
3173         if (ndr_flags & NDR_BUFFERS) {
3174                 if (r->user_name) {
3175                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
3176                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3177                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
3178                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3179                 }
3180                 if (r->logon_domain) {
3181                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->logon_domain, CH_UTF16)));
3182                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3183                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->logon_domain, CH_UTF16)));
3184                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->logon_domain, ndr_charset_length(r->logon_domain, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3185                 }
3186                 if (r->other_domains) {
3187                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->other_domains, CH_UTF16)));
3188                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3189                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->other_domains, CH_UTF16)));
3190                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->other_domains, ndr_charset_length(r->other_domains, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3191                 }
3192                 if (r->logon_server) {
3193                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->logon_server, CH_UTF16)));
3194                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3195                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->logon_server, CH_UTF16)));
3196                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->logon_server, ndr_charset_length(r->logon_server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3197                 }
3198         }
3199         return NDR_ERR_SUCCESS;
3200 }
3201
3202 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserInfo1(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrWkstaUserInfo1 *r)
3203 {
3204         uint32_t _ptr_user_name;
3205         TALLOC_CTX *_mem_save_user_name_0;
3206         uint32_t _ptr_logon_domain;
3207         TALLOC_CTX *_mem_save_logon_domain_0;
3208         uint32_t _ptr_other_domains;
3209         TALLOC_CTX *_mem_save_other_domains_0;
3210         uint32_t _ptr_logon_server;
3211         TALLOC_CTX *_mem_save_logon_server_0;
3212         if (ndr_flags & NDR_SCALARS) {
3213                 NDR_CHECK(ndr_pull_align(ndr, 5));
3214                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3215                 if (_ptr_user_name) {
3216                         NDR_PULL_ALLOC(ndr, r->user_name);
3217                 } else {
3218                         r->user_name = NULL;
3219                 }
3220                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_logon_domain));
3221                 if (_ptr_logon_domain) {
3222                         NDR_PULL_ALLOC(ndr, r->logon_domain);
3223                 } else {
3224                         r->logon_domain = NULL;
3225                 }
3226                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_other_domains));
3227                 if (_ptr_other_domains) {
3228                         NDR_PULL_ALLOC(ndr, r->other_domains);
3229                 } else {
3230                         r->other_domains = NULL;
3231                 }
3232                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_logon_server));
3233                 if (_ptr_logon_server) {
3234                         NDR_PULL_ALLOC(ndr, r->logon_server);
3235                 } else {
3236                         r->logon_server = NULL;
3237                 }
3238                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3239         }
3240         if (ndr_flags & NDR_BUFFERS) {
3241                 if (r->user_name) {
3242                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3243                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3244                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
3245                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
3246                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
3247                                 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));
3248                         }
3249                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
3250                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
3251                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3252                 }
3253                 if (r->logon_domain) {
3254                         _mem_save_logon_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
3255                         NDR_PULL_SET_MEM_CTX(ndr, r->logon_domain, 0);
3256                         NDR_CHECK(ndr_pull_array_size(ndr, &r->logon_domain));
3257                         NDR_CHECK(ndr_pull_array_length(ndr, &r->logon_domain));
3258                         if (ndr_get_array_length(ndr, &r->logon_domain) > ndr_get_array_size(ndr, &r->logon_domain)) {
3259                                 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));
3260                         }
3261                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->logon_domain), sizeof(uint16_t)));
3262                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->logon_domain, ndr_get_array_length(ndr, &r->logon_domain), sizeof(uint16_t), CH_UTF16));
3263                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_logon_domain_0, 0);
3264                 }
3265                 if (r->other_domains) {
3266                         _mem_save_other_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
3267                         NDR_PULL_SET_MEM_CTX(ndr, r->other_domains, 0);
3268                         NDR_CHECK(ndr_pull_array_size(ndr, &r->other_domains));
3269                         NDR_CHECK(ndr_pull_array_length(ndr, &r->other_domains));
3270                         if (ndr_get_array_length(ndr, &r->other_domains) > ndr_get_array_size(ndr, &r->other_domains)) {
3271                                 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));
3272                         }
3273                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->other_domains), sizeof(uint16_t)));
3274                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->other_domains, ndr_get_array_length(ndr, &r->other_domains), sizeof(uint16_t), CH_UTF16));
3275                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_other_domains_0, 0);
3276                 }
3277                 if (r->logon_server) {
3278                         _mem_save_logon_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
3279                         NDR_PULL_SET_MEM_CTX(ndr, r->logon_server, 0);
3280                         NDR_CHECK(ndr_pull_array_size(ndr, &r->logon_server));
3281                         NDR_CHECK(ndr_pull_array_length(ndr, &r->logon_server));
3282                         if (ndr_get_array_length(ndr, &r->logon_server) > ndr_get_array_size(ndr, &r->logon_server)) {
3283                                 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));
3284                         }
3285                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->logon_server), sizeof(uint16_t)));
3286                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->logon_server, ndr_get_array_length(ndr, &r->logon_server), sizeof(uint16_t), CH_UTF16));
3287                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_logon_server_0, 0);
3288                 }
3289         }
3290         return NDR_ERR_SUCCESS;
3291 }
3292
3293 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserInfo1(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrWkstaUserInfo1 *r)
3294 {
3295         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaUserInfo1");
3296         ndr->depth++;
3297         ndr_print_ptr(ndr, "user_name", r->user_name);
3298         ndr->depth++;
3299         if (r->user_name) {
3300                 ndr_print_string(ndr, "user_name", r->user_name);
3301         }
3302         ndr->depth--;
3303         ndr_print_ptr(ndr, "logon_domain", r->logon_domain);
3304         ndr->depth++;
3305         if (r->logon_domain) {
3306                 ndr_print_string(ndr, "logon_domain", r->logon_domain);
3307         }
3308         ndr->depth--;
3309         ndr_print_ptr(ndr, "other_domains", r->other_domains);
3310         ndr->depth++;
3311         if (r->other_domains) {
3312                 ndr_print_string(ndr, "other_domains", r->other_domains);
3313         }
3314         ndr->depth--;
3315         ndr_print_ptr(ndr, "logon_server", r->logon_server);
3316         ndr->depth++;
3317         if (r->logon_server) {
3318                 ndr_print_string(ndr, "logon_server", r->logon_server);
3319         }
3320         ndr->depth--;
3321         ndr->depth--;
3322 }
3323
3324 static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsersCtr1(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaEnumUsersCtr1 *r)
3325 {
3326         uint32_t cntr_user1_1;
3327         if (ndr_flags & NDR_SCALARS) {
3328                 NDR_CHECK(ndr_push_align(ndr, 5));
3329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->entries_read));
3330                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user1));
3331                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3332         }
3333         if (ndr_flags & NDR_BUFFERS) {
3334                 if (r->user1) {
3335                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->entries_read));
3336                         for (cntr_user1_1 = 0; cntr_user1_1 < r->entries_read; cntr_user1_1++) {
3337                                 NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo1(ndr, NDR_SCALARS, &r->user1[cntr_user1_1]));
3338                         }
3339                         for (cntr_user1_1 = 0; cntr_user1_1 < r->entries_read; cntr_user1_1++) {
3340                                 NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo1(ndr, NDR_BUFFERS, &r->user1[cntr_user1_1]));
3341                         }
3342                 }
3343         }
3344         return NDR_ERR_SUCCESS;
3345 }
3346
3347 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsersCtr1(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaEnumUsersCtr1 *r)
3348 {
3349         uint32_t _ptr_user1;
3350         uint32_t cntr_user1_1;
3351         TALLOC_CTX *_mem_save_user1_0;
3352         TALLOC_CTX *_mem_save_user1_1;
3353         if (ndr_flags & NDR_SCALARS) {
3354                 NDR_CHECK(ndr_pull_align(ndr, 5));
3355                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->entries_read));
3356                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user1));
3357                 if (_ptr_user1) {
3358                         NDR_PULL_ALLOC(ndr, r->user1);
3359                 } else {
3360                         r->user1 = NULL;
3361                 }
3362                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3363         }
3364         if (ndr_flags & NDR_BUFFERS) {
3365                 if (r->user1) {
3366                         _mem_save_user1_0 = NDR_PULL_GET_MEM_CTX(ndr);
3367                         NDR_PULL_SET_MEM_CTX(ndr, r->user1, 0);
3368                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user1));
3369                         NDR_PULL_ALLOC_N(ndr, r->user1, ndr_get_array_size(ndr, &r->user1));
3370                         _mem_save_user1_1 = NDR_PULL_GET_MEM_CTX(ndr);
3371                         NDR_PULL_SET_MEM_CTX(ndr, r->user1, 0);
3372                         for (cntr_user1_1 = 0; cntr_user1_1 < r->entries_read; cntr_user1_1++) {
3373                                 NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo1(ndr, NDR_SCALARS, &r->user1[cntr_user1_1]));
3374                         }
3375                         for (cntr_user1_1 = 0; cntr_user1_1 < r->entries_read; cntr_user1_1++) {
3376                                 NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo1(ndr, NDR_BUFFERS, &r->user1[cntr_user1_1]));
3377                         }
3378                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user1_1, 0);
3379                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user1_0, 0);
3380                 }
3381                 if (r->user1) {
3382                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->user1, r->entries_read));
3383                 }
3384         }
3385         return NDR_ERR_SUCCESS;
3386 }
3387
3388 _PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsersCtr1(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaEnumUsersCtr1 *r)
3389 {
3390         uint32_t cntr_user1_1;
3391         ndr_print_struct(ndr, name, "wkssvc_NetWkstaEnumUsersCtr1");
3392         ndr->depth++;
3393         ndr_print_uint32(ndr, "entries_read", r->entries_read);
3394         ndr_print_ptr(ndr, "user1", r->user1);
3395         ndr->depth++;
3396         if (r->user1) {
3397                 ndr->print(ndr, "%s: ARRAY(%d)", "user1", (int)r->entries_read);
3398                 ndr->depth++;
3399                 for (cntr_user1_1=0;cntr_user1_1<r->entries_read;cntr_user1_1++) {
3400                         char *idx_1=NULL;
3401                         if (asprintf(&idx_1, "[%d]", cntr_user1_1) != -1) {
3402                                 ndr_print_wkssvc_NetrWkstaUserInfo1(ndr, "user1", &r->user1[cntr_user1_1]);
3403                                 free(idx_1);
3404                         }
3405                 }
3406                 ndr->depth--;
3407         }
3408         ndr->depth--;
3409         ndr->depth--;
3410 }
3411
3412 static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsersCtr(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetWkstaEnumUsersCtr *r)
3413 {
3414         if (ndr_flags & NDR_SCALARS) {
3415                 int level = ndr_push_get_switch_value(ndr, r);
3416                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
3417                 NDR_CHECK(ndr_push_union_align(ndr, 5));
3418                 switch (level) {
3419                         case 0: {
3420                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user0));
3421                         break; }
3422
3423                         case 1: {
3424                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user1));
3425                         break; }
3426
3427                         default:
3428                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3429                 }
3430         }
3431         if (ndr_flags & NDR_BUFFERS) {
3432                 int level = ndr_push_get_switch_value(ndr, r);
3433                 switch (level) {
3434                         case 0:
3435                                 if (r->user0) {
3436                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->user0));
3437                                 }
3438                         break;
3439
3440                         case 1:
3441                                 if (r->user1) {
3442                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->user1));
3443                                 }
3444                         break;
3445
3446                         default:
3447                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3448                 }
3449         }
3450         return NDR_ERR_SUCCESS;
3451 }
3452
3453 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsersCtr(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetWkstaEnumUsersCtr *r)
3454 {
3455         int level;
3456         uint32_t _level;
3457         TALLOC_CTX *_mem_save_user0_0;
3458         TALLOC_CTX *_mem_save_user1_0;
3459         level = ndr_pull_get_switch_value(ndr, r);
3460         if (ndr_flags & NDR_SCALARS) {
3461                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
3462                 if (_level != level) {
3463                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3464                 }
3465                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
3466                 switch (level) {
3467                         case 0: {
3468                                 uint32_t _ptr_user0;
3469                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user0));
3470                                 if (_ptr_user0) {
3471                                         NDR_PULL_ALLOC(ndr, r->user0);
3472                                 } else {
3473                                         r->user0 = NULL;
3474                                 }
3475                         break; }
3476
3477                         case 1: {
3478                                 uint32_t _ptr_user1;
3479                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user1));
3480                                 if (_ptr_user1) {
3481                                         NDR_PULL_ALLOC(ndr, r->user1);
3482                                 } else {
3483                                         r->user1 = NULL;
3484                                 }
3485                         break; }
3486
3487                         default:
3488                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3489                 }
3490         }
3491         if (ndr_flags & NDR_BUFFERS) {
3492                 switch (level) {
3493                         case 0:
3494                                 if (r->user0) {
3495                                         _mem_save_user0_0 = NDR_PULL_GET_MEM_CTX(ndr);
3496                                         NDR_PULL_SET_MEM_CTX(ndr, r->user0, 0);
3497                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->user0));
3498                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user0_0, 0);
3499                                 }
3500                         break;
3501
3502                         case 1:
3503                                 if (r->user1) {
3504                                         _mem_save_user1_0 = NDR_PULL_GET_MEM_CTX(ndr);
3505                                         NDR_PULL_SET_MEM_CTX(ndr, r->user1, 0);
3506                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->user1));
3507                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user1_0, 0);
3508                                 }
3509                         break;
3510
3511                         default:
3512                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3513                 }
3514         }
3515         return NDR_ERR_SUCCESS;
3516 }
3517
3518 _PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsersCtr(struct ndr_print *ndr, const char *name, const union wkssvc_NetWkstaEnumUsersCtr *r)
3519 {
3520         int level;
3521         level = ndr_print_get_switch_value(ndr, r);
3522         ndr_print_union(ndr, name, level, "wkssvc_NetWkstaEnumUsersCtr");
3523         switch (level) {
3524                 case 0:
3525                         ndr_print_ptr(ndr, "user0", r->user0);
3526                         ndr->depth++;
3527                         if (r->user0) {
3528                                 ndr_print_wkssvc_NetWkstaEnumUsersCtr0(ndr, "user0", r->user0);
3529                         }
3530                         ndr->depth--;
3531                 break;
3532
3533                 case 1:
3534                         ndr_print_ptr(ndr, "user1", r->user1);
3535                         ndr->depth++;
3536                         if (r->user1) {
3537                                 ndr_print_wkssvc_NetWkstaEnumUsersCtr1(ndr, "user1", r->user1);
3538                         }
3539                         ndr->depth--;
3540                 break;
3541
3542                 default:
3543                         ndr_print_bad_level(ndr, name, level);
3544         }
3545 }
3546
3547 static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsersInfo(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaEnumUsersInfo *r)
3548 {
3549         if (ndr_flags & NDR_SCALARS) {
3550                 NDR_CHECK(ndr_push_align(ndr, 5));
3551                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
3552                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
3553                 NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersCtr(ndr, NDR_SCALARS, &r->ctr));
3554                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3555         }
3556         if (ndr_flags & NDR_BUFFERS) {
3557                 NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersCtr(ndr, NDR_BUFFERS, &r->ctr));
3558         }
3559         return NDR_ERR_SUCCESS;
3560 }
3561
3562 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsersInfo(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaEnumUsersInfo *r)
3563 {
3564         if (ndr_flags & NDR_SCALARS) {
3565                 NDR_CHECK(ndr_pull_align(ndr, 5));
3566                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
3567                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
3568                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersCtr(ndr, NDR_SCALARS, &r->ctr));
3569                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3570         }
3571         if (ndr_flags & NDR_BUFFERS) {
3572                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersCtr(ndr, NDR_BUFFERS, &r->ctr));
3573         }
3574         return NDR_ERR_SUCCESS;
3575 }
3576
3577 _PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsersInfo(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaEnumUsersInfo *r)
3578 {
3579         ndr_print_struct(ndr, name, "wkssvc_NetWkstaEnumUsersInfo");
3580         ndr->depth++;
3581         ndr_print_uint32(ndr, "level", r->level);
3582         ndr_print_set_switch_value(ndr, &r->ctr, r->level);
3583         ndr_print_wkssvc_NetWkstaEnumUsersCtr(ndr, "ctr", &r->ctr);
3584         ndr->depth--;
3585 }
3586
3587 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserInfo1101(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrWkstaUserInfo1101 *r)
3588 {
3589         if (ndr_flags & NDR_SCALARS) {
3590                 NDR_CHECK(ndr_push_align(ndr, 5));
3591                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->other_domains));
3592                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3593         }
3594         if (ndr_flags & NDR_BUFFERS) {
3595                 if (r->other_domains) {
3596                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->other_domains, CH_UTF16)));
3597                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3598                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->other_domains, CH_UTF16)));
3599                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->other_domains, ndr_charset_length(r->other_domains, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3600                 }
3601         }
3602         return NDR_ERR_SUCCESS;
3603 }
3604
3605 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserInfo1101(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrWkstaUserInfo1101 *r)
3606 {
3607         uint32_t _ptr_other_domains;
3608         TALLOC_CTX *_mem_save_other_domains_0;
3609         if (ndr_flags & NDR_SCALARS) {
3610                 NDR_CHECK(ndr_pull_align(ndr, 5));
3611                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_other_domains));
3612                 if (_ptr_other_domains) {
3613                         NDR_PULL_ALLOC(ndr, r->other_domains);
3614                 } else {
3615                         r->other_domains = NULL;
3616                 }
3617                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3618         }
3619         if (ndr_flags & NDR_BUFFERS) {
3620                 if (r->other_domains) {
3621                         _mem_save_other_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
3622                         NDR_PULL_SET_MEM_CTX(ndr, r->other_domains, 0);
3623                         NDR_CHECK(ndr_pull_array_size(ndr, &r->other_domains));
3624                         NDR_CHECK(ndr_pull_array_length(ndr, &r->other_domains));
3625                         if (ndr_get_array_length(ndr, &r->other_domains) > ndr_get_array_size(ndr, &r->other_domains)) {
3626                                 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));
3627                         }
3628                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->other_domains), sizeof(uint16_t)));
3629                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->other_domains, ndr_get_array_length(ndr, &r->other_domains), sizeof(uint16_t), CH_UTF16));
3630                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_other_domains_0, 0);
3631                 }
3632         }
3633         return NDR_ERR_SUCCESS;
3634 }
3635
3636 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserInfo1101(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrWkstaUserInfo1101 *r)
3637 {
3638         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaUserInfo1101");
3639         ndr->depth++;
3640         ndr_print_ptr(ndr, "other_domains", r->other_domains);
3641         ndr->depth++;
3642         if (r->other_domains) {
3643                 ndr_print_string(ndr, "other_domains", r->other_domains);
3644         }
3645         ndr->depth--;
3646         ndr->depth--;
3647 }
3648
3649 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserInfo(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetrWkstaUserInfo *r)
3650 {
3651         if (ndr_flags & NDR_SCALARS) {
3652                 int level = ndr_push_get_switch_value(ndr, r);
3653                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
3654                 NDR_CHECK(ndr_push_union_align(ndr, 5));
3655                 switch (level) {
3656                         case 0: {
3657                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
3658                         break; }
3659
3660                         case 1: {
3661                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
3662                         break; }
3663
3664                         case 1101: {
3665                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1101));
3666                         break; }
3667
3668                         default:
3669                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3670                 }
3671         }
3672         if (ndr_flags & NDR_BUFFERS) {
3673                 int level = ndr_push_get_switch_value(ndr, r);
3674                 switch (level) {
3675                         case 0:
3676                                 if (r->info0) {
3677                                         NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
3678                                 }
3679                         break;
3680
3681                         case 1:
3682                                 if (r->info1) {
3683                                         NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
3684                                 }
3685                         break;
3686
3687                         case 1101:
3688                                 if (r->info1101) {
3689                                         NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo1101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1101));
3690                                 }
3691                         break;
3692
3693                         default:
3694                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3695                 }
3696         }
3697         return NDR_ERR_SUCCESS;
3698 }
3699
3700 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserInfo(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetrWkstaUserInfo *r)
3701 {
3702         int level;
3703         uint32_t _level;
3704         TALLOC_CTX *_mem_save_info0_0;
3705         TALLOC_CTX *_mem_save_info1_0;
3706         TALLOC_CTX *_mem_save_info1101_0;
3707         level = ndr_pull_get_switch_value(ndr, r);
3708         if (ndr_flags & NDR_SCALARS) {
3709                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
3710                 if (_level != level) {
3711                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3712                 }
3713                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
3714                 switch (level) {
3715                         case 0: {
3716                                 uint32_t _ptr_info0;
3717                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
3718                                 if (_ptr_info0) {
3719                                         NDR_PULL_ALLOC(ndr, r->info0);
3720                                 } else {
3721                                         r->info0 = NULL;
3722                                 }
3723                         break; }
3724
3725                         case 1: {
3726                                 uint32_t _ptr_info1;
3727                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
3728                                 if (_ptr_info1) {
3729                                         NDR_PULL_ALLOC(ndr, r->info1);
3730                                 } else {
3731                                         r->info1 = NULL;
3732                                 }
3733                         break; }
3734
3735                         case 1101: {
3736                                 uint32_t _ptr_info1101;
3737                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1101));
3738                                 if (_ptr_info1101) {
3739                                         NDR_PULL_ALLOC(ndr, r->info1101);
3740                                 } else {
3741                                         r->info1101 = NULL;
3742                                 }
3743                         break; }
3744
3745                         default:
3746                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3747                 }
3748         }
3749         if (ndr_flags & NDR_BUFFERS) {
3750                 switch (level) {
3751                         case 0:
3752                                 if (r->info0) {
3753                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
3754                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
3755                                         NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
3756                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
3757                                 }
3758                         break;
3759
3760                         case 1:
3761                                 if (r->info1) {
3762                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
3763                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
3764                                         NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
3765                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
3766                                 }
3767                         break;
3768
3769                         case 1101:
3770                                 if (r->info1101) {
3771                                         _mem_save_info1101_0 = NDR_PULL_GET_MEM_CTX(ndr);
3772                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1101, 0);
3773                                         NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo1101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1101));
3774                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1101_0, 0);
3775                                 }
3776                         break;
3777
3778                         default:
3779                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3780                 }
3781         }
3782         return NDR_ERR_SUCCESS;
3783 }
3784
3785 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserInfo(struct ndr_print *ndr, const char *name, const union wkssvc_NetrWkstaUserInfo *r)
3786 {
3787         int level;
3788         level = ndr_print_get_switch_value(ndr, r);
3789         ndr_print_union(ndr, name, level, "wkssvc_NetrWkstaUserInfo");
3790         switch (level) {
3791                 case 0:
3792                         ndr_print_ptr(ndr, "info0", r->info0);
3793                         ndr->depth++;
3794                         if (r->info0) {
3795                                 ndr_print_wkssvc_NetrWkstaUserInfo0(ndr, "info0", r->info0);
3796                         }
3797                         ndr->depth--;
3798                 break;
3799
3800                 case 1:
3801                         ndr_print_ptr(ndr, "info1", r->info1);
3802                         ndr->depth++;
3803                         if (r->info1) {
3804                                 ndr_print_wkssvc_NetrWkstaUserInfo1(ndr, "info1", r->info1);
3805                         }
3806                         ndr->depth--;
3807                 break;
3808
3809                 case 1101:
3810                         ndr_print_ptr(ndr, "info1101", r->info1101);
3811                         ndr->depth++;
3812                         if (r->info1101) {
3813                                 ndr_print_wkssvc_NetrWkstaUserInfo1101(ndr, "info1101", r->info1101);
3814                         }
3815                         ndr->depth--;
3816                 break;
3817
3818                 default:
3819                         ndr_print_bad_level(ndr, name, level);
3820         }
3821 }
3822
3823 static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportInfo0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaTransportInfo0 *r)
3824 {
3825         if (ndr_flags & NDR_SCALARS) {
3826                 NDR_CHECK(ndr_push_align(ndr, 5));
3827                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->quality_of_service));
3828                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->vc_count));
3829                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
3830                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->address));
3831                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->wan_link));
3832                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3833         }
3834         if (ndr_flags & NDR_BUFFERS) {
3835                 if (r->name) {
3836                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
3837                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3838                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
3839                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3840                 }
3841                 if (r->address) {
3842                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->address, CH_UTF16)));
3843                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3844                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->address, CH_UTF16)));
3845                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->address, ndr_charset_length(r->address, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3846                 }
3847         }
3848         return NDR_ERR_SUCCESS;
3849 }
3850
3851 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportInfo0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaTransportInfo0 *r)
3852 {
3853         uint32_t _ptr_name;
3854         TALLOC_CTX *_mem_save_name_0;
3855         uint32_t _ptr_address;
3856         TALLOC_CTX *_mem_save_address_0;
3857         if (ndr_flags & NDR_SCALARS) {
3858                 NDR_CHECK(ndr_pull_align(ndr, 5));
3859                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->quality_of_service));
3860                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->vc_count));
3861                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
3862                 if (_ptr_name) {
3863                         NDR_PULL_ALLOC(ndr, r->name);
3864                 } else {
3865                         r->name = NULL;
3866                 }
3867                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_address));
3868                 if (_ptr_address) {
3869                         NDR_PULL_ALLOC(ndr, r->address);
3870                 } else {
3871                         r->address = NULL;
3872                 }
3873                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->wan_link));
3874                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3875         }
3876         if (ndr_flags & NDR_BUFFERS) {
3877                 if (r->name) {
3878                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3879                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
3880                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
3881                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
3882                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
3883                                 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));
3884                         }
3885                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
3886                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
3887                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
3888                 }
3889                 if (r->address) {
3890                         _mem_save_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
3891                         NDR_PULL_SET_MEM_CTX(ndr, r->address, 0);
3892                         NDR_CHECK(ndr_pull_array_size(ndr, &r->address));
3893                         NDR_CHECK(ndr_pull_array_length(ndr, &r->address));
3894                         if (ndr_get_array_length(ndr, &r->address) > ndr_get_array_size(ndr, &r->address)) {
3895                                 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));
3896                         }
3897                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->address), sizeof(uint16_t)));
3898                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->address, ndr_get_array_length(ndr, &r->address), sizeof(uint16_t), CH_UTF16));
3899                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_address_0, 0);
3900                 }
3901         }
3902         return NDR_ERR_SUCCESS;
3903 }
3904
3905 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportInfo0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaTransportInfo0 *r)
3906 {
3907         ndr_print_struct(ndr, name, "wkssvc_NetWkstaTransportInfo0");
3908         ndr->depth++;
3909         ndr_print_uint32(ndr, "quality_of_service", r->quality_of_service);
3910         ndr_print_uint32(ndr, "vc_count", r->vc_count);
3911         ndr_print_ptr(ndr, "name", r->name);
3912         ndr->depth++;
3913         if (r->name) {
3914                 ndr_print_string(ndr, "name", r->name);
3915         }
3916         ndr->depth--;
3917         ndr_print_ptr(ndr, "address", r->address);
3918         ndr->depth++;
3919         if (r->address) {
3920                 ndr_print_string(ndr, "address", r->address);
3921         }
3922         ndr->depth--;
3923         ndr_print_uint32(ndr, "wan_link", r->wan_link);
3924         ndr->depth--;
3925 }
3926
3927 static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportCtr0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaTransportCtr0 *r)
3928 {
3929         uint32_t cntr_array_1;
3930         if (ndr_flags & NDR_SCALARS) {
3931                 NDR_CHECK(ndr_push_align(ndr, 5));
3932                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3933                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
3934                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3935         }
3936         if (ndr_flags & NDR_BUFFERS) {
3937                 if (r->array) {
3938                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
3939                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3940                                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
3941                         }
3942                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3943                                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
3944                         }
3945                 }
3946         }
3947         return NDR_ERR_SUCCESS;
3948 }
3949
3950 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportCtr0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaTransportCtr0 *r)
3951 {
3952         uint32_t _ptr_array;
3953         uint32_t cntr_array_1;
3954         TALLOC_CTX *_mem_save_array_0;
3955         TALLOC_CTX *_mem_save_array_1;
3956         if (ndr_flags & NDR_SCALARS) {
3957                 NDR_CHECK(ndr_pull_align(ndr, 5));
3958                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3959                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
3960                 if (_ptr_array) {
3961                         NDR_PULL_ALLOC(ndr, r->array);
3962                 } else {
3963                         r->array = NULL;
3964                 }
3965                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3966         }
3967         if (ndr_flags & NDR_BUFFERS) {
3968                 if (r->array) {
3969                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
3970                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
3971                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
3972                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
3973                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
3974                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
3975                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3976                                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
3977                         }
3978                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3979                                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
3980                         }
3981                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
3982                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
3983                 }
3984                 if (r->array) {
3985                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
3986                 }
3987         }
3988         return NDR_ERR_SUCCESS;
3989 }
3990
3991 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportCtr0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaTransportCtr0 *r)
3992 {
3993         uint32_t cntr_array_1;
3994         ndr_print_struct(ndr, name, "wkssvc_NetWkstaTransportCtr0");
3995         ndr->depth++;
3996         ndr_print_uint32(ndr, "count", r->count);
3997         ndr_print_ptr(ndr, "array", r->array);
3998         ndr->depth++;
3999         if (r->array) {
4000                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
4001                 ndr->depth++;
4002                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
4003                         char *idx_1=NULL;
4004                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
4005                                 ndr_print_wkssvc_NetWkstaTransportInfo0(ndr, "array", &r->array[cntr_array_1]);
4006                                 free(idx_1);
4007                         }
4008                 }
4009                 ndr->depth--;
4010         }
4011         ndr->depth--;
4012         ndr->depth--;
4013 }
4014
4015 static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportCtr(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetWkstaTransportCtr *r)
4016 {
4017         if (ndr_flags & NDR_SCALARS) {
4018                 int level = ndr_push_get_switch_value(ndr, r);
4019                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
4020                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4021                 switch (level) {
4022                         case 0: {
4023                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
4024                         break; }
4025
4026                         default:
4027                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4028                 }
4029         }
4030         if (ndr_flags & NDR_BUFFERS) {
4031                 int level = ndr_push_get_switch_value(ndr, r);
4032                 switch (level) {
4033                         case 0:
4034                                 if (r->ctr0) {
4035                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
4036                                 }
4037                         break;
4038
4039                         default:
4040                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4041                 }
4042         }
4043         return NDR_ERR_SUCCESS;
4044 }
4045
4046 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportCtr(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetWkstaTransportCtr *r)
4047 {
4048         int level;
4049         uint32_t _level;
4050         TALLOC_CTX *_mem_save_ctr0_0;
4051         level = ndr_pull_get_switch_value(ndr, r);
4052         if (ndr_flags & NDR_SCALARS) {
4053                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
4054                 if (_level != level) {
4055                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4056                 }
4057                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4058                 switch (level) {
4059                         case 0: {
4060                                 uint32_t _ptr_ctr0;
4061                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));
4062                                 if (_ptr_ctr0) {
4063                                         NDR_PULL_ALLOC(ndr, r->ctr0);
4064                                 } else {
4065                                         r->ctr0 = NULL;
4066                                 }
4067                         break; }
4068
4069                         default:
4070                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4071                 }
4072         }
4073         if (ndr_flags & NDR_BUFFERS) {
4074                 switch (level) {
4075                         case 0:
4076                                 if (r->ctr0) {
4077                                         _mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);
4078                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr0, 0);
4079                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
4080                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);
4081                                 }
4082                         break;
4083
4084                         default:
4085                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4086                 }
4087         }
4088         return NDR_ERR_SUCCESS;
4089 }
4090
4091 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportCtr(struct ndr_print *ndr, const char *name, const union wkssvc_NetWkstaTransportCtr *r)
4092 {
4093         int level;
4094         level = ndr_print_get_switch_value(ndr, r);
4095         ndr_print_union(ndr, name, level, "wkssvc_NetWkstaTransportCtr");
4096         switch (level) {
4097                 case 0:
4098                         ndr_print_ptr(ndr, "ctr0", r->ctr0);
4099                         ndr->depth++;
4100                         if (r->ctr0) {
4101                                 ndr_print_wkssvc_NetWkstaTransportCtr0(ndr, "ctr0", r->ctr0);
4102                         }
4103                         ndr->depth--;
4104                 break;
4105
4106                 default:
4107                         ndr_print_bad_level(ndr, name, level);
4108         }
4109 }
4110
4111 static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportInfo(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaTransportInfo *r)
4112 {
4113         if (ndr_flags & NDR_SCALARS) {
4114                 NDR_CHECK(ndr_push_align(ndr, 5));
4115                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
4116                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
4117                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportCtr(ndr, NDR_SCALARS, &r->ctr));
4118                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4119         }
4120         if (ndr_flags & NDR_BUFFERS) {
4121                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportCtr(ndr, NDR_BUFFERS, &r->ctr));
4122         }
4123         return NDR_ERR_SUCCESS;
4124 }
4125
4126 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportInfo(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaTransportInfo *r)
4127 {
4128         if (ndr_flags & NDR_SCALARS) {
4129                 NDR_CHECK(ndr_pull_align(ndr, 5));
4130                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
4131                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
4132                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportCtr(ndr, NDR_SCALARS, &r->ctr));
4133                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4134         }
4135         if (ndr_flags & NDR_BUFFERS) {
4136                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportCtr(ndr, NDR_BUFFERS, &r->ctr));
4137         }
4138         return NDR_ERR_SUCCESS;
4139 }
4140
4141 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportInfo(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaTransportInfo *r)
4142 {
4143         ndr_print_struct(ndr, name, "wkssvc_NetWkstaTransportInfo");
4144         ndr->depth++;
4145         ndr_print_uint32(ndr, "level", r->level);
4146         ndr_print_set_switch_value(ndr, &r->ctr, r->level);
4147         ndr_print_wkssvc_NetWkstaTransportCtr(ndr, "ctr", &r->ctr);
4148         ndr->depth--;
4149 }
4150
4151 static enum ndr_err_code ndr_push_wkssvc_NetrUseInfo3(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseInfo3 *r)
4152 {
4153         if (ndr_flags & NDR_SCALARS) {
4154                 NDR_CHECK(ndr_push_align(ndr, 5));
4155                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->unknown1));
4156                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->unknown2));
4157                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4158         }
4159         if (ndr_flags & NDR_BUFFERS) {
4160                 if (r->unknown1) {
4161                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->unknown1, CH_UTF16)));
4162                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4163                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->unknown1, CH_UTF16)));
4164                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->unknown1, ndr_charset_length(r->unknown1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4165                 }
4166                 if (r->unknown2) {
4167                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->unknown2, CH_UTF16)));
4168                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4169                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->unknown2, CH_UTF16)));
4170                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->unknown2, ndr_charset_length(r->unknown2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4171                 }
4172         }
4173         return NDR_ERR_SUCCESS;
4174 }
4175
4176 static enum ndr_err_code ndr_pull_wkssvc_NetrUseInfo3(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseInfo3 *r)
4177 {
4178         uint32_t _ptr_unknown1;
4179         TALLOC_CTX *_mem_save_unknown1_0;
4180         uint32_t _ptr_unknown2;
4181         TALLOC_CTX *_mem_save_unknown2_0;
4182         if (ndr_flags & NDR_SCALARS) {
4183                 NDR_CHECK(ndr_pull_align(ndr, 5));
4184                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown1));
4185                 if (_ptr_unknown1) {
4186                         NDR_PULL_ALLOC(ndr, r->unknown1);
4187                 } else {
4188                         r->unknown1 = NULL;
4189                 }
4190                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown2));
4191                 if (_ptr_unknown2) {
4192                         NDR_PULL_ALLOC(ndr, r->unknown2);
4193                 } else {
4194                         r->unknown2 = NULL;
4195                 }
4196                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4197         }
4198         if (ndr_flags & NDR_BUFFERS) {
4199                 if (r->unknown1) {
4200                         _mem_save_unknown1_0 = NDR_PULL_GET_MEM_CTX(ndr);
4201                         NDR_PULL_SET_MEM_CTX(ndr, r->unknown1, 0);
4202                         NDR_CHECK(ndr_pull_array_size(ndr, &r->unknown1));
4203                         NDR_CHECK(ndr_pull_array_length(ndr, &r->unknown1));
4204                         if (ndr_get_array_length(ndr, &r->unknown1) > ndr_get_array_size(ndr, &r->unknown1)) {
4205                                 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));
4206                         }
4207                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->unknown1), sizeof(uint16_t)));
4208                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->unknown1, ndr_get_array_length(ndr, &r->unknown1), sizeof(uint16_t), CH_UTF16));
4209                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown1_0, 0);
4210                 }
4211                 if (r->unknown2) {
4212                         _mem_save_unknown2_0 = NDR_PULL_GET_MEM_CTX(ndr);
4213                         NDR_PULL_SET_MEM_CTX(ndr, r->unknown2, 0);
4214                         NDR_CHECK(ndr_pull_array_size(ndr, &r->unknown2));
4215                         NDR_CHECK(ndr_pull_array_length(ndr, &r->unknown2));
4216                         if (ndr_get_array_length(ndr, &r->unknown2) > ndr_get_array_size(ndr, &r->unknown2)) {
4217                                 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));
4218                         }
4219                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->unknown2), sizeof(uint16_t)));
4220                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->unknown2, ndr_get_array_length(ndr, &r->unknown2), sizeof(uint16_t), CH_UTF16));
4221                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown2_0, 0);
4222                 }
4223         }
4224         return NDR_ERR_SUCCESS;
4225 }
4226
4227 _PUBLIC_ void ndr_print_wkssvc_NetrUseInfo3(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseInfo3 *r)
4228 {
4229         ndr_print_struct(ndr, name, "wkssvc_NetrUseInfo3");
4230         ndr->depth++;
4231         ndr_print_ptr(ndr, "unknown1", r->unknown1);
4232         ndr->depth++;
4233         if (r->unknown1) {
4234                 ndr_print_string(ndr, "unknown1", r->unknown1);
4235         }
4236         ndr->depth--;
4237         ndr_print_ptr(ndr, "unknown2", r->unknown2);
4238         ndr->depth++;
4239         if (r->unknown2) {
4240                 ndr_print_string(ndr, "unknown2", r->unknown2);
4241         }
4242         ndr->depth--;
4243         ndr->depth--;
4244 }
4245
4246 static enum ndr_err_code ndr_push_wkssvc_NetrUseInfo2(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseInfo2 *r)
4247 {
4248         if (ndr_flags & NDR_SCALARS) {
4249                 NDR_CHECK(ndr_push_align(ndr, 5));
4250                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->local));
4251                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote));
4252                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->password));
4253                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
4254                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->asg_type));
4255                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_count));
4256                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_count));
4257                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
4258                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
4259                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4260         }
4261         if (ndr_flags & NDR_BUFFERS) {
4262                 if (r->local) {
4263                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->local, CH_UTF16)));
4264                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4265                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->local, CH_UTF16)));
4266                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->local, ndr_charset_length(r->local, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4267                 }
4268                 if (r->remote) {
4269                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote, CH_UTF16)));
4270                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4271                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote, CH_UTF16)));
4272                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->remote, ndr_charset_length(r->remote, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4273                 }
4274                 if (r->password) {
4275                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));
4276                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4277                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));
4278                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->password, ndr_charset_length(r->password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4279                 }
4280                 if (r->user_name) {
4281                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4282                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4283                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4284                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4285                 }
4286                 if (r->domain_name) {
4287                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
4288                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4289                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
4290                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4291                 }
4292         }
4293         return NDR_ERR_SUCCESS;
4294 }
4295
4296 static enum ndr_err_code ndr_pull_wkssvc_NetrUseInfo2(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseInfo2 *r)
4297 {
4298         uint32_t _ptr_local;
4299         TALLOC_CTX *_mem_save_local_0;
4300         uint32_t _ptr_remote;
4301         TALLOC_CTX *_mem_save_remote_0;
4302         uint32_t _ptr_password;
4303         TALLOC_CTX *_mem_save_password_0;
4304         uint32_t _ptr_user_name;
4305         TALLOC_CTX *_mem_save_user_name_0;
4306         uint32_t _ptr_domain_name;
4307         TALLOC_CTX *_mem_save_domain_name_0;
4308         if (ndr_flags & NDR_SCALARS) {
4309                 NDR_CHECK(ndr_pull_align(ndr, 5));
4310                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local));
4311                 if (_ptr_local) {
4312                         NDR_PULL_ALLOC(ndr, r->local);
4313                 } else {
4314                         r->local = NULL;
4315                 }
4316                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote));
4317                 if (_ptr_remote) {
4318                         NDR_PULL_ALLOC(ndr, r->remote);
4319                 } else {
4320                         r->remote = NULL;
4321                 }
4322                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
4323                 if (_ptr_password) {
4324                         NDR_PULL_ALLOC(ndr, r->password);
4325                 } else {
4326                         r->password = NULL;
4327                 }
4328                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
4329                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->asg_type));
4330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_count));
4331                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_count));
4332                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4333                 if (_ptr_user_name) {
4334                         NDR_PULL_ALLOC(ndr, r->user_name);
4335                 } else {
4336                         r->user_name = NULL;
4337                 }
4338                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
4339                 if (_ptr_domain_name) {
4340                         NDR_PULL_ALLOC(ndr, r->domain_name);
4341                 } else {
4342                         r->domain_name = NULL;
4343                 }
4344                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4345         }
4346         if (ndr_flags & NDR_BUFFERS) {
4347                 if (r->local) {
4348                         _mem_save_local_0 = NDR_PULL_GET_MEM_CTX(ndr);
4349                         NDR_PULL_SET_MEM_CTX(ndr, r->local, 0);
4350                         NDR_CHECK(ndr_pull_array_size(ndr, &r->local));
4351                         NDR_CHECK(ndr_pull_array_length(ndr, &r->local));
4352                         if (ndr_get_array_length(ndr, &r->local) > ndr_get_array_size(ndr, &r->local)) {
4353                                 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));
4354                         }
4355                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->local), sizeof(uint16_t)));
4356                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->local, ndr_get_array_length(ndr, &r->local), sizeof(uint16_t), CH_UTF16));
4357                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_0, 0);
4358                 }
4359                 if (r->remote) {
4360                         _mem_save_remote_0 = NDR_PULL_GET_MEM_CTX(ndr);
4361                         NDR_PULL_SET_MEM_CTX(ndr, r->remote, 0);
4362                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote));
4363                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote));
4364                         if (ndr_get_array_length(ndr, &r->remote) > ndr_get_array_size(ndr, &r->remote)) {
4365                                 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));
4366                         }
4367                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t)));
4368                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->remote, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t), CH_UTF16));
4369                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_0, 0);
4370                 }
4371                 if (r->password) {
4372                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
4373                         NDR_PULL_SET_MEM_CTX(ndr, r->password, 0);
4374                         NDR_CHECK(ndr_pull_array_size(ndr, &r->password));
4375                         NDR_CHECK(ndr_pull_array_length(ndr, &r->password));
4376                         if (ndr_get_array_length(ndr, &r->password) > ndr_get_array_size(ndr, &r->password)) {
4377                                 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));
4378                         }
4379                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t)));
4380                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->password, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t), CH_UTF16));
4381                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
4382                 }
4383                 if (r->user_name) {
4384                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4385                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4386                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
4387                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
4388                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
4389                                 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));
4390                         }
4391                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
4392                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
4393                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4394                 }
4395                 if (r->domain_name) {
4396                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4397                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
4398                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
4399                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
4400                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
4401                                 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));
4402                         }
4403                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
4404                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
4405                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
4406                 }
4407         }
4408         return NDR_ERR_SUCCESS;
4409 }
4410
4411 _PUBLIC_ void ndr_print_wkssvc_NetrUseInfo2(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseInfo2 *r)
4412 {
4413         ndr_print_struct(ndr, name, "wkssvc_NetrUseInfo2");
4414         ndr->depth++;
4415         ndr_print_ptr(ndr, "local", r->local);
4416         ndr->depth++;
4417         if (r->local) {
4418                 ndr_print_string(ndr, "local", r->local);
4419         }
4420         ndr->depth--;
4421         ndr_print_ptr(ndr, "remote", r->remote);
4422         ndr->depth++;
4423         if (r->remote) {
4424                 ndr_print_string(ndr, "remote", r->remote);
4425         }
4426         ndr->depth--;
4427         ndr_print_ptr(ndr, "password", r->password);
4428         ndr->depth++;
4429         if (r->password) {
4430                 ndr_print_string(ndr, "password", r->password);
4431         }
4432         ndr->depth--;
4433         ndr_print_uint32(ndr, "status", r->status);
4434         ndr_print_uint32(ndr, "asg_type", r->asg_type);
4435         ndr_print_uint32(ndr, "ref_count", r->ref_count);
4436         ndr_print_uint32(ndr, "use_count", r->use_count);
4437         ndr_print_ptr(ndr, "user_name", r->user_name);
4438         ndr->depth++;
4439         if (r->user_name) {
4440                 ndr_print_string(ndr, "user_name", r->user_name);
4441         }
4442         ndr->depth--;
4443         ndr_print_ptr(ndr, "domain_name", r->domain_name);
4444         ndr->depth++;
4445         if (r->domain_name) {
4446                 ndr_print_string(ndr, "domain_name", r->domain_name);
4447         }
4448         ndr->depth--;
4449         ndr->depth--;
4450 }
4451
4452 static enum ndr_err_code ndr_push_wkssvc_NetrUseInfo1(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseInfo1 *r)
4453 {
4454         if (ndr_flags & NDR_SCALARS) {
4455                 NDR_CHECK(ndr_push_align(ndr, 5));
4456                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->local));
4457                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote));
4458                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->password));
4459                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
4460                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->asg_type));
4461                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_count));
4462                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_count));
4463                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4464         }
4465         if (ndr_flags & NDR_BUFFERS) {
4466                 if (r->local) {
4467                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->local, CH_UTF16)));
4468                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4469                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->local, CH_UTF16)));
4470                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->local, ndr_charset_length(r->local, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4471                 }
4472                 if (r->remote) {
4473                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote, CH_UTF16)));
4474                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4475                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote, CH_UTF16)));
4476                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->remote, ndr_charset_length(r->remote, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4477                 }
4478                 if (r->password) {
4479                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));
4480                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4481                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));
4482                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->password, ndr_charset_length(r->password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4483                 }
4484         }
4485         return NDR_ERR_SUCCESS;
4486 }
4487
4488 static enum ndr_err_code ndr_pull_wkssvc_NetrUseInfo1(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseInfo1 *r)
4489 {
4490         uint32_t _ptr_local;
4491         TALLOC_CTX *_mem_save_local_0;
4492         uint32_t _ptr_remote;
4493         TALLOC_CTX *_mem_save_remote_0;
4494         uint32_t _ptr_password;
4495         TALLOC_CTX *_mem_save_password_0;
4496         if (ndr_flags & NDR_SCALARS) {
4497                 NDR_CHECK(ndr_pull_align(ndr, 5));
4498                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local));
4499                 if (_ptr_local) {
4500                         NDR_PULL_ALLOC(ndr, r->local);
4501                 } else {
4502                         r->local = NULL;
4503                 }
4504                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote));
4505                 if (_ptr_remote) {
4506                         NDR_PULL_ALLOC(ndr, r->remote);
4507                 } else {
4508                         r->remote = NULL;
4509                 }
4510                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
4511                 if (_ptr_password) {
4512                         NDR_PULL_ALLOC(ndr, r->password);
4513                 } else {
4514                         r->password = NULL;
4515                 }
4516                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
4517                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->asg_type));
4518                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_count));
4519                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_count));
4520                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4521         }
4522         if (ndr_flags & NDR_BUFFERS) {
4523                 if (r->local) {
4524                         _mem_save_local_0 = NDR_PULL_GET_MEM_CTX(ndr);
4525                         NDR_PULL_SET_MEM_CTX(ndr, r->local, 0);
4526                         NDR_CHECK(ndr_pull_array_size(ndr, &r->local));
4527                         NDR_CHECK(ndr_pull_array_length(ndr, &r->local));
4528                         if (ndr_get_array_length(ndr, &r->local) > ndr_get_array_size(ndr, &r->local)) {
4529                                 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));
4530                         }
4531                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->local), sizeof(uint16_t)));
4532                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->local, ndr_get_array_length(ndr, &r->local), sizeof(uint16_t), CH_UTF16));
4533                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_0, 0);
4534                 }
4535                 if (r->remote) {
4536                         _mem_save_remote_0 = NDR_PULL_GET_MEM_CTX(ndr);
4537                         NDR_PULL_SET_MEM_CTX(ndr, r->remote, 0);
4538                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote));
4539                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote));
4540                         if (ndr_get_array_length(ndr, &r->remote) > ndr_get_array_size(ndr, &r->remote)) {
4541                                 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));
4542                         }
4543                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t)));
4544                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->remote, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t), CH_UTF16));
4545                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_0, 0);
4546                 }
4547                 if (r->password) {
4548                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
4549                         NDR_PULL_SET_MEM_CTX(ndr, r->password, 0);
4550                         NDR_CHECK(ndr_pull_array_size(ndr, &r->password));
4551                         NDR_CHECK(ndr_pull_array_length(ndr, &r->password));
4552                         if (ndr_get_array_length(ndr, &r->password) > ndr_get_array_size(ndr, &r->password)) {
4553                                 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));
4554                         }
4555                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t)));
4556                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->password, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t), CH_UTF16));
4557                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
4558                 }
4559         }
4560         return NDR_ERR_SUCCESS;
4561 }
4562
4563 _PUBLIC_ void ndr_print_wkssvc_NetrUseInfo1(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseInfo1 *r)
4564 {
4565         ndr_print_struct(ndr, name, "wkssvc_NetrUseInfo1");
4566         ndr->depth++;
4567         ndr_print_ptr(ndr, "local", r->local);
4568         ndr->depth++;
4569         if (r->local) {
4570                 ndr_print_string(ndr, "local", r->local);
4571         }
4572         ndr->depth--;
4573         ndr_print_ptr(ndr, "remote", r->remote);
4574         ndr->depth++;
4575         if (r->remote) {
4576                 ndr_print_string(ndr, "remote", r->remote);
4577         }
4578         ndr->depth--;
4579         ndr_print_ptr(ndr, "password", r->password);
4580         ndr->depth++;
4581         if (r->password) {
4582                 ndr_print_string(ndr, "password", r->password);
4583         }
4584         ndr->depth--;
4585         ndr_print_uint32(ndr, "status", r->status);
4586         ndr_print_uint32(ndr, "asg_type", r->asg_type);
4587         ndr_print_uint32(ndr, "ref_count", r->ref_count);
4588         ndr_print_uint32(ndr, "use_count", r->use_count);
4589         ndr->depth--;
4590 }
4591
4592 static enum ndr_err_code ndr_push_wkssvc_NetrUseInfo0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseInfo0 *r)
4593 {
4594         if (ndr_flags & NDR_SCALARS) {
4595                 NDR_CHECK(ndr_push_align(ndr, 5));
4596                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->local));
4597                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote));
4598                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4599         }
4600         if (ndr_flags & NDR_BUFFERS) {
4601                 if (r->local) {
4602                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->local, CH_UTF16)));
4603                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4604                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->local, CH_UTF16)));
4605                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->local, ndr_charset_length(r->local, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4606                 }
4607                 if (r->remote) {
4608                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote, CH_UTF16)));
4609                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4610                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote, CH_UTF16)));
4611                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->remote, ndr_charset_length(r->remote, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4612                 }
4613         }
4614         return NDR_ERR_SUCCESS;
4615 }
4616
4617 static enum ndr_err_code ndr_pull_wkssvc_NetrUseInfo0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseInfo0 *r)
4618 {
4619         uint32_t _ptr_local;
4620         TALLOC_CTX *_mem_save_local_0;
4621         uint32_t _ptr_remote;
4622         TALLOC_CTX *_mem_save_remote_0;
4623         if (ndr_flags & NDR_SCALARS) {
4624                 NDR_CHECK(ndr_pull_align(ndr, 5));
4625                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local));
4626                 if (_ptr_local) {
4627                         NDR_PULL_ALLOC(ndr, r->local);
4628                 } else {
4629                         r->local = NULL;
4630                 }
4631                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote));
4632                 if (_ptr_remote) {
4633                         NDR_PULL_ALLOC(ndr, r->remote);
4634                 } else {
4635                         r->remote = NULL;
4636                 }
4637                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4638         }
4639         if (ndr_flags & NDR_BUFFERS) {
4640                 if (r->local) {
4641                         _mem_save_local_0 = NDR_PULL_GET_MEM_CTX(ndr);
4642                         NDR_PULL_SET_MEM_CTX(ndr, r->local, 0);
4643                         NDR_CHECK(ndr_pull_array_size(ndr, &r->local));
4644                         NDR_CHECK(ndr_pull_array_length(ndr, &r->local));
4645                         if (ndr_get_array_length(ndr, &r->local) > ndr_get_array_size(ndr, &r->local)) {
4646                                 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));
4647                         }
4648                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->local), sizeof(uint16_t)));
4649                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->local, ndr_get_array_length(ndr, &r->local), sizeof(uint16_t), CH_UTF16));
4650                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_0, 0);
4651                 }
4652                 if (r->remote) {
4653                         _mem_save_remote_0 = NDR_PULL_GET_MEM_CTX(ndr);
4654                         NDR_PULL_SET_MEM_CTX(ndr, r->remote, 0);
4655                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote));
4656                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote));
4657                         if (ndr_get_array_length(ndr, &r->remote) > ndr_get_array_size(ndr, &r->remote)) {
4658                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->remote), ndr_get_array_length(ndr, &r->remote));
4659                         }
4660                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t)));
4661                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->remote, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t), CH_UTF16));
4662                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_0, 0);
4663                 }
4664         }
4665         return NDR_ERR_SUCCESS;
4666 }
4667
4668 _PUBLIC_ void ndr_print_wkssvc_NetrUseInfo0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseInfo0 *r)
4669 {
4670         ndr_print_struct(ndr, name, "wkssvc_NetrUseInfo0");
4671         ndr->depth++;
4672         ndr_print_ptr(ndr, "local", r->local);
4673         ndr->depth++;
4674         if (r->local) {
4675                 ndr_print_string(ndr, "local", r->local);
4676         }
4677         ndr->depth--;
4678         ndr_print_ptr(ndr, "remote", r->remote);
4679         ndr->depth++;
4680         if (r->remote) {
4681                 ndr_print_string(ndr, "remote", r->remote);
4682         }
4683         ndr->depth--;
4684         ndr->depth--;
4685 }
4686
4687 static enum ndr_err_code ndr_push_wkssvc_NetrUseGetInfoCtr(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetrUseGetInfoCtr *r)
4688 {
4689         if (ndr_flags & NDR_SCALARS) {
4690                 int level = ndr_push_get_switch_value(ndr, r);
4691                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
4692                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4693                 switch (level) {
4694                         case 0: {
4695                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
4696                         break; }
4697
4698                         case 1: {
4699                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
4700                         break; }
4701
4702                         case 2: {
4703                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
4704                         break; }
4705
4706                         case 3: {
4707                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
4708                         break; }
4709
4710                         default:
4711                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4712                 }
4713         }
4714         if (ndr_flags & NDR_BUFFERS) {
4715                 int level = ndr_push_get_switch_value(ndr, r);
4716                 switch (level) {
4717                         case 0:
4718                                 if (r->info0) {
4719                                         NDR_CHECK(ndr_push_wkssvc_NetrUseInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
4720                                 }
4721                         break;
4722
4723                         case 1:
4724                                 if (r->info1) {
4725                                         NDR_CHECK(ndr_push_wkssvc_NetrUseInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
4726                                 }
4727                         break;
4728
4729                         case 2:
4730                                 if (r->info2) {
4731                                         NDR_CHECK(ndr_push_wkssvc_NetrUseInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
4732                                 }
4733                         break;
4734
4735                         case 3:
4736                                 if (r->info3) {
4737                                         NDR_CHECK(ndr_push_wkssvc_NetrUseInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
4738                                 }
4739                         break;
4740
4741                         default:
4742                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4743                 }
4744         }
4745         return NDR_ERR_SUCCESS;
4746 }
4747
4748 static enum ndr_err_code ndr_pull_wkssvc_NetrUseGetInfoCtr(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetrUseGetInfoCtr *r)
4749 {
4750         int level;
4751         uint32_t _level;
4752         TALLOC_CTX *_mem_save_info0_0;
4753         TALLOC_CTX *_mem_save_info1_0;
4754         TALLOC_CTX *_mem_save_info2_0;
4755         TALLOC_CTX *_mem_save_info3_0;
4756         level = ndr_pull_get_switch_value(ndr, r);
4757         if (ndr_flags & NDR_SCALARS) {
4758                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
4759                 if (_level != level) {
4760                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4761                 }
4762                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4763                 switch (level) {
4764                         case 0: {
4765                                 uint32_t _ptr_info0;
4766                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
4767                                 if (_ptr_info0) {
4768                                         NDR_PULL_ALLOC(ndr, r->info0);
4769                                 } else {
4770                                         r->info0 = NULL;
4771                                 }
4772                         break; }
4773
4774                         case 1: {
4775                                 uint32_t _ptr_info1;
4776                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
4777                                 if (_ptr_info1) {
4778                                         NDR_PULL_ALLOC(ndr, r->info1);
4779                                 } else {
4780                                         r->info1 = NULL;
4781                                 }
4782                         break; }
4783
4784                         case 2: {
4785                                 uint32_t _ptr_info2;
4786                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
4787                                 if (_ptr_info2) {
4788                                         NDR_PULL_ALLOC(ndr, r->info2);
4789                                 } else {
4790                                         r->info2 = NULL;
4791                                 }
4792                         break; }
4793
4794                         case 3: {
4795                                 uint32_t _ptr_info3;
4796                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
4797                                 if (_ptr_info3) {
4798                                         NDR_PULL_ALLOC(ndr, r->info3);
4799                                 } else {
4800                                         r->info3 = NULL;
4801                                 }
4802                         break; }
4803
4804                         default:
4805                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4806                 }
4807         }
4808         if (ndr_flags & NDR_BUFFERS) {
4809                 switch (level) {
4810                         case 0:
4811                                 if (r->info0) {
4812                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
4813                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
4814                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
4815                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
4816                                 }
4817                         break;
4818
4819                         case 1:
4820                                 if (r->info1) {
4821                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
4822                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
4823                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
4824                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
4825                                 }
4826                         break;
4827
4828                         case 2:
4829                                 if (r->info2) {
4830                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
4831                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
4832                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
4833                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
4834                                 }
4835                         break;
4836
4837                         case 3:
4838                                 if (r->info3) {
4839                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
4840                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
4841                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
4842                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
4843                                 }
4844                         break;
4845
4846                         default:
4847                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4848                 }
4849         }
4850         return NDR_ERR_SUCCESS;
4851 }
4852
4853 _PUBLIC_ void ndr_print_wkssvc_NetrUseGetInfoCtr(struct ndr_print *ndr, const char *name, const union wkssvc_NetrUseGetInfoCtr *r)
4854 {
4855         int level;
4856         level = ndr_print_get_switch_value(ndr, r);
4857         ndr_print_union(ndr, name, level, "wkssvc_NetrUseGetInfoCtr");
4858         switch (level) {
4859                 case 0:
4860                         ndr_print_ptr(ndr, "info0", r->info0);
4861                         ndr->depth++;
4862                         if (r->info0) {
4863                                 ndr_print_wkssvc_NetrUseInfo0(ndr, "info0", r->info0);
4864                         }
4865                         ndr->depth--;
4866                 break;
4867
4868                 case 1:
4869                         ndr_print_ptr(ndr, "info1", r->info1);
4870                         ndr->depth++;
4871                         if (r->info1) {
4872                                 ndr_print_wkssvc_NetrUseInfo1(ndr, "info1", r->info1);
4873                         }
4874                         ndr->depth--;
4875                 break;
4876
4877                 case 2:
4878                         ndr_print_ptr(ndr, "info2", r->info2);
4879                         ndr->depth++;
4880                         if (r->info2) {
4881                                 ndr_print_wkssvc_NetrUseInfo2(ndr, "info2", r->info2);
4882                         }
4883                         ndr->depth--;
4884                 break;
4885
4886                 case 3:
4887                         ndr_print_ptr(ndr, "info3", r->info3);
4888                         ndr->depth++;
4889                         if (r->info3) {
4890                                 ndr_print_wkssvc_NetrUseInfo3(ndr, "info3", r->info3);
4891                         }
4892                         ndr->depth--;
4893                 break;
4894
4895                 default:
4896                         ndr_print_bad_level(ndr, name, level);
4897         }
4898 }
4899
4900 static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumCtr2(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseEnumCtr2 *r)
4901 {
4902         uint32_t cntr_array_1;
4903         if (ndr_flags & NDR_SCALARS) {
4904                 NDR_CHECK(ndr_push_align(ndr, 5));
4905                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4906                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
4907                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4908         }
4909         if (ndr_flags & NDR_BUFFERS) {
4910                 if (r->array) {
4911                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
4912                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4913                                 NDR_CHECK(ndr_push_wkssvc_NetrUseInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4914                         }
4915                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4916                                 NDR_CHECK(ndr_push_wkssvc_NetrUseInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4917                         }
4918                 }
4919         }
4920         return NDR_ERR_SUCCESS;
4921 }
4922
4923 static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumCtr2(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseEnumCtr2 *r)
4924 {
4925         uint32_t _ptr_array;
4926         uint32_t cntr_array_1;
4927         TALLOC_CTX *_mem_save_array_0;
4928         TALLOC_CTX *_mem_save_array_1;
4929         if (ndr_flags & NDR_SCALARS) {
4930                 NDR_CHECK(ndr_pull_align(ndr, 5));
4931                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4932                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
4933                 if (_ptr_array) {
4934                         NDR_PULL_ALLOC(ndr, r->array);
4935                 } else {
4936                         r->array = NULL;
4937                 }
4938                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4939         }
4940         if (ndr_flags & NDR_BUFFERS) {
4941                 if (r->array) {
4942                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4943                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4944                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
4945                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
4946                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4947                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4948                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4949                                 NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4950                         }
4951                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4952                                 NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4953                         }
4954                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
4955                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
4956                 }
4957                 if (r->array) {
4958                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
4959                 }
4960         }
4961         return NDR_ERR_SUCCESS;
4962 }
4963
4964 _PUBLIC_ void ndr_print_wkssvc_NetrUseEnumCtr2(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseEnumCtr2 *r)
4965 {
4966         uint32_t cntr_array_1;
4967         ndr_print_struct(ndr, name, "wkssvc_NetrUseEnumCtr2");
4968         ndr->depth++;
4969         ndr_print_uint32(ndr, "count", r->count);
4970         ndr_print_ptr(ndr, "array", r->array);
4971         ndr->depth++;
4972         if (r->array) {
4973                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
4974                 ndr->depth++;
4975                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
4976                         char *idx_1=NULL;
4977                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
4978                                 ndr_print_wkssvc_NetrUseInfo2(ndr, "array", &r->array[cntr_array_1]);
4979                                 free(idx_1);
4980                         }
4981                 }
4982                 ndr->depth--;
4983         }
4984         ndr->depth--;
4985         ndr->depth--;
4986 }
4987
4988 static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumCtr1(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseEnumCtr1 *r)
4989 {
4990         uint32_t cntr_array_1;
4991         if (ndr_flags & NDR_SCALARS) {
4992                 NDR_CHECK(ndr_push_align(ndr, 5));
4993                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4994                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
4995                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4996         }
4997         if (ndr_flags & NDR_BUFFERS) {
4998                 if (r->array) {
4999                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5000                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5001                                 NDR_CHECK(ndr_push_wkssvc_NetrUseInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5002                         }
5003                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5004                                 NDR_CHECK(ndr_push_wkssvc_NetrUseInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5005                         }
5006                 }
5007         }
5008         return NDR_ERR_SUCCESS;
5009 }
5010
5011 static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumCtr1(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseEnumCtr1 *r)
5012 {
5013         uint32_t _ptr_array;
5014         uint32_t cntr_array_1;
5015         TALLOC_CTX *_mem_save_array_0;
5016         TALLOC_CTX *_mem_save_array_1;
5017         if (ndr_flags & NDR_SCALARS) {
5018                 NDR_CHECK(ndr_pull_align(ndr, 5));
5019                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5020                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
5021                 if (_ptr_array) {
5022                         NDR_PULL_ALLOC(ndr, r->array);
5023                 } else {
5024                         r->array = NULL;
5025                 }
5026                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5027         }
5028         if (ndr_flags & NDR_BUFFERS) {
5029                 if (r->array) {
5030                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5031                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5032                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
5033                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
5034                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5035                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5036                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5037                                 NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5038                         }
5039                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5040                                 NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5041                         }
5042                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
5043                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
5044                 }
5045                 if (r->array) {
5046                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
5047                 }
5048         }
5049         return NDR_ERR_SUCCESS;
5050 }
5051
5052 _PUBLIC_ void ndr_print_wkssvc_NetrUseEnumCtr1(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseEnumCtr1 *r)
5053 {
5054         uint32_t cntr_array_1;
5055         ndr_print_struct(ndr, name, "wkssvc_NetrUseEnumCtr1");
5056         ndr->depth++;
5057         ndr_print_uint32(ndr, "count", r->count);
5058         ndr_print_ptr(ndr, "array", r->array);
5059         ndr->depth++;
5060         if (r->array) {
5061                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
5062                 ndr->depth++;
5063                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
5064                         char *idx_1=NULL;
5065                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
5066                                 ndr_print_wkssvc_NetrUseInfo1(ndr, "array", &r->array[cntr_array_1]);
5067                                 free(idx_1);
5068                         }
5069                 }
5070                 ndr->depth--;
5071         }
5072         ndr->depth--;
5073         ndr->depth--;
5074 }
5075
5076 static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumCtr0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseEnumCtr0 *r)
5077 {
5078         uint32_t cntr_array_1;
5079         if (ndr_flags & NDR_SCALARS) {
5080                 NDR_CHECK(ndr_push_align(ndr, 5));
5081                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5082                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
5083                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5084         }
5085         if (ndr_flags & NDR_BUFFERS) {
5086                 if (r->array) {
5087                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5088                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5089                                 NDR_CHECK(ndr_push_wkssvc_NetrUseInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5090                         }
5091                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5092                                 NDR_CHECK(ndr_push_wkssvc_NetrUseInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5093                         }
5094                 }
5095         }
5096         return NDR_ERR_SUCCESS;
5097 }
5098
5099 static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumCtr0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseEnumCtr0 *r)
5100 {
5101         uint32_t _ptr_array;
5102         uint32_t cntr_array_1;
5103         TALLOC_CTX *_mem_save_array_0;
5104         TALLOC_CTX *_mem_save_array_1;
5105         if (ndr_flags & NDR_SCALARS) {
5106                 NDR_CHECK(ndr_pull_align(ndr, 5));
5107                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5108                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
5109                 if (_ptr_array) {
5110                         NDR_PULL_ALLOC(ndr, r->array);
5111                 } else {
5112                         r->array = NULL;
5113                 }
5114                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5115         }
5116         if (ndr_flags & NDR_BUFFERS) {
5117                 if (r->array) {
5118                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5119                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5120                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
5121                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
5122                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5123                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5124                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5125                                 NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5126                         }
5127                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5128                                 NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5129                         }
5130                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
5131                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
5132                 }
5133                 if (r->array) {
5134                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
5135                 }
5136         }
5137         return NDR_ERR_SUCCESS;
5138 }
5139
5140 _PUBLIC_ void ndr_print_wkssvc_NetrUseEnumCtr0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseEnumCtr0 *r)
5141 {
5142         uint32_t cntr_array_1;
5143         ndr_print_struct(ndr, name, "wkssvc_NetrUseEnumCtr0");
5144         ndr->depth++;
5145         ndr_print_uint32(ndr, "count", r->count);
5146         ndr_print_ptr(ndr, "array", r->array);
5147         ndr->depth++;
5148         if (r->array) {
5149                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
5150                 ndr->depth++;
5151                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
5152                         char *idx_1=NULL;
5153                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
5154                                 ndr_print_wkssvc_NetrUseInfo0(ndr, "array", &r->array[cntr_array_1]);
5155                                 free(idx_1);
5156                         }
5157                 }
5158                 ndr->depth--;
5159         }
5160         ndr->depth--;
5161         ndr->depth--;
5162 }
5163
5164 static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumCtr(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetrUseEnumCtr *r)
5165 {
5166         if (ndr_flags & NDR_SCALARS) {
5167                 int level = ndr_push_get_switch_value(ndr, r);
5168                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5169                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5170                 switch (level) {
5171                         case 0: {
5172                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
5173                         break; }
5174
5175                         case 1: {
5176                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
5177                         break; }
5178
5179                         case 2: {
5180                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr2));
5181                         break; }
5182
5183                         default:
5184                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5185                 }
5186         }
5187         if (ndr_flags & NDR_BUFFERS) {
5188                 int level = ndr_push_get_switch_value(ndr, r);
5189                 switch (level) {
5190                         case 0:
5191                                 if (r->ctr0) {
5192                                         NDR_CHECK(ndr_push_wkssvc_NetrUseEnumCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
5193                                 }
5194                         break;
5195
5196                         case 1:
5197                                 if (r->ctr1) {
5198                                         NDR_CHECK(ndr_push_wkssvc_NetrUseEnumCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
5199                                 }
5200                         break;
5201
5202                         case 2:
5203                                 if (r->ctr2) {
5204                                         NDR_CHECK(ndr_push_wkssvc_NetrUseEnumCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
5205                                 }
5206                         break;
5207
5208                         default:
5209                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5210                 }
5211         }
5212         return NDR_ERR_SUCCESS;
5213 }
5214
5215 static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumCtr(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetrUseEnumCtr *r)
5216 {
5217         int level;
5218         uint32_t _level;
5219         TALLOC_CTX *_mem_save_ctr0_0;
5220         TALLOC_CTX *_mem_save_ctr1_0;
5221         TALLOC_CTX *_mem_save_ctr2_0;
5222         level = ndr_pull_get_switch_value(ndr, r);
5223         if (ndr_flags & NDR_SCALARS) {
5224                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5225                 if (_level != level) {
5226                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5227                 }
5228                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5229                 switch (level) {
5230                         case 0: {
5231                                 uint32_t _ptr_ctr0;
5232                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));
5233                                 if (_ptr_ctr0) {
5234                                         NDR_PULL_ALLOC(ndr, r->ctr0);
5235                                 } else {
5236                                         r->ctr0 = NULL;
5237                                 }
5238                         break; }
5239
5240                         case 1: {
5241                                 uint32_t _ptr_ctr1;
5242                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
5243                                 if (_ptr_ctr1) {
5244                                         NDR_PULL_ALLOC(ndr, r->ctr1);
5245                                 } else {
5246                                         r->ctr1 = NULL;
5247                                 }
5248                         break; }
5249
5250                         case 2: {
5251                                 uint32_t _ptr_ctr2;
5252                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr2));
5253                                 if (_ptr_ctr2) {
5254                                         NDR_PULL_ALLOC(ndr, r->ctr2);
5255                                 } else {
5256                                         r->ctr2 = NULL;
5257                                 }
5258                         break; }
5259
5260                         default:
5261                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5262                 }
5263         }
5264         if (ndr_flags & NDR_BUFFERS) {
5265                 switch (level) {
5266                         case 0:
5267                                 if (r->ctr0) {
5268                                         _mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);
5269                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr0, 0);
5270                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
5271                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);
5272                                 }
5273                         break;
5274
5275                         case 1:
5276                                 if (r->ctr1) {
5277                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5278                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
5279                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
5280                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
5281                                 }
5282                         break;
5283
5284                         case 2:
5285                                 if (r->ctr2) {
5286                                         _mem_save_ctr2_0 = NDR_PULL_GET_MEM_CTX(ndr);
5287                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr2, 0);
5288                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
5289                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr2_0, 0);
5290                                 }
5291                         break;
5292
5293                         default:
5294                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5295                 }
5296         }
5297         return NDR_ERR_SUCCESS;
5298 }
5299
5300 _PUBLIC_ void ndr_print_wkssvc_NetrUseEnumCtr(struct ndr_print *ndr, const char *name, const union wkssvc_NetrUseEnumCtr *r)
5301 {
5302         int level;
5303         level = ndr_print_get_switch_value(ndr, r);
5304         ndr_print_union(ndr, name, level, "wkssvc_NetrUseEnumCtr");
5305         switch (level) {
5306                 case 0:
5307                         ndr_print_ptr(ndr, "ctr0", r->ctr0);
5308                         ndr->depth++;
5309                         if (r->ctr0) {
5310                                 ndr_print_wkssvc_NetrUseEnumCtr0(ndr, "ctr0", r->ctr0);
5311                         }
5312                         ndr->depth--;
5313                 break;
5314
5315                 case 1:
5316                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
5317                         ndr->depth++;
5318                         if (r->ctr1) {
5319                                 ndr_print_wkssvc_NetrUseEnumCtr1(ndr, "ctr1", r->ctr1);
5320                         }
5321                         ndr->depth--;
5322                 break;
5323
5324                 case 2:
5325                         ndr_print_ptr(ndr, "ctr2", r->ctr2);
5326                         ndr->depth++;
5327                         if (r->ctr2) {
5328                                 ndr_print_wkssvc_NetrUseEnumCtr2(ndr, "ctr2", r->ctr2);
5329                         }
5330                         ndr->depth--;
5331                 break;
5332
5333                 default:
5334                         ndr_print_bad_level(ndr, name, level);
5335         }
5336 }
5337
5338 static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumInfo(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseEnumInfo *r)
5339 {
5340         if (ndr_flags & NDR_SCALARS) {
5341                 NDR_CHECK(ndr_push_align(ndr, 5));
5342                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
5343                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
5344                 NDR_CHECK(ndr_push_wkssvc_NetrUseEnumCtr(ndr, NDR_SCALARS, &r->ctr));
5345                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5346         }
5347         if (ndr_flags & NDR_BUFFERS) {
5348                 NDR_CHECK(ndr_push_wkssvc_NetrUseEnumCtr(ndr, NDR_BUFFERS, &r->ctr));
5349         }
5350         return NDR_ERR_SUCCESS;
5351 }
5352
5353 static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumInfo(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseEnumInfo *r)
5354 {
5355         if (ndr_flags & NDR_SCALARS) {
5356                 NDR_CHECK(ndr_pull_align(ndr, 5));
5357                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
5358                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
5359                 NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumCtr(ndr, NDR_SCALARS, &r->ctr));
5360                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5361         }
5362         if (ndr_flags & NDR_BUFFERS) {
5363                 NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumCtr(ndr, NDR_BUFFERS, &r->ctr));
5364         }
5365         return NDR_ERR_SUCCESS;
5366 }
5367
5368 _PUBLIC_ void ndr_print_wkssvc_NetrUseEnumInfo(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseEnumInfo *r)
5369 {
5370         ndr_print_struct(ndr, name, "wkssvc_NetrUseEnumInfo");
5371         ndr->depth++;
5372         ndr_print_uint32(ndr, "level", r->level);
5373         ndr_print_set_switch_value(ndr, &r->ctr, r->level);
5374         ndr_print_wkssvc_NetrUseEnumCtr(ndr, "ctr", &r->ctr);
5375         ndr->depth--;
5376 }
5377
5378 static enum ndr_err_code ndr_push_wkssvc_NetrWorkstationStatistics(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrWorkstationStatistics *r)
5379 {
5380         if (ndr_flags & NDR_SCALARS) {
5381                 NDR_CHECK(ndr_push_align(ndr, 8));
5382                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown1));
5383                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown2));
5384                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown3));
5385                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown4));
5386                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown5));
5387                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown6));
5388                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown7));
5389                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown8));
5390                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown9));
5391                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown10));
5392                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown11));
5393                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown12));
5394                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown13));
5395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown14));
5396                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown15));
5397                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown16));
5398                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown17));
5399                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown18));
5400                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown19));
5401                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown20));
5402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown21));
5403                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown22));
5404                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown23));
5405                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown24));
5406                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown25));
5407                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown26));
5408                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown27));
5409                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown28));
5410                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown29));
5411                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown30));
5412                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown31));
5413                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown32));
5414                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown33));
5415                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown34));
5416                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown35));
5417                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown36));
5418                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown37));
5419                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown38));
5420                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown39));
5421                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown40));
5422                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
5423         }
5424         if (ndr_flags & NDR_BUFFERS) {
5425         }
5426         return NDR_ERR_SUCCESS;
5427 }
5428
5429 static enum ndr_err_code ndr_pull_wkssvc_NetrWorkstationStatistics(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrWorkstationStatistics *r)
5430 {
5431         if (ndr_flags & NDR_SCALARS) {
5432                 NDR_CHECK(ndr_pull_align(ndr, 8));
5433                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown1));
5434                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown2));
5435                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown3));
5436                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown4));
5437                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown5));
5438                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown6));
5439                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown7));
5440                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown8));
5441                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown9));
5442                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown10));
5443                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown11));
5444                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown12));
5445                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown13));
5446                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown14));
5447                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown15));
5448                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown16));
5449                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown17));
5450                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown18));
5451                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown19));
5452                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown20));
5453                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown21));
5454                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown22));
5455                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown23));
5456                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown24));
5457                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown25));
5458                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown26));
5459                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown27));
5460                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown28));
5461                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown29));
5462                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown30));
5463                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown31));
5464                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown32));
5465                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown33));
5466                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown34));
5467                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown35));
5468                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown36));
5469                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown37));
5470                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown38));
5471                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown39));
5472                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown40));
5473                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
5474         }
5475         if (ndr_flags & NDR_BUFFERS) {
5476         }
5477         return NDR_ERR_SUCCESS;
5478 }
5479
5480 _PUBLIC_ void ndr_print_wkssvc_NetrWorkstationStatistics(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrWorkstationStatistics *r)
5481 {
5482         ndr_print_struct(ndr, name, "wkssvc_NetrWorkstationStatistics");
5483         ndr->depth++;
5484         ndr_print_hyper(ndr, "unknown1", r->unknown1);
5485         ndr_print_hyper(ndr, "unknown2", r->unknown2);
5486         ndr_print_hyper(ndr, "unknown3", r->unknown3);
5487         ndr_print_hyper(ndr, "unknown4", r->unknown4);
5488         ndr_print_hyper(ndr, "unknown5", r->unknown5);
5489         ndr_print_hyper(ndr, "unknown6", r->unknown6);
5490         ndr_print_hyper(ndr, "unknown7", r->unknown7);
5491         ndr_print_hyper(ndr, "unknown8", r->unknown8);
5492         ndr_print_hyper(ndr, "unknown9", r->unknown9);
5493         ndr_print_hyper(ndr, "unknown10", r->unknown10);
5494         ndr_print_hyper(ndr, "unknown11", r->unknown11);
5495         ndr_print_hyper(ndr, "unknown12", r->unknown12);
5496         ndr_print_hyper(ndr, "unknown13", r->unknown13);
5497         ndr_print_uint32(ndr, "unknown14", r->unknown14);
5498         ndr_print_uint32(ndr, "unknown15", r->unknown15);
5499         ndr_print_uint32(ndr, "unknown16", r->unknown16);
5500         ndr_print_uint32(ndr, "unknown17", r->unknown17);
5501         ndr_print_uint32(ndr, "unknown18", r->unknown18);
5502         ndr_print_uint32(ndr, "unknown19", r->unknown19);
5503         ndr_print_uint32(ndr, "unknown20", r->unknown20);
5504         ndr_print_uint32(ndr, "unknown21", r->unknown21);
5505         ndr_print_uint32(ndr, "unknown22", r->unknown22);
5506         ndr_print_uint32(ndr, "unknown23", r->unknown23);
5507         ndr_print_uint32(ndr, "unknown24", r->unknown24);
5508         ndr_print_uint32(ndr, "unknown25", r->unknown25);
5509         ndr_print_uint32(ndr, "unknown26", r->unknown26);
5510         ndr_print_uint32(ndr, "unknown27", r->unknown27);
5511         ndr_print_uint32(ndr, "unknown28", r->unknown28);
5512         ndr_print_uint32(ndr, "unknown29", r->unknown29);
5513         ndr_print_uint32(ndr, "unknown30", r->unknown30);
5514         ndr_print_uint32(ndr, "unknown31", r->unknown31);
5515         ndr_print_uint32(ndr, "unknown32", r->unknown32);
5516         ndr_print_uint32(ndr, "unknown33", r->unknown33);
5517         ndr_print_uint32(ndr, "unknown34", r->unknown34);
5518         ndr_print_uint32(ndr, "unknown35", r->unknown35);
5519         ndr_print_uint32(ndr, "unknown36", r->unknown36);
5520         ndr_print_uint32(ndr, "unknown37", r->unknown37);
5521         ndr_print_uint32(ndr, "unknown38", r->unknown38);
5522         ndr_print_uint32(ndr, "unknown39", r->unknown39);
5523         ndr_print_uint32(ndr, "unknown40", r->unknown40);
5524         ndr->depth--;
5525 }
5526
5527 static enum ndr_err_code ndr_push_wkssvc_renameflags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
5528 {
5529         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5530         return NDR_ERR_SUCCESS;
5531 }
5532
5533 static enum ndr_err_code ndr_pull_wkssvc_renameflags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
5534 {
5535         uint32_t v;
5536         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5537         *r = v;
5538         return NDR_ERR_SUCCESS;
5539 }
5540
5541 _PUBLIC_ void ndr_print_wkssvc_renameflags(struct ndr_print *ndr, const char *name, uint32_t r)
5542 {
5543         ndr_print_uint32(ndr, name, r);
5544         ndr->depth++;
5545         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE", WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE, r);
5546         ndr->depth--;
5547 }
5548
5549 static enum ndr_err_code ndr_push_wkssvc_NetValidateNameType(struct ndr_push *ndr, int ndr_flags, enum wkssvc_NetValidateNameType r)
5550 {
5551         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
5552         return NDR_ERR_SUCCESS;
5553 }
5554
5555 static enum ndr_err_code ndr_pull_wkssvc_NetValidateNameType(struct ndr_pull *ndr, int ndr_flags, enum wkssvc_NetValidateNameType *r)
5556 {
5557         uint16_t v;
5558         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
5559         *r = v;
5560         return NDR_ERR_SUCCESS;
5561 }
5562
5563 _PUBLIC_ void ndr_print_wkssvc_NetValidateNameType(struct ndr_print *ndr, const char *name, enum wkssvc_NetValidateNameType r)
5564 {
5565         const char *val = NULL;
5566
5567         switch (r) {
5568                 case NetSetupUnknown: val = "NetSetupUnknown"; break;
5569                 case NetSetupMachine: val = "NetSetupMachine"; break;
5570                 case NetSetupWorkgroup: val = "NetSetupWorkgroup"; break;
5571                 case NetSetupDomain: val = "NetSetupDomain"; break;
5572                 case NetSetupNonExistentDomain: val = "NetSetupNonExistentDomain"; break;
5573                 case NetSetupDnsMachine: val = "NetSetupDnsMachine"; break;
5574         }
5575         ndr_print_enum(ndr, name, "ENUM", val, r);
5576 }
5577
5578 static enum ndr_err_code ndr_push_wkssvc_NetJoinStatus(struct ndr_push *ndr, int ndr_flags, enum wkssvc_NetJoinStatus r)
5579 {
5580         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
5581         return NDR_ERR_SUCCESS;
5582 }
5583
5584 static enum ndr_err_code ndr_pull_wkssvc_NetJoinStatus(struct ndr_pull *ndr, int ndr_flags, enum wkssvc_NetJoinStatus *r)
5585 {
5586         uint16_t v;
5587         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
5588         *r = v;
5589         return NDR_ERR_SUCCESS;
5590 }
5591
5592 _PUBLIC_ void ndr_print_wkssvc_NetJoinStatus(struct ndr_print *ndr, const char *name, enum wkssvc_NetJoinStatus r)
5593 {
5594         const char *val = NULL;
5595
5596         switch (r) {
5597                 case NET_SETUP_UNKNOWN_STATUS: val = "NET_SETUP_UNKNOWN_STATUS"; break;
5598                 case NET_SETUP_UNJOINED: val = "NET_SETUP_UNJOINED"; break;
5599                 case NET_SETUP_WORKGROUP_NAME: val = "NET_SETUP_WORKGROUP_NAME"; break;
5600                 case NET_SETUP_DOMAIN_NAME: val = "NET_SETUP_DOMAIN_NAME"; break;
5601         }
5602         ndr_print_enum(ndr, name, "ENUM", val, r);
5603 }
5604
5605 static enum ndr_err_code ndr_push_wkssvc_PasswordBuffer(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_PasswordBuffer *r)
5606 {
5607         {
5608                 uint32_t _flags_save_STRUCT = ndr->flags;
5609                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
5610                 if (ndr_flags & NDR_SCALARS) {
5611                         NDR_CHECK(ndr_push_align(ndr, 1));
5612                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, 524));
5613                         NDR_CHECK(ndr_push_trailer_align(ndr, 1));
5614                 }
5615                 if (ndr_flags & NDR_BUFFERS) {
5616                 }
5617                 ndr->flags = _flags_save_STRUCT;
5618         }
5619         return NDR_ERR_SUCCESS;
5620 }
5621
5622 static enum ndr_err_code ndr_pull_wkssvc_PasswordBuffer(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_PasswordBuffer *r)
5623 {
5624         {
5625                 uint32_t _flags_save_STRUCT = ndr->flags;
5626                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
5627                 if (ndr_flags & NDR_SCALARS) {
5628                         NDR_CHECK(ndr_pull_align(ndr, 1));
5629                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, 524));
5630                         NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
5631                 }
5632                 if (ndr_flags & NDR_BUFFERS) {
5633                 }
5634                 ndr->flags = _flags_save_STRUCT;
5635         }
5636         return NDR_ERR_SUCCESS;
5637 }
5638
5639 _PUBLIC_ void ndr_print_wkssvc_PasswordBuffer(struct ndr_print *ndr, const char *name, const struct wkssvc_PasswordBuffer *r)
5640 {
5641         ndr_print_struct(ndr, name, "wkssvc_PasswordBuffer");
5642         {
5643                 uint32_t _flags_save_STRUCT = ndr->flags;
5644                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
5645                 ndr->depth++;
5646                 ndr_print_array_uint8(ndr, "data", r->data, 524);
5647                 ndr->depth--;
5648                 ndr->flags = _flags_save_STRUCT;
5649         }
5650 }
5651
5652 static enum ndr_err_code ndr_push_wkssvc_joinflags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
5653 {
5654         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5655         return NDR_ERR_SUCCESS;
5656 }
5657
5658 static enum ndr_err_code ndr_pull_wkssvc_joinflags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
5659 {
5660         uint32_t v;
5661         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5662         *r = v;
5663         return NDR_ERR_SUCCESS;
5664 }
5665
5666 _PUBLIC_ void ndr_print_wkssvc_joinflags(struct ndr_print *ndr, const char *name, uint32_t r)
5667 {
5668         ndr_print_uint32(ndr, name, r);
5669         ndr->depth++;
5670         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_IGNORE_UNSUPPORTED_FLAGS", WKSSVC_JOIN_FLAGS_IGNORE_UNSUPPORTED_FLAGS, r);
5671         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_JOIN_WITH_NEW_NAME", WKSSVC_JOIN_FLAGS_JOIN_WITH_NEW_NAME, r);
5672         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_JOIN_DC_ACCOUNT", WKSSVC_JOIN_FLAGS_JOIN_DC_ACCOUNT, r);
5673         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_DEFER_SPN", WKSSVC_JOIN_FLAGS_DEFER_SPN, r);
5674         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_MACHINE_PWD_PASSED", WKSSVC_JOIN_FLAGS_MACHINE_PWD_PASSED, r);
5675         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_JOIN_UNSECURE", WKSSVC_JOIN_FLAGS_JOIN_UNSECURE, r);
5676         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_DOMAIN_JOIN_IF_JOINED", WKSSVC_JOIN_FLAGS_DOMAIN_JOIN_IF_JOINED, r);
5677         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_WIN9X_UPGRADE", WKSSVC_JOIN_FLAGS_WIN9X_UPGRADE, r);
5678         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_ACCOUNT_DELETE", WKSSVC_JOIN_FLAGS_ACCOUNT_DELETE, r);
5679         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE", WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE, r);
5680         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_JOIN_TYPE", WKSSVC_JOIN_FLAGS_JOIN_TYPE, r);
5681         ndr->depth--;
5682 }
5683
5684 static enum ndr_err_code ndr_push_wkssvc_ComputerNameType(struct ndr_push *ndr, int ndr_flags, enum wkssvc_ComputerNameType r)
5685 {
5686         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
5687         return NDR_ERR_SUCCESS;
5688 }
5689
5690 static enum ndr_err_code ndr_pull_wkssvc_ComputerNameType(struct ndr_pull *ndr, int ndr_flags, enum wkssvc_ComputerNameType *r)
5691 {
5692         uint16_t v;
5693         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
5694         *r = v;
5695         return NDR_ERR_SUCCESS;
5696 }
5697
5698 _PUBLIC_ void ndr_print_wkssvc_ComputerNameType(struct ndr_print *ndr, const char *name, enum wkssvc_ComputerNameType r)
5699 {
5700         const char *val = NULL;
5701
5702         switch (r) {
5703                 case NetPrimaryComputerName: val = "NetPrimaryComputerName"; break;
5704                 case NetAlternateComputerNames: val = "NetAlternateComputerNames"; break;
5705                 case NetAllComputerNames: val = "NetAllComputerNames"; break;
5706                 case NetComputerNameTypeMax: val = "NetComputerNameTypeMax"; break;
5707         }
5708         ndr_print_enum(ndr, name, "ENUM", val, r);
5709 }
5710
5711 static enum ndr_err_code ndr_push_wkssvc_ComputerNamesCtr(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_ComputerNamesCtr *r)
5712 {
5713         uint32_t cntr_computer_name_1;
5714         if (ndr_flags & NDR_SCALARS) {
5715                 NDR_CHECK(ndr_push_align(ndr, 5));
5716                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5717                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_name));
5718                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5719         }
5720         if (ndr_flags & NDR_BUFFERS) {
5721                 if (r->computer_name) {
5722                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5723                         for (cntr_computer_name_1 = 0; cntr_computer_name_1 < r->count; cntr_computer_name_1++) {
5724                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->computer_name[cntr_computer_name_1]));
5725                         }
5726                         for (cntr_computer_name_1 = 0; cntr_computer_name_1 < r->count; cntr_computer_name_1++) {
5727                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->computer_name[cntr_computer_name_1]));
5728                         }
5729                 }
5730         }
5731         return NDR_ERR_SUCCESS;
5732 }
5733
5734 static enum ndr_err_code ndr_pull_wkssvc_ComputerNamesCtr(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_ComputerNamesCtr *r)
5735 {
5736         uint32_t _ptr_computer_name;
5737         uint32_t cntr_computer_name_1;
5738         TALLOC_CTX *_mem_save_computer_name_0;
5739         TALLOC_CTX *_mem_save_computer_name_1;
5740         if (ndr_flags & NDR_SCALARS) {
5741                 NDR_CHECK(ndr_pull_align(ndr, 5));
5742                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5743                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_name));
5744                 if (_ptr_computer_name) {
5745                         NDR_PULL_ALLOC(ndr, r->computer_name);
5746                 } else {
5747                         r->computer_name = NULL;
5748                 }
5749                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5750         }
5751         if (ndr_flags & NDR_BUFFERS) {
5752                 if (r->computer_name) {
5753                         _mem_save_computer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5754                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_name, 0);
5755                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_name));
5756                         NDR_PULL_ALLOC_N(ndr, r->computer_name, ndr_get_array_size(ndr, &r->computer_name));
5757                         _mem_save_computer_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
5758                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_name, 0);
5759                         for (cntr_computer_name_1 = 0; cntr_computer_name_1 < r->count; cntr_computer_name_1++) {
5760                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->computer_name[cntr_computer_name_1]));
5761                         }
5762                         for (cntr_computer_name_1 = 0; cntr_computer_name_1 < r->count; cntr_computer_name_1++) {
5763                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->computer_name[cntr_computer_name_1]));
5764                         }
5765                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_name_1, 0);
5766                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_name_0, 0);
5767                 }
5768                 if (r->computer_name) {
5769                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->computer_name, r->count));
5770                 }
5771         }
5772         return NDR_ERR_SUCCESS;
5773 }
5774
5775 _PUBLIC_ void ndr_print_wkssvc_ComputerNamesCtr(struct ndr_print *ndr, const char *name, const struct wkssvc_ComputerNamesCtr *r)
5776 {
5777         uint32_t cntr_computer_name_1;
5778         ndr_print_struct(ndr, name, "wkssvc_ComputerNamesCtr");
5779         ndr->depth++;
5780         ndr_print_uint32(ndr, "count", r->count);
5781         ndr_print_ptr(ndr, "computer_name", r->computer_name);
5782         ndr->depth++;
5783         if (r->computer_name) {
5784                 ndr->print(ndr, "%s: ARRAY(%d)", "computer_name", (int)r->count);
5785                 ndr->depth++;
5786                 for (cntr_computer_name_1=0;cntr_computer_name_1<r->count;cntr_computer_name_1++) {
5787                         char *idx_1=NULL;
5788                         if (asprintf(&idx_1, "[%d]", cntr_computer_name_1) != -1) {
5789                                 ndr_print_lsa_String(ndr, "computer_name", &r->computer_name[cntr_computer_name_1]);
5790                                 free(idx_1);
5791                         }
5792                 }
5793                 ndr->depth--;
5794         }
5795         ndr->depth--;
5796         ndr->depth--;
5797 }
5798
5799 static enum ndr_err_code ndr_push_wkssvc_NetWkstaGetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaGetInfo *r)
5800 {
5801         if (flags & NDR_IN) {
5802                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
5803                 if (r->in.server_name) {
5804                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
5805                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5806                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
5807                         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));
5808                 }
5809                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
5810         }
5811         if (flags & NDR_OUT) {
5812                 if (r->out.info == NULL) {
5813                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5814                 }
5815                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
5816                 NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
5817                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5818         }
5819         return NDR_ERR_SUCCESS;
5820 }
5821
5822 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaGetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaGetInfo *r)
5823 {
5824         uint32_t _ptr_server_name;
5825         TALLOC_CTX *_mem_save_server_name_0;
5826         TALLOC_CTX *_mem_save_info_0;
5827         if (flags & NDR_IN) {
5828                 ZERO_STRUCT(r->out);
5829
5830                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5831                 if (_ptr_server_name) {
5832                         NDR_PULL_ALLOC(ndr, r->in.server_name);
5833                 } else {
5834                         r->in.server_name = NULL;
5835                 }
5836                 if (r->in.server_name) {
5837                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5838                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
5839                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
5840                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
5841                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
5842                                 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));
5843                         }
5844                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
5845                         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));
5846                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5847                 }
5848                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
5849                 NDR_PULL_ALLOC(ndr, r->out.info);
5850                 ZERO_STRUCTP(r->out.info);
5851         }
5852         if (flags & NDR_OUT) {
5853                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5854                         NDR_PULL_ALLOC(ndr, r->out.info);
5855                 }
5856                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
5857                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
5858                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
5859                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
5860                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
5861                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5862         }
5863         return NDR_ERR_SUCCESS;
5864 }
5865
5866 _PUBLIC_ void ndr_print_wkssvc_NetWkstaGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaGetInfo *r)
5867 {
5868         ndr_print_struct(ndr, name, "wkssvc_NetWkstaGetInfo");
5869         ndr->depth++;
5870         if (flags & NDR_SET_VALUES) {
5871                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5872         }
5873         if (flags & NDR_IN) {
5874                 ndr_print_struct(ndr, "in", "wkssvc_NetWkstaGetInfo");
5875                 ndr->depth++;
5876                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
5877                 ndr->depth++;
5878                 if (r->in.server_name) {
5879                         ndr_print_string(ndr, "server_name", r->in.server_name);
5880                 }
5881                 ndr->depth--;
5882                 ndr_print_uint32(ndr, "level", r->in.level);
5883                 ndr->depth--;
5884         }
5885         if (flags & NDR_OUT) {
5886                 ndr_print_struct(ndr, "out", "wkssvc_NetWkstaGetInfo");
5887                 ndr->depth++;
5888                 ndr_print_ptr(ndr, "info", r->out.info);
5889                 ndr->depth++;
5890                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
5891                 ndr_print_wkssvc_NetWkstaInfo(ndr, "info", r->out.info);
5892                 ndr->depth--;
5893                 ndr_print_WERROR(ndr, "result", r->out.result);
5894                 ndr->depth--;
5895         }
5896         ndr->depth--;
5897 }
5898
5899 static enum ndr_err_code ndr_push_wkssvc_NetWkstaSetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaSetInfo *r)
5900 {
5901         if (flags & NDR_IN) {
5902                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
5903                 if (r->in.server_name) {
5904                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
5905                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5906                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
5907                         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));
5908                 }
5909                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
5910                 if (r->in.info == NULL) {
5911                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5912                 }
5913                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
5914                 NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
5915                 if (r->in.parm_error == NULL) {
5916                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5917                 }
5918                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_error));
5919         }
5920         if (flags & NDR_OUT) {
5921                 if (r->out.parm_error == NULL) {
5922                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5923                 }
5924                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_error));
5925                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5926         }
5927         return NDR_ERR_SUCCESS;
5928 }
5929
5930 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaSetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaSetInfo *r)
5931 {
5932         uint32_t _ptr_server_name;
5933         TALLOC_CTX *_mem_save_server_name_0;
5934         TALLOC_CTX *_mem_save_info_0;
5935         TALLOC_CTX *_mem_save_parm_error_0;
5936         if (flags & NDR_IN) {
5937                 ZERO_STRUCT(r->out);
5938
5939                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5940                 if (_ptr_server_name) {
5941                         NDR_PULL_ALLOC(ndr, r->in.server_name);
5942                 } else {
5943                         r->in.server_name = NULL;
5944                 }
5945                 if (r->in.server_name) {
5946                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5947                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
5948                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
5949                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
5950                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
5951                                 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));
5952                         }
5953                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
5954                         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));
5955                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5956                 }
5957                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
5958                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5959                         NDR_PULL_ALLOC(ndr, r->in.info);
5960                 }
5961                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
5962                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
5963                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
5964                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
5965                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
5966                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5967                         NDR_PULL_ALLOC(ndr, r->in.parm_error);
5968                 }
5969                 _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
5970                 NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_error, LIBNDR_FLAG_REF_ALLOC);
5971                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_error));
5972                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, LIBNDR_FLAG_REF_ALLOC);
5973                 NDR_PULL_ALLOC(ndr, r->out.parm_error);
5974                 *r->out.parm_error = *r->in.parm_error;
5975         }
5976         if (flags & NDR_OUT) {
5977                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5978                         NDR_PULL_ALLOC(ndr, r->out.parm_error);
5979                 }
5980                 _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
5981                 NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_error, LIBNDR_FLAG_REF_ALLOC);
5982                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_error));
5983                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, LIBNDR_FLAG_REF_ALLOC);
5984                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5985         }
5986         return NDR_ERR_SUCCESS;
5987 }
5988
5989 _PUBLIC_ void ndr_print_wkssvc_NetWkstaSetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaSetInfo *r)
5990 {
5991         ndr_print_struct(ndr, name, "wkssvc_NetWkstaSetInfo");
5992         ndr->depth++;
5993         if (flags & NDR_SET_VALUES) {
5994                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5995         }
5996         if (flags & NDR_IN) {
5997                 ndr_print_struct(ndr, "in", "wkssvc_NetWkstaSetInfo");
5998                 ndr->depth++;
5999                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
6000                 ndr->depth++;
6001                 if (r->in.server_name) {
6002                         ndr_print_string(ndr, "server_name", r->in.server_name);
6003                 }
6004                 ndr->depth--;
6005                 ndr_print_uint32(ndr, "level", r->in.level);
6006                 ndr_print_ptr(ndr, "info", r->in.info);
6007                 ndr->depth++;
6008                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
6009                 ndr_print_wkssvc_NetWkstaInfo(ndr, "info", r->in.info);
6010                 ndr->depth--;
6011                 ndr_print_ptr(ndr, "parm_error", r->in.parm_error);
6012                 ndr->depth++;
6013                 ndr_print_uint32(ndr, "parm_error", *r->in.parm_error);
6014                 ndr->depth--;
6015                 ndr->depth--;
6016         }
6017         if (flags & NDR_OUT) {
6018                 ndr_print_struct(ndr, "out", "wkssvc_NetWkstaSetInfo");
6019                 ndr->depth++;
6020                 ndr_print_ptr(ndr, "parm_error", r->out.parm_error);
6021                 ndr->depth++;
6022                 ndr_print_uint32(ndr, "parm_error", *r->out.parm_error);
6023                 ndr->depth--;
6024                 ndr_print_WERROR(ndr, "result", r->out.result);
6025                 ndr->depth--;
6026         }
6027         ndr->depth--;
6028 }
6029
6030 static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsers(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaEnumUsers *r)
6031 {
6032         if (flags & NDR_IN) {
6033                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
6034                 if (r->in.server_name) {
6035                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6036                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6037                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6038                         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));
6039                 }
6040                 if (r->in.info == NULL) {
6041                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6042                 }
6043                 NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6044                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.prefmaxlen));
6045                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
6046                 if (r->in.resume_handle) {
6047                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
6048                 }
6049         }
6050         if (flags & NDR_OUT) {
6051                 if (r->out.info == NULL) {
6052                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6053                 }
6054                 NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
6055                 if (r->out.entries_read == NULL) {
6056                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6057                 }
6058                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.entries_read));
6059                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
6060                 if (r->out.resume_handle) {
6061                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
6062                 }
6063                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6064         }
6065         return NDR_ERR_SUCCESS;
6066 }
6067
6068 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsers(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaEnumUsers *r)
6069 {
6070         uint32_t _ptr_server_name;
6071         uint32_t _ptr_resume_handle;
6072         TALLOC_CTX *_mem_save_server_name_0;
6073         TALLOC_CTX *_mem_save_info_0;
6074         TALLOC_CTX *_mem_save_entries_read_0;
6075         TALLOC_CTX *_mem_save_resume_handle_0;
6076         if (flags & NDR_IN) {
6077                 ZERO_STRUCT(r->out);
6078
6079                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6080                 if (_ptr_server_name) {
6081                         NDR_PULL_ALLOC(ndr, r->in.server_name);
6082                 } else {
6083                         r->in.server_name = NULL;
6084                 }
6085                 if (r->in.server_name) {
6086                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6087                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
6088                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
6089                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
6090                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
6091                                 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));
6092                         }
6093                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
6094                         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));
6095                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6096                 }
6097                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6098                         NDR_PULL_ALLOC(ndr, r->in.info);
6099                 }
6100                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6101                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
6102                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6103                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6104                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.prefmaxlen));
6105                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
6106                 if (_ptr_resume_handle) {
6107                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
6108                 } else {
6109                         r->in.resume_handle = NULL;
6110                 }
6111                 if (r->in.resume_handle) {
6112                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6113                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
6114                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
6115                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
6116                 }
6117                 NDR_PULL_ALLOC(ndr, r->out.info);
6118                 *r->out.info = *r->in.info;
6119                 NDR_PULL_ALLOC(ndr, r->out.entries_read);
6120                 ZERO_STRUCTP(r->out.entries_read);
6121         }
6122         if (flags & NDR_OUT) {
6123                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6124                         NDR_PULL_ALLOC(ndr, r->out.info);
6125                 }
6126                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6127                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
6128                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
6129                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6130                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6131                         NDR_PULL_ALLOC(ndr, r->out.entries_read);
6132                 }
6133                 _mem_save_entries_read_0 = NDR_PULL_GET_MEM_CTX(ndr);
6134                 NDR_PULL_SET_MEM_CTX(ndr, r->out.entries_read, LIBNDR_FLAG_REF_ALLOC);
6135                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.entries_read));
6136                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_read_0, LIBNDR_FLAG_REF_ALLOC);
6137                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
6138                 if (_ptr_resume_handle) {
6139                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6140                 } else {
6141                         r->out.resume_handle = NULL;
6142                 }
6143                 if (r->out.resume_handle) {
6144                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6145                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
6146                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
6147                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
6148                 }
6149                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6150         }
6151         return NDR_ERR_SUCCESS;
6152 }
6153
6154 _PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsers(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaEnumUsers *r)
6155 {
6156         ndr_print_struct(ndr, name, "wkssvc_NetWkstaEnumUsers");
6157         ndr->depth++;
6158         if (flags & NDR_SET_VALUES) {
6159                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6160         }
6161         if (flags & NDR_IN) {
6162                 ndr_print_struct(ndr, "in", "wkssvc_NetWkstaEnumUsers");
6163                 ndr->depth++;
6164                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
6165                 ndr->depth++;
6166                 if (r->in.server_name) {
6167                         ndr_print_string(ndr, "server_name", r->in.server_name);
6168                 }
6169                 ndr->depth--;
6170                 ndr_print_ptr(ndr, "info", r->in.info);
6171                 ndr->depth++;
6172                 ndr_print_wkssvc_NetWkstaEnumUsersInfo(ndr, "info", r->in.info);
6173                 ndr->depth--;
6174                 ndr_print_uint32(ndr, "prefmaxlen", r->in.prefmaxlen);
6175                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
6176                 ndr->depth++;
6177                 if (r->in.resume_handle) {
6178                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
6179                 }
6180                 ndr->depth--;
6181                 ndr->depth--;
6182         }
6183         if (flags & NDR_OUT) {
6184                 ndr_print_struct(ndr, "out", "wkssvc_NetWkstaEnumUsers");
6185                 ndr->depth++;
6186                 ndr_print_ptr(ndr, "info", r->out.info);
6187                 ndr->depth++;
6188                 ndr_print_wkssvc_NetWkstaEnumUsersInfo(ndr, "info", r->out.info);
6189                 ndr->depth--;
6190                 ndr_print_ptr(ndr, "entries_read", r->out.entries_read);
6191                 ndr->depth++;
6192                 ndr_print_uint32(ndr, "entries_read", *r->out.entries_read);
6193                 ndr->depth--;
6194                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
6195                 ndr->depth++;
6196                 if (r->out.resume_handle) {
6197                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
6198                 }
6199                 ndr->depth--;
6200                 ndr_print_WERROR(ndr, "result", r->out.result);
6201                 ndr->depth--;
6202         }
6203         ndr->depth--;
6204 }
6205
6206 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserGetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetrWkstaUserGetInfo *r)
6207 {
6208         if (flags & NDR_IN) {
6209                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown));
6210                 if (r->in.unknown) {
6211                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));
6212                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6213                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));
6214                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.unknown, ndr_charset_length(r->in.unknown, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6215                 }
6216                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
6217         }
6218         if (flags & NDR_OUT) {
6219                 if (r->out.info == NULL) {
6220                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6221                 }
6222                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
6223                 NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
6224                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6225         }
6226         return NDR_ERR_SUCCESS;
6227 }
6228
6229 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserGetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetrWkstaUserGetInfo *r)
6230 {
6231         uint32_t _ptr_unknown;
6232         TALLOC_CTX *_mem_save_unknown_0;
6233         TALLOC_CTX *_mem_save_info_0;
6234         if (flags & NDR_IN) {
6235                 ZERO_STRUCT(r->out);
6236
6237                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown));
6238                 if (_ptr_unknown) {
6239                         NDR_PULL_ALLOC(ndr, r->in.unknown);
6240                 } else {
6241                         r->in.unknown = NULL;
6242                 }
6243                 if (r->in.unknown) {
6244                         _mem_save_unknown_0 = NDR_PULL_GET_MEM_CTX(ndr);
6245                         NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown, 0);
6246                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.unknown));
6247                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.unknown));
6248                         if (ndr_get_array_length(ndr, &r->in.unknown) > ndr_get_array_size(ndr, &r->in.unknown)) {
6249                                 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));
6250                         }
6251                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t)));
6252                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.unknown, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t), CH_UTF16));
6253                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown_0, 0);
6254                 }
6255                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
6256                 NDR_PULL_ALLOC(ndr, r->out.info);
6257                 ZERO_STRUCTP(r->out.info);
6258         }
6259         if (flags & NDR_OUT) {
6260                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6261                         NDR_PULL_ALLOC(ndr, r->out.info);
6262                 }
6263                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6264                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
6265                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
6266                 NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
6267                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6268                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6269         }
6270         return NDR_ERR_SUCCESS;
6271 }
6272
6273 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrWkstaUserGetInfo *r)
6274 {
6275         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaUserGetInfo");
6276         ndr->depth++;
6277         if (flags & NDR_SET_VALUES) {
6278                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6279         }
6280         if (flags & NDR_IN) {
6281                 ndr_print_struct(ndr, "in", "wkssvc_NetrWkstaUserGetInfo");
6282                 ndr->depth++;
6283                 ndr_print_ptr(ndr, "unknown", r->in.unknown);
6284                 ndr->depth++;
6285                 if (r->in.unknown) {
6286                         ndr_print_string(ndr, "unknown", r->in.unknown);
6287                 }
6288                 ndr->depth--;
6289                 ndr_print_uint32(ndr, "level", r->in.level);
6290                 ndr->depth--;
6291         }
6292         if (flags & NDR_OUT) {
6293                 ndr_print_struct(ndr, "out", "wkssvc_NetrWkstaUserGetInfo");
6294                 ndr->depth++;
6295                 ndr_print_ptr(ndr, "info", r->out.info);
6296                 ndr->depth++;
6297                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
6298                 ndr_print_wkssvc_NetrWkstaUserInfo(ndr, "info", r->out.info);
6299                 ndr->depth--;
6300                 ndr_print_WERROR(ndr, "result", r->out.result);
6301                 ndr->depth--;
6302         }
6303         ndr->depth--;
6304 }
6305
6306 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserSetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetrWkstaUserSetInfo *r)
6307 {
6308         if (flags & NDR_IN) {
6309                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown));
6310                 if (r->in.unknown) {
6311                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));
6312                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6313                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));
6314                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.unknown, ndr_charset_length(r->in.unknown, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6315                 }
6316                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
6317                 if (r->in.info == NULL) {
6318                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6319                 }
6320                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
6321                 NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6322                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_err));
6323                 if (r->in.parm_err) {
6324                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_err));
6325                 }
6326         }
6327         if (flags & NDR_OUT) {
6328                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_err));
6329                 if (r->out.parm_err) {
6330                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_err));
6331                 }
6332                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6333         }
6334         return NDR_ERR_SUCCESS;
6335 }
6336
6337 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserSetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetrWkstaUserSetInfo *r)
6338 {
6339         uint32_t _ptr_unknown;
6340         uint32_t _ptr_parm_err;
6341         TALLOC_CTX *_mem_save_unknown_0;
6342         TALLOC_CTX *_mem_save_info_0;
6343         TALLOC_CTX *_mem_save_parm_err_0;
6344         if (flags & NDR_IN) {
6345                 ZERO_STRUCT(r->out);
6346
6347                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown));
6348                 if (_ptr_unknown) {
6349                         NDR_PULL_ALLOC(ndr, r->in.unknown);
6350                 } else {
6351                         r->in.unknown = NULL;
6352                 }
6353                 if (r->in.unknown) {
6354                         _mem_save_unknown_0 = NDR_PULL_GET_MEM_CTX(ndr);
6355                         NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown, 0);
6356                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.unknown));
6357                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.unknown));
6358                         if (ndr_get_array_length(ndr, &r->in.unknown) > ndr_get_array_size(ndr, &r->in.unknown)) {
6359                                 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));
6360                         }
6361                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t)));
6362                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.unknown, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t), CH_UTF16));
6363                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown_0, 0);
6364                 }
6365                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
6366                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6367                         NDR_PULL_ALLOC(ndr, r->in.info);
6368                 }
6369                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6370                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
6371                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
6372                 NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6373                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6374                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));
6375                 if (_ptr_parm_err) {
6376                         NDR_PULL_ALLOC(ndr, r->in.parm_err);
6377                 } else {
6378                         r->in.parm_err = NULL;
6379                 }
6380                 if (r->in.parm_err) {
6381                         _mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);
6382                         NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_err, 0);
6383                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_err));
6384                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);
6385                 }
6386         }
6387         if (flags & NDR_OUT) {
6388                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));
6389                 if (_ptr_parm_err) {
6390                         NDR_PULL_ALLOC(ndr, r->out.parm_err);
6391                 } else {
6392                         r->out.parm_err = NULL;
6393                 }
6394                 if (r->out.parm_err) {
6395                         _mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);
6396                         NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_err, 0);
6397                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_err));
6398                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);
6399                 }
6400                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6401         }
6402         return NDR_ERR_SUCCESS;
6403 }
6404
6405 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserSetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrWkstaUserSetInfo *r)
6406 {
6407         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaUserSetInfo");
6408         ndr->depth++;
6409         if (flags & NDR_SET_VALUES) {
6410                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6411         }
6412         if (flags & NDR_IN) {
6413                 ndr_print_struct(ndr, "in", "wkssvc_NetrWkstaUserSetInfo");
6414                 ndr->depth++;
6415                 ndr_print_ptr(ndr, "unknown", r->in.unknown);
6416                 ndr->depth++;
6417                 if (r->in.unknown) {
6418                         ndr_print_string(ndr, "unknown", r->in.unknown);
6419                 }
6420                 ndr->depth--;
6421                 ndr_print_uint32(ndr, "level", r->in.level);
6422                 ndr_print_ptr(ndr, "info", r->in.info);
6423                 ndr->depth++;
6424                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
6425                 ndr_print_wkssvc_NetrWkstaUserInfo(ndr, "info", r->in.info);
6426                 ndr->depth--;
6427                 ndr_print_ptr(ndr, "parm_err", r->in.parm_err);
6428                 ndr->depth++;
6429                 if (r->in.parm_err) {
6430                         ndr_print_uint32(ndr, "parm_err", *r->in.parm_err);
6431                 }
6432                 ndr->depth--;
6433                 ndr->depth--;
6434         }
6435         if (flags & NDR_OUT) {
6436                 ndr_print_struct(ndr, "out", "wkssvc_NetrWkstaUserSetInfo");
6437                 ndr->depth++;
6438                 ndr_print_ptr(ndr, "parm_err", r->out.parm_err);
6439                 ndr->depth++;
6440                 if (r->out.parm_err) {
6441                         ndr_print_uint32(ndr, "parm_err", *r->out.parm_err);
6442                 }
6443                 ndr->depth--;
6444                 ndr_print_WERROR(ndr, "result", r->out.result);
6445                 ndr->depth--;
6446         }
6447         ndr->depth--;
6448 }
6449
6450 static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportEnum(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaTransportEnum *r)
6451 {
6452         if (flags & NDR_IN) {
6453                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
6454                 if (r->in.server_name) {
6455                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6456                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6457                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6458                         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));
6459                 }
6460                 if (r->in.info == NULL) {
6461                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6462                 }
6463                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6464                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));
6465                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
6466                 if (r->in.resume_handle) {
6467                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
6468                 }
6469         }
6470         if (flags & NDR_OUT) {
6471                 if (r->out.info == NULL) {
6472                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6473                 }
6474                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
6475                 if (r->out.total_entries == NULL) {
6476                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6477                 }
6478                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_entries));
6479                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
6480                 if (r->out.resume_handle) {
6481                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
6482                 }
6483                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6484         }
6485         return NDR_ERR_SUCCESS;
6486 }
6487
6488 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportEnum(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaTransportEnum *r)
6489 {
6490         uint32_t _ptr_server_name;
6491         uint32_t _ptr_resume_handle;
6492         TALLOC_CTX *_mem_save_server_name_0;
6493         TALLOC_CTX *_mem_save_info_0;
6494         TALLOC_CTX *_mem_save_total_entries_0;
6495         TALLOC_CTX *_mem_save_resume_handle_0;
6496         if (flags & NDR_IN) {
6497                 ZERO_STRUCT(r->out);
6498
6499                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6500                 if (_ptr_server_name) {
6501                         NDR_PULL_ALLOC(ndr, r->in.server_name);
6502                 } else {
6503                         r->in.server_name = NULL;
6504                 }
6505                 if (r->in.server_name) {
6506                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6507                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
6508                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
6509                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
6510                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
6511                                 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));
6512                         }
6513                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
6514                         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));
6515                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6516                 }
6517                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6518                         NDR_PULL_ALLOC(ndr, r->in.info);
6519                 }
6520                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6521                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
6522                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6523                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6524                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));
6525                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
6526                 if (_ptr_resume_handle) {
6527                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
6528                 } else {
6529                         r->in.resume_handle = NULL;
6530                 }
6531                 if (r->in.resume_handle) {
6532                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6533                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
6534                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
6535                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
6536                 }
6537                 NDR_PULL_ALLOC(ndr, r->out.info);
6538                 *r->out.info = *r->in.info;
6539                 NDR_PULL_ALLOC(ndr, r->out.total_entries);
6540                 ZERO_STRUCTP(r->out.total_entries);
6541         }
6542         if (flags & NDR_OUT) {
6543                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6544                         NDR_PULL_ALLOC(ndr, r->out.info);
6545                 }
6546                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6547                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
6548                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
6549                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6550                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6551                         NDR_PULL_ALLOC(ndr, r->out.total_entries);
6552                 }
6553                 _mem_save_total_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
6554                 NDR_PULL_SET_MEM_CTX(ndr, r->out.total_entries, LIBNDR_FLAG_REF_ALLOC);
6555                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_entries));
6556                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_entries_0, LIBNDR_FLAG_REF_ALLOC);
6557                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
6558                 if (_ptr_resume_handle) {
6559                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6560                 } else {
6561                         r->out.resume_handle = NULL;
6562                 }
6563                 if (r->out.resume_handle) {
6564                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6565                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
6566                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
6567                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
6568                 }
6569                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6570         }
6571         return NDR_ERR_SUCCESS;
6572 }
6573
6574 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportEnum(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaTransportEnum *r)
6575 {
6576         ndr_print_struct(ndr, name, "wkssvc_NetWkstaTransportEnum");
6577         ndr->depth++;
6578         if (flags & NDR_SET_VALUES) {
6579                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6580         }
6581         if (flags & NDR_IN) {
6582                 ndr_print_struct(ndr, "in", "wkssvc_NetWkstaTransportEnum");
6583                 ndr->depth++;
6584                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
6585                 ndr->depth++;
6586                 if (r->in.server_name) {
6587                         ndr_print_string(ndr, "server_name", r->in.server_name);
6588                 }
6589                 ndr->depth--;
6590                 ndr_print_ptr(ndr, "info", r->in.info);
6591                 ndr->depth++;
6592                 ndr_print_wkssvc_NetWkstaTransportInfo(ndr, "info", r->in.info);
6593                 ndr->depth--;
6594                 ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);
6595                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
6596                 ndr->depth++;
6597                 if (r->in.resume_handle) {
6598                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
6599                 }
6600                 ndr->depth--;
6601                 ndr->depth--;
6602         }
6603         if (flags & NDR_OUT) {
6604                 ndr_print_struct(ndr, "out", "wkssvc_NetWkstaTransportEnum");
6605                 ndr->depth++;
6606                 ndr_print_ptr(ndr, "info", r->out.info);
6607                 ndr->depth++;
6608                 ndr_print_wkssvc_NetWkstaTransportInfo(ndr, "info", r->out.info);
6609                 ndr->depth--;
6610                 ndr_print_ptr(ndr, "total_entries", r->out.total_entries);
6611                 ndr->depth++;
6612                 ndr_print_uint32(ndr, "total_entries", *r->out.total_entries);
6613                 ndr->depth--;
6614                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
6615                 ndr->depth++;
6616                 if (r->out.resume_handle) {
6617                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
6618                 }
6619                 ndr->depth--;
6620                 ndr_print_WERROR(ndr, "result", r->out.result);
6621                 ndr->depth--;
6622         }
6623         ndr->depth--;
6624 }
6625
6626 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaTransportAdd(struct ndr_push *ndr, int flags, const struct wkssvc_NetrWkstaTransportAdd *r)
6627 {
6628         if (flags & NDR_IN) {
6629                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
6630                 if (r->in.server_name) {
6631                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6632                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6633                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6634                         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));
6635                 }
6636                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
6637                 if (r->in.info0 == NULL) {
6638                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6639                 }
6640                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info0));
6641                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_err));
6642                 if (r->in.parm_err) {
6643                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_err));
6644                 }
6645         }
6646         if (flags & NDR_OUT) {
6647                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_err));
6648                 if (r->out.parm_err) {
6649                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_err));
6650                 }
6651                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6652         }
6653         return NDR_ERR_SUCCESS;
6654 }
6655
6656 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaTransportAdd(struct ndr_pull *ndr, int flags, struct wkssvc_NetrWkstaTransportAdd *r)
6657 {
6658         uint32_t _ptr_server_name;
6659         uint32_t _ptr_parm_err;
6660         TALLOC_CTX *_mem_save_server_name_0;
6661         TALLOC_CTX *_mem_save_info0_0;
6662         TALLOC_CTX *_mem_save_parm_err_0;
6663         if (flags & NDR_IN) {
6664                 ZERO_STRUCT(r->out);
6665
6666                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6667                 if (_ptr_server_name) {
6668                         NDR_PULL_ALLOC(ndr, r->in.server_name);
6669                 } else {
6670                         r->in.server_name = NULL;
6671                 }
6672                 if (r->in.server_name) {
6673                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6674                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
6675                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
6676                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
6677                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
6678                                 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));
6679                         }
6680                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
6681                         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));
6682                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6683                 }
6684                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
6685                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6686                         NDR_PULL_ALLOC(ndr, r->in.info0);
6687                 }
6688                 _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
6689                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info0, LIBNDR_FLAG_REF_ALLOC);
6690                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info0));
6691                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, LIBNDR_FLAG_REF_ALLOC);
6692                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));
6693                 if (_ptr_parm_err) {
6694                         NDR_PULL_ALLOC(ndr, r->in.parm_err);
6695                 } else {
6696                         r->in.parm_err = NULL;
6697                 }
6698                 if (r->in.parm_err) {
6699                         _mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);
6700                         NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_err, 0);
6701                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_err));
6702                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);
6703                 }
6704         }
6705         if (flags & NDR_OUT) {
6706                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));
6707                 if (_ptr_parm_err) {
6708                         NDR_PULL_ALLOC(ndr, r->out.parm_err);
6709                 } else {
6710                         r->out.parm_err = NULL;
6711                 }
6712                 if (r->out.parm_err) {
6713                         _mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);
6714                         NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_err, 0);
6715                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_err));
6716                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);
6717                 }
6718                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6719         }
6720         return NDR_ERR_SUCCESS;
6721 }
6722
6723 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaTransportAdd(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrWkstaTransportAdd *r)
6724 {
6725         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaTransportAdd");
6726         ndr->depth++;
6727         if (flags & NDR_SET_VALUES) {
6728                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6729         }
6730         if (flags & NDR_IN) {
6731                 ndr_print_struct(ndr, "in", "wkssvc_NetrWkstaTransportAdd");
6732                 ndr->depth++;
6733                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
6734                 ndr->depth++;
6735                 if (r->in.server_name) {
6736                         ndr_print_string(ndr, "server_name", r->in.server_name);
6737                 }
6738                 ndr->depth--;
6739                 ndr_print_uint32(ndr, "level", r->in.level);
6740                 ndr_print_ptr(ndr, "info0", r->in.info0);
6741                 ndr->depth++;
6742                 ndr_print_wkssvc_NetWkstaTransportInfo0(ndr, "info0", r->in.info0);
6743                 ndr->depth--;
6744                 ndr_print_ptr(ndr, "parm_err", r->in.parm_err);
6745                 ndr->depth++;
6746                 if (r->in.parm_err) {
6747                         ndr_print_uint32(ndr, "parm_err", *r->in.parm_err);
6748                 }
6749                 ndr->depth--;
6750                 ndr->depth--;
6751         }
6752         if (flags & NDR_OUT) {
6753                 ndr_print_struct(ndr, "out", "wkssvc_NetrWkstaTransportAdd");
6754                 ndr->depth++;
6755                 ndr_print_ptr(ndr, "parm_err", r->out.parm_err);
6756                 ndr->depth++;
6757                 if (r->out.parm_err) {
6758                         ndr_print_uint32(ndr, "parm_err", *r->out.parm_err);
6759                 }
6760                 ndr->depth--;
6761                 ndr_print_WERROR(ndr, "result", r->out.result);
6762                 ndr->depth--;
6763         }
6764         ndr->depth--;
6765 }
6766
6767 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaTransportDel(struct ndr_push *ndr, int flags, const struct wkssvc_NetrWkstaTransportDel *r)
6768 {
6769         if (flags & NDR_IN) {
6770                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
6771                 if (r->in.server_name) {
6772                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6773                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6774                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6775                         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));
6776                 }
6777                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.transport_name));
6778                 if (r->in.transport_name) {
6779                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.transport_name, CH_UTF16)));
6780                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6781                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.transport_name, CH_UTF16)));
6782                         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));
6783                 }
6784                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown3));
6785         }
6786         if (flags & NDR_OUT) {
6787                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6788         }
6789         return NDR_ERR_SUCCESS;
6790 }
6791
6792 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaTransportDel(struct ndr_pull *ndr, int flags, struct wkssvc_NetrWkstaTransportDel *r)
6793 {
6794         uint32_t _ptr_server_name;
6795         uint32_t _ptr_transport_name;
6796         TALLOC_CTX *_mem_save_server_name_0;
6797         TALLOC_CTX *_mem_save_transport_name_0;
6798         if (flags & NDR_IN) {
6799                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6800                 if (_ptr_server_name) {
6801                         NDR_PULL_ALLOC(ndr, r->in.server_name);
6802                 } else {
6803                         r->in.server_name = NULL;
6804                 }
6805                 if (r->in.server_name) {
6806                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6807                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
6808                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
6809                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
6810                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
6811                                 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));
6812                         }
6813                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
6814                         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));
6815                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6816                 }
6817                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_name));
6818                 if (_ptr_transport_name) {
6819                         NDR_PULL_ALLOC(ndr, r->in.transport_name);
6820                 } else {
6821                         r->in.transport_name = NULL;
6822                 }
6823                 if (r->in.transport_name) {
6824                         _mem_save_transport_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6825                         NDR_PULL_SET_MEM_CTX(ndr, r->in.transport_name, 0);
6826                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.transport_name));
6827                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.transport_name));
6828                         if (ndr_get_array_length(ndr, &r->in.transport_name) > ndr_get_array_size(ndr, &r->in.transport_name)) {
6829                                 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));
6830                         }
6831                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.transport_name), sizeof(uint16_t)));
6832                         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));
6833                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_name_0, 0);
6834                 }
6835                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown3));
6836         }
6837         if (flags & NDR_OUT) {
6838                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6839         }
6840         return NDR_ERR_SUCCESS;
6841 }
6842
6843 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaTransportDel(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrWkstaTransportDel *r)
6844 {
6845         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaTransportDel");
6846         ndr->depth++;
6847         if (flags & NDR_SET_VALUES) {
6848                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6849         }
6850         if (flags & NDR_IN) {
6851                 ndr_print_struct(ndr, "in", "wkssvc_NetrWkstaTransportDel");
6852                 ndr->depth++;
6853                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
6854                 ndr->depth++;
6855                 if (r->in.server_name) {
6856                         ndr_print_string(ndr, "server_name", r->in.server_name);
6857                 }
6858                 ndr->depth--;
6859                 ndr_print_ptr(ndr, "transport_name", r->in.transport_name);
6860                 ndr->depth++;
6861                 if (r->in.transport_name) {
6862                         ndr_print_string(ndr, "transport_name", r->in.transport_name);
6863                 }
6864                 ndr->depth--;
6865                 ndr_print_uint32(ndr, "unknown3", r->in.unknown3);
6866                 ndr->depth--;
6867         }
6868         if (flags & NDR_OUT) {
6869                 ndr_print_struct(ndr, "out", "wkssvc_NetrWkstaTransportDel");
6870                 ndr->depth++;
6871                 ndr_print_WERROR(ndr, "result", r->out.result);
6872                 ndr->depth--;
6873         }
6874         ndr->depth--;
6875 }
6876
6877 static enum ndr_err_code ndr_push_wkssvc_NetrUseAdd(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUseAdd *r)
6878 {
6879         if (flags & NDR_IN) {
6880                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
6881                 if (r->in.server_name) {
6882                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6883                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6884                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6885                         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));
6886                 }
6887                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
6888                 if (r->in.ctr == NULL) {
6889                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6890                 }
6891                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.ctr, r->in.level));
6892                 NDR_CHECK(ndr_push_wkssvc_NetrUseGetInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
6893                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_err));
6894                 if (r->in.parm_err) {
6895                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_err));
6896                 }
6897         }
6898         if (flags & NDR_OUT) {
6899                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_err));
6900                 if (r->out.parm_err) {
6901                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_err));
6902                 }
6903                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6904         }
6905         return NDR_ERR_SUCCESS;
6906 }
6907
6908 static enum ndr_err_code ndr_pull_wkssvc_NetrUseAdd(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUseAdd *r)
6909 {
6910         uint32_t _ptr_server_name;
6911         uint32_t _ptr_parm_err;
6912         TALLOC_CTX *_mem_save_server_name_0;
6913         TALLOC_CTX *_mem_save_ctr_0;
6914         TALLOC_CTX *_mem_save_parm_err_0;
6915         if (flags & NDR_IN) {
6916                 ZERO_STRUCT(r->out);
6917
6918                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6919                 if (_ptr_server_name) {
6920                         NDR_PULL_ALLOC(ndr, r->in.server_name);
6921                 } else {
6922                         r->in.server_name = NULL;
6923                 }
6924                 if (r->in.server_name) {
6925                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6926                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
6927                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
6928                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
6929                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
6930                                 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));
6931                         }
6932                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
6933                         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));
6934                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6935                 }
6936                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
6937                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6938                         NDR_PULL_ALLOC(ndr, r->in.ctr);
6939                 }
6940                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
6941                 NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, LIBNDR_FLAG_REF_ALLOC);
6942                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.ctr, r->in.level));
6943                 NDR_CHECK(ndr_pull_wkssvc_NetrUseGetInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
6944                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
6945                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));
6946                 if (_ptr_parm_err) {
6947                         NDR_PULL_ALLOC(ndr, r->in.parm_err);
6948                 } else {
6949                         r->in.parm_err = NULL;
6950                 }
6951                 if (r->in.parm_err) {
6952                         _mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);
6953                         NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_err, 0);
6954                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_err));
6955                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);
6956                 }
6957         }
6958         if (flags & NDR_OUT) {
6959                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));
6960                 if (_ptr_parm_err) {
6961                         NDR_PULL_ALLOC(ndr, r->out.parm_err);
6962                 } else {
6963                         r->out.parm_err = NULL;
6964                 }
6965                 if (r->out.parm_err) {
6966                         _mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);
6967                         NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_err, 0);
6968                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_err));
6969                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);
6970                 }
6971                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6972         }
6973         return NDR_ERR_SUCCESS;
6974 }
6975
6976 _PUBLIC_ void ndr_print_wkssvc_NetrUseAdd(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUseAdd *r)
6977 {
6978         ndr_print_struct(ndr, name, "wkssvc_NetrUseAdd");
6979         ndr->depth++;
6980         if (flags & NDR_SET_VALUES) {
6981                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6982         }
6983         if (flags & NDR_IN) {
6984                 ndr_print_struct(ndr, "in", "wkssvc_NetrUseAdd");
6985                 ndr->depth++;
6986                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
6987                 ndr->depth++;
6988                 if (r->in.server_name) {
6989                         ndr_print_string(ndr, "server_name", r->in.server_name);
6990                 }
6991                 ndr->depth--;
6992                 ndr_print_uint32(ndr, "level", r->in.level);
6993                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
6994                 ndr->depth++;
6995                 ndr_print_set_switch_value(ndr, r->in.ctr, r->in.level);
6996                 ndr_print_wkssvc_NetrUseGetInfoCtr(ndr, "ctr", r->in.ctr);
6997                 ndr->depth--;
6998                 ndr_print_ptr(ndr, "parm_err", r->in.parm_err);
6999                 ndr->depth++;
7000                 if (r->in.parm_err) {
7001                         ndr_print_uint32(ndr, "parm_err", *r->in.parm_err);
7002                 }
7003                 ndr->depth--;
7004                 ndr->depth--;
7005         }
7006         if (flags & NDR_OUT) {
7007                 ndr_print_struct(ndr, "out", "wkssvc_NetrUseAdd");
7008                 ndr->depth++;
7009                 ndr_print_ptr(ndr, "parm_err", r->out.parm_err);
7010                 ndr->depth++;
7011                 if (r->out.parm_err) {
7012                         ndr_print_uint32(ndr, "parm_err", *r->out.parm_err);
7013                 }
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_NetrUseGetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUseGetInfo *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_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7027                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7028                         NDR_CHECK(ndr_push_uint3264(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_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.use_name, CH_UTF16)));
7035                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7036                 NDR_CHECK(ndr_push_uint3264(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.level));
7039         }
7040         if (flags & NDR_OUT) {
7041                 if (r->out.ctr == NULL) {
7042                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7043                 }
7044                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, r->in.level));
7045                 NDR_CHECK(ndr_push_wkssvc_NetrUseGetInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
7046                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7047         }
7048         return NDR_ERR_SUCCESS;
7049 }
7050
7051 static enum ndr_err_code ndr_pull_wkssvc_NetrUseGetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUseGetInfo *r)
7052 {
7053         uint32_t _ptr_server_name;
7054         TALLOC_CTX *_mem_save_server_name_0;
7055         TALLOC_CTX *_mem_save_ctr_0;
7056         if (flags & NDR_IN) {
7057                 ZERO_STRUCT(r->out);
7058
7059                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
7060                 if (_ptr_server_name) {
7061                         NDR_PULL_ALLOC(ndr, r->in.server_name);
7062                 } else {
7063                         r->in.server_name = NULL;
7064                 }
7065                 if (r->in.server_name) {
7066                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7067                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
7068                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
7069                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
7070                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
7071                                 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));
7072                         }
7073                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
7074                         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));
7075                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
7076                 }
7077                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.use_name));
7078                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.use_name));
7079                 if (ndr_get_array_length(ndr, &r->in.use_name) > ndr_get_array_size(ndr, &r->in.use_name)) {
7080                         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));
7081                 }
7082                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.use_name), sizeof(uint16_t)));
7083                 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));
7084                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
7085                 NDR_PULL_ALLOC(ndr, r->out.ctr);
7086                 ZERO_STRUCTP(r->out.ctr);
7087         }
7088         if (flags & NDR_OUT) {
7089                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7090                         NDR_PULL_ALLOC(ndr, r->out.ctr);
7091                 }
7092                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
7093                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
7094                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, r->in.level));
7095                 NDR_CHECK(ndr_pull_wkssvc_NetrUseGetInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
7096                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
7097                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7098         }
7099         return NDR_ERR_SUCCESS;
7100 }
7101
7102 _PUBLIC_ void ndr_print_wkssvc_NetrUseGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUseGetInfo *r)
7103 {
7104         ndr_print_struct(ndr, name, "wkssvc_NetrUseGetInfo");
7105         ndr->depth++;
7106         if (flags & NDR_SET_VALUES) {
7107                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7108         }
7109         if (flags & NDR_IN) {
7110                 ndr_print_struct(ndr, "in", "wkssvc_NetrUseGetInfo");
7111                 ndr->depth++;
7112                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
7113                 ndr->depth++;
7114                 if (r->in.server_name) {
7115                         ndr_print_string(ndr, "server_name", r->in.server_name);
7116                 }
7117                 ndr->depth--;
7118                 ndr_print_ptr(ndr, "use_name", r->in.use_name);
7119                 ndr->depth++;
7120                 ndr_print_string(ndr, "use_name", r->in.use_name);
7121                 ndr->depth--;
7122                 ndr_print_uint32(ndr, "level", r->in.level);
7123                 ndr->depth--;
7124         }
7125         if (flags & NDR_OUT) {
7126                 ndr_print_struct(ndr, "out", "wkssvc_NetrUseGetInfo");
7127                 ndr->depth++;
7128                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
7129                 ndr->depth++;
7130                 ndr_print_set_switch_value(ndr, r->out.ctr, r->in.level);
7131                 ndr_print_wkssvc_NetrUseGetInfoCtr(ndr, "ctr", r->out.ctr);
7132                 ndr->depth--;
7133                 ndr_print_WERROR(ndr, "result", r->out.result);
7134                 ndr->depth--;
7135         }
7136         ndr->depth--;
7137 }
7138
7139 static enum ndr_err_code ndr_push_wkssvc_NetrUseDel(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUseDel *r)
7140 {
7141         if (flags & NDR_IN) {
7142                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
7143                 if (r->in.server_name) {
7144                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7145                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7146                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7147                         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));
7148                 }
7149                 if (r->in.use_name == NULL) {
7150                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7151                 }
7152                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.use_name, CH_UTF16)));
7153                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7154                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.use_name, CH_UTF16)));
7155                 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));
7156                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.force_cond));
7157         }
7158         if (flags & NDR_OUT) {
7159                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7160         }
7161         return NDR_ERR_SUCCESS;
7162 }
7163
7164 static enum ndr_err_code ndr_pull_wkssvc_NetrUseDel(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUseDel *r)
7165 {
7166         uint32_t _ptr_server_name;
7167         TALLOC_CTX *_mem_save_server_name_0;
7168         if (flags & NDR_IN) {
7169                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
7170                 if (_ptr_server_name) {
7171                         NDR_PULL_ALLOC(ndr, r->in.server_name);
7172                 } else {
7173                         r->in.server_name = NULL;
7174                 }
7175                 if (r->in.server_name) {
7176                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7177                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
7178                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
7179                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
7180                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
7181                                 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));
7182                         }
7183                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
7184                         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));
7185                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
7186                 }
7187                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.use_name));
7188                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.use_name));
7189                 if (ndr_get_array_length(ndr, &r->in.use_name) > ndr_get_array_size(ndr, &r->in.use_name)) {
7190                         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));
7191                 }
7192                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.use_name), sizeof(uint16_t)));
7193                 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));
7194                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.force_cond));
7195         }
7196         if (flags & NDR_OUT) {
7197                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7198         }
7199         return NDR_ERR_SUCCESS;
7200 }
7201
7202 _PUBLIC_ void ndr_print_wkssvc_NetrUseDel(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUseDel *r)
7203 {
7204         ndr_print_struct(ndr, name, "wkssvc_NetrUseDel");
7205         ndr->depth++;
7206         if (flags & NDR_SET_VALUES) {
7207                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7208         }
7209         if (flags & NDR_IN) {
7210                 ndr_print_struct(ndr, "in", "wkssvc_NetrUseDel");
7211                 ndr->depth++;
7212                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
7213                 ndr->depth++;
7214                 if (r->in.server_name) {
7215                         ndr_print_string(ndr, "server_name", r->in.server_name);
7216                 }
7217                 ndr->depth--;
7218                 ndr_print_ptr(ndr, "use_name", r->in.use_name);
7219                 ndr->depth++;
7220                 ndr_print_string(ndr, "use_name", r->in.use_name);
7221                 ndr->depth--;
7222                 ndr_print_uint32(ndr, "force_cond", r->in.force_cond);
7223                 ndr->depth--;
7224         }
7225         if (flags & NDR_OUT) {
7226                 ndr_print_struct(ndr, "out", "wkssvc_NetrUseDel");
7227                 ndr->depth++;
7228                 ndr_print_WERROR(ndr, "result", r->out.result);
7229                 ndr->depth--;
7230         }
7231         ndr->depth--;
7232 }
7233
7234 static enum ndr_err_code ndr_push_wkssvc_NetrUseEnum(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUseEnum *r)
7235 {
7236         if (flags & NDR_IN) {
7237                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
7238                 if (r->in.server_name) {
7239                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7240                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7241                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7242                         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));
7243                 }
7244                 if (r->in.info == NULL) {
7245                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7246                 }
7247                 NDR_CHECK(ndr_push_wkssvc_NetrUseEnumInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
7248                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.prefmaxlen));
7249                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
7250                 if (r->in.resume_handle) {
7251                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
7252                 }
7253         }
7254         if (flags & NDR_OUT) {
7255                 if (r->out.info == NULL) {
7256                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7257                 }
7258                 NDR_CHECK(ndr_push_wkssvc_NetrUseEnumInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
7259                 if (r->out.entries_read == NULL) {
7260                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7261                 }
7262                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.entries_read));
7263                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
7264                 if (r->out.resume_handle) {
7265                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
7266                 }
7267                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7268         }
7269         return NDR_ERR_SUCCESS;
7270 }
7271
7272 static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnum(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUseEnum *r)
7273 {
7274         uint32_t _ptr_server_name;
7275         uint32_t _ptr_resume_handle;
7276         TALLOC_CTX *_mem_save_server_name_0;
7277         TALLOC_CTX *_mem_save_info_0;
7278         TALLOC_CTX *_mem_save_entries_read_0;
7279         TALLOC_CTX *_mem_save_resume_handle_0;
7280         if (flags & NDR_IN) {
7281                 ZERO_STRUCT(r->out);
7282
7283                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
7284                 if (_ptr_server_name) {
7285                         NDR_PULL_ALLOC(ndr, r->in.server_name);
7286                 } else {
7287                         r->in.server_name = NULL;
7288                 }
7289                 if (r->in.server_name) {
7290                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7291                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
7292                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
7293                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
7294                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
7295                                 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));
7296                         }
7297                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
7298                         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));
7299                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
7300                 }
7301                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7302                         NDR_PULL_ALLOC(ndr, r->in.info);
7303                 }
7304                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
7305                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
7306                 NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
7307                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
7308                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.prefmaxlen));
7309                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
7310                 if (_ptr_resume_handle) {
7311                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
7312                 } else {
7313                         r->in.resume_handle = NULL;
7314                 }
7315                 if (r->in.resume_handle) {
7316                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7317                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
7318                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
7319                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
7320                 }
7321                 NDR_PULL_ALLOC(ndr, r->out.info);
7322                 *r->out.info = *r->in.info;
7323                 NDR_PULL_ALLOC(ndr, r->out.entries_read);
7324                 ZERO_STRUCTP(r->out.entries_read);
7325         }
7326         if (flags & NDR_OUT) {
7327                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7328                         NDR_PULL_ALLOC(ndr, r->out.info);
7329                 }
7330                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
7331                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
7332                 NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
7333                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
7334                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7335                         NDR_PULL_ALLOC(ndr, r->out.entries_read);
7336                 }
7337                 _mem_save_entries_read_0 = NDR_PULL_GET_MEM_CTX(ndr);
7338                 NDR_PULL_SET_MEM_CTX(ndr, r->out.entries_read, LIBNDR_FLAG_REF_ALLOC);
7339                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.entries_read));
7340                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_read_0, LIBNDR_FLAG_REF_ALLOC);
7341                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
7342                 if (_ptr_resume_handle) {
7343                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
7344                 } else {
7345                         r->out.resume_handle = NULL;
7346                 }
7347                 if (r->out.resume_handle) {
7348                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7349                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
7350                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
7351                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
7352                 }
7353                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7354         }
7355         return NDR_ERR_SUCCESS;
7356 }
7357
7358 _PUBLIC_ void ndr_print_wkssvc_NetrUseEnum(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUseEnum *r)
7359 {
7360         ndr_print_struct(ndr, name, "wkssvc_NetrUseEnum");
7361         ndr->depth++;
7362         if (flags & NDR_SET_VALUES) {
7363                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7364         }
7365         if (flags & NDR_IN) {
7366                 ndr_print_struct(ndr, "in", "wkssvc_NetrUseEnum");
7367                 ndr->depth++;
7368                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
7369                 ndr->depth++;
7370                 if (r->in.server_name) {
7371                         ndr_print_string(ndr, "server_name", r->in.server_name);
7372                 }
7373                 ndr->depth--;
7374                 ndr_print_ptr(ndr, "info", r->in.info);
7375                 ndr->depth++;
7376                 ndr_print_wkssvc_NetrUseEnumInfo(ndr, "info", r->in.info);
7377                 ndr->depth--;
7378                 ndr_print_uint32(ndr, "prefmaxlen", r->in.prefmaxlen);
7379                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
7380                 ndr->depth++;
7381                 if (r->in.resume_handle) {
7382                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
7383                 }
7384                 ndr->depth--;
7385                 ndr->depth--;
7386         }
7387         if (flags & NDR_OUT) {
7388                 ndr_print_struct(ndr, "out", "wkssvc_NetrUseEnum");
7389                 ndr->depth++;
7390                 ndr_print_ptr(ndr, "info", r->out.info);
7391                 ndr->depth++;
7392                 ndr_print_wkssvc_NetrUseEnumInfo(ndr, "info", r->out.info);
7393                 ndr->depth--;
7394                 ndr_print_ptr(ndr, "entries_read", r->out.entries_read);
7395                 ndr->depth++;
7396                 ndr_print_uint32(ndr, "entries_read", *r->out.entries_read);
7397                 ndr->depth--;
7398                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
7399                 ndr->depth++;
7400                 if (r->out.resume_handle) {
7401                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
7402                 }
7403                 ndr->depth--;
7404                 ndr_print_WERROR(ndr, "result", r->out.result);
7405                 ndr->depth--;
7406         }
7407         ndr->depth--;
7408 }
7409
7410 static enum ndr_err_code ndr_push_wkssvc_NetrMessageBufferSend(struct ndr_push *ndr, int flags, const struct wkssvc_NetrMessageBufferSend *r)
7411 {
7412         if (flags & NDR_IN) {
7413                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
7414                 if (r->in.server_name) {
7415                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7416                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7417                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7418                         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));
7419                 }
7420                 if (r->in.message_name == NULL) {
7421                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7422                 }
7423                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.message_name, CH_UTF16)));
7424                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7425                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.message_name, CH_UTF16)));
7426                 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));
7427                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.message_sender_name));
7428                 if (r->in.message_sender_name) {
7429                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.message_sender_name, CH_UTF16)));
7430                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7431                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.message_sender_name, CH_UTF16)));
7432                         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));
7433                 }
7434                 if (r->in.message_buffer == NULL) {
7435                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7436                 }
7437                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.message_size));
7438                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.message_buffer, r->in.message_size));
7439                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.message_size));
7440         }
7441         if (flags & NDR_OUT) {
7442                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7443         }
7444         return NDR_ERR_SUCCESS;
7445 }
7446
7447 static enum ndr_err_code ndr_pull_wkssvc_NetrMessageBufferSend(struct ndr_pull *ndr, int flags, struct wkssvc_NetrMessageBufferSend *r)
7448 {
7449         uint32_t _ptr_server_name;
7450         uint32_t _ptr_message_sender_name;
7451         TALLOC_CTX *_mem_save_server_name_0;
7452         TALLOC_CTX *_mem_save_message_sender_name_0;
7453         if (flags & NDR_IN) {
7454                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
7455                 if (_ptr_server_name) {
7456                         NDR_PULL_ALLOC(ndr, r->in.server_name);
7457                 } else {
7458                         r->in.server_name = NULL;
7459                 }
7460                 if (r->in.server_name) {
7461                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7462                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
7463                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
7464                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
7465                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
7466                                 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));
7467                         }
7468                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
7469                         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));
7470                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
7471                 }
7472                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.message_name));
7473                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.message_name));
7474                 if (ndr_get_array_length(ndr, &r->in.message_name) > ndr_get_array_size(ndr, &r->in.message_name)) {
7475                         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));
7476                 }
7477                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.message_name), sizeof(uint16_t)));
7478                 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));
7479                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_message_sender_name));
7480                 if (_ptr_message_sender_name) {
7481                         NDR_PULL_ALLOC(ndr, r->in.message_sender_name);
7482                 } else {
7483                         r->in.message_sender_name = NULL;
7484                 }
7485                 if (r->in.message_sender_name) {
7486                         _mem_save_message_sender_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7487                         NDR_PULL_SET_MEM_CTX(ndr, r->in.message_sender_name, 0);
7488                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.message_sender_name));
7489                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.message_sender_name));
7490                         if (ndr_get_array_length(ndr, &r->in.message_sender_name) > ndr_get_array_size(ndr, &r->in.message_sender_name)) {
7491                                 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));
7492                         }
7493                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.message_sender_name), sizeof(uint16_t)));
7494                         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));
7495                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_message_sender_name_0, 0);
7496                 }
7497                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.message_buffer));
7498                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7499                         NDR_PULL_ALLOC_N(ndr, r->in.message_buffer, ndr_get_array_size(ndr, &r->in.message_buffer));
7500                 }
7501                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.message_buffer, ndr_get_array_size(ndr, &r->in.message_buffer)));
7502                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.message_size));
7503                 if (r->in.message_buffer) {
7504                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.message_buffer, r->in.message_size));
7505                 }
7506         }
7507         if (flags & NDR_OUT) {
7508                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7509         }
7510         return NDR_ERR_SUCCESS;
7511 }
7512
7513 _PUBLIC_ void ndr_print_wkssvc_NetrMessageBufferSend(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrMessageBufferSend *r)
7514 {
7515         ndr_print_struct(ndr, name, "wkssvc_NetrMessageBufferSend");
7516         ndr->depth++;
7517         if (flags & NDR_SET_VALUES) {
7518                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7519         }
7520         if (flags & NDR_IN) {
7521                 ndr_print_struct(ndr, "in", "wkssvc_NetrMessageBufferSend");
7522                 ndr->depth++;
7523                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
7524                 ndr->depth++;
7525                 if (r->in.server_name) {
7526                         ndr_print_string(ndr, "server_name", r->in.server_name);
7527                 }
7528                 ndr->depth--;
7529                 ndr_print_ptr(ndr, "message_name", r->in.message_name);
7530                 ndr->depth++;
7531                 ndr_print_string(ndr, "message_name", r->in.message_name);
7532                 ndr->depth--;
7533                 ndr_print_ptr(ndr, "message_sender_name", r->in.message_sender_name);
7534                 ndr->depth++;
7535                 if (r->in.message_sender_name) {
7536                         ndr_print_string(ndr, "message_sender_name", r->in.message_sender_name);
7537                 }
7538                 ndr->depth--;
7539                 ndr_print_ptr(ndr, "message_buffer", r->in.message_buffer);
7540                 ndr->depth++;
7541                 ndr_print_array_uint8(ndr, "message_buffer", r->in.message_buffer, r->in.message_size);
7542                 ndr->depth--;
7543                 ndr_print_uint32(ndr, "message_size", r->in.message_size);
7544                 ndr->depth--;
7545         }
7546         if (flags & NDR_OUT) {
7547                 ndr_print_struct(ndr, "out", "wkssvc_NetrMessageBufferSend");
7548                 ndr->depth++;
7549                 ndr_print_WERROR(ndr, "result", r->out.result);
7550                 ndr->depth--;
7551         }
7552         ndr->depth--;
7553 }
7554
7555 static enum ndr_err_code ndr_push_wkssvc_NetrWorkstationStatisticsGet(struct ndr_push *ndr, int flags, const struct wkssvc_NetrWorkstationStatisticsGet *r)
7556 {
7557         if (flags & NDR_IN) {
7558                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
7559                 if (r->in.server_name) {
7560                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7561                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7562                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7563                         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));
7564                 }
7565                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown2));
7566                 if (r->in.unknown2) {
7567                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown2, CH_UTF16)));
7568                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7569                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown2, CH_UTF16)));
7570                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.unknown2, ndr_charset_length(r->in.unknown2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7571                 }
7572                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown3));
7573                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown4));
7574         }
7575         if (flags & NDR_OUT) {
7576                 if (r->out.info == NULL) {
7577                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7578                 }
7579                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
7580                 if (*r->out.info) {
7581                         NDR_CHECK(ndr_push_wkssvc_NetrWorkstationStatistics(ndr, NDR_SCALARS, *r->out.info));
7582                 }
7583                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7584         }
7585         return NDR_ERR_SUCCESS;
7586 }
7587
7588 static enum ndr_err_code ndr_pull_wkssvc_NetrWorkstationStatisticsGet(struct ndr_pull *ndr, int flags, struct wkssvc_NetrWorkstationStatisticsGet *r)
7589 {
7590         uint32_t _ptr_server_name;
7591         uint32_t _ptr_unknown2;
7592         uint32_t _ptr_info;
7593         TALLOC_CTX *_mem_save_server_name_0;
7594         TALLOC_CTX *_mem_save_unknown2_0;
7595         TALLOC_CTX *_mem_save_info_0;
7596         TALLOC_CTX *_mem_save_info_1;
7597         if (flags & NDR_IN) {
7598                 ZERO_STRUCT(r->out);
7599
7600                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
7601                 if (_ptr_server_name) {
7602                         NDR_PULL_ALLOC(ndr, r->in.server_name);
7603                 } else {
7604                         r->in.server_name = NULL;
7605                 }
7606                 if (r->in.server_name) {
7607                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7608                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
7609                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
7610                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
7611                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
7612                                 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));
7613                         }
7614                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
7615                         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));
7616                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
7617                 }
7618                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown2));
7619                 if (_ptr_unknown2) {
7620                         NDR_PULL_ALLOC(ndr, r->in.unknown2);
7621                 } else {
7622                         r->in.unknown2 = NULL;
7623                 }
7624                 if (r->in.unknown2) {
7625                         _mem_save_unknown2_0 = NDR_PULL_GET_MEM_CTX(ndr);
7626                         NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown2, 0);
7627                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.unknown2));
7628                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.unknown2));
7629                         if (ndr_get_array_length(ndr, &r->in.unknown2) > ndr_get_array_size(ndr, &r->in.unknown2)) {
7630                                 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));
7631                         }
7632                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.unknown2), sizeof(uint16_t)));
7633                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.unknown2, ndr_get_array_length(ndr, &r->in.unknown2), sizeof(uint16_t), CH_UTF16));
7634                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown2_0, 0);
7635                 }
7636                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown3));
7637                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown4));
7638                 NDR_PULL_ALLOC(ndr, r->out.info);
7639                 ZERO_STRUCTP(r->out.info);
7640         }
7641         if (flags & NDR_OUT) {
7642                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7643                         NDR_PULL_ALLOC(ndr, r->out.info);
7644                 }
7645                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
7646                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
7647                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
7648                 if (_ptr_info) {
7649                         NDR_PULL_ALLOC(ndr, *r->out.info);
7650                 } else {
7651                         *r->out.info = NULL;
7652                 }
7653                 if (*r->out.info) {
7654                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
7655                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
7656                         NDR_CHECK(ndr_pull_wkssvc_NetrWorkstationStatistics(ndr, NDR_SCALARS, *r->out.info));
7657                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
7658                 }
7659                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
7660                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7661         }
7662         return NDR_ERR_SUCCESS;
7663 }
7664
7665 _PUBLIC_ void ndr_print_wkssvc_NetrWorkstationStatisticsGet(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrWorkstationStatisticsGet *r)
7666 {
7667         ndr_print_struct(ndr, name, "wkssvc_NetrWorkstationStatisticsGet");
7668         ndr->depth++;
7669         if (flags & NDR_SET_VALUES) {
7670                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7671         }
7672         if (flags & NDR_IN) {
7673                 ndr_print_struct(ndr, "in", "wkssvc_NetrWorkstationStatisticsGet");
7674                 ndr->depth++;
7675                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
7676                 ndr->depth++;
7677                 if (r->in.server_name) {
7678                         ndr_print_string(ndr, "server_name", r->in.server_name);
7679                 }
7680                 ndr->depth--;
7681                 ndr_print_ptr(ndr, "unknown2", r->in.unknown2);
7682                 ndr->depth++;
7683                 if (r->in.unknown2) {
7684                         ndr_print_string(ndr, "unknown2", r->in.unknown2);
7685                 }
7686                 ndr->depth--;
7687                 ndr_print_uint32(ndr, "unknown3", r->in.unknown3);
7688                 ndr_print_uint32(ndr, "unknown4", r->in.unknown4);
7689                 ndr->depth--;
7690         }
7691         if (flags & NDR_OUT) {
7692                 ndr_print_struct(ndr, "out", "wkssvc_NetrWorkstationStatisticsGet");
7693                 ndr->depth++;
7694                 ndr_print_ptr(ndr, "info", r->out.info);
7695                 ndr->depth++;
7696                 ndr_print_ptr(ndr, "info", *r->out.info);
7697                 ndr->depth++;
7698                 if (*r->out.info) {
7699                         ndr_print_wkssvc_NetrWorkstationStatistics(ndr, "info", *r->out.info);
7700                 }
7701                 ndr->depth--;
7702                 ndr->depth--;
7703                 ndr_print_WERROR(ndr, "result", r->out.result);
7704                 ndr->depth--;
7705         }
7706         ndr->depth--;
7707 }
7708
7709 static enum ndr_err_code ndr_push_wkssvc_NetrLogonDomainNameAdd(struct ndr_push *ndr, int flags, const struct wkssvc_NetrLogonDomainNameAdd *r)
7710 {
7711         if (flags & NDR_IN) {
7712                 if (r->in.domain_name == NULL) {
7713                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7714                 }
7715                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
7716                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7717                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
7718                 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));
7719         }
7720         if (flags & NDR_OUT) {
7721                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7722         }
7723         return NDR_ERR_SUCCESS;
7724 }
7725
7726 static enum ndr_err_code ndr_pull_wkssvc_NetrLogonDomainNameAdd(struct ndr_pull *ndr, int flags, struct wkssvc_NetrLogonDomainNameAdd *r)
7727 {
7728         if (flags & NDR_IN) {
7729                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
7730                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
7731                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
7732                         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));
7733                 }
7734                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
7735                 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));
7736         }
7737         if (flags & NDR_OUT) {
7738                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7739         }
7740         return NDR_ERR_SUCCESS;
7741 }
7742
7743 _PUBLIC_ void ndr_print_wkssvc_NetrLogonDomainNameAdd(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrLogonDomainNameAdd *r)
7744 {
7745         ndr_print_struct(ndr, name, "wkssvc_NetrLogonDomainNameAdd");
7746         ndr->depth++;
7747         if (flags & NDR_SET_VALUES) {
7748                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7749         }
7750         if (flags & NDR_IN) {
7751                 ndr_print_struct(ndr, "in", "wkssvc_NetrLogonDomainNameAdd");
7752                 ndr->depth++;
7753                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
7754                 ndr->depth++;
7755                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
7756                 ndr->depth--;
7757                 ndr->depth--;
7758         }
7759         if (flags & NDR_OUT) {
7760                 ndr_print_struct(ndr, "out", "wkssvc_NetrLogonDomainNameAdd");
7761                 ndr->depth++;
7762                 ndr_print_WERROR(ndr, "result", r->out.result);
7763                 ndr->depth--;
7764         }
7765         ndr->depth--;
7766 }
7767
7768 static enum ndr_err_code ndr_push_wkssvc_NetrLogonDomainNameDel(struct ndr_push *ndr, int flags, const struct wkssvc_NetrLogonDomainNameDel *r)
7769 {
7770         if (flags & NDR_IN) {
7771                 if (r->in.domain_name == NULL) {
7772                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7773                 }
7774                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
7775                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7776                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
7777                 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));
7778         }
7779         if (flags & NDR_OUT) {
7780                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7781         }
7782         return NDR_ERR_SUCCESS;
7783 }
7784
7785 static enum ndr_err_code ndr_pull_wkssvc_NetrLogonDomainNameDel(struct ndr_pull *ndr, int flags, struct wkssvc_NetrLogonDomainNameDel *r)
7786 {
7787         if (flags & NDR_IN) {
7788                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
7789                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
7790                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
7791                         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));
7792                 }
7793                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
7794                 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));
7795         }
7796         if (flags & NDR_OUT) {
7797                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7798         }
7799         return NDR_ERR_SUCCESS;
7800 }
7801
7802 _PUBLIC_ void ndr_print_wkssvc_NetrLogonDomainNameDel(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrLogonDomainNameDel *r)
7803 {
7804         ndr_print_struct(ndr, name, "wkssvc_NetrLogonDomainNameDel");
7805         ndr->depth++;
7806         if (flags & NDR_SET_VALUES) {
7807                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7808         }
7809         if (flags & NDR_IN) {
7810                 ndr_print_struct(ndr, "in", "wkssvc_NetrLogonDomainNameDel");
7811                 ndr->depth++;
7812                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
7813                 ndr->depth++;
7814                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
7815                 ndr->depth--;
7816                 ndr->depth--;
7817         }
7818         if (flags & NDR_OUT) {
7819                 ndr_print_struct(ndr, "out", "wkssvc_NetrLogonDomainNameDel");
7820                 ndr->depth++;
7821                 ndr_print_WERROR(ndr, "result", r->out.result);
7822                 ndr->depth--;
7823         }
7824         ndr->depth--;
7825 }
7826
7827 static enum ndr_err_code ndr_push_wkssvc_NetrJoinDomain(struct ndr_push *ndr, int flags, const struct wkssvc_NetrJoinDomain *r)
7828 {
7829         if (flags & NDR_IN) {
7830                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
7831                 if (r->in.server_name) {
7832                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7833                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7834                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7835                         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));
7836                 }
7837                 if (r->in.domain_name == NULL) {
7838                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7839                 }
7840                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
7841                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7842                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
7843                 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));
7844                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.account_ou));
7845                 if (r->in.account_ou) {
7846                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.account_ou, CH_UTF16)));
7847                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7848                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.account_ou, CH_UTF16)));
7849                         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));
7850                 }
7851                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
7852                 if (r->in.Account) {
7853                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
7854                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7855                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
7856                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7857                 }
7858                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
7859                 if (r->in.password) {
7860                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
7861                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7862                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
7863                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7864                 }
7865                 NDR_CHECK(ndr_push_wkssvc_joinflags(ndr, NDR_SCALARS, r->in.join_flags));
7866         }
7867         if (flags & NDR_OUT) {
7868                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7869         }
7870         return NDR_ERR_SUCCESS;
7871 }
7872
7873 static enum ndr_err_code ndr_pull_wkssvc_NetrJoinDomain(struct ndr_pull *ndr, int flags, struct wkssvc_NetrJoinDomain *r)
7874 {
7875         uint32_t _ptr_server_name;
7876         uint32_t _ptr_account_ou;
7877         uint32_t _ptr_Account;
7878         uint32_t _ptr_password;
7879         TALLOC_CTX *_mem_save_server_name_0;
7880         TALLOC_CTX *_mem_save_account_ou_0;
7881         TALLOC_CTX *_mem_save_Account_0;
7882         TALLOC_CTX *_mem_save_password_0;
7883         if (flags & NDR_IN) {
7884                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
7885                 if (_ptr_server_name) {
7886                         NDR_PULL_ALLOC(ndr, r->in.server_name);
7887                 } else {
7888                         r->in.server_name = NULL;
7889                 }
7890                 if (r->in.server_name) {
7891                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7892                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
7893                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
7894                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
7895                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
7896                                 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));
7897                         }
7898                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
7899                         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));
7900                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
7901                 }
7902                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
7903                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
7904                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
7905                         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));
7906                 }
7907                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
7908                 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));
7909                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account_ou));
7910                 if (_ptr_account_ou) {
7911                         NDR_PULL_ALLOC(ndr, r->in.account_ou);
7912                 } else {
7913                         r->in.account_ou = NULL;
7914                 }
7915                 if (r->in.account_ou) {
7916                         _mem_save_account_ou_0 = NDR_PULL_GET_MEM_CTX(ndr);
7917                         NDR_PULL_SET_MEM_CTX(ndr, r->in.account_ou, 0);
7918                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.account_ou));
7919                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.account_ou));
7920                         if (ndr_get_array_length(ndr, &r->in.account_ou) > ndr_get_array_size(ndr, &r->in.account_ou)) {
7921                                 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));
7922                         }
7923                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.account_ou), sizeof(uint16_t)));
7924                         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));
7925                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_ou_0, 0);
7926                 }
7927                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
7928                 if (_ptr_Account) {
7929                         NDR_PULL_ALLOC(ndr, r->in.Account);
7930                 } else {
7931                         r->in.Account = NULL;
7932                 }
7933                 if (r->in.Account) {
7934                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
7935                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
7936                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
7937                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
7938                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
7939                                 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));
7940                         }
7941                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
7942                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
7943                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
7944                 }
7945                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
7946                 if (_ptr_password) {
7947                         NDR_PULL_ALLOC(ndr, r->in.password);
7948                 } else {
7949                         r->in.password = NULL;
7950                 }
7951                 if (r->in.password) {
7952                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
7953                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
7954                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.password));
7955                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.password));
7956                         if (ndr_get_array_length(ndr, &r->in.password) > ndr_get_array_size(ndr, &r->in.password)) {
7957                                 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));
7958                         }
7959                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t)));
7960                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.password, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t), CH_UTF16));
7961                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
7962                 }
7963                 NDR_CHECK(ndr_pull_wkssvc_joinflags(ndr, NDR_SCALARS, &r->in.join_flags));
7964         }
7965         if (flags & NDR_OUT) {
7966                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7967         }
7968         return NDR_ERR_SUCCESS;
7969 }
7970
7971 _PUBLIC_ void ndr_print_wkssvc_NetrJoinDomain(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrJoinDomain *r)
7972 {
7973         ndr_print_struct(ndr, name, "wkssvc_NetrJoinDomain");
7974         ndr->depth++;
7975         if (flags & NDR_SET_VALUES) {
7976                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7977         }
7978         if (flags & NDR_IN) {
7979                 ndr_print_struct(ndr, "in", "wkssvc_NetrJoinDomain");
7980                 ndr->depth++;
7981                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
7982                 ndr->depth++;
7983                 if (r->in.server_name) {
7984                         ndr_print_string(ndr, "server_name", r->in.server_name);
7985                 }
7986                 ndr->depth--;
7987                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
7988                 ndr->depth++;
7989                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
7990                 ndr->depth--;
7991                 ndr_print_ptr(ndr, "account_ou", r->in.account_ou);
7992                 ndr->depth++;
7993                 if (r->in.account_ou) {
7994                         ndr_print_string(ndr, "account_ou", r->in.account_ou);
7995                 }
7996                 ndr->depth--;
7997                 ndr_print_ptr(ndr, "Account", r->in.Account);
7998                 ndr->depth++;
7999                 if (r->in.Account) {
8000                         ndr_print_string(ndr, "Account", r->in.Account);
8001                 }
8002                 ndr->depth--;
8003                 ndr_print_ptr(ndr, "password", r->in.password);
8004                 ndr->depth++;
8005                 if (r->in.password) {
8006                         ndr_print_string(ndr, "password", r->in.password);
8007                 }
8008                 ndr->depth--;
8009                 ndr_print_wkssvc_joinflags(ndr, "join_flags", r->in.join_flags);
8010                 ndr->depth--;
8011         }
8012         if (flags & NDR_OUT) {
8013                 ndr_print_struct(ndr, "out", "wkssvc_NetrJoinDomain");
8014                 ndr->depth++;
8015                 ndr_print_WERROR(ndr, "result", r->out.result);
8016                 ndr->depth--;
8017         }
8018         ndr->depth--;
8019 }
8020
8021 static enum ndr_err_code ndr_push_wkssvc_NetrUnjoinDomain(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUnjoinDomain *r)
8022 {
8023         if (flags & NDR_IN) {
8024                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
8025                 if (r->in.server_name) {
8026                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8027                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8028                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8029                         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));
8030                 }
8031                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
8032                 if (r->in.Account) {
8033                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
8034                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8035                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
8036                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8037                 }
8038                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
8039                 if (r->in.password) {
8040                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
8041                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8042                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
8043                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8044                 }
8045                 NDR_CHECK(ndr_push_wkssvc_joinflags(ndr, NDR_SCALARS, r->in.unjoin_flags));
8046         }
8047         if (flags & NDR_OUT) {
8048                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
8049         }
8050         return NDR_ERR_SUCCESS;
8051 }
8052
8053 static enum ndr_err_code ndr_pull_wkssvc_NetrUnjoinDomain(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUnjoinDomain *r)
8054 {
8055         uint32_t _ptr_server_name;
8056         uint32_t _ptr_Account;
8057         uint32_t _ptr_password;
8058         TALLOC_CTX *_mem_save_server_name_0;
8059         TALLOC_CTX *_mem_save_Account_0;
8060         TALLOC_CTX *_mem_save_password_0;
8061         if (flags & NDR_IN) {
8062                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
8063                 if (_ptr_server_name) {
8064                         NDR_PULL_ALLOC(ndr, r->in.server_name);
8065                 } else {
8066                         r->in.server_name = NULL;
8067                 }
8068                 if (r->in.server_name) {
8069                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8070                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
8071                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
8072                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
8073                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
8074                                 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));
8075                         }
8076                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
8077                         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));
8078                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
8079                 }
8080                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
8081                 if (_ptr_Account) {
8082                         NDR_PULL_ALLOC(ndr, r->in.Account);
8083                 } else {
8084                         r->in.Account = NULL;
8085                 }
8086                 if (r->in.Account) {
8087                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
8088                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
8089                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
8090                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
8091                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
8092                                 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));
8093                         }
8094                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
8095                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
8096                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
8097                 }
8098                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
8099                 if (_ptr_password) {
8100                         NDR_PULL_ALLOC(ndr, r->in.password);
8101                 } else {
8102                         r->in.password = NULL;
8103                 }
8104                 if (r->in.password) {
8105                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
8106                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
8107                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.password));
8108                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.password));
8109                         if (ndr_get_array_length(ndr, &r->in.password) > ndr_get_array_size(ndr, &r->in.password)) {
8110                                 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));
8111                         }
8112                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t)));
8113                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.password, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t), CH_UTF16));
8114                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
8115                 }
8116                 NDR_CHECK(ndr_pull_wkssvc_joinflags(ndr, NDR_SCALARS, &r->in.unjoin_flags));
8117         }
8118         if (flags & NDR_OUT) {
8119                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
8120         }
8121         return NDR_ERR_SUCCESS;
8122 }
8123
8124 _PUBLIC_ void ndr_print_wkssvc_NetrUnjoinDomain(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUnjoinDomain *r)
8125 {
8126         ndr_print_struct(ndr, name, "wkssvc_NetrUnjoinDomain");
8127         ndr->depth++;
8128         if (flags & NDR_SET_VALUES) {
8129                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8130         }
8131         if (flags & NDR_IN) {
8132                 ndr_print_struct(ndr, "in", "wkssvc_NetrUnjoinDomain");
8133                 ndr->depth++;
8134                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
8135                 ndr->depth++;
8136                 if (r->in.server_name) {
8137                         ndr_print_string(ndr, "server_name", r->in.server_name);
8138                 }
8139                 ndr->depth--;
8140                 ndr_print_ptr(ndr, "Account", r->in.Account);
8141                 ndr->depth++;
8142                 if (r->in.Account) {
8143                         ndr_print_string(ndr, "Account", r->in.Account);
8144                 }
8145                 ndr->depth--;
8146                 ndr_print_ptr(ndr, "password", r->in.password);
8147                 ndr->depth++;
8148                 if (r->in.password) {
8149                         ndr_print_string(ndr, "password", r->in.password);
8150                 }
8151                 ndr->depth--;
8152                 ndr_print_wkssvc_joinflags(ndr, "unjoin_flags", r->in.unjoin_flags);
8153                 ndr->depth--;
8154         }
8155         if (flags & NDR_OUT) {
8156                 ndr_print_struct(ndr, "out", "wkssvc_NetrUnjoinDomain");
8157                 ndr->depth++;
8158                 ndr_print_WERROR(ndr, "result", r->out.result);
8159                 ndr->depth--;
8160         }
8161         ndr->depth--;
8162 }
8163
8164 static enum ndr_err_code ndr_push_wkssvc_NetrRenameMachineInDomain(struct ndr_push *ndr, int flags, const struct wkssvc_NetrRenameMachineInDomain *r)
8165 {
8166         if (flags & NDR_IN) {
8167                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
8168                 if (r->in.server_name) {
8169                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8170                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8171                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8172                         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));
8173                 }
8174                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.NewMachineName));
8175                 if (r->in.NewMachineName) {
8176                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewMachineName, CH_UTF16)));
8177                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8178                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewMachineName, CH_UTF16)));
8179                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.NewMachineName, ndr_charset_length(r->in.NewMachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8180                 }
8181                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
8182                 if (r->in.Account) {
8183                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
8184                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8185                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
8186                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8187                 }
8188                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
8189                 if (r->in.password) {
8190                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
8191                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8192                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
8193                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8194                 }
8195                 NDR_CHECK(ndr_push_wkssvc_renameflags(ndr, NDR_SCALARS, r->in.RenameOptions));
8196         }
8197         if (flags & NDR_OUT) {
8198                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
8199         }
8200         return NDR_ERR_SUCCESS;
8201 }
8202
8203 static enum ndr_err_code ndr_pull_wkssvc_NetrRenameMachineInDomain(struct ndr_pull *ndr, int flags, struct wkssvc_NetrRenameMachineInDomain *r)
8204 {
8205         uint32_t _ptr_server_name;
8206         uint32_t _ptr_NewMachineName;
8207         uint32_t _ptr_Account;
8208         uint32_t _ptr_password;
8209         TALLOC_CTX *_mem_save_server_name_0;
8210         TALLOC_CTX *_mem_save_NewMachineName_0;
8211         TALLOC_CTX *_mem_save_Account_0;
8212         TALLOC_CTX *_mem_save_password_0;
8213         if (flags & NDR_IN) {
8214                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
8215                 if (_ptr_server_name) {
8216                         NDR_PULL_ALLOC(ndr, r->in.server_name);
8217                 } else {
8218                         r->in.server_name = NULL;
8219                 }
8220                 if (r->in.server_name) {
8221                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8222                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
8223                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
8224                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
8225                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
8226                                 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));
8227                         }
8228                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
8229                         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));
8230                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
8231                 }
8232                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_NewMachineName));
8233                 if (_ptr_NewMachineName) {
8234                         NDR_PULL_ALLOC(ndr, r->in.NewMachineName);
8235                 } else {
8236                         r->in.NewMachineName = NULL;
8237                 }
8238                 if (r->in.NewMachineName) {
8239                         _mem_save_NewMachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);
8240                         NDR_PULL_SET_MEM_CTX(ndr, r->in.NewMachineName, 0);
8241                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.NewMachineName));
8242                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.NewMachineName));
8243                         if (ndr_get_array_length(ndr, &r->in.NewMachineName) > ndr_get_array_size(ndr, &r->in.NewMachineName)) {
8244                                 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));
8245                         }
8246                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.NewMachineName), sizeof(uint16_t)));
8247                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.NewMachineName, ndr_get_array_length(ndr, &r->in.NewMachineName), sizeof(uint16_t), CH_UTF16));
8248                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_NewMachineName_0, 0);
8249                 }
8250                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
8251                 if (_ptr_Account) {
8252                         NDR_PULL_ALLOC(ndr, r->in.Account);
8253                 } else {
8254                         r->in.Account = NULL;
8255                 }
8256                 if (r->in.Account) {
8257                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
8258                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
8259                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
8260                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
8261                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
8262                                 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));
8263                         }
8264                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
8265                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
8266                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
8267                 }
8268                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
8269                 if (_ptr_password) {
8270                         NDR_PULL_ALLOC(ndr, r->in.password);
8271                 } else {
8272                         r->in.password = NULL;
8273                 }
8274                 if (r->in.password) {
8275                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
8276                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
8277                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.password));
8278                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.password));
8279                         if (ndr_get_array_length(ndr, &r->in.password) > ndr_get_array_size(ndr, &r->in.password)) {
8280                                 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));
8281                         }
8282                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t)));
8283                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.password, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t), CH_UTF16));
8284                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
8285                 }
8286                 NDR_CHECK(ndr_pull_wkssvc_renameflags(ndr, NDR_SCALARS, &r->in.RenameOptions));
8287         }
8288         if (flags & NDR_OUT) {
8289                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
8290         }
8291         return NDR_ERR_SUCCESS;
8292 }
8293
8294 _PUBLIC_ void ndr_print_wkssvc_NetrRenameMachineInDomain(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrRenameMachineInDomain *r)
8295 {
8296         ndr_print_struct(ndr, name, "wkssvc_NetrRenameMachineInDomain");
8297         ndr->depth++;
8298         if (flags & NDR_SET_VALUES) {
8299                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8300         }
8301         if (flags & NDR_IN) {
8302                 ndr_print_struct(ndr, "in", "wkssvc_NetrRenameMachineInDomain");
8303                 ndr->depth++;
8304                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
8305                 ndr->depth++;
8306                 if (r->in.server_name) {
8307                         ndr_print_string(ndr, "server_name", r->in.server_name);
8308                 }
8309                 ndr->depth--;
8310                 ndr_print_ptr(ndr, "NewMachineName", r->in.NewMachineName);
8311                 ndr->depth++;
8312                 if (r->in.NewMachineName) {
8313                         ndr_print_string(ndr, "NewMachineName", r->in.NewMachineName);
8314                 }
8315                 ndr->depth--;
8316                 ndr_print_ptr(ndr, "Account", r->in.Account);
8317                 ndr->depth++;
8318                 if (r->in.Account) {
8319                         ndr_print_string(ndr, "Account", r->in.Account);
8320                 }
8321                 ndr->depth--;
8322                 ndr_print_ptr(ndr, "password", r->in.password);
8323                 ndr->depth++;
8324                 if (r->in.password) {
8325                         ndr_print_string(ndr, "password", r->in.password);
8326                 }
8327                 ndr->depth--;
8328                 ndr_print_wkssvc_renameflags(ndr, "RenameOptions", r->in.RenameOptions);
8329                 ndr->depth--;
8330         }
8331         if (flags & NDR_OUT) {
8332                 ndr_print_struct(ndr, "out", "wkssvc_NetrRenameMachineInDomain");
8333                 ndr->depth++;
8334                 ndr_print_WERROR(ndr, "result", r->out.result);
8335                 ndr->depth--;
8336         }
8337         ndr->depth--;
8338 }
8339
8340 static enum ndr_err_code ndr_push_wkssvc_NetrValidateName(struct ndr_push *ndr, int flags, const struct wkssvc_NetrValidateName *r)
8341 {
8342         if (flags & NDR_IN) {
8343                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
8344                 if (r->in.server_name) {
8345                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8346                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8347                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8348                         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));
8349                 }
8350                 if (r->in.name == NULL) {
8351                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8352                 }
8353                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF16)));
8354                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8355                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF16)));
8356                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.name, ndr_charset_length(r->in.name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8357                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
8358                 if (r->in.Account) {
8359                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
8360                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8361                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
8362                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8363                 }
8364                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Password));
8365                 if (r->in.Password) {
8366                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Password, CH_UTF16)));
8367                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8368                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Password, CH_UTF16)));
8369                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Password, ndr_charset_length(r->in.Password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8370                 }
8371                 NDR_CHECK(ndr_push_wkssvc_NetValidateNameType(ndr, NDR_SCALARS, r->in.name_type));
8372         }
8373         if (flags & NDR_OUT) {
8374                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
8375         }
8376         return NDR_ERR_SUCCESS;
8377 }
8378
8379 static enum ndr_err_code ndr_pull_wkssvc_NetrValidateName(struct ndr_pull *ndr, int flags, struct wkssvc_NetrValidateName *r)
8380 {
8381         uint32_t _ptr_server_name;
8382         uint32_t _ptr_Account;
8383         uint32_t _ptr_Password;
8384         TALLOC_CTX *_mem_save_server_name_0;
8385         TALLOC_CTX *_mem_save_Account_0;
8386         TALLOC_CTX *_mem_save_Password_0;
8387         if (flags & NDR_IN) {
8388                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
8389                 if (_ptr_server_name) {
8390                         NDR_PULL_ALLOC(ndr, r->in.server_name);
8391                 } else {
8392                         r->in.server_name = NULL;
8393                 }
8394                 if (r->in.server_name) {
8395                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8396                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
8397                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
8398                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
8399                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
8400                                 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));
8401                         }
8402                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
8403                         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));
8404                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
8405                 }
8406                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.name));
8407                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.name));
8408                 if (ndr_get_array_length(ndr, &r->in.name) > ndr_get_array_size(ndr, &r->in.name)) {
8409                         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));
8410                 }
8411                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.name), sizeof(uint16_t)));
8412                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.name, ndr_get_array_length(ndr, &r->in.name), sizeof(uint16_t), CH_UTF16));
8413                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
8414                 if (_ptr_Account) {
8415                         NDR_PULL_ALLOC(ndr, r->in.Account);
8416                 } else {
8417                         r->in.Account = NULL;
8418                 }
8419                 if (r->in.Account) {
8420                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
8421                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
8422                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
8423                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
8424                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
8425                                 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));
8426                         }
8427                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
8428                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
8429                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
8430                 }
8431                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Password));
8432                 if (_ptr_Password) {
8433                         NDR_PULL_ALLOC(ndr, r->in.Password);
8434                 } else {
8435                         r->in.Password = NULL;
8436                 }
8437                 if (r->in.Password) {
8438                         _mem_save_Password_0 = NDR_PULL_GET_MEM_CTX(ndr);
8439                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Password, 0);
8440                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Password));
8441                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Password));
8442                         if (ndr_get_array_length(ndr, &r->in.Password) > ndr_get_array_size(ndr, &r->in.Password)) {
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.Password), ndr_get_array_length(ndr, &r->in.Password));
8444                         }
8445                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Password), sizeof(uint16_t)));
8446                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Password, ndr_get_array_length(ndr, &r->in.Password), sizeof(uint16_t), CH_UTF16));
8447                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Password_0, 0);
8448                 }
8449                 NDR_CHECK(ndr_pull_wkssvc_NetValidateNameType(ndr, NDR_SCALARS, &r->in.name_type));
8450         }
8451         if (flags & NDR_OUT) {
8452                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
8453         }
8454         return NDR_ERR_SUCCESS;
8455 }
8456
8457 _PUBLIC_ void ndr_print_wkssvc_NetrValidateName(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrValidateName *r)
8458 {
8459         ndr_print_struct(ndr, name, "wkssvc_NetrValidateName");
8460         ndr->depth++;
8461         if (flags & NDR_SET_VALUES) {
8462                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8463         }
8464         if (flags & NDR_IN) {
8465                 ndr_print_struct(ndr, "in", "wkssvc_NetrValidateName");
8466                 ndr->depth++;
8467                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
8468                 ndr->depth++;
8469                 if (r->in.server_name) {
8470                         ndr_print_string(ndr, "server_name", r->in.server_name);
8471                 }
8472                 ndr->depth--;
8473                 ndr_print_ptr(ndr, "name", r->in.name);
8474                 ndr->depth++;
8475                 ndr_print_string(ndr, "name", r->in.name);
8476                 ndr->depth--;
8477                 ndr_print_ptr(ndr, "Account", r->in.Account);
8478                 ndr->depth++;
8479                 if (r->in.Account) {
8480                         ndr_print_string(ndr, "Account", r->in.Account);
8481                 }
8482                 ndr->depth--;
8483                 ndr_print_ptr(ndr, "Password", r->in.Password);
8484                 ndr->depth++;
8485                 if (r->in.Password) {
8486                         ndr_print_string(ndr, "Password", r->in.Password);
8487                 }
8488                 ndr->depth--;
8489                 ndr_print_wkssvc_NetValidateNameType(ndr, "name_type", r->in.name_type);
8490                 ndr->depth--;
8491         }
8492         if (flags & NDR_OUT) {
8493                 ndr_print_struct(ndr, "out", "wkssvc_NetrValidateName");
8494                 ndr->depth++;
8495                 ndr_print_WERROR(ndr, "result", r->out.result);
8496                 ndr->depth--;
8497         }
8498         ndr->depth--;
8499 }
8500
8501 static enum ndr_err_code ndr_push_wkssvc_NetrGetJoinInformation(struct ndr_push *ndr, int flags, const struct wkssvc_NetrGetJoinInformation *r)
8502 {
8503         if (flags & NDR_IN) {
8504                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
8505                 if (r->in.server_name) {
8506                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8507                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8508                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8509                         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));
8510                 }
8511                 if (r->in.name_buffer == NULL) {
8512                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8513                 }
8514                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->in.name_buffer));
8515                 if (*r->in.name_buffer) {
8516                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->in.name_buffer, CH_UTF16)));
8517                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8518                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->in.name_buffer, CH_UTF16)));
8519                         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));
8520                 }
8521         }
8522         if (flags & NDR_OUT) {
8523                 if (r->out.name_buffer == NULL) {
8524                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8525                 }
8526                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.name_buffer));
8527                 if (*r->out.name_buffer) {
8528                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.name_buffer, CH_UTF16)));
8529                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8530                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.name_buffer, CH_UTF16)));
8531                         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));
8532                 }
8533                 if (r->out.name_type == NULL) {
8534                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8535                 }
8536                 NDR_CHECK(ndr_push_wkssvc_NetJoinStatus(ndr, NDR_SCALARS, *r->out.name_type));
8537                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
8538         }
8539         return NDR_ERR_SUCCESS;
8540 }
8541
8542 static enum ndr_err_code ndr_pull_wkssvc_NetrGetJoinInformation(struct ndr_pull *ndr, int flags, struct wkssvc_NetrGetJoinInformation *r)
8543 {
8544         uint32_t _ptr_server_name;
8545         uint32_t _ptr_name_buffer;
8546         TALLOC_CTX *_mem_save_server_name_0;
8547         TALLOC_CTX *_mem_save_name_buffer_0;
8548         TALLOC_CTX *_mem_save_name_buffer_1;
8549         TALLOC_CTX *_mem_save_name_type_0;
8550         if (flags & NDR_IN) {
8551                 ZERO_STRUCT(r->out);
8552
8553                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
8554                 if (_ptr_server_name) {
8555                         NDR_PULL_ALLOC(ndr, r->in.server_name);
8556                 } else {
8557                         r->in.server_name = NULL;
8558                 }
8559                 if (r->in.server_name) {
8560                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8561                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
8562                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
8563                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
8564                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
8565                                 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));
8566                         }
8567                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
8568                         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));
8569                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
8570                 }
8571                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8572                         NDR_PULL_ALLOC(ndr, r->in.name_buffer);
8573                 }
8574                 _mem_save_name_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
8575                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name_buffer, LIBNDR_FLAG_REF_ALLOC);
8576                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_buffer));
8577                 if (_ptr_name_buffer) {
8578                         NDR_PULL_ALLOC(ndr, *r->in.name_buffer);
8579                 } else {
8580                         *r->in.name_buffer = NULL;
8581                 }
8582                 if (*r->in.name_buffer) {
8583                         _mem_save_name_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
8584                         NDR_PULL_SET_MEM_CTX(ndr, *r->in.name_buffer, 0);
8585                         NDR_CHECK(ndr_pull_array_size(ndr, r->in.name_buffer));
8586                         NDR_CHECK(ndr_pull_array_length(ndr, r->in.name_buffer));
8587                         if (ndr_get_array_length(ndr, r->in.name_buffer) > ndr_get_array_size(ndr, r->in.name_buffer)) {
8588                                 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));
8589                         }
8590                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->in.name_buffer), sizeof(uint16_t)));
8591                         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));
8592                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_buffer_1, 0);
8593                 }
8594                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_buffer_0, LIBNDR_FLAG_REF_ALLOC);
8595                 NDR_PULL_ALLOC(ndr, r->out.name_buffer);
8596                 *r->out.name_buffer = *r->in.name_buffer;
8597                 NDR_PULL_ALLOC(ndr, r->out.name_type);
8598                 ZERO_STRUCTP(r->out.name_type);
8599         }
8600         if (flags & NDR_OUT) {
8601                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8602                         NDR_PULL_ALLOC(ndr, r->out.name_buffer);
8603                 }
8604                 _mem_save_name_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
8605                 NDR_PULL_SET_MEM_CTX(ndr, r->out.name_buffer, LIBNDR_FLAG_REF_ALLOC);
8606                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_buffer));
8607                 if (_ptr_name_buffer) {
8608                         NDR_PULL_ALLOC(ndr, *r->out.name_buffer);
8609                 } else {
8610                         *r->out.name_buffer = NULL;
8611                 }
8612                 if (*r->out.name_buffer) {
8613                         _mem_save_name_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
8614                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.name_buffer, 0);
8615                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.name_buffer));
8616                         NDR_CHECK(ndr_pull_array_length(ndr, r->out.name_buffer));
8617                         if (ndr_get_array_length(ndr, r->out.name_buffer) > ndr_get_array_size(ndr, r->out.name_buffer)) {
8618                                 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));
8619                         }
8620                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->out.name_buffer), sizeof(uint16_t)));
8621                         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));
8622                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_buffer_1, 0);
8623                 }
8624                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_buffer_0, LIBNDR_FLAG_REF_ALLOC);
8625                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8626                         NDR_PULL_ALLOC(ndr, r->out.name_type);
8627                 }
8628                 _mem_save_name_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
8629                 NDR_PULL_SET_MEM_CTX(ndr, r->out.name_type, LIBNDR_FLAG_REF_ALLOC);
8630                 NDR_CHECK(ndr_pull_wkssvc_NetJoinStatus(ndr, NDR_SCALARS, r->out.name_type));
8631                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_type_0, LIBNDR_FLAG_REF_ALLOC);
8632                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
8633         }
8634         return NDR_ERR_SUCCESS;
8635 }
8636
8637 _PUBLIC_ void ndr_print_wkssvc_NetrGetJoinInformation(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrGetJoinInformation *r)
8638 {
8639         ndr_print_struct(ndr, name, "wkssvc_NetrGetJoinInformation");
8640         ndr->depth++;
8641         if (flags & NDR_SET_VALUES) {
8642                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8643         }
8644         if (flags & NDR_IN) {
8645                 ndr_print_struct(ndr, "in", "wkssvc_NetrGetJoinInformation");
8646                 ndr->depth++;
8647                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
8648                 ndr->depth++;
8649                 if (r->in.server_name) {
8650                         ndr_print_string(ndr, "server_name", r->in.server_name);
8651                 }
8652                 ndr->depth--;
8653                 ndr_print_ptr(ndr, "name_buffer", r->in.name_buffer);
8654                 ndr->depth++;
8655                 ndr_print_ptr(ndr, "name_buffer", *r->in.name_buffer);
8656                 ndr->depth++;
8657                 if (*r->in.name_buffer) {
8658                         ndr_print_string(ndr, "name_buffer", *r->in.name_buffer);
8659                 }
8660                 ndr->depth--;
8661                 ndr->depth--;
8662                 ndr->depth--;
8663         }
8664         if (flags & NDR_OUT) {
8665                 ndr_print_struct(ndr, "out", "wkssvc_NetrGetJoinInformation");
8666                 ndr->depth++;
8667                 ndr_print_ptr(ndr, "name_buffer", r->out.name_buffer);
8668                 ndr->depth++;
8669                 ndr_print_ptr(ndr, "name_buffer", *r->out.name_buffer);
8670                 ndr->depth++;
8671                 if (*r->out.name_buffer) {
8672                         ndr_print_string(ndr, "name_buffer", *r->out.name_buffer);
8673                 }
8674                 ndr->depth--;
8675                 ndr->depth--;
8676                 ndr_print_ptr(ndr, "name_type", r->out.name_type);
8677                 ndr->depth++;
8678                 ndr_print_wkssvc_NetJoinStatus(ndr, "name_type", *r->out.name_type);
8679                 ndr->depth--;
8680                 ndr_print_WERROR(ndr, "result", r->out.result);
8681                 ndr->depth--;
8682         }
8683         ndr->depth--;
8684 }
8685
8686 static enum ndr_err_code ndr_push_wkssvc_NetrGetJoinableOus(struct ndr_push *ndr, int flags, const struct wkssvc_NetrGetJoinableOus *r)
8687 {
8688         uint32_t cntr_ous_2;
8689         if (flags & NDR_IN) {
8690                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
8691                 if (r->in.server_name) {
8692                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8693                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8694                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8695                         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));
8696                 }
8697                 if (r->in.domain_name == NULL) {
8698                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8699                 }
8700                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
8701                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8702                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
8703                 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));
8704                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
8705                 if (r->in.Account) {
8706                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
8707                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8708                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
8709                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8710                 }
8711                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown));
8712                 if (r->in.unknown) {
8713                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));
8714                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8715                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));
8716                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.unknown, ndr_charset_length(r->in.unknown, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8717                 }
8718                 if (r->in.num_ous == NULL) {
8719                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8720                 }
8721                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.num_ous));
8722         }
8723         if (flags & NDR_OUT) {
8724                 if (r->out.num_ous == NULL) {
8725                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8726                 }
8727                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_ous));
8728                 if (r->out.ous == NULL) {
8729                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8730                 }
8731                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.ous));
8732                 if (*r->out.ous) {
8733                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.num_ous));
8734                         for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {
8735                                 NDR_CHECK(ndr_push_unique_ptr(ndr, (*r->out.ous)[cntr_ous_2]));
8736                         }
8737                         for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {
8738                                 if ((*r->out.ous)[cntr_ous_2]) {
8739                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length((*r->out.ous)[cntr_ous_2], CH_UTF16)));
8740                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8741                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length((*r->out.ous)[cntr_ous_2], CH_UTF16)));
8742                                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, (*r->out.ous)[cntr_ous_2], ndr_charset_length((*r->out.ous)[cntr_ous_2], CH_UTF16), sizeof(uint16_t), CH_UTF16));
8743                                 }
8744                         }
8745                 }
8746                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
8747         }
8748         return NDR_ERR_SUCCESS;
8749 }
8750
8751 static enum ndr_err_code ndr_pull_wkssvc_NetrGetJoinableOus(struct ndr_pull *ndr, int flags, struct wkssvc_NetrGetJoinableOus *r)
8752 {
8753         uint32_t _ptr_server_name;
8754         uint32_t _ptr_Account;
8755         uint32_t _ptr_unknown;
8756         uint32_t _ptr_ous;
8757         uint32_t cntr_ous_2;
8758         TALLOC_CTX *_mem_save_server_name_0;
8759         TALLOC_CTX *_mem_save_Account_0;
8760         TALLOC_CTX *_mem_save_unknown_0;
8761         TALLOC_CTX *_mem_save_num_ous_0;
8762         TALLOC_CTX *_mem_save_ous_0;
8763         TALLOC_CTX *_mem_save_ous_1;
8764         TALLOC_CTX *_mem_save_ous_2;
8765         TALLOC_CTX *_mem_save_ous_3;
8766         if (flags & NDR_IN) {
8767                 ZERO_STRUCT(r->out);
8768
8769                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
8770                 if (_ptr_server_name) {
8771                         NDR_PULL_ALLOC(ndr, r->in.server_name);
8772                 } else {
8773                         r->in.server_name = NULL;
8774                 }
8775                 if (r->in.server_name) {
8776                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8777                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
8778                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
8779                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
8780                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
8781                                 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));
8782                         }
8783                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
8784                         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));
8785                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
8786                 }
8787                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
8788                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
8789                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
8790                         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));
8791                 }
8792                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
8793                 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));
8794                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
8795                 if (_ptr_Account) {
8796                         NDR_PULL_ALLOC(ndr, r->in.Account);
8797                 } else {
8798                         r->in.Account = NULL;
8799                 }
8800                 if (r->in.Account) {
8801                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
8802                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
8803                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
8804                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
8805                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
8806                                 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));
8807                         }
8808                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
8809                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
8810                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
8811                 }
8812                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown));
8813                 if (_ptr_unknown) {
8814                         NDR_PULL_ALLOC(ndr, r->in.unknown);
8815                 } else {
8816                         r->in.unknown = NULL;
8817                 }
8818                 if (r->in.unknown) {
8819                         _mem_save_unknown_0 = NDR_PULL_GET_MEM_CTX(ndr);
8820                         NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown, 0);
8821                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.unknown));
8822                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.unknown));
8823                         if (ndr_get_array_length(ndr, &r->in.unknown) > ndr_get_array_size(ndr, &r->in.unknown)) {
8824                                 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));
8825                         }
8826                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t)));
8827                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.unknown, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t), CH_UTF16));
8828                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown_0, 0);
8829                 }
8830                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8831                         NDR_PULL_ALLOC(ndr, r->in.num_ous);
8832                 }
8833                 _mem_save_num_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);
8834                 NDR_PULL_SET_MEM_CTX(ndr, r->in.num_ous, LIBNDR_FLAG_REF_ALLOC);
8835                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.num_ous));
8836                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_ous_0, LIBNDR_FLAG_REF_ALLOC);
8837                 NDR_PULL_ALLOC(ndr, r->out.num_ous);
8838                 *r->out.num_ous = *r->in.num_ous;
8839                 NDR_PULL_ALLOC(ndr, r->out.ous);
8840                 ZERO_STRUCTP(r->out.ous);
8841         }
8842         if (flags & NDR_OUT) {
8843                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8844                         NDR_PULL_ALLOC(ndr, r->out.num_ous);
8845                 }
8846                 _mem_save_num_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);
8847                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_ous, LIBNDR_FLAG_REF_ALLOC);
8848                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_ous));
8849                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_ous_0, LIBNDR_FLAG_REF_ALLOC);
8850                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8851                         NDR_PULL_ALLOC(ndr, r->out.ous);
8852                 }
8853                 _mem_save_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);
8854                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ous, LIBNDR_FLAG_REF_ALLOC);
8855                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ous));
8856                 if (_ptr_ous) {
8857                         NDR_PULL_ALLOC(ndr, *r->out.ous);
8858                 } else {
8859                         *r->out.ous = NULL;
8860                 }
8861                 if (*r->out.ous) {
8862                         _mem_save_ous_1 = NDR_PULL_GET_MEM_CTX(ndr);
8863                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.ous, 0);
8864                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.ous));
8865                         NDR_PULL_ALLOC_N(ndr, *r->out.ous, ndr_get_array_size(ndr, r->out.ous));
8866                         _mem_save_ous_2 = NDR_PULL_GET_MEM_CTX(ndr);
8867                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.ous, 0);
8868                         for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {
8869                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ous));
8870                                 if (_ptr_ous) {
8871                                         NDR_PULL_ALLOC(ndr, (*r->out.ous)[cntr_ous_2]);
8872                                 } else {
8873                                         (*r->out.ous)[cntr_ous_2] = NULL;
8874                                 }
8875                         }
8876                         for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {
8877                                 if ((*r->out.ous)[cntr_ous_2]) {
8878                                         _mem_save_ous_3 = NDR_PULL_GET_MEM_CTX(ndr);
8879                                         NDR_PULL_SET_MEM_CTX(ndr, (*r->out.ous)[cntr_ous_2], 0);
8880                                         NDR_CHECK(ndr_pull_array_size(ndr, &(*r->out.ous)[cntr_ous_2]));
8881                                         NDR_CHECK(ndr_pull_array_length(ndr, &(*r->out.ous)[cntr_ous_2]));
8882                                         if (ndr_get_array_length(ndr, &(*r->out.ous)[cntr_ous_2]) > ndr_get_array_size(ndr, &(*r->out.ous)[cntr_ous_2])) {
8883                                                 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.ous)[cntr_ous_2]), ndr_get_array_length(ndr, &(*r->out.ous)[cntr_ous_2]));
8884                                         }
8885                                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &(*r->out.ous)[cntr_ous_2]), sizeof(uint16_t)));
8886                                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &(*r->out.ous)[cntr_ous_2], ndr_get_array_length(ndr, &(*r->out.ous)[cntr_ous_2]), sizeof(uint16_t), CH_UTF16));
8887                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_3, 0);
8888                                 }
8889                         }
8890                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_2, 0);
8891                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_1, 0);
8892                 }
8893                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_0, LIBNDR_FLAG_REF_ALLOC);
8894                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
8895                 if (*r->out.ous) {
8896                         NDR_CHECK(ndr_check_array_size(ndr, (void*)r->out.ous, *r->out.num_ous));
8897                 }
8898         }
8899         return NDR_ERR_SUCCESS;
8900 }
8901
8902 _PUBLIC_ void ndr_print_wkssvc_NetrGetJoinableOus(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrGetJoinableOus *r)
8903 {
8904         uint32_t cntr_ous_2;
8905         ndr_print_struct(ndr, name, "wkssvc_NetrGetJoinableOus");
8906         ndr->depth++;
8907         if (flags & NDR_SET_VALUES) {
8908                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8909         }
8910         if (flags & NDR_IN) {
8911                 ndr_print_struct(ndr, "in", "wkssvc_NetrGetJoinableOus");
8912                 ndr->depth++;
8913                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
8914                 ndr->depth++;
8915                 if (r->in.server_name) {
8916                         ndr_print_string(ndr, "server_name", r->in.server_name);
8917                 }
8918                 ndr->depth--;
8919                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
8920                 ndr->depth++;
8921                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
8922                 ndr->depth--;
8923                 ndr_print_ptr(ndr, "Account", r->in.Account);
8924                 ndr->depth++;
8925                 if (r->in.Account) {
8926                         ndr_print_string(ndr, "Account", r->in.Account);
8927                 }
8928                 ndr->depth--;
8929                 ndr_print_ptr(ndr, "unknown", r->in.unknown);
8930                 ndr->depth++;
8931                 if (r->in.unknown) {
8932                         ndr_print_string(ndr, "unknown", r->in.unknown);
8933                 }
8934                 ndr->depth--;
8935                 ndr_print_ptr(ndr, "num_ous", r->in.num_ous);
8936                 ndr->depth++;
8937                 ndr_print_uint32(ndr, "num_ous", *r->in.num_ous);
8938                 ndr->depth--;
8939                 ndr->depth--;
8940         }
8941         if (flags & NDR_OUT) {
8942                 ndr_print_struct(ndr, "out", "wkssvc_NetrGetJoinableOus");
8943                 ndr->depth++;
8944                 ndr_print_ptr(ndr, "num_ous", r->out.num_ous);
8945                 ndr->depth++;
8946                 ndr_print_uint32(ndr, "num_ous", *r->out.num_ous);
8947                 ndr->depth--;
8948                 ndr_print_ptr(ndr, "ous", r->out.ous);
8949                 ndr->depth++;
8950                 ndr_print_ptr(ndr, "ous", *r->out.ous);
8951                 ndr->depth++;
8952                 if (*r->out.ous) {
8953                         ndr->print(ndr, "%s: ARRAY(%d)", "ous", (int)*r->out.num_ous);
8954                         ndr->depth++;
8955                         for (cntr_ous_2=0;cntr_ous_2<*r->out.num_ous;cntr_ous_2++) {
8956                                 char *idx_2=NULL;
8957                                 if (asprintf(&idx_2, "[%d]", cntr_ous_2) != -1) {
8958                                         ndr_print_ptr(ndr, "ous", (*r->out.ous)[cntr_ous_2]);
8959                                         ndr->depth++;
8960                                         if ((*r->out.ous)[cntr_ous_2]) {
8961                                                 ndr_print_string(ndr, "ous", (*r->out.ous)[cntr_ous_2]);
8962                                         }
8963                                         ndr->depth--;
8964                                         free(idx_2);
8965                                 }
8966                         }
8967                         ndr->depth--;
8968                 }
8969                 ndr->depth--;
8970                 ndr->depth--;
8971                 ndr_print_WERROR(ndr, "result", r->out.result);
8972                 ndr->depth--;
8973         }
8974         ndr->depth--;
8975 }
8976
8977 static enum ndr_err_code ndr_push_wkssvc_NetrJoinDomain2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrJoinDomain2 *r)
8978 {
8979         if (flags & NDR_IN) {
8980                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
8981                 if (r->in.server_name) {
8982                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8983                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8984                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8985                         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));
8986                 }
8987                 if (r->in.domain_name == NULL) {
8988                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8989                 }
8990                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
8991                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8992                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
8993                 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));
8994                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.account_ou));
8995                 if (r->in.account_ou) {
8996                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.account_ou, CH_UTF16)));
8997                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8998                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.account_ou, CH_UTF16)));
8999                         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));
9000                 }
9001                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.admin_account));
9002                 if (r->in.admin_account) {
9003                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.admin_account, CH_UTF16)));
9004                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9005                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.admin_account, CH_UTF16)));
9006                         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));
9007                 }
9008                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.encrypted_password));
9009                 if (r->in.encrypted_password) {
9010                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));
9011                 }
9012                 NDR_CHECK(ndr_push_wkssvc_joinflags(ndr, NDR_SCALARS, r->in.join_flags));
9013         }
9014         if (flags & NDR_OUT) {
9015                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9016         }
9017         return NDR_ERR_SUCCESS;
9018 }
9019
9020 static enum ndr_err_code ndr_pull_wkssvc_NetrJoinDomain2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrJoinDomain2 *r)
9021 {
9022         uint32_t _ptr_server_name;
9023         uint32_t _ptr_account_ou;
9024         uint32_t _ptr_admin_account;
9025         uint32_t _ptr_encrypted_password;
9026         TALLOC_CTX *_mem_save_server_name_0;
9027         TALLOC_CTX *_mem_save_account_ou_0;
9028         TALLOC_CTX *_mem_save_admin_account_0;
9029         TALLOC_CTX *_mem_save_encrypted_password_0;
9030         if (flags & NDR_IN) {
9031                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
9032                 if (_ptr_server_name) {
9033                         NDR_PULL_ALLOC(ndr, r->in.server_name);
9034                 } else {
9035                         r->in.server_name = NULL;
9036                 }
9037                 if (r->in.server_name) {
9038                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9039                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
9040                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
9041                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
9042                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
9043                                 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));
9044                         }
9045                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
9046                         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));
9047                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
9048                 }
9049                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
9050                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
9051                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
9052                         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));
9053                 }
9054                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
9055                 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));
9056                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account_ou));
9057                 if (_ptr_account_ou) {
9058                         NDR_PULL_ALLOC(ndr, r->in.account_ou);
9059                 } else {
9060                         r->in.account_ou = NULL;
9061                 }
9062                 if (r->in.account_ou) {
9063                         _mem_save_account_ou_0 = NDR_PULL_GET_MEM_CTX(ndr);
9064                         NDR_PULL_SET_MEM_CTX(ndr, r->in.account_ou, 0);
9065                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.account_ou));
9066                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.account_ou));
9067                         if (ndr_get_array_length(ndr, &r->in.account_ou) > ndr_get_array_size(ndr, &r->in.account_ou)) {
9068                                 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));
9069                         }
9070                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.account_ou), sizeof(uint16_t)));
9071                         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));
9072                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_ou_0, 0);
9073                 }
9074                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_admin_account));
9075                 if (_ptr_admin_account) {
9076                         NDR_PULL_ALLOC(ndr, r->in.admin_account);
9077                 } else {
9078                         r->in.admin_account = NULL;
9079                 }
9080                 if (r->in.admin_account) {
9081                         _mem_save_admin_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
9082                         NDR_PULL_SET_MEM_CTX(ndr, r->in.admin_account, 0);
9083                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.admin_account));
9084                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.admin_account));
9085                         if (ndr_get_array_length(ndr, &r->in.admin_account) > ndr_get_array_size(ndr, &r->in.admin_account)) {
9086                                 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));
9087                         }
9088                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.admin_account), sizeof(uint16_t)));
9089                         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));
9090                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_admin_account_0, 0);
9091                 }
9092                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_encrypted_password));
9093                 if (_ptr_encrypted_password) {
9094                         NDR_PULL_ALLOC(ndr, r->in.encrypted_password);
9095                 } else {
9096                         r->in.encrypted_password = NULL;
9097                 }
9098                 if (r->in.encrypted_password) {
9099                         _mem_save_encrypted_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
9100                         NDR_PULL_SET_MEM_CTX(ndr, r->in.encrypted_password, 0);
9101                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));
9102                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_encrypted_password_0, 0);
9103                 }
9104                 NDR_CHECK(ndr_pull_wkssvc_joinflags(ndr, NDR_SCALARS, &r->in.join_flags));
9105         }
9106         if (flags & NDR_OUT) {
9107                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9108         }
9109         return NDR_ERR_SUCCESS;
9110 }
9111
9112 _PUBLIC_ void ndr_print_wkssvc_NetrJoinDomain2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrJoinDomain2 *r)
9113 {
9114         ndr_print_struct(ndr, name, "wkssvc_NetrJoinDomain2");
9115         ndr->depth++;
9116         if (flags & NDR_SET_VALUES) {
9117                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9118         }
9119         if (flags & NDR_IN) {
9120                 ndr_print_struct(ndr, "in", "wkssvc_NetrJoinDomain2");
9121                 ndr->depth++;
9122                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
9123                 ndr->depth++;
9124                 if (r->in.server_name) {
9125                         ndr_print_string(ndr, "server_name", r->in.server_name);
9126                 }
9127                 ndr->depth--;
9128                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
9129                 ndr->depth++;
9130                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
9131                 ndr->depth--;
9132                 ndr_print_ptr(ndr, "account_ou", r->in.account_ou);
9133                 ndr->depth++;
9134                 if (r->in.account_ou) {
9135                         ndr_print_string(ndr, "account_ou", r->in.account_ou);
9136                 }
9137                 ndr->depth--;
9138                 ndr_print_ptr(ndr, "admin_account", r->in.admin_account);
9139                 ndr->depth++;
9140                 if (r->in.admin_account) {
9141                         ndr_print_string(ndr, "admin_account", r->in.admin_account);
9142                 }
9143                 ndr->depth--;
9144                 ndr_print_ptr(ndr, "encrypted_password", r->in.encrypted_password);
9145                 ndr->depth++;
9146                 if (r->in.encrypted_password) {
9147                         ndr_print_wkssvc_PasswordBuffer(ndr, "encrypted_password", r->in.encrypted_password);
9148                 }
9149                 ndr->depth--;
9150                 ndr_print_wkssvc_joinflags(ndr, "join_flags", r->in.join_flags);
9151                 ndr->depth--;
9152         }
9153         if (flags & NDR_OUT) {
9154                 ndr_print_struct(ndr, "out", "wkssvc_NetrJoinDomain2");
9155                 ndr->depth++;
9156                 ndr_print_WERROR(ndr, "result", r->out.result);
9157                 ndr->depth--;
9158         }
9159         ndr->depth--;
9160 }
9161
9162 static enum ndr_err_code ndr_push_wkssvc_NetrUnjoinDomain2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUnjoinDomain2 *r)
9163 {
9164         if (flags & NDR_IN) {
9165                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
9166                 if (r->in.server_name) {
9167                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9168                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9169                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9170                         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));
9171                 }
9172                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.account));
9173                 if (r->in.account) {
9174                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.account, CH_UTF16)));
9175                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9176                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.account, CH_UTF16)));
9177                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.account, ndr_charset_length(r->in.account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9178                 }
9179                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.encrypted_password));
9180                 if (r->in.encrypted_password) {
9181                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));
9182                 }
9183                 NDR_CHECK(ndr_push_wkssvc_joinflags(ndr, NDR_SCALARS, r->in.unjoin_flags));
9184         }
9185         if (flags & NDR_OUT) {
9186                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9187         }
9188         return NDR_ERR_SUCCESS;
9189 }
9190
9191 static enum ndr_err_code ndr_pull_wkssvc_NetrUnjoinDomain2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUnjoinDomain2 *r)
9192 {
9193         uint32_t _ptr_server_name;
9194         uint32_t _ptr_account;
9195         uint32_t _ptr_encrypted_password;
9196         TALLOC_CTX *_mem_save_server_name_0;
9197         TALLOC_CTX *_mem_save_account_0;
9198         TALLOC_CTX *_mem_save_encrypted_password_0;
9199         if (flags & NDR_IN) {
9200                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
9201                 if (_ptr_server_name) {
9202                         NDR_PULL_ALLOC(ndr, r->in.server_name);
9203                 } else {
9204                         r->in.server_name = NULL;
9205                 }
9206                 if (r->in.server_name) {
9207                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9208                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
9209                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
9210                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
9211                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
9212                                 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));
9213                         }
9214                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
9215                         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));
9216                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
9217                 }
9218                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account));
9219                 if (_ptr_account) {
9220                         NDR_PULL_ALLOC(ndr, r->in.account);
9221                 } else {
9222                         r->in.account = NULL;
9223                 }
9224                 if (r->in.account) {
9225                         _mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
9226                         NDR_PULL_SET_MEM_CTX(ndr, r->in.account, 0);
9227                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.account));
9228                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.account));
9229                         if (ndr_get_array_length(ndr, &r->in.account) > ndr_get_array_size(ndr, &r->in.account)) {
9230                                 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));
9231                         }
9232                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.account), sizeof(uint16_t)));
9233                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.account, ndr_get_array_length(ndr, &r->in.account), sizeof(uint16_t), CH_UTF16));
9234                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, 0);
9235                 }
9236                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_encrypted_password));
9237                 if (_ptr_encrypted_password) {
9238                         NDR_PULL_ALLOC(ndr, r->in.encrypted_password);
9239                 } else {
9240                         r->in.encrypted_password = NULL;
9241                 }
9242                 if (r->in.encrypted_password) {
9243                         _mem_save_encrypted_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
9244                         NDR_PULL_SET_MEM_CTX(ndr, r->in.encrypted_password, 0);
9245                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));
9246                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_encrypted_password_0, 0);
9247                 }
9248                 NDR_CHECK(ndr_pull_wkssvc_joinflags(ndr, NDR_SCALARS, &r->in.unjoin_flags));
9249         }
9250         if (flags & NDR_OUT) {
9251                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9252         }
9253         return NDR_ERR_SUCCESS;
9254 }
9255
9256 _PUBLIC_ void ndr_print_wkssvc_NetrUnjoinDomain2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUnjoinDomain2 *r)
9257 {
9258         ndr_print_struct(ndr, name, "wkssvc_NetrUnjoinDomain2");
9259         ndr->depth++;
9260         if (flags & NDR_SET_VALUES) {
9261                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9262         }
9263         if (flags & NDR_IN) {
9264                 ndr_print_struct(ndr, "in", "wkssvc_NetrUnjoinDomain2");
9265                 ndr->depth++;
9266                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
9267                 ndr->depth++;
9268                 if (r->in.server_name) {
9269                         ndr_print_string(ndr, "server_name", r->in.server_name);
9270                 }
9271                 ndr->depth--;
9272                 ndr_print_ptr(ndr, "account", r->in.account);
9273                 ndr->depth++;
9274                 if (r->in.account) {
9275                         ndr_print_string(ndr, "account", r->in.account);
9276                 }
9277                 ndr->depth--;
9278                 ndr_print_ptr(ndr, "encrypted_password", r->in.encrypted_password);
9279                 ndr->depth++;
9280                 if (r->in.encrypted_password) {
9281                         ndr_print_wkssvc_PasswordBuffer(ndr, "encrypted_password", r->in.encrypted_password);
9282                 }
9283                 ndr->depth--;
9284                 ndr_print_wkssvc_joinflags(ndr, "unjoin_flags", r->in.unjoin_flags);
9285                 ndr->depth--;
9286         }
9287         if (flags & NDR_OUT) {
9288                 ndr_print_struct(ndr, "out", "wkssvc_NetrUnjoinDomain2");
9289                 ndr->depth++;
9290                 ndr_print_WERROR(ndr, "result", r->out.result);
9291                 ndr->depth--;
9292         }
9293         ndr->depth--;
9294 }
9295
9296 static enum ndr_err_code ndr_push_wkssvc_NetrRenameMachineInDomain2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrRenameMachineInDomain2 *r)
9297 {
9298         if (flags & NDR_IN) {
9299                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
9300                 if (r->in.server_name) {
9301                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9302                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9303                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9304                         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));
9305                 }
9306                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.NewMachineName));
9307                 if (r->in.NewMachineName) {
9308                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewMachineName, CH_UTF16)));
9309                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9310                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewMachineName, CH_UTF16)));
9311                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.NewMachineName, ndr_charset_length(r->in.NewMachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9312                 }
9313                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
9314                 if (r->in.Account) {
9315                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9316                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9317                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9318                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9319                 }
9320                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
9321                 if (r->in.EncryptedPassword) {
9322                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9323                 }
9324                 NDR_CHECK(ndr_push_wkssvc_renameflags(ndr, NDR_SCALARS, r->in.RenameOptions));
9325         }
9326         if (flags & NDR_OUT) {
9327                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9328         }
9329         return NDR_ERR_SUCCESS;
9330 }
9331
9332 static enum ndr_err_code ndr_pull_wkssvc_NetrRenameMachineInDomain2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrRenameMachineInDomain2 *r)
9333 {
9334         uint32_t _ptr_server_name;
9335         uint32_t _ptr_NewMachineName;
9336         uint32_t _ptr_Account;
9337         uint32_t _ptr_EncryptedPassword;
9338         TALLOC_CTX *_mem_save_server_name_0;
9339         TALLOC_CTX *_mem_save_NewMachineName_0;
9340         TALLOC_CTX *_mem_save_Account_0;
9341         TALLOC_CTX *_mem_save_EncryptedPassword_0;
9342         if (flags & NDR_IN) {
9343                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
9344                 if (_ptr_server_name) {
9345                         NDR_PULL_ALLOC(ndr, r->in.server_name);
9346                 } else {
9347                         r->in.server_name = NULL;
9348                 }
9349                 if (r->in.server_name) {
9350                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9351                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
9352                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
9353                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
9354                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
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.server_name), ndr_get_array_length(ndr, &r->in.server_name));
9356                         }
9357                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
9358                         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));
9359                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
9360                 }
9361                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_NewMachineName));
9362                 if (_ptr_NewMachineName) {
9363                         NDR_PULL_ALLOC(ndr, r->in.NewMachineName);
9364                 } else {
9365                         r->in.NewMachineName = NULL;
9366                 }
9367                 if (r->in.NewMachineName) {
9368                         _mem_save_NewMachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);
9369                         NDR_PULL_SET_MEM_CTX(ndr, r->in.NewMachineName, 0);
9370                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.NewMachineName));
9371                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.NewMachineName));
9372                         if (ndr_get_array_length(ndr, &r->in.NewMachineName) > ndr_get_array_size(ndr, &r->in.NewMachineName)) {
9373                                 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));
9374                         }
9375                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.NewMachineName), sizeof(uint16_t)));
9376                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.NewMachineName, ndr_get_array_length(ndr, &r->in.NewMachineName), sizeof(uint16_t), CH_UTF16));
9377                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_NewMachineName_0, 0);
9378                 }
9379                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
9380                 if (_ptr_Account) {
9381                         NDR_PULL_ALLOC(ndr, r->in.Account);
9382                 } else {
9383                         r->in.Account = NULL;
9384                 }
9385                 if (r->in.Account) {
9386                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
9387                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
9388                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
9389                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
9390                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
9391                                 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));
9392                         }
9393                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
9394                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
9395                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
9396                 }
9397                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
9398                 if (_ptr_EncryptedPassword) {
9399                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
9400                 } else {
9401                         r->in.EncryptedPassword = NULL;
9402                 }
9403                 if (r->in.EncryptedPassword) {
9404                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
9405                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
9406                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9407                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
9408                 }
9409                 NDR_CHECK(ndr_pull_wkssvc_renameflags(ndr, NDR_SCALARS, &r->in.RenameOptions));
9410         }
9411         if (flags & NDR_OUT) {
9412                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9413         }
9414         return NDR_ERR_SUCCESS;
9415 }
9416
9417 _PUBLIC_ void ndr_print_wkssvc_NetrRenameMachineInDomain2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrRenameMachineInDomain2 *r)
9418 {
9419         ndr_print_struct(ndr, name, "wkssvc_NetrRenameMachineInDomain2");
9420         ndr->depth++;
9421         if (flags & NDR_SET_VALUES) {
9422                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9423         }
9424         if (flags & NDR_IN) {
9425                 ndr_print_struct(ndr, "in", "wkssvc_NetrRenameMachineInDomain2");
9426                 ndr->depth++;
9427                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
9428                 ndr->depth++;
9429                 if (r->in.server_name) {
9430                         ndr_print_string(ndr, "server_name", r->in.server_name);
9431                 }
9432                 ndr->depth--;
9433                 ndr_print_ptr(ndr, "NewMachineName", r->in.NewMachineName);
9434                 ndr->depth++;
9435                 if (r->in.NewMachineName) {
9436                         ndr_print_string(ndr, "NewMachineName", r->in.NewMachineName);
9437                 }
9438                 ndr->depth--;
9439                 ndr_print_ptr(ndr, "Account", r->in.Account);
9440                 ndr->depth++;
9441                 if (r->in.Account) {
9442                         ndr_print_string(ndr, "Account", r->in.Account);
9443                 }
9444                 ndr->depth--;
9445                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9446                 ndr->depth++;
9447                 if (r->in.EncryptedPassword) {
9448                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9449                 }
9450                 ndr->depth--;
9451                 ndr_print_wkssvc_renameflags(ndr, "RenameOptions", r->in.RenameOptions);
9452                 ndr->depth--;
9453         }
9454         if (flags & NDR_OUT) {
9455                 ndr_print_struct(ndr, "out", "wkssvc_NetrRenameMachineInDomain2");
9456                 ndr->depth++;
9457                 ndr_print_WERROR(ndr, "result", r->out.result);
9458                 ndr->depth--;
9459         }
9460         ndr->depth--;
9461 }
9462
9463 static enum ndr_err_code ndr_push_wkssvc_NetrValidateName2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrValidateName2 *r)
9464 {
9465         if (flags & NDR_IN) {
9466                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
9467                 if (r->in.server_name) {
9468                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9469                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9470                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9471                         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));
9472                 }
9473                 if (r->in.name == NULL) {
9474                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9475                 }
9476                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF16)));
9477                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9478                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF16)));
9479                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.name, ndr_charset_length(r->in.name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9480                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
9481                 if (r->in.Account) {
9482                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9483                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9484                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9485                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9486                 }
9487                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
9488                 if (r->in.EncryptedPassword) {
9489                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9490                 }
9491                 NDR_CHECK(ndr_push_wkssvc_NetValidateNameType(ndr, NDR_SCALARS, r->in.name_type));
9492         }
9493         if (flags & NDR_OUT) {
9494                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9495         }
9496         return NDR_ERR_SUCCESS;
9497 }
9498
9499 static enum ndr_err_code ndr_pull_wkssvc_NetrValidateName2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrValidateName2 *r)
9500 {
9501         uint32_t _ptr_server_name;
9502         uint32_t _ptr_Account;
9503         uint32_t _ptr_EncryptedPassword;
9504         TALLOC_CTX *_mem_save_server_name_0;
9505         TALLOC_CTX *_mem_save_Account_0;
9506         TALLOC_CTX *_mem_save_EncryptedPassword_0;
9507         if (flags & NDR_IN) {
9508                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
9509                 if (_ptr_server_name) {
9510                         NDR_PULL_ALLOC(ndr, r->in.server_name);
9511                 } else {
9512                         r->in.server_name = NULL;
9513                 }
9514                 if (r->in.server_name) {
9515                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9516                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
9517                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
9518                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
9519                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
9520                                 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));
9521                         }
9522                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
9523                         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));
9524                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
9525                 }
9526                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.name));
9527                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.name));
9528                 if (ndr_get_array_length(ndr, &r->in.name) > ndr_get_array_size(ndr, &r->in.name)) {
9529                         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));
9530                 }
9531                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.name), sizeof(uint16_t)));
9532                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.name, ndr_get_array_length(ndr, &r->in.name), sizeof(uint16_t), CH_UTF16));
9533                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
9534                 if (_ptr_Account) {
9535                         NDR_PULL_ALLOC(ndr, r->in.Account);
9536                 } else {
9537                         r->in.Account = NULL;
9538                 }
9539                 if (r->in.Account) {
9540                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
9541                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
9542                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
9543                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
9544                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
9545                                 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));
9546                         }
9547                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
9548                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
9549                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
9550                 }
9551                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
9552                 if (_ptr_EncryptedPassword) {
9553                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
9554                 } else {
9555                         r->in.EncryptedPassword = NULL;
9556                 }
9557                 if (r->in.EncryptedPassword) {
9558                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
9559                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
9560                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9561                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
9562                 }
9563                 NDR_CHECK(ndr_pull_wkssvc_NetValidateNameType(ndr, NDR_SCALARS, &r->in.name_type));
9564         }
9565         if (flags & NDR_OUT) {
9566                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9567         }
9568         return NDR_ERR_SUCCESS;
9569 }
9570
9571 _PUBLIC_ void ndr_print_wkssvc_NetrValidateName2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrValidateName2 *r)
9572 {
9573         ndr_print_struct(ndr, name, "wkssvc_NetrValidateName2");
9574         ndr->depth++;
9575         if (flags & NDR_SET_VALUES) {
9576                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9577         }
9578         if (flags & NDR_IN) {
9579                 ndr_print_struct(ndr, "in", "wkssvc_NetrValidateName2");
9580                 ndr->depth++;
9581                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
9582                 ndr->depth++;
9583                 if (r->in.server_name) {
9584                         ndr_print_string(ndr, "server_name", r->in.server_name);
9585                 }
9586                 ndr->depth--;
9587                 ndr_print_ptr(ndr, "name", r->in.name);
9588                 ndr->depth++;
9589                 ndr_print_string(ndr, "name", r->in.name);
9590                 ndr->depth--;
9591                 ndr_print_ptr(ndr, "Account", r->in.Account);
9592                 ndr->depth++;
9593                 if (r->in.Account) {
9594                         ndr_print_string(ndr, "Account", r->in.Account);
9595                 }
9596                 ndr->depth--;
9597                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9598                 ndr->depth++;
9599                 if (r->in.EncryptedPassword) {
9600                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9601                 }
9602                 ndr->depth--;
9603                 ndr_print_wkssvc_NetValidateNameType(ndr, "name_type", r->in.name_type);
9604                 ndr->depth--;
9605         }
9606         if (flags & NDR_OUT) {
9607                 ndr_print_struct(ndr, "out", "wkssvc_NetrValidateName2");
9608                 ndr->depth++;
9609                 ndr_print_WERROR(ndr, "result", r->out.result);
9610                 ndr->depth--;
9611         }
9612         ndr->depth--;
9613 }
9614
9615 static enum ndr_err_code ndr_push_wkssvc_NetrGetJoinableOus2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrGetJoinableOus2 *r)
9616 {
9617         uint32_t cntr_ous_2;
9618         if (flags & NDR_IN) {
9619                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
9620                 if (r->in.server_name) {
9621                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9622                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9623                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9624                         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));
9625                 }
9626                 if (r->in.domain_name == NULL) {
9627                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9628                 }
9629                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
9630                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9631                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
9632                 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));
9633                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
9634                 if (r->in.Account) {
9635                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9636                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9637                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9638                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9639                 }
9640                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
9641                 if (r->in.EncryptedPassword) {
9642                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9643                 }
9644                 if (r->in.num_ous == NULL) {
9645                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9646                 }
9647                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.num_ous));
9648         }
9649         if (flags & NDR_OUT) {
9650                 if (r->out.num_ous == NULL) {
9651                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9652                 }
9653                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_ous));
9654                 if (r->out.ous == NULL) {
9655                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9656                 }
9657                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.ous));
9658                 if (*r->out.ous) {
9659                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.num_ous));
9660                         for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {
9661                                 NDR_CHECK(ndr_push_unique_ptr(ndr, (*r->out.ous)[cntr_ous_2]));
9662                         }
9663                         for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {
9664                                 if ((*r->out.ous)[cntr_ous_2]) {
9665                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length((*r->out.ous)[cntr_ous_2], CH_UTF16)));
9666                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9667                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length((*r->out.ous)[cntr_ous_2], CH_UTF16)));
9668                                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, (*r->out.ous)[cntr_ous_2], ndr_charset_length((*r->out.ous)[cntr_ous_2], CH_UTF16), sizeof(uint16_t), CH_UTF16));
9669                                 }
9670                         }
9671                 }
9672                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9673         }
9674         return NDR_ERR_SUCCESS;
9675 }
9676
9677 static enum ndr_err_code ndr_pull_wkssvc_NetrGetJoinableOus2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrGetJoinableOus2 *r)
9678 {
9679         uint32_t _ptr_server_name;
9680         uint32_t _ptr_Account;
9681         uint32_t _ptr_EncryptedPassword;
9682         uint32_t _ptr_ous;
9683         uint32_t cntr_ous_2;
9684         TALLOC_CTX *_mem_save_server_name_0;
9685         TALLOC_CTX *_mem_save_Account_0;
9686         TALLOC_CTX *_mem_save_EncryptedPassword_0;
9687         TALLOC_CTX *_mem_save_num_ous_0;
9688         TALLOC_CTX *_mem_save_ous_0;
9689         TALLOC_CTX *_mem_save_ous_1;
9690         TALLOC_CTX *_mem_save_ous_2;
9691         TALLOC_CTX *_mem_save_ous_3;
9692         if (flags & NDR_IN) {
9693                 ZERO_STRUCT(r->out);
9694
9695                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
9696                 if (_ptr_server_name) {
9697                         NDR_PULL_ALLOC(ndr, r->in.server_name);
9698                 } else {
9699                         r->in.server_name = NULL;
9700                 }
9701                 if (r->in.server_name) {
9702                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9703                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
9704                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
9705                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
9706                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
9707                                 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));
9708                         }
9709                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
9710                         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));
9711                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
9712                 }
9713                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
9714                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
9715                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
9716                         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));
9717                 }
9718                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
9719                 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));
9720                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
9721                 if (_ptr_Account) {
9722                         NDR_PULL_ALLOC(ndr, r->in.Account);
9723                 } else {
9724                         r->in.Account = NULL;
9725                 }
9726                 if (r->in.Account) {
9727                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
9728                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
9729                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
9730                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
9731                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
9732                                 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));
9733                         }
9734                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
9735                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
9736                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
9737                 }
9738                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
9739                 if (_ptr_EncryptedPassword) {
9740                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
9741                 } else {
9742                         r->in.EncryptedPassword = NULL;
9743                 }
9744                 if (r->in.EncryptedPassword) {
9745                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
9746                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
9747                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9748                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
9749                 }
9750                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9751                         NDR_PULL_ALLOC(ndr, r->in.num_ous);
9752                 }
9753                 _mem_save_num_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);
9754                 NDR_PULL_SET_MEM_CTX(ndr, r->in.num_ous, LIBNDR_FLAG_REF_ALLOC);
9755                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.num_ous));
9756                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_ous_0, LIBNDR_FLAG_REF_ALLOC);
9757                 NDR_PULL_ALLOC(ndr, r->out.num_ous);
9758                 *r->out.num_ous = *r->in.num_ous;
9759                 NDR_PULL_ALLOC(ndr, r->out.ous);
9760                 ZERO_STRUCTP(r->out.ous);
9761         }
9762         if (flags & NDR_OUT) {
9763                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9764                         NDR_PULL_ALLOC(ndr, r->out.num_ous);
9765                 }
9766                 _mem_save_num_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);
9767                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_ous, LIBNDR_FLAG_REF_ALLOC);
9768                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_ous));
9769                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_ous_0, LIBNDR_FLAG_REF_ALLOC);
9770                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9771                         NDR_PULL_ALLOC(ndr, r->out.ous);
9772                 }
9773                 _mem_save_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);
9774                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ous, LIBNDR_FLAG_REF_ALLOC);
9775                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ous));
9776                 if (_ptr_ous) {
9777                         NDR_PULL_ALLOC(ndr, *r->out.ous);
9778                 } else {
9779                         *r->out.ous = NULL;
9780                 }
9781                 if (*r->out.ous) {
9782                         _mem_save_ous_1 = NDR_PULL_GET_MEM_CTX(ndr);
9783                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.ous, 0);
9784                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.ous));
9785                         NDR_PULL_ALLOC_N(ndr, *r->out.ous, ndr_get_array_size(ndr, r->out.ous));
9786                         _mem_save_ous_2 = NDR_PULL_GET_MEM_CTX(ndr);
9787                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.ous, 0);
9788                         for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {
9789                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ous));
9790                                 if (_ptr_ous) {
9791                                         NDR_PULL_ALLOC(ndr, (*r->out.ous)[cntr_ous_2]);
9792                                 } else {
9793                                         (*r->out.ous)[cntr_ous_2] = NULL;
9794                                 }
9795                         }
9796                         for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {
9797                                 if ((*r->out.ous)[cntr_ous_2]) {
9798                                         _mem_save_ous_3 = NDR_PULL_GET_MEM_CTX(ndr);
9799                                         NDR_PULL_SET_MEM_CTX(ndr, (*r->out.ous)[cntr_ous_2], 0);
9800                                         NDR_CHECK(ndr_pull_array_size(ndr, &(*r->out.ous)[cntr_ous_2]));
9801                                         NDR_CHECK(ndr_pull_array_length(ndr, &(*r->out.ous)[cntr_ous_2]));
9802                                         if (ndr_get_array_length(ndr, &(*r->out.ous)[cntr_ous_2]) > ndr_get_array_size(ndr, &(*r->out.ous)[cntr_ous_2])) {
9803                                                 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.ous)[cntr_ous_2]), ndr_get_array_length(ndr, &(*r->out.ous)[cntr_ous_2]));
9804                                         }
9805                                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &(*r->out.ous)[cntr_ous_2]), sizeof(uint16_t)));
9806                                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &(*r->out.ous)[cntr_ous_2], ndr_get_array_length(ndr, &(*r->out.ous)[cntr_ous_2]), sizeof(uint16_t), CH_UTF16));
9807                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_3, 0);
9808                                 }
9809                         }
9810                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_2, 0);
9811                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_1, 0);
9812                 }
9813                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_0, LIBNDR_FLAG_REF_ALLOC);
9814                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9815                 if (*r->out.ous) {
9816                         NDR_CHECK(ndr_check_array_size(ndr, (void*)r->out.ous, *r->out.num_ous));
9817                 }
9818         }
9819         return NDR_ERR_SUCCESS;
9820 }
9821
9822 _PUBLIC_ void ndr_print_wkssvc_NetrGetJoinableOus2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrGetJoinableOus2 *r)
9823 {
9824         uint32_t cntr_ous_2;
9825         ndr_print_struct(ndr, name, "wkssvc_NetrGetJoinableOus2");
9826         ndr->depth++;
9827         if (flags & NDR_SET_VALUES) {
9828                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9829         }
9830         if (flags & NDR_IN) {
9831                 ndr_print_struct(ndr, "in", "wkssvc_NetrGetJoinableOus2");
9832                 ndr->depth++;
9833                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
9834                 ndr->depth++;
9835                 if (r->in.server_name) {
9836                         ndr_print_string(ndr, "server_name", r->in.server_name);
9837                 }
9838                 ndr->depth--;
9839                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
9840                 ndr->depth++;
9841                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
9842                 ndr->depth--;
9843                 ndr_print_ptr(ndr, "Account", r->in.Account);
9844                 ndr->depth++;
9845                 if (r->in.Account) {
9846                         ndr_print_string(ndr, "Account", r->in.Account);
9847                 }
9848                 ndr->depth--;
9849                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9850                 ndr->depth++;
9851                 if (r->in.EncryptedPassword) {
9852                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9853                 }
9854                 ndr->depth--;
9855                 ndr_print_ptr(ndr, "num_ous", r->in.num_ous);
9856                 ndr->depth++;
9857                 ndr_print_uint32(ndr, "num_ous", *r->in.num_ous);
9858                 ndr->depth--;
9859                 ndr->depth--;
9860         }
9861         if (flags & NDR_OUT) {
9862                 ndr_print_struct(ndr, "out", "wkssvc_NetrGetJoinableOus2");
9863                 ndr->depth++;
9864                 ndr_print_ptr(ndr, "num_ous", r->out.num_ous);
9865                 ndr->depth++;
9866                 ndr_print_uint32(ndr, "num_ous", *r->out.num_ous);
9867                 ndr->depth--;
9868                 ndr_print_ptr(ndr, "ous", r->out.ous);
9869                 ndr->depth++;
9870                 ndr_print_ptr(ndr, "ous", *r->out.ous);
9871                 ndr->depth++;
9872                 if (*r->out.ous) {
9873                         ndr->print(ndr, "%s: ARRAY(%d)", "ous", (int)*r->out.num_ous);
9874                         ndr->depth++;
9875                         for (cntr_ous_2=0;cntr_ous_2<*r->out.num_ous;cntr_ous_2++) {
9876                                 char *idx_2=NULL;
9877                                 if (asprintf(&idx_2, "[%d]", cntr_ous_2) != -1) {
9878                                         ndr_print_ptr(ndr, "ous", (*r->out.ous)[cntr_ous_2]);
9879                                         ndr->depth++;
9880                                         if ((*r->out.ous)[cntr_ous_2]) {
9881                                                 ndr_print_string(ndr, "ous", (*r->out.ous)[cntr_ous_2]);
9882                                         }
9883                                         ndr->depth--;
9884                                         free(idx_2);
9885                                 }
9886                         }
9887                         ndr->depth--;
9888                 }
9889                 ndr->depth--;
9890                 ndr->depth--;
9891                 ndr_print_WERROR(ndr, "result", r->out.result);
9892                 ndr->depth--;
9893         }
9894         ndr->depth--;
9895 }
9896
9897 static enum ndr_err_code ndr_push_wkssvc_NetrAddAlternateComputerName(struct ndr_push *ndr, int flags, const struct wkssvc_NetrAddAlternateComputerName *r)
9898 {
9899         if (flags & NDR_IN) {
9900                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
9901                 if (r->in.server_name) {
9902                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9903                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9904                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9905                         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));
9906                 }
9907                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.NewAlternateMachineName));
9908                 if (r->in.NewAlternateMachineName) {
9909                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewAlternateMachineName, CH_UTF16)));
9910                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9911                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewAlternateMachineName, CH_UTF16)));
9912                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.NewAlternateMachineName, ndr_charset_length(r->in.NewAlternateMachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9913                 }
9914                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
9915                 if (r->in.Account) {
9916                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9917                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9918                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9919                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9920                 }
9921                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
9922                 if (r->in.EncryptedPassword) {
9923                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9924                 }
9925                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Reserved));
9926         }
9927         if (flags & NDR_OUT) {
9928                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9929         }
9930         return NDR_ERR_SUCCESS;
9931 }
9932
9933 static enum ndr_err_code ndr_pull_wkssvc_NetrAddAlternateComputerName(struct ndr_pull *ndr, int flags, struct wkssvc_NetrAddAlternateComputerName *r)
9934 {
9935         uint32_t _ptr_server_name;
9936         uint32_t _ptr_NewAlternateMachineName;
9937         uint32_t _ptr_Account;
9938         uint32_t _ptr_EncryptedPassword;
9939         TALLOC_CTX *_mem_save_server_name_0;
9940         TALLOC_CTX *_mem_save_NewAlternateMachineName_0;
9941         TALLOC_CTX *_mem_save_Account_0;
9942         TALLOC_CTX *_mem_save_EncryptedPassword_0;
9943         if (flags & NDR_IN) {
9944                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
9945                 if (_ptr_server_name) {
9946                         NDR_PULL_ALLOC(ndr, r->in.server_name);
9947                 } else {
9948                         r->in.server_name = NULL;
9949                 }
9950                 if (r->in.server_name) {
9951                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9952                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
9953                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
9954                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
9955                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
9956                                 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));
9957                         }
9958                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
9959                         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));
9960                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
9961                 }
9962                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_NewAlternateMachineName));
9963                 if (_ptr_NewAlternateMachineName) {
9964                         NDR_PULL_ALLOC(ndr, r->in.NewAlternateMachineName);
9965                 } else {
9966                         r->in.NewAlternateMachineName = NULL;
9967                 }
9968                 if (r->in.NewAlternateMachineName) {
9969                         _mem_save_NewAlternateMachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);
9970                         NDR_PULL_SET_MEM_CTX(ndr, r->in.NewAlternateMachineName, 0);
9971                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.NewAlternateMachineName));
9972                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.NewAlternateMachineName));
9973                         if (ndr_get_array_length(ndr, &r->in.NewAlternateMachineName) > ndr_get_array_size(ndr, &r->in.NewAlternateMachineName)) {
9974                                 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));
9975                         }
9976                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.NewAlternateMachineName), sizeof(uint16_t)));
9977                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.NewAlternateMachineName, ndr_get_array_length(ndr, &r->in.NewAlternateMachineName), sizeof(uint16_t), CH_UTF16));
9978                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_NewAlternateMachineName_0, 0);
9979                 }
9980                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
9981                 if (_ptr_Account) {
9982                         NDR_PULL_ALLOC(ndr, r->in.Account);
9983                 } else {
9984                         r->in.Account = NULL;
9985                 }
9986                 if (r->in.Account) {
9987                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
9988                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
9989                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
9990                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
9991                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
9992                                 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));
9993                         }
9994                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
9995                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
9996                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
9997                 }
9998                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
9999                 if (_ptr_EncryptedPassword) {
10000                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
10001                 } else {
10002                         r->in.EncryptedPassword = NULL;
10003                 }
10004                 if (r->in.EncryptedPassword) {
10005                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
10006                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
10007                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
10008                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
10009                 }
10010                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Reserved));
10011         }
10012         if (flags & NDR_OUT) {
10013                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
10014         }
10015         return NDR_ERR_SUCCESS;
10016 }
10017
10018 _PUBLIC_ void ndr_print_wkssvc_NetrAddAlternateComputerName(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrAddAlternateComputerName *r)
10019 {
10020         ndr_print_struct(ndr, name, "wkssvc_NetrAddAlternateComputerName");
10021         ndr->depth++;
10022         if (flags & NDR_SET_VALUES) {
10023                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10024         }
10025         if (flags & NDR_IN) {
10026                 ndr_print_struct(ndr, "in", "wkssvc_NetrAddAlternateComputerName");
10027                 ndr->depth++;
10028                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
10029                 ndr->depth++;
10030                 if (r->in.server_name) {
10031                         ndr_print_string(ndr, "server_name", r->in.server_name);
10032                 }
10033                 ndr->depth--;
10034                 ndr_print_ptr(ndr, "NewAlternateMachineName", r->in.NewAlternateMachineName);
10035                 ndr->depth++;
10036                 if (r->in.NewAlternateMachineName) {
10037                         ndr_print_string(ndr, "NewAlternateMachineName", r->in.NewAlternateMachineName);
10038                 }
10039                 ndr->depth--;
10040                 ndr_print_ptr(ndr, "Account", r->in.Account);
10041                 ndr->depth++;
10042                 if (r->in.Account) {
10043                         ndr_print_string(ndr, "Account", r->in.Account);
10044                 }
10045                 ndr->depth--;
10046                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
10047                 ndr->depth++;
10048                 if (r->in.EncryptedPassword) {
10049                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
10050                 }
10051                 ndr->depth--;
10052                 ndr_print_uint32(ndr, "Reserved", r->in.Reserved);
10053                 ndr->depth--;
10054         }
10055         if (flags & NDR_OUT) {
10056                 ndr_print_struct(ndr, "out", "wkssvc_NetrAddAlternateComputerName");
10057                 ndr->depth++;
10058                 ndr_print_WERROR(ndr, "result", r->out.result);
10059                 ndr->depth--;
10060         }
10061         ndr->depth--;
10062 }
10063
10064 static enum ndr_err_code ndr_push_wkssvc_NetrRemoveAlternateComputerName(struct ndr_push *ndr, int flags, const struct wkssvc_NetrRemoveAlternateComputerName *r)
10065 {
10066         if (flags & NDR_IN) {
10067                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
10068                 if (r->in.server_name) {
10069                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
10070                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10071                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
10072                         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));
10073                 }
10074                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.AlternateMachineNameToRemove));
10075                 if (r->in.AlternateMachineNameToRemove) {
10076                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.AlternateMachineNameToRemove, CH_UTF16)));
10077                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10078                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.AlternateMachineNameToRemove, CH_UTF16)));
10079                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.AlternateMachineNameToRemove, ndr_charset_length(r->in.AlternateMachineNameToRemove, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10080                 }
10081                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
10082                 if (r->in.Account) {
10083                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
10084                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10085                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
10086                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10087                 }
10088                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
10089                 if (r->in.EncryptedPassword) {
10090                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
10091                 }
10092                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Reserved));
10093         }
10094         if (flags & NDR_OUT) {
10095                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
10096         }
10097         return NDR_ERR_SUCCESS;
10098 }
10099
10100 static enum ndr_err_code ndr_pull_wkssvc_NetrRemoveAlternateComputerName(struct ndr_pull *ndr, int flags, struct wkssvc_NetrRemoveAlternateComputerName *r)
10101 {
10102         uint32_t _ptr_server_name;
10103         uint32_t _ptr_AlternateMachineNameToRemove;
10104         uint32_t _ptr_Account;
10105         uint32_t _ptr_EncryptedPassword;
10106         TALLOC_CTX *_mem_save_server_name_0;
10107         TALLOC_CTX *_mem_save_AlternateMachineNameToRemove_0;
10108         TALLOC_CTX *_mem_save_Account_0;
10109         TALLOC_CTX *_mem_save_EncryptedPassword_0;
10110         if (flags & NDR_IN) {
10111                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
10112                 if (_ptr_server_name) {
10113                         NDR_PULL_ALLOC(ndr, r->in.server_name);
10114                 } else {
10115                         r->in.server_name = NULL;
10116                 }
10117                 if (r->in.server_name) {
10118                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10119                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
10120                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
10121                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
10122                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
10123                                 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));
10124                         }
10125                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
10126                         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));
10127                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
10128                 }
10129                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_AlternateMachineNameToRemove));
10130                 if (_ptr_AlternateMachineNameToRemove) {
10131                         NDR_PULL_ALLOC(ndr, r->in.AlternateMachineNameToRemove);
10132                 } else {
10133                         r->in.AlternateMachineNameToRemove = NULL;
10134                 }
10135                 if (r->in.AlternateMachineNameToRemove) {
10136                         _mem_save_AlternateMachineNameToRemove_0 = NDR_PULL_GET_MEM_CTX(ndr);
10137                         NDR_PULL_SET_MEM_CTX(ndr, r->in.AlternateMachineNameToRemove, 0);
10138                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.AlternateMachineNameToRemove));
10139                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.AlternateMachineNameToRemove));
10140                         if (ndr_get_array_length(ndr, &r->in.AlternateMachineNameToRemove) > ndr_get_array_size(ndr, &r->in.AlternateMachineNameToRemove)) {
10141                                 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));
10142                         }
10143                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.AlternateMachineNameToRemove), sizeof(uint16_t)));
10144                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.AlternateMachineNameToRemove, ndr_get_array_length(ndr, &r->in.AlternateMachineNameToRemove), sizeof(uint16_t), CH_UTF16));
10145                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_AlternateMachineNameToRemove_0, 0);
10146                 }
10147                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
10148                 if (_ptr_Account) {
10149                         NDR_PULL_ALLOC(ndr, r->in.Account);
10150                 } else {
10151                         r->in.Account = NULL;
10152                 }
10153                 if (r->in.Account) {
10154                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
10155                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
10156                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
10157                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
10158                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
10159                                 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));
10160                         }
10161                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
10162                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
10163                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
10164                 }
10165                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
10166                 if (_ptr_EncryptedPassword) {
10167                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
10168                 } else {
10169                         r->in.EncryptedPassword = NULL;
10170                 }
10171                 if (r->in.EncryptedPassword) {
10172                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
10173                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
10174                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
10175                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
10176                 }
10177                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Reserved));
10178         }
10179         if (flags & NDR_OUT) {
10180                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
10181         }
10182         return NDR_ERR_SUCCESS;
10183 }
10184
10185 _PUBLIC_ void ndr_print_wkssvc_NetrRemoveAlternateComputerName(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrRemoveAlternateComputerName *r)
10186 {
10187         ndr_print_struct(ndr, name, "wkssvc_NetrRemoveAlternateComputerName");
10188         ndr->depth++;
10189         if (flags & NDR_SET_VALUES) {
10190                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10191         }
10192         if (flags & NDR_IN) {
10193                 ndr_print_struct(ndr, "in", "wkssvc_NetrRemoveAlternateComputerName");
10194                 ndr->depth++;
10195                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
10196                 ndr->depth++;
10197                 if (r->in.server_name) {
10198                         ndr_print_string(ndr, "server_name", r->in.server_name);
10199                 }
10200                 ndr->depth--;
10201                 ndr_print_ptr(ndr, "AlternateMachineNameToRemove", r->in.AlternateMachineNameToRemove);
10202                 ndr->depth++;
10203                 if (r->in.AlternateMachineNameToRemove) {
10204                         ndr_print_string(ndr, "AlternateMachineNameToRemove", r->in.AlternateMachineNameToRemove);
10205                 }
10206                 ndr->depth--;
10207                 ndr_print_ptr(ndr, "Account", r->in.Account);
10208                 ndr->depth++;
10209                 if (r->in.Account) {
10210                         ndr_print_string(ndr, "Account", r->in.Account);
10211                 }
10212                 ndr->depth--;
10213                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
10214                 ndr->depth++;
10215                 if (r->in.EncryptedPassword) {
10216                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
10217                 }
10218                 ndr->depth--;
10219                 ndr_print_uint32(ndr, "Reserved", r->in.Reserved);
10220                 ndr->depth--;
10221         }
10222         if (flags & NDR_OUT) {
10223                 ndr_print_struct(ndr, "out", "wkssvc_NetrRemoveAlternateComputerName");
10224                 ndr->depth++;
10225                 ndr_print_WERROR(ndr, "result", r->out.result);
10226                 ndr->depth--;
10227         }
10228         ndr->depth--;
10229 }
10230
10231 static enum ndr_err_code ndr_push_wkssvc_NetrSetPrimaryComputername(struct ndr_push *ndr, int flags, const struct wkssvc_NetrSetPrimaryComputername *r)
10232 {
10233         if (flags & NDR_IN) {
10234                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
10235                 if (r->in.server_name) {
10236                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
10237                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10238                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
10239                         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));
10240                 }
10241                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.primary_name));
10242                 if (r->in.primary_name) {
10243                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.primary_name, CH_UTF16)));
10244                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10245                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.primary_name, CH_UTF16)));
10246                         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));
10247                 }
10248                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
10249                 if (r->in.Account) {
10250                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
10251                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10252                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
10253                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10254                 }
10255                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
10256                 if (r->in.EncryptedPassword) {
10257                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
10258                 }
10259                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Reserved));
10260         }
10261         if (flags & NDR_OUT) {
10262                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
10263         }
10264         return NDR_ERR_SUCCESS;
10265 }
10266
10267 static enum ndr_err_code ndr_pull_wkssvc_NetrSetPrimaryComputername(struct ndr_pull *ndr, int flags, struct wkssvc_NetrSetPrimaryComputername *r)
10268 {
10269         uint32_t _ptr_server_name;
10270         uint32_t _ptr_primary_name;
10271         uint32_t _ptr_Account;
10272         uint32_t _ptr_EncryptedPassword;
10273         TALLOC_CTX *_mem_save_server_name_0;
10274         TALLOC_CTX *_mem_save_primary_name_0;
10275         TALLOC_CTX *_mem_save_Account_0;
10276         TALLOC_CTX *_mem_save_EncryptedPassword_0;
10277         if (flags & NDR_IN) {
10278                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
10279                 if (_ptr_server_name) {
10280                         NDR_PULL_ALLOC(ndr, r->in.server_name);
10281                 } else {
10282                         r->in.server_name = NULL;
10283                 }
10284                 if (r->in.server_name) {
10285                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10286                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
10287                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
10288                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
10289                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
10290                                 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));
10291                         }
10292                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
10293                         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));
10294                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
10295                 }
10296                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_primary_name));
10297                 if (_ptr_primary_name) {
10298                         NDR_PULL_ALLOC(ndr, r->in.primary_name);
10299                 } else {
10300                         r->in.primary_name = NULL;
10301                 }
10302                 if (r->in.primary_name) {
10303                         _mem_save_primary_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10304                         NDR_PULL_SET_MEM_CTX(ndr, r->in.primary_name, 0);
10305                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.primary_name));
10306                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.primary_name));
10307                         if (ndr_get_array_length(ndr, &r->in.primary_name) > ndr_get_array_size(ndr, &r->in.primary_name)) {
10308                                 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));
10309                         }
10310                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.primary_name), sizeof(uint16_t)));
10311                         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));
10312                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_primary_name_0, 0);
10313                 }
10314                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
10315                 if (_ptr_Account) {
10316                         NDR_PULL_ALLOC(ndr, r->in.Account);
10317                 } else {
10318                         r->in.Account = NULL;
10319                 }
10320                 if (r->in.Account) {
10321                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
10322                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
10323                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
10324                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
10325                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
10326                                 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));
10327                         }
10328                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
10329                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
10330                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
10331                 }
10332                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
10333                 if (_ptr_EncryptedPassword) {
10334                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
10335                 } else {
10336                         r->in.EncryptedPassword = NULL;
10337                 }
10338                 if (r->in.EncryptedPassword) {
10339                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
10340                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
10341                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
10342                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
10343                 }
10344                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Reserved));
10345         }
10346         if (flags & NDR_OUT) {
10347                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
10348         }
10349         return NDR_ERR_SUCCESS;
10350 }
10351
10352 _PUBLIC_ void ndr_print_wkssvc_NetrSetPrimaryComputername(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrSetPrimaryComputername *r)
10353 {
10354         ndr_print_struct(ndr, name, "wkssvc_NetrSetPrimaryComputername");
10355         ndr->depth++;
10356         if (flags & NDR_SET_VALUES) {
10357                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10358         }
10359         if (flags & NDR_IN) {
10360                 ndr_print_struct(ndr, "in", "wkssvc_NetrSetPrimaryComputername");
10361                 ndr->depth++;
10362                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
10363                 ndr->depth++;
10364                 if (r->in.server_name) {
10365                         ndr_print_string(ndr, "server_name", r->in.server_name);
10366                 }
10367                 ndr->depth--;
10368                 ndr_print_ptr(ndr, "primary_name", r->in.primary_name);
10369                 ndr->depth++;
10370                 if (r->in.primary_name) {
10371                         ndr_print_string(ndr, "primary_name", r->in.primary_name);
10372                 }
10373                 ndr->depth--;
10374                 ndr_print_ptr(ndr, "Account", r->in.Account);
10375                 ndr->depth++;
10376                 if (r->in.Account) {
10377                         ndr_print_string(ndr, "Account", r->in.Account);
10378                 }
10379                 ndr->depth--;
10380                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
10381                 ndr->depth++;
10382                 if (r->in.EncryptedPassword) {
10383                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
10384                 }
10385                 ndr->depth--;
10386                 ndr_print_uint32(ndr, "Reserved", r->in.Reserved);
10387                 ndr->depth--;
10388         }
10389         if (flags & NDR_OUT) {
10390                 ndr_print_struct(ndr, "out", "wkssvc_NetrSetPrimaryComputername");
10391                 ndr->depth++;
10392                 ndr_print_WERROR(ndr, "result", r->out.result);
10393                 ndr->depth--;
10394         }
10395         ndr->depth--;
10396 }
10397
10398 static enum ndr_err_code ndr_push_wkssvc_NetrEnumerateComputerNames(struct ndr_push *ndr, int flags, const struct wkssvc_NetrEnumerateComputerNames *r)
10399 {
10400         if (flags & NDR_IN) {
10401                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
10402                 if (r->in.server_name) {
10403                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
10404                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10405                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
10406                         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));
10407                 }
10408                 NDR_CHECK(ndr_push_wkssvc_ComputerNameType(ndr, NDR_SCALARS, r->in.name_type));
10409                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Reserved));
10410         }
10411         if (flags & NDR_OUT) {
10412                 if (r->out.ctr == NULL) {
10413                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10414                 }
10415                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.ctr));
10416                 if (*r->out.ctr) {
10417                         NDR_CHECK(ndr_push_wkssvc_ComputerNamesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.ctr));
10418                 }
10419                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
10420         }
10421         return NDR_ERR_SUCCESS;
10422 }
10423
10424 static enum ndr_err_code ndr_pull_wkssvc_NetrEnumerateComputerNames(struct ndr_pull *ndr, int flags, struct wkssvc_NetrEnumerateComputerNames *r)
10425 {
10426         uint32_t _ptr_server_name;
10427         uint32_t _ptr_ctr;
10428         TALLOC_CTX *_mem_save_server_name_0;
10429         TALLOC_CTX *_mem_save_ctr_0;
10430         TALLOC_CTX *_mem_save_ctr_1;
10431         if (flags & NDR_IN) {
10432                 ZERO_STRUCT(r->out);
10433
10434                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
10435                 if (_ptr_server_name) {
10436                         NDR_PULL_ALLOC(ndr, r->in.server_name);
10437                 } else {
10438                         r->in.server_name = NULL;
10439                 }
10440                 if (r->in.server_name) {
10441                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10442                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
10443                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
10444                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
10445                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
10446                                 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));
10447                         }
10448                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
10449                         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));
10450                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
10451                 }
10452                 NDR_CHECK(ndr_pull_wkssvc_ComputerNameType(ndr, NDR_SCALARS, &r->in.name_type));
10453                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Reserved));
10454                 NDR_PULL_ALLOC(ndr, r->out.ctr);
10455                 ZERO_STRUCTP(r->out.ctr);
10456         }
10457         if (flags & NDR_OUT) {
10458                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10459                         NDR_PULL_ALLOC(ndr, r->out.ctr);
10460                 }
10461                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
10462                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
10463                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
10464                 if (_ptr_ctr) {
10465                         NDR_PULL_ALLOC(ndr, *r->out.ctr);
10466                 } else {
10467                         *r->out.ctr = NULL;
10468                 }
10469                 if (*r->out.ctr) {
10470                         _mem_save_ctr_1 = NDR_PULL_GET_MEM_CTX(ndr);
10471                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.ctr, 0);
10472                         NDR_CHECK(ndr_pull_wkssvc_ComputerNamesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.ctr));
10473                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_1, 0);
10474                 }
10475                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
10476                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
10477         }
10478         return NDR_ERR_SUCCESS;
10479 }
10480
10481 _PUBLIC_ void ndr_print_wkssvc_NetrEnumerateComputerNames(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrEnumerateComputerNames *r)
10482 {
10483         ndr_print_struct(ndr, name, "wkssvc_NetrEnumerateComputerNames");
10484         ndr->depth++;
10485         if (flags & NDR_SET_VALUES) {
10486                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10487         }
10488         if (flags & NDR_IN) {
10489                 ndr_print_struct(ndr, "in", "wkssvc_NetrEnumerateComputerNames");
10490                 ndr->depth++;
10491                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
10492                 ndr->depth++;
10493                 if (r->in.server_name) {
10494                         ndr_print_string(ndr, "server_name", r->in.server_name);
10495                 }
10496                 ndr->depth--;
10497                 ndr_print_wkssvc_ComputerNameType(ndr, "name_type", r->in.name_type);
10498                 ndr_print_uint32(ndr, "Reserved", r->in.Reserved);
10499                 ndr->depth--;
10500         }
10501         if (flags & NDR_OUT) {
10502                 ndr_print_struct(ndr, "out", "wkssvc_NetrEnumerateComputerNames");
10503                 ndr->depth++;
10504                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
10505                 ndr->depth++;
10506                 ndr_print_ptr(ndr, "ctr", *r->out.ctr);
10507                 ndr->depth++;
10508                 if (*r->out.ctr) {
10509                         ndr_print_wkssvc_ComputerNamesCtr(ndr, "ctr", *r->out.ctr);
10510                 }
10511                 ndr->depth--;
10512                 ndr->depth--;
10513                 ndr_print_WERROR(ndr, "result", r->out.result);
10514                 ndr->depth--;
10515         }
10516         ndr->depth--;
10517 }
10518
10519 static const struct ndr_interface_call wkssvc_calls[] = {
10520         {
10521                 "wkssvc_NetWkstaGetInfo",
10522                 sizeof(struct wkssvc_NetWkstaGetInfo),
10523                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaGetInfo,
10524                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaGetInfo,
10525                 (ndr_print_function_t) ndr_print_wkssvc_NetWkstaGetInfo,
10526                 false,
10527         },
10528         {
10529                 "wkssvc_NetWkstaSetInfo",
10530                 sizeof(struct wkssvc_NetWkstaSetInfo),
10531                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaSetInfo,
10532                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaSetInfo,
10533                 (ndr_print_function_t) ndr_print_wkssvc_NetWkstaSetInfo,
10534                 false,
10535         },
10536         {
10537                 "wkssvc_NetWkstaEnumUsers",
10538                 sizeof(struct wkssvc_NetWkstaEnumUsers),
10539                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaEnumUsers,
10540                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaEnumUsers,
10541                 (ndr_print_function_t) ndr_print_wkssvc_NetWkstaEnumUsers,
10542                 false,
10543         },
10544         {
10545                 "wkssvc_NetrWkstaUserGetInfo",
10546                 sizeof(struct wkssvc_NetrWkstaUserGetInfo),
10547                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrWkstaUserGetInfo,
10548                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrWkstaUserGetInfo,
10549                 (ndr_print_function_t) ndr_print_wkssvc_NetrWkstaUserGetInfo,
10550                 false,
10551         },
10552         {
10553                 "wkssvc_NetrWkstaUserSetInfo",
10554                 sizeof(struct wkssvc_NetrWkstaUserSetInfo),
10555                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrWkstaUserSetInfo,
10556                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrWkstaUserSetInfo,
10557                 (ndr_print_function_t) ndr_print_wkssvc_NetrWkstaUserSetInfo,
10558                 false,
10559         },
10560         {
10561                 "wkssvc_NetWkstaTransportEnum",
10562                 sizeof(struct wkssvc_NetWkstaTransportEnum),
10563                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaTransportEnum,
10564                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaTransportEnum,
10565                 (ndr_print_function_t) ndr_print_wkssvc_NetWkstaTransportEnum,
10566                 false,
10567         },
10568         {
10569                 "wkssvc_NetrWkstaTransportAdd",
10570                 sizeof(struct wkssvc_NetrWkstaTransportAdd),
10571                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrWkstaTransportAdd,
10572                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrWkstaTransportAdd,
10573                 (ndr_print_function_t) ndr_print_wkssvc_NetrWkstaTransportAdd,
10574                 false,
10575         },
10576         {
10577                 "wkssvc_NetrWkstaTransportDel",
10578                 sizeof(struct wkssvc_NetrWkstaTransportDel),
10579                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrWkstaTransportDel,
10580                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrWkstaTransportDel,
10581                 (ndr_print_function_t) ndr_print_wkssvc_NetrWkstaTransportDel,
10582                 false,
10583         },
10584         {
10585                 "wkssvc_NetrUseAdd",
10586                 sizeof(struct wkssvc_NetrUseAdd),
10587                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUseAdd,
10588                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUseAdd,
10589                 (ndr_print_function_t) ndr_print_wkssvc_NetrUseAdd,
10590                 false,
10591         },
10592         {
10593                 "wkssvc_NetrUseGetInfo",
10594                 sizeof(struct wkssvc_NetrUseGetInfo),
10595                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUseGetInfo,
10596                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUseGetInfo,
10597                 (ndr_print_function_t) ndr_print_wkssvc_NetrUseGetInfo,
10598                 false,
10599         },
10600         {
10601                 "wkssvc_NetrUseDel",
10602                 sizeof(struct wkssvc_NetrUseDel),
10603                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUseDel,
10604                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUseDel,
10605                 (ndr_print_function_t) ndr_print_wkssvc_NetrUseDel,
10606                 false,
10607         },
10608         {
10609                 "wkssvc_NetrUseEnum",
10610                 sizeof(struct wkssvc_NetrUseEnum),
10611                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUseEnum,
10612                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUseEnum,
10613                 (ndr_print_function_t) ndr_print_wkssvc_NetrUseEnum,
10614                 false,
10615         },
10616         {
10617                 "wkssvc_NetrMessageBufferSend",
10618                 sizeof(struct wkssvc_NetrMessageBufferSend),
10619                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrMessageBufferSend,
10620                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrMessageBufferSend,
10621                 (ndr_print_function_t) ndr_print_wkssvc_NetrMessageBufferSend,
10622                 false,
10623         },
10624         {
10625                 "wkssvc_NetrWorkstationStatisticsGet",
10626                 sizeof(struct wkssvc_NetrWorkstationStatisticsGet),
10627                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrWorkstationStatisticsGet,
10628                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrWorkstationStatisticsGet,
10629                 (ndr_print_function_t) ndr_print_wkssvc_NetrWorkstationStatisticsGet,
10630                 false,
10631         },
10632         {
10633                 "wkssvc_NetrLogonDomainNameAdd",
10634                 sizeof(struct wkssvc_NetrLogonDomainNameAdd),
10635                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrLogonDomainNameAdd,
10636                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrLogonDomainNameAdd,
10637                 (ndr_print_function_t) ndr_print_wkssvc_NetrLogonDomainNameAdd,
10638                 false,
10639         },
10640         {
10641                 "wkssvc_NetrLogonDomainNameDel",
10642                 sizeof(struct wkssvc_NetrLogonDomainNameDel),
10643                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrLogonDomainNameDel,
10644                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrLogonDomainNameDel,
10645                 (ndr_print_function_t) ndr_print_wkssvc_NetrLogonDomainNameDel,
10646                 false,
10647         },
10648         {
10649                 "wkssvc_NetrJoinDomain",
10650                 sizeof(struct wkssvc_NetrJoinDomain),
10651                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrJoinDomain,
10652                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrJoinDomain,
10653                 (ndr_print_function_t) ndr_print_wkssvc_NetrJoinDomain,
10654                 false,
10655         },
10656         {
10657                 "wkssvc_NetrUnjoinDomain",
10658                 sizeof(struct wkssvc_NetrUnjoinDomain),
10659                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUnjoinDomain,
10660                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUnjoinDomain,
10661                 (ndr_print_function_t) ndr_print_wkssvc_NetrUnjoinDomain,
10662                 false,
10663         },
10664         {
10665                 "wkssvc_NetrRenameMachineInDomain",
10666                 sizeof(struct wkssvc_NetrRenameMachineInDomain),
10667                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrRenameMachineInDomain,
10668                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrRenameMachineInDomain,
10669                 (ndr_print_function_t) ndr_print_wkssvc_NetrRenameMachineInDomain,
10670                 false,
10671         },
10672         {
10673                 "wkssvc_NetrValidateName",
10674                 sizeof(struct wkssvc_NetrValidateName),
10675                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrValidateName,
10676                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrValidateName,
10677                 (ndr_print_function_t) ndr_print_wkssvc_NetrValidateName,
10678                 false,
10679         },
10680         {
10681                 "wkssvc_NetrGetJoinInformation",
10682                 sizeof(struct wkssvc_NetrGetJoinInformation),
10683                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrGetJoinInformation,
10684                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrGetJoinInformation,
10685                 (ndr_print_function_t) ndr_print_wkssvc_NetrGetJoinInformation,
10686                 false,
10687         },
10688         {
10689                 "wkssvc_NetrGetJoinableOus",
10690                 sizeof(struct wkssvc_NetrGetJoinableOus),
10691                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrGetJoinableOus,
10692                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrGetJoinableOus,
10693                 (ndr_print_function_t) ndr_print_wkssvc_NetrGetJoinableOus,
10694                 false,
10695         },
10696         {
10697                 "wkssvc_NetrJoinDomain2",
10698                 sizeof(struct wkssvc_NetrJoinDomain2),
10699                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrJoinDomain2,
10700                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrJoinDomain2,
10701                 (ndr_print_function_t) ndr_print_wkssvc_NetrJoinDomain2,
10702                 false,
10703         },
10704         {
10705                 "wkssvc_NetrUnjoinDomain2",
10706                 sizeof(struct wkssvc_NetrUnjoinDomain2),
10707                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUnjoinDomain2,
10708                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUnjoinDomain2,
10709                 (ndr_print_function_t) ndr_print_wkssvc_NetrUnjoinDomain2,
10710                 false,
10711         },
10712         {
10713                 "wkssvc_NetrRenameMachineInDomain2",
10714                 sizeof(struct wkssvc_NetrRenameMachineInDomain2),
10715                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrRenameMachineInDomain2,
10716                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrRenameMachineInDomain2,
10717                 (ndr_print_function_t) ndr_print_wkssvc_NetrRenameMachineInDomain2,
10718                 false,
10719         },
10720         {
10721                 "wkssvc_NetrValidateName2",
10722                 sizeof(struct wkssvc_NetrValidateName2),
10723                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrValidateName2,
10724                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrValidateName2,
10725                 (ndr_print_function_t) ndr_print_wkssvc_NetrValidateName2,
10726                 false,
10727         },
10728         {
10729                 "wkssvc_NetrGetJoinableOus2",
10730                 sizeof(struct wkssvc_NetrGetJoinableOus2),
10731                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrGetJoinableOus2,
10732                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrGetJoinableOus2,
10733                 (ndr_print_function_t) ndr_print_wkssvc_NetrGetJoinableOus2,
10734                 false,
10735         },
10736         {
10737                 "wkssvc_NetrAddAlternateComputerName",
10738                 sizeof(struct wkssvc_NetrAddAlternateComputerName),
10739                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrAddAlternateComputerName,
10740                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrAddAlternateComputerName,
10741                 (ndr_print_function_t) ndr_print_wkssvc_NetrAddAlternateComputerName,
10742                 false,
10743         },
10744         {
10745                 "wkssvc_NetrRemoveAlternateComputerName",
10746                 sizeof(struct wkssvc_NetrRemoveAlternateComputerName),
10747                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrRemoveAlternateComputerName,
10748                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrRemoveAlternateComputerName,
10749                 (ndr_print_function_t) ndr_print_wkssvc_NetrRemoveAlternateComputerName,
10750                 false,
10751         },
10752         {
10753                 "wkssvc_NetrSetPrimaryComputername",
10754                 sizeof(struct wkssvc_NetrSetPrimaryComputername),
10755                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrSetPrimaryComputername,
10756                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrSetPrimaryComputername,
10757                 (ndr_print_function_t) ndr_print_wkssvc_NetrSetPrimaryComputername,
10758                 false,
10759         },
10760         {
10761                 "wkssvc_NetrEnumerateComputerNames",
10762                 sizeof(struct wkssvc_NetrEnumerateComputerNames),
10763                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrEnumerateComputerNames,
10764                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrEnumerateComputerNames,
10765                 (ndr_print_function_t) ndr_print_wkssvc_NetrEnumerateComputerNames,
10766                 false,
10767         },
10768         { NULL, 0, NULL, NULL, NULL, false }
10769 };
10770
10771 static const char * const wkssvc_endpoint_strings[] = {
10772         "ncacn_np:[\\pipe\\wkssvc]",
10773         "ncacn_ip_tcp:",
10774         "ncalrpc:",
10775 };
10776
10777 static const struct ndr_interface_string_array wkssvc_endpoints = {
10778         .count  = 3,
10779         .names  = wkssvc_endpoint_strings
10780 };
10781
10782 static const char * const wkssvc_authservice_strings[] = {
10783         "host",
10784 };
10785
10786 static const struct ndr_interface_string_array wkssvc_authservices = {
10787         .count  = 1,
10788         .names  = wkssvc_authservice_strings
10789 };
10790
10791
10792 const struct ndr_interface_table ndr_table_wkssvc = {
10793         .name           = "wkssvc",
10794         .syntax_id      = {
10795                 {0x6bffd098,0xa112,0x3610,{0x98,0x33},{0x46,0xc3,0xf8,0x7e,0x34,0x5a}},
10796                 NDR_WKSSVC_VERSION
10797         },
10798         .helpstring     = NDR_WKSSVC_HELPSTRING,
10799         .num_calls      = 31,
10800         .calls          = wkssvc_calls,
10801         .endpoints      = &wkssvc_endpoints,
10802         .authservices   = &wkssvc_authservices
10803 };
10804