librpc/gen_ndr/ndr_wkssvc.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_wkssvc.h"
   5
   6 #include "librpc/gen_ndr/ndr_srvsvc.h"
   7 #include "librpc/gen_ndr/ndr_lsa.h"
   8 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo100(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo100 *r)
   9 {
  10         if (ndr_flags & NDR_SCALARS) {
  11                 NDR_CHECK(ndr_push_align(ndr, 4));
  12                 NDR_CHECK(ndr_push_srvsvc_PlatformId(ndr, NDR_SCALARS, r->platform_id));
  13                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
  14                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
  15                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_major));
  16                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_minor));
  17         }
  18         if (ndr_flags & NDR_BUFFERS) {
  19                 if (r->server_name) {
  20                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
  21                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  22                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
  23                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
  24                 }
  25                 if (r->domain_name) {
  26                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
  27                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  28                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
  29                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
  30                 }
  31         }
  32         return NDR_ERR_SUCCESS;
  33 }
  34
  35 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo100(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo100 *r)
  36 {
  37         uint32_t _ptr_server_name;
  38         TALLOC_CTX *_mem_save_server_name_0;
  39         uint32_t _ptr_domain_name;
  40         TALLOC_CTX *_mem_save_domain_name_0;
  41         if (ndr_flags & NDR_SCALARS) {
  42                 NDR_CHECK(ndr_pull_align(ndr, 4));
  43                 NDR_CHECK(ndr_pull_srvsvc_PlatformId(ndr, NDR_SCALARS, &r->platform_id));
  44                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
  45                 if (_ptr_server_name) {
  46                         NDR_PULL_ALLOC(ndr, r->server_name);
  47                 } else {
  48                         r->server_name = NULL;
  49                 }
  50                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
  51                 if (_ptr_domain_name) {
  52                         NDR_PULL_ALLOC(ndr, r->domain_name);
  53                 } else {
  54                         r->domain_name = NULL;
  55                 }
  56                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_major));
  57                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_minor));
  58         }
  59         if (ndr_flags & NDR_BUFFERS) {
  60                 if (r->server_name) {
  61                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
  62                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
  63                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
  64                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
  65                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
  66                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
  67                         }
  68                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
  69                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
  70                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
  71                 }
  72                 if (r->domain_name) {
  73                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
  74                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
  75                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
  76                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
  77                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
  78                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->domain_name), ndr_get_array_length(ndr, &r->domain_name));
  79                         }
  80                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
  81                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
  82                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
  83                 }
  84         }
  85         return NDR_ERR_SUCCESS;
  86 }
  87
  88 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo100(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo100 *r)
  89 {
  90         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo100");
  91         ndr->depth++;
  92         ndr_print_srvsvc_PlatformId(ndr, "platform_id", r->platform_id);
  93         ndr_print_ptr(ndr, "server_name", r->server_name);
  94         ndr->depth++;
  95         if (r->server_name) {
  96                 ndr_print_string(ndr, "server_name", r->server_name);
  97         }
  98         ndr->depth--;
  99         ndr_print_ptr(ndr, "domain_name", r->domain_name);
 100         ndr->depth++;
 101         if (r->domain_name) {
 102                 ndr_print_string(ndr, "domain_name", r->domain_name);
 103         }
 104         ndr->depth--;
 105         ndr_print_uint32(ndr, "version_major", r->version_major);
 106         ndr_print_uint32(ndr, "version_minor", r->version_minor);
 107         ndr->depth--;
 108 }
 109
 110 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo101(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo101 *r)
 111 {
 112         if (ndr_flags & NDR_SCALARS) {
 113                 NDR_CHECK(ndr_push_align(ndr, 4));
 114                 NDR_CHECK(ndr_push_srvsvc_PlatformId(ndr, NDR_SCALARS, r->platform_id));
 115                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
 116                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
 117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_major));
 118                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_minor));
 119                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->lan_root));
 120         }
 121         if (ndr_flags & NDR_BUFFERS) {
 122                 if (r->server_name) {
 123                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
 124                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 125                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
 126                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 127                 }
 128                 if (r->domain_name) {
 129                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
 130                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 131                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
 132                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 133                 }
 134                 if (r->lan_root) {
 135                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->lan_root, CH_UTF16)));
 136                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 137                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->lan_root, CH_UTF16)));
 138                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->lan_root, ndr_charset_length(r->lan_root, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 139                 }
 140         }
 141         return NDR_ERR_SUCCESS;
 142 }
 143
 144 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo101(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo101 *r)
 145 {
 146         uint32_t _ptr_server_name;
 147         TALLOC_CTX *_mem_save_server_name_0;
 148         uint32_t _ptr_domain_name;
 149         TALLOC_CTX *_mem_save_domain_name_0;
 150         uint32_t _ptr_lan_root;
 151         TALLOC_CTX *_mem_save_lan_root_0;
 152         if (ndr_flags & NDR_SCALARS) {
 153                 NDR_CHECK(ndr_pull_align(ndr, 4));
 154                 NDR_CHECK(ndr_pull_srvsvc_PlatformId(ndr, NDR_SCALARS, &r->platform_id));
 155                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
 156                 if (_ptr_server_name) {
 157                         NDR_PULL_ALLOC(ndr, r->server_name);
 158                 } else {
 159                         r->server_name = NULL;
 160                 }
 161                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
 162                 if (_ptr_domain_name) {
 163                         NDR_PULL_ALLOC(ndr, r->domain_name);
 164                 } else {
 165                         r->domain_name = NULL;
 166                 }
 167                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_major));
 168                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_minor));
 169                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lan_root));
 170                 if (_ptr_lan_root) {
 171                         NDR_PULL_ALLOC(ndr, r->lan_root);
 172                 } else {
 173                         r->lan_root = NULL;
 174                 }
 175         }
 176         if (ndr_flags & NDR_BUFFERS) {
 177                 if (r->server_name) {
 178                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 179                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
 180                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
 181                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
 182                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
 183                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
 184                         }
 185                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
 186                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
 187                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
 188                 }
 189                 if (r->domain_name) {
 190                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 191                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
 192                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
 193                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
 194                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
 195                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->domain_name), ndr_get_array_length(ndr, &r->domain_name));
 196                         }
 197                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
 198                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
 199                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
 200                 }
 201                 if (r->lan_root) {
 202                         _mem_save_lan_root_0 = NDR_PULL_GET_MEM_CTX(ndr);
 203                         NDR_PULL_SET_MEM_CTX(ndr, r->lan_root, 0);
 204                         NDR_CHECK(ndr_pull_array_size(ndr, &r->lan_root));
 205                         NDR_CHECK(ndr_pull_array_length(ndr, &r->lan_root));
 206                         if (ndr_get_array_length(ndr, &r->lan_root) > ndr_get_array_size(ndr, &r->lan_root)) {
 207                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->lan_root), ndr_get_array_length(ndr, &r->lan_root));
 208                         }
 209                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->lan_root), sizeof(uint16_t)));
 210                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->lan_root, ndr_get_array_length(ndr, &r->lan_root), sizeof(uint16_t), CH_UTF16));
 211                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lan_root_0, 0);
 212                 }
 213         }
 214         return NDR_ERR_SUCCESS;
 215 }
 216
 217 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo101(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo101 *r)
 218 {
 219         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo101");
 220         ndr->depth++;
 221         ndr_print_srvsvc_PlatformId(ndr, "platform_id", r->platform_id);
 222         ndr_print_ptr(ndr, "server_name", r->server_name);
 223         ndr->depth++;
 224         if (r->server_name) {
 225                 ndr_print_string(ndr, "server_name", r->server_name);
 226         }
 227         ndr->depth--;
 228         ndr_print_ptr(ndr, "domain_name", r->domain_name);
 229         ndr->depth++;
 230         if (r->domain_name) {
 231                 ndr_print_string(ndr, "domain_name", r->domain_name);
 232         }
 233         ndr->depth--;
 234         ndr_print_uint32(ndr, "version_major", r->version_major);
 235         ndr_print_uint32(ndr, "version_minor", r->version_minor);
 236         ndr_print_ptr(ndr, "lan_root", r->lan_root);
 237         ndr->depth++;
 238         if (r->lan_root) {
 239                 ndr_print_string(ndr, "lan_root", r->lan_root);
 240         }
 241         ndr->depth--;
 242         ndr->depth--;
 243 }
 244
 245 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo102(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo102 *r)
 246 {
 247         if (ndr_flags & NDR_SCALARS) {
 248                 NDR_CHECK(ndr_push_align(ndr, 4));
 249                 NDR_CHECK(ndr_push_srvsvc_PlatformId(ndr, NDR_SCALARS, r->platform_id));
 250                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
 251                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
 252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_major));
 253                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_minor));
 254                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->lan_root));
 255                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->logged_on_users));
 256         }
 257         if (ndr_flags & NDR_BUFFERS) {
 258                 if (r->server_name) {
 259                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
 260                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 261                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
 262                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 263                 }
 264                 if (r->domain_name) {
 265                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
 266                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 267                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
 268                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 269                 }
 270                 if (r->lan_root) {
 271                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->lan_root, CH_UTF16)));
 272                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 273                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->lan_root, CH_UTF16)));
 274                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->lan_root, ndr_charset_length(r->lan_root, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 275                 }
 276         }
 277         return NDR_ERR_SUCCESS;
 278 }
 279
 280 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo102(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo102 *r)
 281 {
 282         uint32_t _ptr_server_name;
 283         TALLOC_CTX *_mem_save_server_name_0;
 284         uint32_t _ptr_domain_name;
 285         TALLOC_CTX *_mem_save_domain_name_0;
 286         uint32_t _ptr_lan_root;
 287         TALLOC_CTX *_mem_save_lan_root_0;
 288         if (ndr_flags & NDR_SCALARS) {
 289                 NDR_CHECK(ndr_pull_align(ndr, 4));
 290                 NDR_CHECK(ndr_pull_srvsvc_PlatformId(ndr, NDR_SCALARS, &r->platform_id));
 291                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
 292                 if (_ptr_server_name) {
 293                         NDR_PULL_ALLOC(ndr, r->server_name);
 294                 } else {
 295                         r->server_name = NULL;
 296                 }
 297                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
 298                 if (_ptr_domain_name) {
 299                         NDR_PULL_ALLOC(ndr, r->domain_name);
 300                 } else {
 301                         r->domain_name = NULL;
 302                 }
 303                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_major));
 304                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_minor));
 305                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lan_root));
 306                 if (_ptr_lan_root) {
 307                         NDR_PULL_ALLOC(ndr, r->lan_root);
 308                 } else {
 309                         r->lan_root = NULL;
 310                 }
 311                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->logged_on_users));
 312         }
 313         if (ndr_flags & NDR_BUFFERS) {
 314                 if (r->server_name) {
 315                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 316                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
 317                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
 318                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
 319                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
 320                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
 321                         }
 322                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
 323                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
 324                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
 325                 }
 326                 if (r->domain_name) {
 327                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 328                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
 329                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
 330                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
 331                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
 332                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->domain_name), ndr_get_array_length(ndr, &r->domain_name));
 333                         }
 334                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
 335                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
 336                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
 337                 }
 338                 if (r->lan_root) {
 339                         _mem_save_lan_root_0 = NDR_PULL_GET_MEM_CTX(ndr);
 340                         NDR_PULL_SET_MEM_CTX(ndr, r->lan_root, 0);
 341                         NDR_CHECK(ndr_pull_array_size(ndr, &r->lan_root));
 342                         NDR_CHECK(ndr_pull_array_length(ndr, &r->lan_root));
 343                         if (ndr_get_array_length(ndr, &r->lan_root) > ndr_get_array_size(ndr, &r->lan_root)) {
 344                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->lan_root), ndr_get_array_length(ndr, &r->lan_root));
 345                         }
 346                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->lan_root), sizeof(uint16_t)));
 347                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->lan_root, ndr_get_array_length(ndr, &r->lan_root), sizeof(uint16_t), CH_UTF16));
 348                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lan_root_0, 0);
 349                 }
 350         }
 351         return NDR_ERR_SUCCESS;
 352 }
 353
 354 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo102(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo102 *r)
 355 {
 356         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo102");
 357         ndr->depth++;
 358         ndr_print_srvsvc_PlatformId(ndr, "platform_id", r->platform_id);
 359         ndr_print_ptr(ndr, "server_name", r->server_name);
 360         ndr->depth++;
 361         if (r->server_name) {
 362                 ndr_print_string(ndr, "server_name", r->server_name);
 363         }
 364         ndr->depth--;
 365         ndr_print_ptr(ndr, "domain_name", r->domain_name);
 366         ndr->depth++;
 367         if (r->domain_name) {
 368                 ndr_print_string(ndr, "domain_name", r->domain_name);
 369         }
 370         ndr->depth--;
 371         ndr_print_uint32(ndr, "version_major", r->version_major);
 372         ndr_print_uint32(ndr, "version_minor", r->version_minor);
 373         ndr_print_ptr(ndr, "lan_root", r->lan_root);
 374         ndr->depth++;
 375         if (r->lan_root) {
 376                 ndr_print_string(ndr, "lan_root", r->lan_root);
 377         }
 378         ndr->depth--;
 379         ndr_print_uint32(ndr, "logged_on_users", r->logged_on_users);
 380         ndr->depth--;
 381 }
 382
 383 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo502(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo502 *r)
 384 {
 385         if (ndr_flags & NDR_SCALARS) {
 386                 NDR_CHECK(ndr_push_align(ndr, 4));
 387                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->char_wait));
 388                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->collection_time));
 389                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maximum_collection_count));
 390                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->keep_connection));
 391                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_commands));
 392                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_timeout));
 393                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_char_buf));
 394                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_threads));
 395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_quota));
 396                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_increment));
 397                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_maximum));
 398                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pipe_increment));
 399                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pipe_maximum));
 400                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cache_file_timeout));
 401                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dormant_file_limit));
 402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->read_ahead_throughput));
 403                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_mailslot_buffers));
 404                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_srv_announce_buffers));
 405                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_illegal_dgram_events));
 406                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dgram_event_reset_freq));
 407                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->log_election_packets));
 408                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_opportunistic_locking));
 409                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_unlock_behind));
 410                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_close_behind));
 411                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_named_pipes));
 412                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_lock_read_unlock));
 413                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->utilize_nt_caching));
 414                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_raw_read));
 415                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_raw_write));
 416                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_write_raw_data));
 417                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_encryption));
 418                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_files_deny_write));
 419                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_read_only_files));
 420                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->force_core_create_mode));
 421                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_512_byte_max_transfer));
 422         }
 423         if (ndr_flags & NDR_BUFFERS) {
 424         }
 425         return NDR_ERR_SUCCESS;
 426 }
 427
 428 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo502(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo502 *r)
 429 {
 430         if (ndr_flags & NDR_SCALARS) {
 431                 NDR_CHECK(ndr_pull_align(ndr, 4));
 432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->char_wait));
 433                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->collection_time));
 434                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maximum_collection_count));
 435                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->keep_connection));
 436                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_commands));
 437                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_timeout));
 438                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_char_buf));
 439                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_threads));
 440                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_quota));
 441                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_increment));
 442                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_maximum));
 443                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pipe_increment));
 444                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pipe_maximum));
 445                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cache_file_timeout));
 446                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dormant_file_limit));
 447                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->read_ahead_throughput));
 448                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_mailslot_buffers));
 449                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_srv_announce_buffers));
 450                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_illegal_dgram_events));
 451                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dgram_event_reset_freq));
 452                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->log_election_packets));
 453                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_opportunistic_locking));
 454                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_unlock_behind));
 455                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_close_behind));
 456                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_named_pipes));
 457                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_lock_read_unlock));
 458                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->utilize_nt_caching));
 459                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_raw_read));
 460                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_raw_write));
 461                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_write_raw_data));
 462                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_encryption));
 463                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_files_deny_write));
 464                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_read_only_files));
 465                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->force_core_create_mode));
 466                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_512_byte_max_transfer));
 467         }
 468         if (ndr_flags & NDR_BUFFERS) {
 469         }
 470         return NDR_ERR_SUCCESS;
 471 }
 472
 473 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo502(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo502 *r)
 474 {
 475         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo502");
 476         ndr->depth++;
 477         ndr_print_uint32(ndr, "char_wait", r->char_wait);
 478         ndr_print_uint32(ndr, "collection_time", r->collection_time);
 479         ndr_print_uint32(ndr, "maximum_collection_count", r->maximum_collection_count);
 480         ndr_print_uint32(ndr, "keep_connection", r->keep_connection);
 481         ndr_print_uint32(ndr, "max_commands", r->max_commands);
 482         ndr_print_uint32(ndr, "session_timeout", r->session_timeout);
 483         ndr_print_uint32(ndr, "size_char_buf", r->size_char_buf);
 484         ndr_print_uint32(ndr, "max_threads", r->max_threads);
 485         ndr_print_uint32(ndr, "lock_quota", r->lock_quota);
 486         ndr_print_uint32(ndr, "lock_increment", r->lock_increment);
 487         ndr_print_uint32(ndr, "lock_maximum", r->lock_maximum);
 488         ndr_print_uint32(ndr, "pipe_increment", r->pipe_increment);
 489         ndr_print_uint32(ndr, "pipe_maximum", r->pipe_maximum);
 490         ndr_print_uint32(ndr, "cache_file_timeout", r->cache_file_timeout);
 491         ndr_print_uint32(ndr, "dormant_file_limit", r->dormant_file_limit);
 492         ndr_print_uint32(ndr, "read_ahead_throughput", r->read_ahead_throughput);
 493         ndr_print_uint32(ndr, "num_mailslot_buffers", r->num_mailslot_buffers);
 494         ndr_print_uint32(ndr, "num_srv_announce_buffers", r->num_srv_announce_buffers);
 495         ndr_print_uint32(ndr, "max_illegal_dgram_events", r->max_illegal_dgram_events);
 496         ndr_print_uint32(ndr, "dgram_event_reset_freq", r->dgram_event_reset_freq);
 497         ndr_print_uint32(ndr, "log_election_packets", r->log_election_packets);
 498         ndr_print_uint32(ndr, "use_opportunistic_locking", r->use_opportunistic_locking);
 499         ndr_print_uint32(ndr, "use_unlock_behind", r->use_unlock_behind);
 500         ndr_print_uint32(ndr, "use_close_behind", r->use_close_behind);
 501         ndr_print_uint32(ndr, "buf_named_pipes", r->buf_named_pipes);
 502         ndr_print_uint32(ndr, "use_lock_read_unlock", r->use_lock_read_unlock);
 503         ndr_print_uint32(ndr, "utilize_nt_caching", r->utilize_nt_caching);
 504         ndr_print_uint32(ndr, "use_raw_read", r->use_raw_read);
 505         ndr_print_uint32(ndr, "use_raw_write", r->use_raw_write);
 506         ndr_print_uint32(ndr, "use_write_raw_data", r->use_write_raw_data);
 507         ndr_print_uint32(ndr, "use_encryption", r->use_encryption);
 508         ndr_print_uint32(ndr, "buf_files_deny_write", r->buf_files_deny_write);
 509         ndr_print_uint32(ndr, "buf_read_only_files", r->buf_read_only_files);
 510         ndr_print_uint32(ndr, "force_core_create_mode", r->force_core_create_mode);
 511         ndr_print_uint32(ndr, "use_512_byte_max_transfer", r->use_512_byte_max_transfer);
 512         ndr->depth--;
 513 }
 514
 515 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1010(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1010 *r)
 516 {
 517         if (ndr_flags & NDR_SCALARS) {
 518                 NDR_CHECK(ndr_push_align(ndr, 4));
 519                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->char_wait));
 520         }
 521         if (ndr_flags & NDR_BUFFERS) {
 522         }
 523         return NDR_ERR_SUCCESS;
 524 }
 525
 526 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1010(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1010 *r)
 527 {
 528         if (ndr_flags & NDR_SCALARS) {
 529                 NDR_CHECK(ndr_pull_align(ndr, 4));
 530                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->char_wait));
 531         }
 532         if (ndr_flags & NDR_BUFFERS) {
 533         }
 534         return NDR_ERR_SUCCESS;
 535 }
 536
 537 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1010(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1010 *r)
 538 {
 539         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1010");
 540         ndr->depth++;
 541         ndr_print_uint32(ndr, "char_wait", r->char_wait);
 542         ndr->depth--;
 543 }
 544
 545 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1011(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1011 *r)
 546 {
 547         if (ndr_flags & NDR_SCALARS) {
 548                 NDR_CHECK(ndr_push_align(ndr, 4));
 549                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->collection_time));
 550         }
 551         if (ndr_flags & NDR_BUFFERS) {
 552         }
 553         return NDR_ERR_SUCCESS;
 554 }
 555
 556 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1011(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1011 *r)
 557 {
 558         if (ndr_flags & NDR_SCALARS) {
 559                 NDR_CHECK(ndr_pull_align(ndr, 4));
 560                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->collection_time));
 561         }
 562         if (ndr_flags & NDR_BUFFERS) {
 563         }
 564         return NDR_ERR_SUCCESS;
 565 }
 566
 567 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1011(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1011 *r)
 568 {
 569         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1011");
 570         ndr->depth++;
 571         ndr_print_uint32(ndr, "collection_time", r->collection_time);
 572         ndr->depth--;
 573 }
 574
 575 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1012(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1012 *r)
 576 {
 577         if (ndr_flags & NDR_SCALARS) {
 578                 NDR_CHECK(ndr_push_align(ndr, 4));
 579                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maximum_collection_count));
 580         }
 581         if (ndr_flags & NDR_BUFFERS) {
 582         }
 583         return NDR_ERR_SUCCESS;
 584 }
 585
 586 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1012(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1012 *r)
 587 {
 588         if (ndr_flags & NDR_SCALARS) {
 589                 NDR_CHECK(ndr_pull_align(ndr, 4));
 590                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maximum_collection_count));
 591         }
 592         if (ndr_flags & NDR_BUFFERS) {
 593         }
 594         return NDR_ERR_SUCCESS;
 595 }
 596
 597 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1012(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1012 *r)
 598 {
 599         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1012");
 600         ndr->depth++;
 601         ndr_print_uint32(ndr, "maximum_collection_count", r->maximum_collection_count);
 602         ndr->depth--;
 603 }
 604
 605 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1013(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1013 *r)
 606 {
 607         if (ndr_flags & NDR_SCALARS) {
 608                 NDR_CHECK(ndr_push_align(ndr, 4));
 609                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->keep_connection));
 610         }
 611         if (ndr_flags & NDR_BUFFERS) {
 612         }
 613         return NDR_ERR_SUCCESS;
 614 }
 615
 616 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1013(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1013 *r)
 617 {
 618         if (ndr_flags & NDR_SCALARS) {
 619                 NDR_CHECK(ndr_pull_align(ndr, 4));
 620                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->keep_connection));
 621         }
 622         if (ndr_flags & NDR_BUFFERS) {
 623         }
 624         return NDR_ERR_SUCCESS;
 625 }
 626
 627 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1013(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1013 *r)
 628 {
 629         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1013");
 630         ndr->depth++;
 631         ndr_print_uint32(ndr, "keep_connection", r->keep_connection);
 632         ndr->depth--;
 633 }
 634
 635 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1018(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1018 *r)
 636 {
 637         if (ndr_flags & NDR_SCALARS) {
 638                 NDR_CHECK(ndr_push_align(ndr, 4));
 639                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_timeout));
 640         }
 641         if (ndr_flags & NDR_BUFFERS) {
 642         }
 643         return NDR_ERR_SUCCESS;
 644 }
 645
 646 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1018(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1018 *r)
 647 {
 648         if (ndr_flags & NDR_SCALARS) {
 649                 NDR_CHECK(ndr_pull_align(ndr, 4));
 650                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_timeout));
 651         }
 652         if (ndr_flags & NDR_BUFFERS) {
 653         }
 654         return NDR_ERR_SUCCESS;
 655 }
 656
 657 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1018(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1018 *r)
 658 {
 659         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1018");
 660         ndr->depth++;
 661         ndr_print_uint32(ndr, "session_timeout", r->session_timeout);
 662         ndr->depth--;
 663 }
 664
 665 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1023(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1023 *r)
 666 {
 667         if (ndr_flags & NDR_SCALARS) {
 668                 NDR_CHECK(ndr_push_align(ndr, 4));
 669                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_char_buf));
 670         }
 671         if (ndr_flags & NDR_BUFFERS) {
 672         }
 673         return NDR_ERR_SUCCESS;
 674 }
 675
 676 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1023(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1023 *r)
 677 {
 678         if (ndr_flags & NDR_SCALARS) {
 679                 NDR_CHECK(ndr_pull_align(ndr, 4));
 680                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_char_buf));
 681         }
 682         if (ndr_flags & NDR_BUFFERS) {
 683         }
 684         return NDR_ERR_SUCCESS;
 685 }
 686
 687 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1023(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1023 *r)
 688 {
 689         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1023");
 690         ndr->depth++;
 691         ndr_print_uint32(ndr, "size_char_buf", r->size_char_buf);
 692         ndr->depth--;
 693 }
 694
 695 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1027(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1027 *r)
 696 {
 697         if (ndr_flags & NDR_SCALARS) {
 698                 NDR_CHECK(ndr_push_align(ndr, 4));
 699                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->errorlog_sz));
 700         }
 701         if (ndr_flags & NDR_BUFFERS) {
 702         }
 703         return NDR_ERR_SUCCESS;
 704 }
 705
 706 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1027(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1027 *r)
 707 {
 708         if (ndr_flags & NDR_SCALARS) {
 709                 NDR_CHECK(ndr_pull_align(ndr, 4));
 710                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->errorlog_sz));
 711         }
 712         if (ndr_flags & NDR_BUFFERS) {
 713         }
 714         return NDR_ERR_SUCCESS;
 715 }
 716
 717 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1027(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1027 *r)
 718 {
 719         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1027");
 720         ndr->depth++;
 721         ndr_print_uint32(ndr, "errorlog_sz", r->errorlog_sz);
 722         ndr->depth--;
 723 }
 724
 725 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1028(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1028 *r)
 726 {
 727         if (ndr_flags & NDR_SCALARS) {
 728                 NDR_CHECK(ndr_push_align(ndr, 4));
 729                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->print_buf_time));
 730         }
 731         if (ndr_flags & NDR_BUFFERS) {
 732         }
 733         return NDR_ERR_SUCCESS;
 734 }
 735
 736 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1028(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1028 *r)
 737 {
 738         if (ndr_flags & NDR_SCALARS) {
 739                 NDR_CHECK(ndr_pull_align(ndr, 4));
 740                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->print_buf_time));
 741         }
 742         if (ndr_flags & NDR_BUFFERS) {
 743         }
 744         return NDR_ERR_SUCCESS;
 745 }
 746
 747 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1028(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1028 *r)
 748 {
 749         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1028");
 750         ndr->depth++;
 751         ndr_print_uint32(ndr, "print_buf_time", r->print_buf_time);
 752         ndr->depth--;
 753 }
 754
 755 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1032(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1032 *r)
 756 {
 757         if (ndr_flags & NDR_SCALARS) {
 758                 NDR_CHECK(ndr_push_align(ndr, 4));
 759                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->wrk_heuristics));
 760         }
 761         if (ndr_flags & NDR_BUFFERS) {
 762         }
 763         return NDR_ERR_SUCCESS;
 764 }
 765
 766 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1032(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1032 *r)
 767 {
 768         if (ndr_flags & NDR_SCALARS) {
 769                 NDR_CHECK(ndr_pull_align(ndr, 4));
 770                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->wrk_heuristics));
 771         }
 772         if (ndr_flags & NDR_BUFFERS) {
 773         }
 774         return NDR_ERR_SUCCESS;
 775 }
 776
 777 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1032(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1032 *r)
 778 {
 779         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1032");
 780         ndr->depth++;
 781         ndr_print_uint32(ndr, "wrk_heuristics", r->wrk_heuristics);
 782         ndr->depth--;
 783 }
 784
 785 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1033(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1033 *r)
 786 {
 787         if (ndr_flags & NDR_SCALARS) {
 788                 NDR_CHECK(ndr_push_align(ndr, 4));
 789                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_threads));
 790         }
 791         if (ndr_flags & NDR_BUFFERS) {
 792         }
 793         return NDR_ERR_SUCCESS;
 794 }
 795
 796 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1033(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1033 *r)
 797 {
 798         if (ndr_flags & NDR_SCALARS) {
 799                 NDR_CHECK(ndr_pull_align(ndr, 4));
 800                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_threads));
 801         }
 802         if (ndr_flags & NDR_BUFFERS) {
 803         }
 804         return NDR_ERR_SUCCESS;
 805 }
 806
 807 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1033(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1033 *r)
 808 {
 809         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1033");
 810         ndr->depth++;
 811         ndr_print_uint32(ndr, "max_threads", r->max_threads);
 812         ndr->depth--;
 813 }
 814
 815 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1041(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1041 *r)
 816 {
 817         if (ndr_flags & NDR_SCALARS) {
 818                 NDR_CHECK(ndr_push_align(ndr, 4));
 819                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_quota));
 820         }
 821         if (ndr_flags & NDR_BUFFERS) {
 822         }
 823         return NDR_ERR_SUCCESS;
 824 }
 825
 826 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1041(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1041 *r)
 827 {
 828         if (ndr_flags & NDR_SCALARS) {
 829                 NDR_CHECK(ndr_pull_align(ndr, 4));
 830                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_quota));
 831         }
 832         if (ndr_flags & NDR_BUFFERS) {
 833         }
 834         return NDR_ERR_SUCCESS;
 835 }
 836
 837 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1041(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1041 *r)
 838 {
 839         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1041");
 840         ndr->depth++;
 841         ndr_print_uint32(ndr, "lock_quota", r->lock_quota);
 842         ndr->depth--;
 843 }
 844
 845 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1042(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1042 *r)
 846 {
 847         if (ndr_flags & NDR_SCALARS) {
 848                 NDR_CHECK(ndr_push_align(ndr, 4));
 849                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_increment));
 850         }
 851         if (ndr_flags & NDR_BUFFERS) {
 852         }
 853         return NDR_ERR_SUCCESS;
 854 }
 855
 856 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1042(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1042 *r)
 857 {
 858         if (ndr_flags & NDR_SCALARS) {
 859                 NDR_CHECK(ndr_pull_align(ndr, 4));
 860                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_increment));
 861         }
 862         if (ndr_flags & NDR_BUFFERS) {
 863         }
 864         return NDR_ERR_SUCCESS;
 865 }
 866
 867 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1042(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1042 *r)
 868 {
 869         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1042");
 870         ndr->depth++;
 871         ndr_print_uint32(ndr, "lock_increment", r->lock_increment);
 872         ndr->depth--;
 873 }
 874
 875 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1043(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1043 *r)
 876 {
 877         if (ndr_flags & NDR_SCALARS) {
 878                 NDR_CHECK(ndr_push_align(ndr, 4));
 879                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_maximum));
 880         }
 881         if (ndr_flags & NDR_BUFFERS) {
 882         }
 883         return NDR_ERR_SUCCESS;
 884 }
 885
 886 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1043(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1043 *r)
 887 {
 888         if (ndr_flags & NDR_SCALARS) {
 889                 NDR_CHECK(ndr_pull_align(ndr, 4));
 890                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_maximum));
 891         }
 892         if (ndr_flags & NDR_BUFFERS) {
 893         }
 894         return NDR_ERR_SUCCESS;
 895 }
 896
 897 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1043(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1043 *r)
 898 {
 899         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1043");
 900         ndr->depth++;
 901         ndr_print_uint32(ndr, "lock_maximum", r->lock_maximum);
 902         ndr->depth--;
 903 }
 904
 905 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1044(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1044 *r)
 906 {
 907         if (ndr_flags & NDR_SCALARS) {
 908                 NDR_CHECK(ndr_push_align(ndr, 4));
 909                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pipe_increment));
 910         }
 911         if (ndr_flags & NDR_BUFFERS) {
 912         }
 913         return NDR_ERR_SUCCESS;
 914 }
 915
 916 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1044(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1044 *r)
 917 {
 918         if (ndr_flags & NDR_SCALARS) {
 919                 NDR_CHECK(ndr_pull_align(ndr, 4));
 920                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pipe_increment));
 921         }
 922         if (ndr_flags & NDR_BUFFERS) {
 923         }
 924         return NDR_ERR_SUCCESS;
 925 }
 926
 927 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1044(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1044 *r)
 928 {
 929         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1044");
 930         ndr->depth++;
 931         ndr_print_uint32(ndr, "pipe_increment", r->pipe_increment);
 932         ndr->depth--;
 933 }
 934
 935 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1045(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1045 *r)
 936 {
 937         if (ndr_flags & NDR_SCALARS) {
 938                 NDR_CHECK(ndr_push_align(ndr, 4));
 939                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pipe_maximum));
 940         }
 941         if (ndr_flags & NDR_BUFFERS) {
 942         }
 943         return NDR_ERR_SUCCESS;
 944 }
 945
 946 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1045(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1045 *r)
 947 {
 948         if (ndr_flags & NDR_SCALARS) {
 949                 NDR_CHECK(ndr_pull_align(ndr, 4));
 950                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pipe_maximum));
 951         }
 952         if (ndr_flags & NDR_BUFFERS) {
 953         }
 954         return NDR_ERR_SUCCESS;
 955 }
 956
 957 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1045(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1045 *r)
 958 {
 959         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1045");
 960         ndr->depth++;
 961         ndr_print_uint32(ndr, "pipe_maximum", r->pipe_maximum);
 962         ndr->depth--;
 963 }
 964
 965 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1046(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1046 *r)
 966 {
 967         if (ndr_flags & NDR_SCALARS) {
 968                 NDR_CHECK(ndr_push_align(ndr, 4));
 969                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dormant_file_limit));
 970         }
 971         if (ndr_flags & NDR_BUFFERS) {
 972         }
 973         return NDR_ERR_SUCCESS;
 974 }
 975
 976 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1046(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1046 *r)
 977 {
 978         if (ndr_flags & NDR_SCALARS) {
 979                 NDR_CHECK(ndr_pull_align(ndr, 4));
 980                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dormant_file_limit));
 981         }
 982         if (ndr_flags & NDR_BUFFERS) {
 983         }
 984         return NDR_ERR_SUCCESS;
 985 }
 986
 987 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1046(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1046 *r)
 988 {
 989         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1046");
 990         ndr->depth++;
 991         ndr_print_uint32(ndr, "dormant_file_limit", r->dormant_file_limit);
 992         ndr->depth--;
 993 }
 994
 995 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1047(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1047 *r)
 996 {
 997         if (ndr_flags & NDR_SCALARS) {
 998                 NDR_CHECK(ndr_push_align(ndr, 4));
 999                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cache_file_timeout));
1000         }
1001         if (ndr_flags & NDR_BUFFERS) {
1002         }
1003         return NDR_ERR_SUCCESS;
1004 }
1005
1006 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1047(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1047 *r)
1007 {
1008         if (ndr_flags & NDR_SCALARS) {
1009                 NDR_CHECK(ndr_pull_align(ndr, 4));
1010                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cache_file_timeout));
1011         }
1012         if (ndr_flags & NDR_BUFFERS) {
1013         }
1014         return NDR_ERR_SUCCESS;
1015 }
1016
1017 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1047(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1047 *r)
1018 {
1019         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1047");
1020         ndr->depth++;
1021         ndr_print_uint32(ndr, "cache_file_timeout", r->cache_file_timeout);
1022         ndr->depth--;
1023 }
1024
1025 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1048(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1048 *r)
1026 {
1027         if (ndr_flags & NDR_SCALARS) {
1028                 NDR_CHECK(ndr_push_align(ndr, 4));
1029                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_opportunistic_locking));
1030         }
1031         if (ndr_flags & NDR_BUFFERS) {
1032         }
1033         return NDR_ERR_SUCCESS;
1034 }
1035
1036 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1048(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1048 *r)
1037 {
1038         if (ndr_flags & NDR_SCALARS) {
1039                 NDR_CHECK(ndr_pull_align(ndr, 4));
1040                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_opportunistic_locking));
1041         }
1042         if (ndr_flags & NDR_BUFFERS) {
1043         }
1044         return NDR_ERR_SUCCESS;
1045 }
1046
1047 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1048(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1048 *r)
1048 {
1049         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1048");
1050         ndr->depth++;
1051         ndr_print_uint32(ndr, "use_opportunistic_locking", r->use_opportunistic_locking);
1052         ndr->depth--;
1053 }
1054
1055 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1049(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1049 *r)
1056 {
1057         if (ndr_flags & NDR_SCALARS) {
1058                 NDR_CHECK(ndr_push_align(ndr, 4));
1059                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_unlock_behind));
1060         }
1061         if (ndr_flags & NDR_BUFFERS) {
1062         }
1063         return NDR_ERR_SUCCESS;
1064 }
1065
1066 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1049(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1049 *r)
1067 {
1068         if (ndr_flags & NDR_SCALARS) {
1069                 NDR_CHECK(ndr_pull_align(ndr, 4));
1070                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_unlock_behind));
1071         }
1072         if (ndr_flags & NDR_BUFFERS) {
1073         }
1074         return NDR_ERR_SUCCESS;
1075 }
1076
1077 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1049(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1049 *r)
1078 {
1079         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1049");
1080         ndr->depth++;
1081         ndr_print_uint32(ndr, "use_unlock_behind", r->use_unlock_behind);
1082         ndr->depth--;
1083 }
1084
1085 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1050(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1050 *r)
1086 {
1087         if (ndr_flags & NDR_SCALARS) {
1088                 NDR_CHECK(ndr_push_align(ndr, 4));
1089                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_close_behind));
1090         }
1091         if (ndr_flags & NDR_BUFFERS) {
1092         }
1093         return NDR_ERR_SUCCESS;
1094 }
1095
1096 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1050(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1050 *r)
1097 {
1098         if (ndr_flags & NDR_SCALARS) {
1099                 NDR_CHECK(ndr_pull_align(ndr, 4));
1100                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_close_behind));
1101         }
1102         if (ndr_flags & NDR_BUFFERS) {
1103         }
1104         return NDR_ERR_SUCCESS;
1105 }
1106
1107 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1050(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1050 *r)
1108 {
1109         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1050");
1110         ndr->depth++;
1111         ndr_print_uint32(ndr, "use_close_behind", r->use_close_behind);
1112         ndr->depth--;
1113 }
1114
1115 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1051(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1051 *r)
1116 {
1117         if (ndr_flags & NDR_SCALARS) {
1118                 NDR_CHECK(ndr_push_align(ndr, 4));
1119                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_named_pipes));
1120         }
1121         if (ndr_flags & NDR_BUFFERS) {
1122         }
1123         return NDR_ERR_SUCCESS;
1124 }
1125
1126 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1051(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1051 *r)
1127 {
1128         if (ndr_flags & NDR_SCALARS) {
1129                 NDR_CHECK(ndr_pull_align(ndr, 4));
1130                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_named_pipes));
1131         }
1132         if (ndr_flags & NDR_BUFFERS) {
1133         }
1134         return NDR_ERR_SUCCESS;
1135 }
1136
1137 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1051(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1051 *r)
1138 {
1139         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1051");
1140         ndr->depth++;
1141         ndr_print_uint32(ndr, "buf_named_pipes", r->buf_named_pipes);
1142         ndr->depth--;
1143 }
1144
1145 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1052(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1052 *r)
1146 {
1147         if (ndr_flags & NDR_SCALARS) {
1148                 NDR_CHECK(ndr_push_align(ndr, 4));
1149                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_lock_read_unlock));
1150         }
1151         if (ndr_flags & NDR_BUFFERS) {
1152         }
1153         return NDR_ERR_SUCCESS;
1154 }
1155
1156 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1052(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1052 *r)
1157 {
1158         if (ndr_flags & NDR_SCALARS) {
1159                 NDR_CHECK(ndr_pull_align(ndr, 4));
1160                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_lock_read_unlock));
1161         }
1162         if (ndr_flags & NDR_BUFFERS) {
1163         }
1164         return NDR_ERR_SUCCESS;
1165 }
1166
1167 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1052(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1052 *r)
1168 {
1169         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1052");
1170         ndr->depth++;
1171         ndr_print_uint32(ndr, "use_lock_read_unlock", r->use_lock_read_unlock);
1172         ndr->depth--;
1173 }
1174
1175 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1053(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1053 *r)
1176 {
1177         if (ndr_flags & NDR_SCALARS) {
1178                 NDR_CHECK(ndr_push_align(ndr, 4));
1179                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->utilize_nt_caching));
1180         }
1181         if (ndr_flags & NDR_BUFFERS) {
1182         }
1183         return NDR_ERR_SUCCESS;
1184 }
1185
1186 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1053(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1053 *r)
1187 {
1188         if (ndr_flags & NDR_SCALARS) {
1189                 NDR_CHECK(ndr_pull_align(ndr, 4));
1190                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->utilize_nt_caching));
1191         }
1192         if (ndr_flags & NDR_BUFFERS) {
1193         }
1194         return NDR_ERR_SUCCESS;
1195 }
1196
1197 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1053(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1053 *r)
1198 {
1199         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1053");
1200         ndr->depth++;
1201         ndr_print_uint32(ndr, "utilize_nt_caching", r->utilize_nt_caching);
1202         ndr->depth--;
1203 }
1204
1205 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1054(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1054 *r)
1206 {
1207         if (ndr_flags & NDR_SCALARS) {
1208                 NDR_CHECK(ndr_push_align(ndr, 4));
1209                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_raw_read));
1210         }
1211         if (ndr_flags & NDR_BUFFERS) {
1212         }
1213         return NDR_ERR_SUCCESS;
1214 }
1215
1216 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1054(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1054 *r)
1217 {
1218         if (ndr_flags & NDR_SCALARS) {
1219                 NDR_CHECK(ndr_pull_align(ndr, 4));
1220                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_raw_read));
1221         }
1222         if (ndr_flags & NDR_BUFFERS) {
1223         }
1224         return NDR_ERR_SUCCESS;
1225 }
1226
1227 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1054(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1054 *r)
1228 {
1229         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1054");
1230         ndr->depth++;
1231         ndr_print_uint32(ndr, "use_raw_read", r->use_raw_read);
1232         ndr->depth--;
1233 }
1234
1235 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1055(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1055 *r)
1236 {
1237         if (ndr_flags & NDR_SCALARS) {
1238                 NDR_CHECK(ndr_push_align(ndr, 4));
1239                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_raw_write));
1240         }
1241         if (ndr_flags & NDR_BUFFERS) {
1242         }
1243         return NDR_ERR_SUCCESS;
1244 }
1245
1246 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1055(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1055 *r)
1247 {
1248         if (ndr_flags & NDR_SCALARS) {
1249                 NDR_CHECK(ndr_pull_align(ndr, 4));
1250                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_raw_write));
1251         }
1252         if (ndr_flags & NDR_BUFFERS) {
1253         }
1254         return NDR_ERR_SUCCESS;
1255 }
1256
1257 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1055(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1055 *r)
1258 {
1259         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1055");
1260         ndr->depth++;
1261         ndr_print_uint32(ndr, "use_raw_write", r->use_raw_write);
1262         ndr->depth--;
1263 }
1264
1265 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1056(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1056 *r)
1266 {
1267         if (ndr_flags & NDR_SCALARS) {
1268                 NDR_CHECK(ndr_push_align(ndr, 4));
1269                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_write_raw_data));
1270         }
1271         if (ndr_flags & NDR_BUFFERS) {
1272         }
1273         return NDR_ERR_SUCCESS;
1274 }
1275
1276 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1056(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1056 *r)
1277 {
1278         if (ndr_flags & NDR_SCALARS) {
1279                 NDR_CHECK(ndr_pull_align(ndr, 4));
1280                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_write_raw_data));
1281         }
1282         if (ndr_flags & NDR_BUFFERS) {
1283         }
1284         return NDR_ERR_SUCCESS;
1285 }
1286
1287 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1056(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1056 *r)
1288 {
1289         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1056");
1290         ndr->depth++;
1291         ndr_print_uint32(ndr, "use_write_raw_data", r->use_write_raw_data);
1292         ndr->depth--;
1293 }
1294
1295 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1057(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1057 *r)
1296 {
1297         if (ndr_flags & NDR_SCALARS) {
1298                 NDR_CHECK(ndr_push_align(ndr, 4));
1299                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_encryption));
1300         }
1301         if (ndr_flags & NDR_BUFFERS) {
1302         }
1303         return NDR_ERR_SUCCESS;
1304 }
1305
1306 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1057(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1057 *r)
1307 {
1308         if (ndr_flags & NDR_SCALARS) {
1309                 NDR_CHECK(ndr_pull_align(ndr, 4));
1310                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_encryption));
1311         }
1312         if (ndr_flags & NDR_BUFFERS) {
1313         }
1314         return NDR_ERR_SUCCESS;
1315 }
1316
1317 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1057(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1057 *r)
1318 {
1319         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1057");
1320         ndr->depth++;
1321         ndr_print_uint32(ndr, "use_encryption", r->use_encryption);
1322         ndr->depth--;
1323 }
1324
1325 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1058(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1058 *r)
1326 {
1327         if (ndr_flags & NDR_SCALARS) {
1328                 NDR_CHECK(ndr_push_align(ndr, 4));
1329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_files_deny_write));
1330         }
1331         if (ndr_flags & NDR_BUFFERS) {
1332         }
1333         return NDR_ERR_SUCCESS;
1334 }
1335
1336 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1058(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1058 *r)
1337 {
1338         if (ndr_flags & NDR_SCALARS) {
1339                 NDR_CHECK(ndr_pull_align(ndr, 4));
1340                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_files_deny_write));
1341         }
1342         if (ndr_flags & NDR_BUFFERS) {
1343         }
1344         return NDR_ERR_SUCCESS;
1345 }
1346
1347 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1058(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1058 *r)
1348 {
1349         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1058");
1350         ndr->depth++;
1351         ndr_print_uint32(ndr, "buf_files_deny_write", r->buf_files_deny_write);
1352         ndr->depth--;
1353 }
1354
1355 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1059(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1059 *r)
1356 {
1357         if (ndr_flags & NDR_SCALARS) {
1358                 NDR_CHECK(ndr_push_align(ndr, 4));
1359                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_read_only_files));
1360         }
1361         if (ndr_flags & NDR_BUFFERS) {
1362         }
1363         return NDR_ERR_SUCCESS;
1364 }
1365
1366 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1059(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1059 *r)
1367 {
1368         if (ndr_flags & NDR_SCALARS) {
1369                 NDR_CHECK(ndr_pull_align(ndr, 4));
1370                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_read_only_files));
1371         }
1372         if (ndr_flags & NDR_BUFFERS) {
1373         }
1374         return NDR_ERR_SUCCESS;
1375 }
1376
1377 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1059(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1059 *r)
1378 {
1379         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1059");
1380         ndr->depth++;
1381         ndr_print_uint32(ndr, "buf_read_only_files", r->buf_read_only_files);
1382         ndr->depth--;
1383 }
1384
1385 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1060(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1060 *r)
1386 {
1387         if (ndr_flags & NDR_SCALARS) {
1388                 NDR_CHECK(ndr_push_align(ndr, 4));
1389                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->force_core_create_mode));
1390         }
1391         if (ndr_flags & NDR_BUFFERS) {
1392         }
1393         return NDR_ERR_SUCCESS;
1394 }
1395
1396 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1060(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1060 *r)
1397 {
1398         if (ndr_flags & NDR_SCALARS) {
1399                 NDR_CHECK(ndr_pull_align(ndr, 4));
1400                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->force_core_create_mode));
1401         }
1402         if (ndr_flags & NDR_BUFFERS) {
1403         }
1404         return NDR_ERR_SUCCESS;
1405 }
1406
1407 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1060(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1060 *r)
1408 {
1409         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1060");
1410         ndr->depth++;
1411         ndr_print_uint32(ndr, "force_core_create_mode", r->force_core_create_mode);
1412         ndr->depth--;
1413 }
1414
1415 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1061(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1061 *r)
1416 {
1417         if (ndr_flags & NDR_SCALARS) {
1418                 NDR_CHECK(ndr_push_align(ndr, 4));
1419                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_512_byte_max_transfer));
1420         }
1421         if (ndr_flags & NDR_BUFFERS) {
1422         }
1423         return NDR_ERR_SUCCESS;
1424 }
1425
1426 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1061(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1061 *r)
1427 {
1428         if (ndr_flags & NDR_SCALARS) {
1429                 NDR_CHECK(ndr_pull_align(ndr, 4));
1430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_512_byte_max_transfer));
1431         }
1432         if (ndr_flags & NDR_BUFFERS) {
1433         }
1434         return NDR_ERR_SUCCESS;
1435 }
1436
1437 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1061(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1061 *r)
1438 {
1439         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1061");
1440         ndr->depth++;
1441         ndr_print_uint32(ndr, "use_512_byte_max_transfer", r->use_512_byte_max_transfer);
1442         ndr->depth--;
1443 }
1444
1445 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1062(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1062 *r)
1446 {
1447         if (ndr_flags & NDR_SCALARS) {
1448                 NDR_CHECK(ndr_push_align(ndr, 4));
1449                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->read_ahead_throughput));
1450         }
1451         if (ndr_flags & NDR_BUFFERS) {
1452         }
1453         return NDR_ERR_SUCCESS;
1454 }
1455
1456 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1062(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1062 *r)
1457 {
1458         if (ndr_flags & NDR_SCALARS) {
1459                 NDR_CHECK(ndr_pull_align(ndr, 4));
1460                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->read_ahead_throughput));
1461         }
1462         if (ndr_flags & NDR_BUFFERS) {
1463         }
1464         return NDR_ERR_SUCCESS;
1465 }
1466
1467 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1062(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1062 *r)
1468 {
1469         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1062");
1470         ndr->depth++;
1471         ndr_print_uint32(ndr, "read_ahead_throughput", r->read_ahead_throughput);
1472         ndr->depth--;
1473 }
1474
1475 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetWkstaInfo *r)
1476 {
1477         if (ndr_flags & NDR_SCALARS) {
1478                 int level = ndr_push_get_switch_value(ndr, r);
1479                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
1480                 switch (level) {
1481                         case 100: {
1482                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info100));
1483                         break; }
1484
1485                         case 101: {
1486                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info101));
1487                         break; }
1488
1489                         case 102: {
1490                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info102));
1491                         break; }
1492
1493                         case 502: {
1494                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info502));
1495                         break; }
1496
1497                         case 1010: {
1498                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1010));
1499                         break; }
1500
1501                         case 1011: {
1502                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1011));
1503                         break; }
1504
1505                         case 1012: {
1506                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1012));
1507                         break; }
1508
1509                         case 1013: {
1510                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1013));
1511                         break; }
1512
1513                         case 1018: {
1514                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1018));
1515                         break; }
1516
1517                         case 1023: {
1518                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1023));
1519                         break; }
1520
1521                         case 1027: {
1522                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1027));
1523                         break; }
1524
1525                         case 1028: {
1526                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1028));
1527                         break; }
1528
1529                         case 1032: {
1530                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1032));
1531                         break; }
1532
1533                         case 1033: {
1534                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1033));
1535                         break; }
1536
1537                         case 1041: {
1538                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1041));
1539                         break; }
1540
1541                         case 1042: {
1542                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1042));
1543                         break; }
1544
1545                         case 1043: {
1546                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1043));
1547                         break; }
1548
1549                         case 1044: {
1550                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1044));
1551                         break; }
1552
1553                         case 1045: {
1554                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1045));
1555                         break; }
1556
1557                         case 1046: {
1558                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1046));
1559                         break; }
1560
1561                         case 1047: {
1562                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1047));
1563                         break; }
1564
1565                         case 1048: {
1566                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1048));
1567                         break; }
1568
1569                         case 1049: {
1570                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1049));
1571                         break; }
1572
1573                         case 1050: {
1574                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1050));
1575                         break; }
1576
1577                         case 1051: {
1578                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1051));
1579                         break; }
1580
1581                         case 1052: {
1582                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1052));
1583                         break; }
1584
1585                         case 1053: {
1586                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1053));
1587                         break; }
1588
1589                         case 1054: {
1590                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1054));
1591                         break; }
1592
1593                         case 1055: {
1594                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1055));
1595                         break; }
1596
1597                         case 1056: {
1598                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1056));
1599                         break; }
1600
1601                         case 1057: {
1602                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1057));
1603                         break; }
1604
1605                         case 1058: {
1606                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1058));
1607                         break; }
1608
1609                         case 1059: {
1610                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1059));
1611                         break; }
1612
1613                         case 1060: {
1614                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1060));
1615                         break; }
1616
1617                         case 1061: {
1618                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1061));
1619                         break; }
1620
1621                         case 1062: {
1622                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1062));
1623                         break; }
1624
1625                         default: {
1626                         break; }
1627
1628                 }
1629         }
1630         if (ndr_flags & NDR_BUFFERS) {
1631                 int level = ndr_push_get_switch_value(ndr, r);
1632                 switch (level) {
1633                         case 100:
1634                                 if (r->info100) {
1635                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo100(ndr, NDR_SCALARS|NDR_BUFFERS, r->info100));
1636                                 }
1637                         break;
1638
1639                         case 101:
1640                                 if (r->info101) {
1641                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info101));
1642                                 }
1643                         break;
1644
1645                         case 102:
1646                                 if (r->info102) {
1647                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo102(ndr, NDR_SCALARS|NDR_BUFFERS, r->info102));
1648                                 }
1649                         break;
1650
1651                         case 502:
1652                                 if (r->info502) {
1653                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo502(ndr, NDR_SCALARS, r->info502));
1654                                 }
1655                         break;
1656
1657                         case 1010:
1658                                 if (r->info1010) {
1659                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1010(ndr, NDR_SCALARS, r->info1010));
1660                                 }
1661                         break;
1662
1663                         case 1011:
1664                                 if (r->info1011) {
1665                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1011(ndr, NDR_SCALARS, r->info1011));
1666                                 }
1667                         break;
1668
1669                         case 1012:
1670                                 if (r->info1012) {
1671                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1012(ndr, NDR_SCALARS, r->info1012));
1672                                 }
1673                         break;
1674
1675                         case 1013:
1676                                 if (r->info1013) {
1677                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1013(ndr, NDR_SCALARS, r->info1013));
1678                                 }
1679                         break;
1680
1681                         case 1018:
1682                                 if (r->info1018) {
1683                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1018(ndr, NDR_SCALARS, r->info1018));
1684                                 }
1685                         break;
1686
1687                         case 1023:
1688                                 if (r->info1023) {
1689                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1023(ndr, NDR_SCALARS, r->info1023));
1690                                 }
1691                         break;
1692
1693                         case 1027:
1694                                 if (r->info1027) {
1695                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1027(ndr, NDR_SCALARS, r->info1027));
1696                                 }
1697                         break;
1698
1699                         case 1028:
1700                                 if (r->info1028) {
1701                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1028(ndr, NDR_SCALARS, r->info1028));
1702                                 }
1703                         break;
1704
1705                         case 1032:
1706                                 if (r->info1032) {
1707                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1032(ndr, NDR_SCALARS, r->info1032));
1708                                 }
1709                         break;
1710
1711                         case 1033:
1712                                 if (r->info1033) {
1713                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1033(ndr, NDR_SCALARS, r->info1033));
1714                                 }
1715                         break;
1716
1717                         case 1041:
1718                                 if (r->info1041) {
1719                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1041(ndr, NDR_SCALARS, r->info1041));
1720                                 }
1721                         break;
1722
1723                         case 1042:
1724                                 if (r->info1042) {
1725                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1042(ndr, NDR_SCALARS, r->info1042));
1726                                 }
1727                         break;
1728
1729                         case 1043:
1730                                 if (r->info1043) {
1731                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1043(ndr, NDR_SCALARS, r->info1043));
1732                                 }
1733                         break;
1734
1735                         case 1044:
1736                                 if (r->info1044) {
1737                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1044(ndr, NDR_SCALARS, r->info1044));
1738                                 }
1739                         break;
1740
1741                         case 1045:
1742                                 if (r->info1045) {
1743                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1045(ndr, NDR_SCALARS, r->info1045));
1744                                 }
1745                         break;
1746
1747                         case 1046:
1748                                 if (r->info1046) {
1749                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1046(ndr, NDR_SCALARS, r->info1046));
1750                                 }
1751                         break;
1752
1753                         case 1047:
1754                                 if (r->info1047) {
1755                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1047(ndr, NDR_SCALARS, r->info1047));
1756                                 }
1757                         break;
1758
1759                         case 1048:
1760                                 if (r->info1048) {
1761                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1048(ndr, NDR_SCALARS, r->info1048));
1762                                 }
1763                         break;
1764
1765                         case 1049:
1766                                 if (r->info1049) {
1767                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1049(ndr, NDR_SCALARS, r->info1049));
1768                                 }
1769                         break;
1770
1771                         case 1050:
1772                                 if (r->info1050) {
1773                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1050(ndr, NDR_SCALARS, r->info1050));
1774                                 }
1775                         break;
1776
1777                         case 1051:
1778                                 if (r->info1051) {
1779                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1051(ndr, NDR_SCALARS, r->info1051));
1780                                 }
1781                         break;
1782
1783                         case 1052:
1784                                 if (r->info1052) {
1785                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1052(ndr, NDR_SCALARS, r->info1052));
1786                                 }
1787                         break;
1788
1789                         case 1053:
1790                                 if (r->info1053) {
1791                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1053(ndr, NDR_SCALARS, r->info1053));
1792                                 }
1793                         break;
1794
1795                         case 1054:
1796                                 if (r->info1054) {
1797                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1054(ndr, NDR_SCALARS, r->info1054));
1798                                 }
1799                         break;
1800
1801                         case 1055:
1802                                 if (r->info1055) {
1803                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1055(ndr, NDR_SCALARS, r->info1055));
1804                                 }
1805                         break;
1806
1807                         case 1056:
1808                                 if (r->info1056) {
1809                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1056(ndr, NDR_SCALARS, r->info1056));
1810                                 }
1811                         break;
1812
1813                         case 1057:
1814                                 if (r->info1057) {
1815                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1057(ndr, NDR_SCALARS, r->info1057));
1816                                 }
1817                         break;
1818
1819                         case 1058:
1820                                 if (r->info1058) {
1821                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1058(ndr, NDR_SCALARS, r->info1058));
1822                                 }
1823                         break;
1824
1825                         case 1059:
1826                                 if (r->info1059) {
1827                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1059(ndr, NDR_SCALARS, r->info1059));
1828                                 }
1829                         break;
1830
1831                         case 1060:
1832                                 if (r->info1060) {
1833                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1060(ndr, NDR_SCALARS, r->info1060));
1834                                 }
1835                         break;
1836
1837                         case 1061:
1838                                 if (r->info1061) {
1839                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1061(ndr, NDR_SCALARS, r->info1061));
1840                                 }
1841                         break;
1842
1843                         case 1062:
1844                                 if (r->info1062) {
1845                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1062(ndr, NDR_SCALARS, r->info1062));
1846                                 }
1847                         break;
1848
1849                         default:
1850                         break;
1851
1852                 }
1853         }
1854         return NDR_ERR_SUCCESS;
1855 }
1856
1857 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetWkstaInfo *r)
1858 {
1859         int level;
1860         uint32_t _level;
1861         TALLOC_CTX *_mem_save_info100_0;
1862         TALLOC_CTX *_mem_save_info101_0;
1863         TALLOC_CTX *_mem_save_info102_0;
1864         TALLOC_CTX *_mem_save_info502_0;
1865         TALLOC_CTX *_mem_save_info1010_0;
1866         TALLOC_CTX *_mem_save_info1011_0;
1867         TALLOC_CTX *_mem_save_info1012_0;
1868         TALLOC_CTX *_mem_save_info1013_0;
1869         TALLOC_CTX *_mem_save_info1018_0;
1870         TALLOC_CTX *_mem_save_info1023_0;
1871         TALLOC_CTX *_mem_save_info1027_0;
1872         TALLOC_CTX *_mem_save_info1028_0;
1873         TALLOC_CTX *_mem_save_info1032_0;
1874         TALLOC_CTX *_mem_save_info1033_0;
1875         TALLOC_CTX *_mem_save_info1041_0;
1876         TALLOC_CTX *_mem_save_info1042_0;
1877         TALLOC_CTX *_mem_save_info1043_0;
1878         TALLOC_CTX *_mem_save_info1044_0;
1879         TALLOC_CTX *_mem_save_info1045_0;
1880         TALLOC_CTX *_mem_save_info1046_0;
1881         TALLOC_CTX *_mem_save_info1047_0;
1882         TALLOC_CTX *_mem_save_info1048_0;
1883         TALLOC_CTX *_mem_save_info1049_0;
1884         TALLOC_CTX *_mem_save_info1050_0;
1885         TALLOC_CTX *_mem_save_info1051_0;
1886         TALLOC_CTX *_mem_save_info1052_0;
1887         TALLOC_CTX *_mem_save_info1053_0;
1888         TALLOC_CTX *_mem_save_info1054_0;
1889         TALLOC_CTX *_mem_save_info1055_0;
1890         TALLOC_CTX *_mem_save_info1056_0;
1891         TALLOC_CTX *_mem_save_info1057_0;
1892         TALLOC_CTX *_mem_save_info1058_0;
1893         TALLOC_CTX *_mem_save_info1059_0;
1894         TALLOC_CTX *_mem_save_info1060_0;
1895         TALLOC_CTX *_mem_save_info1061_0;
1896         TALLOC_CTX *_mem_save_info1062_0;
1897         level = ndr_pull_get_switch_value(ndr, r);
1898         if (ndr_flags & NDR_SCALARS) {
1899                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
1900                 if (_level != level) {
1901                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1902                 }
1903                 switch (level) {
1904                         case 100: {
1905                                 uint32_t _ptr_info100;
1906                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info100));
1907                                 if (_ptr_info100) {
1908                                         NDR_PULL_ALLOC(ndr, r->info100);
1909                                 } else {
1910                                         r->info100 = NULL;
1911                                 }
1912                         break; }
1913
1914                         case 101: {
1915                                 uint32_t _ptr_info101;
1916                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info101));
1917                                 if (_ptr_info101) {
1918                                         NDR_PULL_ALLOC(ndr, r->info101);
1919                                 } else {
1920                                         r->info101 = NULL;
1921                                 }
1922                         break; }
1923
1924                         case 102: {
1925                                 uint32_t _ptr_info102;
1926                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info102));
1927                                 if (_ptr_info102) {
1928                                         NDR_PULL_ALLOC(ndr, r->info102);
1929                                 } else {
1930                                         r->info102 = NULL;
1931                                 }
1932                         break; }
1933
1934                         case 502: {
1935                                 uint32_t _ptr_info502;
1936                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info502));
1937                                 if (_ptr_info502) {
1938                                         NDR_PULL_ALLOC(ndr, r->info502);
1939                                 } else {
1940                                         r->info502 = NULL;
1941                                 }
1942                         break; }
1943
1944                         case 1010: {
1945                                 uint32_t _ptr_info1010;
1946                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1010));
1947                                 if (_ptr_info1010) {
1948                                         NDR_PULL_ALLOC(ndr, r->info1010);
1949                                 } else {
1950                                         r->info1010 = NULL;
1951                                 }
1952                         break; }
1953
1954                         case 1011: {
1955                                 uint32_t _ptr_info1011;
1956                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1011));
1957                                 if (_ptr_info1011) {
1958                                         NDR_PULL_ALLOC(ndr, r->info1011);
1959                                 } else {
1960                                         r->info1011 = NULL;
1961                                 }
1962                         break; }
1963
1964                         case 1012: {
1965                                 uint32_t _ptr_info1012;
1966                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1012));
1967                                 if (_ptr_info1012) {
1968                                         NDR_PULL_ALLOC(ndr, r->info1012);
1969                                 } else {
1970                                         r->info1012 = NULL;
1971                                 }
1972                         break; }
1973
1974                         case 1013: {
1975                                 uint32_t _ptr_info1013;
1976                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1013));
1977                                 if (_ptr_info1013) {
1978                                         NDR_PULL_ALLOC(ndr, r->info1013);
1979                                 } else {
1980                                         r->info1013 = NULL;
1981                                 }
1982                         break; }
1983
1984                         case 1018: {
1985                                 uint32_t _ptr_info1018;
1986                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1018));
1987                                 if (_ptr_info1018) {
1988                                         NDR_PULL_ALLOC(ndr, r->info1018);
1989                                 } else {
1990                                         r->info1018 = NULL;
1991                                 }
1992                         break; }
1993
1994                         case 1023: {
1995                                 uint32_t _ptr_info1023;
1996                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1023));
1997                                 if (_ptr_info1023) {
1998                                         NDR_PULL_ALLOC(ndr, r->info1023);
1999                                 } else {
2000                                         r->info1023 = NULL;
2001                                 }
2002                         break; }
2003
2004                         case 1027: {
2005                                 uint32_t _ptr_info1027;
2006                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1027));
2007                                 if (_ptr_info1027) {
2008                                         NDR_PULL_ALLOC(ndr, r->info1027);
2009                                 } else {
2010                                         r->info1027 = NULL;
2011                                 }
2012                         break; }
2013
2014                         case 1028: {
2015                                 uint32_t _ptr_info1028;
2016                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1028));
2017                                 if (_ptr_info1028) {
2018                                         NDR_PULL_ALLOC(ndr, r->info1028);
2019                                 } else {
2020                                         r->info1028 = NULL;
2021                                 }
2022                         break; }
2023
2024                         case 1032: {
2025                                 uint32_t _ptr_info1032;
2026                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1032));
2027                                 if (_ptr_info1032) {
2028                                         NDR_PULL_ALLOC(ndr, r->info1032);
2029                                 } else {
2030                                         r->info1032 = NULL;
2031                                 }
2032                         break; }
2033
2034                         case 1033: {
2035                                 uint32_t _ptr_info1033;
2036                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1033));
2037                                 if (_ptr_info1033) {
2038                                         NDR_PULL_ALLOC(ndr, r->info1033);
2039                                 } else {
2040                                         r->info1033 = NULL;
2041                                 }
2042                         break; }
2043
2044                         case 1041: {
2045                                 uint32_t _ptr_info1041;
2046                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1041));
2047                                 if (_ptr_info1041) {
2048                                         NDR_PULL_ALLOC(ndr, r->info1041);
2049                                 } else {
2050                                         r->info1041 = NULL;
2051                                 }
2052                         break; }
2053
2054                         case 1042: {
2055                                 uint32_t _ptr_info1042;
2056                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1042));
2057                                 if (_ptr_info1042) {
2058                                         NDR_PULL_ALLOC(ndr, r->info1042);
2059                                 } else {
2060                                         r->info1042 = NULL;
2061                                 }
2062                         break; }
2063
2064                         case 1043: {
2065                                 uint32_t _ptr_info1043;
2066                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1043));
2067                                 if (_ptr_info1043) {
2068                                         NDR_PULL_ALLOC(ndr, r->info1043);
2069                                 } else {
2070                                         r->info1043 = NULL;
2071                                 }
2072                         break; }
2073
2074                         case 1044: {
2075                                 uint32_t _ptr_info1044;
2076                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1044));
2077                                 if (_ptr_info1044) {
2078                                         NDR_PULL_ALLOC(ndr, r->info1044);
2079                                 } else {
2080                                         r->info1044 = NULL;
2081                                 }
2082                         break; }
2083
2084                         case 1045: {
2085                                 uint32_t _ptr_info1045;
2086                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1045));
2087                                 if (_ptr_info1045) {
2088                                         NDR_PULL_ALLOC(ndr, r->info1045);
2089                                 } else {
2090                                         r->info1045 = NULL;
2091                                 }
2092                         break; }
2093
2094                         case 1046: {
2095                                 uint32_t _ptr_info1046;
2096                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1046));
2097                                 if (_ptr_info1046) {
2098                                         NDR_PULL_ALLOC(ndr, r->info1046);
2099                                 } else {
2100                                         r->info1046 = NULL;
2101                                 }
2102                         break; }
2103
2104                         case 1047: {
2105                                 uint32_t _ptr_info1047;
2106                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1047));
2107                                 if (_ptr_info1047) {
2108                                         NDR_PULL_ALLOC(ndr, r->info1047);
2109                                 } else {
2110                                         r->info1047 = NULL;
2111                                 }
2112                         break; }
2113
2114                         case 1048: {
2115                                 uint32_t _ptr_info1048;
2116                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1048));
2117                                 if (_ptr_info1048) {
2118                                         NDR_PULL_ALLOC(ndr, r->info1048);
2119                                 } else {
2120                                         r->info1048 = NULL;
2121                                 }
2122                         break; }
2123
2124                         case 1049: {
2125                                 uint32_t _ptr_info1049;
2126                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1049));
2127                                 if (_ptr_info1049) {
2128                                         NDR_PULL_ALLOC(ndr, r->info1049);
2129                                 } else {
2130                                         r->info1049 = NULL;
2131                                 }
2132                         break; }
2133
2134                         case 1050: {
2135                                 uint32_t _ptr_info1050;
2136                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1050));
2137                                 if (_ptr_info1050) {
2138                                         NDR_PULL_ALLOC(ndr, r->info1050);
2139                                 } else {
2140                                         r->info1050 = NULL;
2141                                 }
2142                         break; }
2143
2144                         case 1051: {
2145                                 uint32_t _ptr_info1051;
2146                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1051));
2147                                 if (_ptr_info1051) {
2148                                         NDR_PULL_ALLOC(ndr, r->info1051);
2149                                 } else {
2150                                         r->info1051 = NULL;
2151                                 }
2152                         break; }
2153
2154                         case 1052: {
2155                                 uint32_t _ptr_info1052;
2156                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1052));
2157                                 if (_ptr_info1052) {
2158                                         NDR_PULL_ALLOC(ndr, r->info1052);
2159                                 } else {
2160                                         r->info1052 = NULL;
2161                                 }
2162                         break; }
2163
2164                         case 1053: {
2165                                 uint32_t _ptr_info1053;
2166                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1053));
2167                                 if (_ptr_info1053) {
2168                                         NDR_PULL_ALLOC(ndr, r->info1053);
2169                                 } else {
2170                                         r->info1053 = NULL;
2171                                 }
2172                         break; }
2173
2174                         case 1054: {
2175                                 uint32_t _ptr_info1054;
2176                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1054));
2177                                 if (_ptr_info1054) {
2178                                         NDR_PULL_ALLOC(ndr, r->info1054);
2179                                 } else {
2180                                         r->info1054 = NULL;
2181                                 }
2182                         break; }
2183
2184                         case 1055: {
2185                                 uint32_t _ptr_info1055;
2186                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1055));
2187                                 if (_ptr_info1055) {
2188                                         NDR_PULL_ALLOC(ndr, r->info1055);
2189                                 } else {
2190                                         r->info1055 = NULL;
2191                                 }
2192                         break; }
2193
2194                         case 1056: {
2195                                 uint32_t _ptr_info1056;
2196                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1056));
2197                                 if (_ptr_info1056) {
2198                                         NDR_PULL_ALLOC(ndr, r->info1056);
2199                                 } else {
2200                                         r->info1056 = NULL;
2201                                 }
2202                         break; }
2203
2204                         case 1057: {
2205                                 uint32_t _ptr_info1057;
2206                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1057));
2207                                 if (_ptr_info1057) {
2208                                         NDR_PULL_ALLOC(ndr, r->info1057);
2209                                 } else {
2210                                         r->info1057 = NULL;
2211                                 }
2212                         break; }
2213
2214                         case 1058: {
2215                                 uint32_t _ptr_info1058;
2216                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1058));
2217                                 if (_ptr_info1058) {
2218                                         NDR_PULL_ALLOC(ndr, r->info1058);
2219                                 } else {
2220                                         r->info1058 = NULL;
2221                                 }
2222                         break; }
2223
2224                         case 1059: {
2225                                 uint32_t _ptr_info1059;
2226                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1059));
2227                                 if (_ptr_info1059) {
2228                                         NDR_PULL_ALLOC(ndr, r->info1059);
2229                                 } else {
2230                                         r->info1059 = NULL;
2231                                 }
2232                         break; }
2233
2234                         case 1060: {
2235                                 uint32_t _ptr_info1060;
2236                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1060));
2237                                 if (_ptr_info1060) {
2238                                         NDR_PULL_ALLOC(ndr, r->info1060);
2239                                 } else {
2240                                         r->info1060 = NULL;
2241                                 }
2242                         break; }
2243
2244                         case 1061: {
2245                                 uint32_t _ptr_info1061;
2246                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1061));
2247                                 if (_ptr_info1061) {
2248                                         NDR_PULL_ALLOC(ndr, r->info1061);
2249                                 } else {
2250                                         r->info1061 = NULL;
2251                                 }
2252                         break; }
2253
2254                         case 1062: {
2255                                 uint32_t _ptr_info1062;
2256                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1062));
2257                                 if (_ptr_info1062) {
2258                                         NDR_PULL_ALLOC(ndr, r->info1062);
2259                                 } else {
2260                                         r->info1062 = NULL;
2261                                 }
2262                         break; }
2263
2264                         default: {
2265                         break; }
2266
2267                 }
2268         }
2269         if (ndr_flags & NDR_BUFFERS) {
2270                 switch (level) {
2271                         case 100:
2272                                 if (r->info100) {
2273                                         _mem_save_info100_0 = NDR_PULL_GET_MEM_CTX(ndr);
2274                                         NDR_PULL_SET_MEM_CTX(ndr, r->info100, 0);
2275                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo100(ndr, NDR_SCALARS|NDR_BUFFERS, r->info100));
2276                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info100_0, 0);
2277                                 }
2278                         break;
2279
2280                         case 101:
2281                                 if (r->info101) {
2282                                         _mem_save_info101_0 = NDR_PULL_GET_MEM_CTX(ndr);
2283                                         NDR_PULL_SET_MEM_CTX(ndr, r->info101, 0);
2284                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info101));
2285                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info101_0, 0);
2286                                 }
2287                         break;
2288
2289                         case 102:
2290                                 if (r->info102) {
2291                                         _mem_save_info102_0 = NDR_PULL_GET_MEM_CTX(ndr);
2292                                         NDR_PULL_SET_MEM_CTX(ndr, r->info102, 0);
2293                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo102(ndr, NDR_SCALARS|NDR_BUFFERS, r->info102));
2294                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info102_0, 0);
2295                                 }
2296                         break;
2297
2298                         case 502:
2299                                 if (r->info502) {
2300                                         _mem_save_info502_0 = NDR_PULL_GET_MEM_CTX(ndr);
2301                                         NDR_PULL_SET_MEM_CTX(ndr, r->info502, 0);
2302                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo502(ndr, NDR_SCALARS, r->info502));
2303                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info502_0, 0);
2304                                 }
2305                         break;
2306
2307                         case 1010:
2308                                 if (r->info1010) {
2309                                         _mem_save_info1010_0 = NDR_PULL_GET_MEM_CTX(ndr);
2310                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1010, 0);
2311                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1010(ndr, NDR_SCALARS, r->info1010));
2312                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1010_0, 0);
2313                                 }
2314                         break;
2315
2316                         case 1011:
2317                                 if (r->info1011) {
2318                                         _mem_save_info1011_0 = NDR_PULL_GET_MEM_CTX(ndr);
2319                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1011, 0);
2320                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1011(ndr, NDR_SCALARS, r->info1011));
2321                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1011_0, 0);
2322                                 }
2323                         break;
2324
2325                         case 1012:
2326                                 if (r->info1012) {
2327                                         _mem_save_info1012_0 = NDR_PULL_GET_MEM_CTX(ndr);
2328                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1012, 0);
2329                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1012(ndr, NDR_SCALARS, r->info1012));
2330                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1012_0, 0);
2331                                 }
2332                         break;
2333
2334                         case 1013:
2335                                 if (r->info1013) {
2336                                         _mem_save_info1013_0 = NDR_PULL_GET_MEM_CTX(ndr);
2337                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1013, 0);
2338                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1013(ndr, NDR_SCALARS, r->info1013));
2339                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1013_0, 0);
2340                                 }
2341                         break;
2342
2343                         case 1018:
2344                                 if (r->info1018) {
2345                                         _mem_save_info1018_0 = NDR_PULL_GET_MEM_CTX(ndr);
2346                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1018, 0);
2347                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1018(ndr, NDR_SCALARS, r->info1018));
2348                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1018_0, 0);
2349                                 }
2350                         break;
2351
2352                         case 1023:
2353                                 if (r->info1023) {
2354                                         _mem_save_info1023_0 = NDR_PULL_GET_MEM_CTX(ndr);
2355                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1023, 0);
2356                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1023(ndr, NDR_SCALARS, r->info1023));
2357                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1023_0, 0);
2358                                 }
2359                         break;
2360
2361                         case 1027:
2362                                 if (r->info1027) {
2363                                         _mem_save_info1027_0 = NDR_PULL_GET_MEM_CTX(ndr);
2364                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1027, 0);
2365                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1027(ndr, NDR_SCALARS, r->info1027));
2366                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1027_0, 0);
2367                                 }
2368                         break;
2369
2370                         case 1028:
2371                                 if (r->info1028) {
2372                                         _mem_save_info1028_0 = NDR_PULL_GET_MEM_CTX(ndr);
2373                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1028, 0);
2374                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1028(ndr, NDR_SCALARS, r->info1028));
2375                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1028_0, 0);
2376                                 }
2377                         break;
2378
2379                         case 1032:
2380                                 if (r->info1032) {
2381                                         _mem_save_info1032_0 = NDR_PULL_GET_MEM_CTX(ndr);
2382                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1032, 0);
2383                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1032(ndr, NDR_SCALARS, r->info1032));
2384                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1032_0, 0);
2385                                 }
2386                         break;
2387
2388                         case 1033:
2389                                 if (r->info1033) {
2390                                         _mem_save_info1033_0 = NDR_PULL_GET_MEM_CTX(ndr);
2391                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1033, 0);
2392                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1033(ndr, NDR_SCALARS, r->info1033));
2393                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1033_0, 0);
2394                                 }
2395                         break;
2396
2397                         case 1041:
2398                                 if (r->info1041) {
2399                                         _mem_save_info1041_0 = NDR_PULL_GET_MEM_CTX(ndr);
2400                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1041, 0);
2401                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1041(ndr, NDR_SCALARS, r->info1041));
2402                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1041_0, 0);
2403                                 }
2404                         break;
2405
2406                         case 1042:
2407                                 if (r->info1042) {
2408                                         _mem_save_info1042_0 = NDR_PULL_GET_MEM_CTX(ndr);
2409                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1042, 0);
2410                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1042(ndr, NDR_SCALARS, r->info1042));
2411                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1042_0, 0);
2412                                 }
2413                         break;
2414
2415                         case 1043:
2416                                 if (r->info1043) {
2417                                         _mem_save_info1043_0 = NDR_PULL_GET_MEM_CTX(ndr);
2418                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1043, 0);
2419                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1043(ndr, NDR_SCALARS, r->info1043));
2420                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1043_0, 0);
2421                                 }
2422                         break;
2423
2424                         case 1044:
2425                                 if (r->info1044) {
2426                                         _mem_save_info1044_0 = NDR_PULL_GET_MEM_CTX(ndr);
2427                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1044, 0);
2428                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1044(ndr, NDR_SCALARS, r->info1044));
2429                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1044_0, 0);
2430                                 }
2431                         break;
2432
2433                         case 1045:
2434                                 if (r->info1045) {
2435                                         _mem_save_info1045_0 = NDR_PULL_GET_MEM_CTX(ndr);
2436                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1045, 0);
2437                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1045(ndr, NDR_SCALARS, r->info1045));
2438                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1045_0, 0);
2439                                 }
2440                         break;
2441
2442                         case 1046:
2443                                 if (r->info1046) {
2444                                         _mem_save_info1046_0 = NDR_PULL_GET_MEM_CTX(ndr);
2445                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1046, 0);
2446                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1046(ndr, NDR_SCALARS, r->info1046));
2447                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1046_0, 0);
2448                                 }
2449                         break;
2450
2451                         case 1047:
2452                                 if (r->info1047) {
2453                                         _mem_save_info1047_0 = NDR_PULL_GET_MEM_CTX(ndr);
2454                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1047, 0);
2455                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1047(ndr, NDR_SCALARS, r->info1047));
2456                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1047_0, 0);
2457                                 }
2458                         break;
2459
2460                         case 1048:
2461                                 if (r->info1048) {
2462                                         _mem_save_info1048_0 = NDR_PULL_GET_MEM_CTX(ndr);
2463                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1048, 0);
2464                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1048(ndr, NDR_SCALARS, r->info1048));
2465                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1048_0, 0);
2466                                 }
2467                         break;
2468
2469                         case 1049:
2470                                 if (r->info1049) {
2471                                         _mem_save_info1049_0 = NDR_PULL_GET_MEM_CTX(ndr);
2472                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1049, 0);
2473                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1049(ndr, NDR_SCALARS, r->info1049));
2474                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1049_0, 0);
2475                                 }
2476                         break;
2477
2478                         case 1050:
2479                                 if (r->info1050) {
2480                                         _mem_save_info1050_0 = NDR_PULL_GET_MEM_CTX(ndr);
2481                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1050, 0);
2482                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1050(ndr, NDR_SCALARS, r->info1050));
2483                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1050_0, 0);
2484                                 }
2485                         break;
2486
2487                         case 1051:
2488                                 if (r->info1051) {
2489                                         _mem_save_info1051_0 = NDR_PULL_GET_MEM_CTX(ndr);
2490                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1051, 0);
2491                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1051(ndr, NDR_SCALARS, r->info1051));
2492                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1051_0, 0);
2493                                 }
2494                         break;
2495
2496                         case 1052:
2497                                 if (r->info1052) {
2498                                         _mem_save_info1052_0 = NDR_PULL_GET_MEM_CTX(ndr);
2499                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1052, 0);
2500                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1052(ndr, NDR_SCALARS, r->info1052));
2501                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1052_0, 0);
2502                                 }
2503                         break;
2504
2505                         case 1053:
2506                                 if (r->info1053) {
2507                                         _mem_save_info1053_0 = NDR_PULL_GET_MEM_CTX(ndr);
2508                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1053, 0);
2509                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1053(ndr, NDR_SCALARS, r->info1053));
2510                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1053_0, 0);
2511                                 }
2512                         break;
2513
2514                         case 1054:
2515                                 if (r->info1054) {
2516                                         _mem_save_info1054_0 = NDR_PULL_GET_MEM_CTX(ndr);
2517                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1054, 0);
2518                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1054(ndr, NDR_SCALARS, r->info1054));
2519                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1054_0, 0);
2520                                 }
2521                         break;
2522
2523                         case 1055:
2524                                 if (r->info1055) {
2525                                         _mem_save_info1055_0 = NDR_PULL_GET_MEM_CTX(ndr);
2526                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1055, 0);
2527                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1055(ndr, NDR_SCALARS, r->info1055));
2528                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1055_0, 0);
2529                                 }
2530                         break;
2531
2532                         case 1056:
2533                                 if (r->info1056) {
2534                                         _mem_save_info1056_0 = NDR_PULL_GET_MEM_CTX(ndr);
2535                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1056, 0);
2536                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1056(ndr, NDR_SCALARS, r->info1056));
2537                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1056_0, 0);
2538                                 }
2539                         break;
2540
2541                         case 1057:
2542                                 if (r->info1057) {
2543                                         _mem_save_info1057_0 = NDR_PULL_GET_MEM_CTX(ndr);
2544                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1057, 0);
2545                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1057(ndr, NDR_SCALARS, r->info1057));
2546                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1057_0, 0);
2547                                 }
2548                         break;
2549
2550                         case 1058:
2551                                 if (r->info1058) {
2552                                         _mem_save_info1058_0 = NDR_PULL_GET_MEM_CTX(ndr);
2553                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1058, 0);
2554                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1058(ndr, NDR_SCALARS, r->info1058));
2555                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1058_0, 0);
2556                                 }
2557                         break;
2558
2559                         case 1059:
2560                                 if (r->info1059) {
2561                                         _mem_save_info1059_0 = NDR_PULL_GET_MEM_CTX(ndr);
2562                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1059, 0);
2563                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1059(ndr, NDR_SCALARS, r->info1059));
2564                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1059_0, 0);
2565                                 }
2566                         break;
2567
2568                         case 1060:
2569                                 if (r->info1060) {
2570                                         _mem_save_info1060_0 = NDR_PULL_GET_MEM_CTX(ndr);
2571                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1060, 0);
2572                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1060(ndr, NDR_SCALARS, r->info1060));
2573                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1060_0, 0);
2574                                 }
2575                         break;
2576
2577                         case 1061:
2578                                 if (r->info1061) {
2579                                         _mem_save_info1061_0 = NDR_PULL_GET_MEM_CTX(ndr);
2580                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1061, 0);
2581                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1061(ndr, NDR_SCALARS, r->info1061));
2582                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1061_0, 0);
2583                                 }
2584                         break;
2585
2586                         case 1062:
2587                                 if (r->info1062) {
2588                                         _mem_save_info1062_0 = NDR_PULL_GET_MEM_CTX(ndr);
2589                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1062, 0);
2590                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1062(ndr, NDR_SCALARS, r->info1062));
2591                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1062_0, 0);
2592                                 }
2593                         break;
2594
2595                         default:
2596                         break;
2597
2598                 }
2599         }
2600         return NDR_ERR_SUCCESS;
2601 }
2602
2603 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo(struct ndr_print *ndr, const char *name, const union wkssvc_NetWkstaInfo *r)
2604 {
2605         int level;
2606         level = ndr_print_get_switch_value(ndr, r);
2607         ndr_print_union(ndr, name, level, "wkssvc_NetWkstaInfo");
2608         switch (level) {
2609                 case 100:
2610                         ndr_print_ptr(ndr, "info100", r->info100);
2611                         ndr->depth++;
2612                         if (r->info100) {
2613                                 ndr_print_wkssvc_NetWkstaInfo100(ndr, "info100", r->info100);
2614                         }
2615                         ndr->depth--;
2616                 break;
2617
2618                 case 101:
2619                         ndr_print_ptr(ndr, "info101", r->info101);
2620                         ndr->depth++;
2621                         if (r->info101) {
2622                                 ndr_print_wkssvc_NetWkstaInfo101(ndr, "info101", r->info101);
2623                         }
2624                         ndr->depth--;
2625                 break;
2626
2627                 case 102:
2628                         ndr_print_ptr(ndr, "info102", r->info102);
2629                         ndr->depth++;
2630                         if (r->info102) {
2631                                 ndr_print_wkssvc_NetWkstaInfo102(ndr, "info102", r->info102);
2632                         }
2633                         ndr->depth--;
2634                 break;
2635
2636                 case 502:
2637                         ndr_print_ptr(ndr, "info502", r->info502);
2638                         ndr->depth++;
2639                         if (r->info502) {
2640                                 ndr_print_wkssvc_NetWkstaInfo502(ndr, "info502", r->info502);
2641                         }
2642                         ndr->depth--;
2643                 break;
2644
2645                 case 1010:
2646                         ndr_print_ptr(ndr, "info1010", r->info1010);
2647                         ndr->depth++;
2648                         if (r->info1010) {
2649                                 ndr_print_wkssvc_NetWkstaInfo1010(ndr, "info1010", r->info1010);
2650                         }
2651                         ndr->depth--;
2652                 break;
2653
2654                 case 1011:
2655                         ndr_print_ptr(ndr, "info1011", r->info1011);
2656                         ndr->depth++;
2657                         if (r->info1011) {
2658                                 ndr_print_wkssvc_NetWkstaInfo1011(ndr, "info1011", r->info1011);
2659                         }
2660                         ndr->depth--;
2661                 break;
2662
2663                 case 1012:
2664                         ndr_print_ptr(ndr, "info1012", r->info1012);
2665                         ndr->depth++;
2666                         if (r->info1012) {
2667                                 ndr_print_wkssvc_NetWkstaInfo1012(ndr, "info1012", r->info1012);
2668                         }
2669                         ndr->depth--;
2670                 break;
2671
2672                 case 1013:
2673                         ndr_print_ptr(ndr, "info1013", r->info1013);
2674                         ndr->depth++;
2675                         if (r->info1013) {
2676                                 ndr_print_wkssvc_NetWkstaInfo1013(ndr, "info1013", r->info1013);
2677                         }
2678                         ndr->depth--;
2679                 break;
2680
2681                 case 1018:
2682                         ndr_print_ptr(ndr, "info1018", r->info1018);
2683                         ndr->depth++;
2684                         if (r->info1018) {
2685                                 ndr_print_wkssvc_NetWkstaInfo1018(ndr, "info1018", r->info1018);
2686                         }
2687                         ndr->depth--;
2688                 break;
2689
2690                 case 1023:
2691                         ndr_print_ptr(ndr, "info1023", r->info1023);
2692                         ndr->depth++;
2693                         if (r->info1023) {
2694                                 ndr_print_wkssvc_NetWkstaInfo1023(ndr, "info1023", r->info1023);
2695                         }
2696                         ndr->depth--;
2697                 break;
2698
2699                 case 1027:
2700                         ndr_print_ptr(ndr, "info1027", r->info1027);
2701                         ndr->depth++;
2702                         if (r->info1027) {
2703                                 ndr_print_wkssvc_NetWkstaInfo1027(ndr, "info1027", r->info1027);
2704                         }
2705                         ndr->depth--;
2706                 break;
2707
2708                 case 1028:
2709                         ndr_print_ptr(ndr, "info1028", r->info1028);
2710                         ndr->depth++;
2711                         if (r->info1028) {
2712                                 ndr_print_wkssvc_NetWkstaInfo1028(ndr, "info1028", r->info1028);
2713                         }
2714                         ndr->depth--;
2715                 break;
2716
2717                 case 1032:
2718                         ndr_print_ptr(ndr, "info1032", r->info1032);
2719                         ndr->depth++;
2720                         if (r->info1032) {
2721                                 ndr_print_wkssvc_NetWkstaInfo1032(ndr, "info1032", r->info1032);
2722                         }
2723                         ndr->depth--;
2724                 break;
2725
2726                 case 1033:
2727                         ndr_print_ptr(ndr, "info1033", r->info1033);
2728                         ndr->depth++;
2729                         if (r->info1033) {
2730                                 ndr_print_wkssvc_NetWkstaInfo1033(ndr, "info1033", r->info1033);
2731                         }
2732                         ndr->depth--;
2733                 break;
2734
2735                 case 1041:
2736                         ndr_print_ptr(ndr, "info1041", r->info1041);
2737                         ndr->depth++;
2738                         if (r->info1041) {
2739                                 ndr_print_wkssvc_NetWkstaInfo1041(ndr, "info1041", r->info1041);
2740                         }
2741                         ndr->depth--;
2742                 break;
2743
2744                 case 1042:
2745                         ndr_print_ptr(ndr, "info1042", r->info1042);
2746                         ndr->depth++;
2747                         if (r->info1042) {
2748                                 ndr_print_wkssvc_NetWkstaInfo1042(ndr, "info1042", r->info1042);
2749                         }
2750                         ndr->depth--;
2751                 break;
2752
2753                 case 1043:
2754                         ndr_print_ptr(ndr, "info1043", r->info1043);
2755                         ndr->depth++;
2756                         if (r->info1043) {
2757                                 ndr_print_wkssvc_NetWkstaInfo1043(ndr, "info1043", r->info1043);
2758                         }
2759                         ndr->depth--;
2760                 break;
2761
2762                 case 1044:
2763                         ndr_print_ptr(ndr, "info1044", r->info1044);
2764                         ndr->depth++;
2765                         if (r->info1044) {
2766                                 ndr_print_wkssvc_NetWkstaInfo1044(ndr, "info1044", r->info1044);
2767                         }
2768                         ndr->depth--;
2769                 break;
2770
2771                 case 1045:
2772                         ndr_print_ptr(ndr, "info1045", r->info1045);
2773                         ndr->depth++;
2774                         if (r->info1045) {
2775                                 ndr_print_wkssvc_NetWkstaInfo1045(ndr, "info1045", r->info1045);
2776                         }
2777                         ndr->depth--;
2778                 break;
2779
2780                 case 1046:
2781                         ndr_print_ptr(ndr, "info1046", r->info1046);
2782                         ndr->depth++;
2783                         if (r->info1046) {
2784                                 ndr_print_wkssvc_NetWkstaInfo1046(ndr, "info1046", r->info1046);
2785                         }
2786                         ndr->depth--;
2787                 break;
2788
2789                 case 1047:
2790                         ndr_print_ptr(ndr, "info1047", r->info1047);
2791                         ndr->depth++;
2792                         if (r->info1047) {
2793                                 ndr_print_wkssvc_NetWkstaInfo1047(ndr, "info1047", r->info1047);
2794                         }
2795                         ndr->depth--;
2796                 break;
2797
2798                 case 1048:
2799                         ndr_print_ptr(ndr, "info1048", r->info1048);
2800                         ndr->depth++;
2801                         if (r->info1048) {
2802                                 ndr_print_wkssvc_NetWkstaInfo1048(ndr, "info1048", r->info1048);
2803                         }
2804                         ndr->depth--;
2805                 break;
2806
2807                 case 1049:
2808                         ndr_print_ptr(ndr, "info1049", r->info1049);
2809                         ndr->depth++;
2810                         if (r->info1049) {
2811                                 ndr_print_wkssvc_NetWkstaInfo1049(ndr, "info1049", r->info1049);
2812                         }
2813                         ndr->depth--;
2814                 break;
2815
2816                 case 1050:
2817                         ndr_print_ptr(ndr, "info1050", r->info1050);
2818                         ndr->depth++;
2819                         if (r->info1050) {
2820                                 ndr_print_wkssvc_NetWkstaInfo1050(ndr, "info1050", r->info1050);
2821                         }
2822                         ndr->depth--;
2823                 break;
2824
2825                 case 1051:
2826                         ndr_print_ptr(ndr, "info1051", r->info1051);
2827                         ndr->depth++;
2828                         if (r->info1051) {
2829                                 ndr_print_wkssvc_NetWkstaInfo1051(ndr, "info1051", r->info1051);
2830                         }
2831                         ndr->depth--;
2832                 break;
2833
2834                 case 1052:
2835                         ndr_print_ptr(ndr, "info1052", r->info1052);
2836                         ndr->depth++;
2837                         if (r->info1052) {
2838                                 ndr_print_wkssvc_NetWkstaInfo1052(ndr, "info1052", r->info1052);
2839                         }
2840                         ndr->depth--;
2841                 break;
2842
2843                 case 1053:
2844                         ndr_print_ptr(ndr, "info1053", r->info1053);
2845                         ndr->depth++;
2846                         if (r->info1053) {
2847                                 ndr_print_wkssvc_NetWkstaInfo1053(ndr, "info1053", r->info1053);
2848                         }
2849                         ndr->depth--;
2850                 break;
2851
2852                 case 1054:
2853                         ndr_print_ptr(ndr, "info1054", r->info1054);
2854                         ndr->depth++;
2855                         if (r->info1054) {
2856                                 ndr_print_wkssvc_NetWkstaInfo1054(ndr, "info1054", r->info1054);
2857                         }
2858                         ndr->depth--;
2859                 break;
2860
2861                 case 1055:
2862                         ndr_print_ptr(ndr, "info1055", r->info1055);
2863                         ndr->depth++;
2864                         if (r->info1055) {
2865                                 ndr_print_wkssvc_NetWkstaInfo1055(ndr, "info1055", r->info1055);
2866                         }
2867                         ndr->depth--;
2868                 break;
2869
2870                 case 1056:
2871                         ndr_print_ptr(ndr, "info1056", r->info1056);
2872                         ndr->depth++;
2873                         if (r->info1056) {
2874                                 ndr_print_wkssvc_NetWkstaInfo1056(ndr, "info1056", r->info1056);
2875                         }
2876                         ndr->depth--;
2877                 break;
2878
2879                 case 1057:
2880                         ndr_print_ptr(ndr, "info1057", r->info1057);
2881                         ndr->depth++;
2882                         if (r->info1057) {
2883                                 ndr_print_wkssvc_NetWkstaInfo1057(ndr, "info1057", r->info1057);
2884                         }
2885                         ndr->depth--;
2886                 break;
2887
2888                 case 1058:
2889                         ndr_print_ptr(ndr, "info1058", r->info1058);
2890                         ndr->depth++;
2891                         if (r->info1058) {
2892                                 ndr_print_wkssvc_NetWkstaInfo1058(ndr, "info1058", r->info1058);
2893                         }
2894                         ndr->depth--;
2895                 break;
2896
2897                 case 1059:
2898                         ndr_print_ptr(ndr, "info1059", r->info1059);
2899                         ndr->depth++;
2900                         if (r->info1059) {
2901                                 ndr_print_wkssvc_NetWkstaInfo1059(ndr, "info1059", r->info1059);
2902                         }
2903                         ndr->depth--;
2904                 break;
2905
2906                 case 1060:
2907                         ndr_print_ptr(ndr, "info1060", r->info1060);
2908                         ndr->depth++;
2909                         if (r->info1060) {
2910                                 ndr_print_wkssvc_NetWkstaInfo1060(ndr, "info1060", r->info1060);
2911                         }
2912                         ndr->depth--;
2913                 break;
2914
2915                 case 1061:
2916                         ndr_print_ptr(ndr, "info1061", r->info1061);
2917                         ndr->depth++;
2918                         if (r->info1061) {
2919                                 ndr_print_wkssvc_NetWkstaInfo1061(ndr, "info1061", r->info1061);
2920                         }
2921                         ndr->depth--;
2922                 break;
2923
2924                 case 1062:
2925                         ndr_print_ptr(ndr, "info1062", r->info1062);
2926                         ndr->depth++;
2927                         if (r->info1062) {
2928                                 ndr_print_wkssvc_NetWkstaInfo1062(ndr, "info1062", r->info1062);
2929                         }
2930                         ndr->depth--;
2931                 break;
2932
2933                 default:
2934                 break;
2935
2936         }
2937 }
2938
2939 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserInfo0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrWkstaUserInfo0 *r)
2940 {
2941         if (ndr_flags & NDR_SCALARS) {
2942                 NDR_CHECK(ndr_push_align(ndr, 4));
2943                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
2944         }
2945         if (ndr_flags & NDR_BUFFERS) {
2946                 if (r->user_name) {
2947                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
2948                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2949                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
2950                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2951                 }
2952         }
2953         return NDR_ERR_SUCCESS;
2954 }
2955
2956 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserInfo0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrWkstaUserInfo0 *r)
2957 {
2958         uint32_t _ptr_user_name;
2959         TALLOC_CTX *_mem_save_user_name_0;
2960         if (ndr_flags & NDR_SCALARS) {
2961                 NDR_CHECK(ndr_pull_align(ndr, 4));
2962                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
2963                 if (_ptr_user_name) {
2964                         NDR_PULL_ALLOC(ndr, r->user_name);
2965                 } else {
2966                         r->user_name = NULL;
2967                 }
2968         }
2969         if (ndr_flags & NDR_BUFFERS) {
2970                 if (r->user_name) {
2971                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2972                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
2973                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
2974                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
2975                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
2976                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
2977                         }
2978                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
2979                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
2980                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
2981                 }
2982         }
2983         return NDR_ERR_SUCCESS;
2984 }
2985
2986 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserInfo0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrWkstaUserInfo0 *r)
2987 {
2988         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaUserInfo0");
2989         ndr->depth++;
2990         ndr_print_ptr(ndr, "user_name", r->user_name);
2991         ndr->depth++;
2992         if (r->user_name) {
2993                 ndr_print_string(ndr, "user_name", r->user_name);
2994         }
2995         ndr->depth--;
2996         ndr->depth--;
2997 }
2998
2999 static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsersCtr0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaEnumUsersCtr0 *r)
3000 {
3001         uint32_t cntr_user0_1;
3002         if (ndr_flags & NDR_SCALARS) {
3003                 NDR_CHECK(ndr_push_align(ndr, 4));
3004                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->entries_read));
3005                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user0));
3006         }
3007         if (ndr_flags & NDR_BUFFERS) {
3008                 if (r->user0) {
3009                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->entries_read));
3010                         for (cntr_user0_1 = 0; cntr_user0_1 < r->entries_read; cntr_user0_1++) {
3011                                 NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo0(ndr, NDR_SCALARS, &r->user0[cntr_user0_1]));
3012                         }
3013                         for (cntr_user0_1 = 0; cntr_user0_1 < r->entries_read; cntr_user0_1++) {
3014                                 NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo0(ndr, NDR_BUFFERS, &r->user0[cntr_user0_1]));
3015                         }
3016                 }
3017         }
3018         return NDR_ERR_SUCCESS;
3019 }
3020
3021 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsersCtr0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaEnumUsersCtr0 *r)
3022 {
3023         uint32_t _ptr_user0;
3024         uint32_t cntr_user0_1;
3025         TALLOC_CTX *_mem_save_user0_0;
3026         TALLOC_CTX *_mem_save_user0_1;
3027         if (ndr_flags & NDR_SCALARS) {
3028                 NDR_CHECK(ndr_pull_align(ndr, 4));
3029                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->entries_read));
3030                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user0));
3031                 if (_ptr_user0) {
3032                         NDR_PULL_ALLOC(ndr, r->user0);
3033                 } else {
3034                         r->user0 = NULL;
3035                 }
3036         }
3037         if (ndr_flags & NDR_BUFFERS) {
3038                 if (r->user0) {
3039                         _mem_save_user0_0 = NDR_PULL_GET_MEM_CTX(ndr);
3040                         NDR_PULL_SET_MEM_CTX(ndr, r->user0, 0);
3041                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user0));
3042                         NDR_PULL_ALLOC_N(ndr, r->user0, ndr_get_array_size(ndr, &r->user0));
3043                         _mem_save_user0_1 = NDR_PULL_GET_MEM_CTX(ndr);
3044                         NDR_PULL_SET_MEM_CTX(ndr, r->user0, 0);
3045                         for (cntr_user0_1 = 0; cntr_user0_1 < r->entries_read; cntr_user0_1++) {
3046                                 NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo0(ndr, NDR_SCALARS, &r->user0[cntr_user0_1]));
3047                         }
3048                         for (cntr_user0_1 = 0; cntr_user0_1 < r->entries_read; cntr_user0_1++) {
3049                                 NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo0(ndr, NDR_BUFFERS, &r->user0[cntr_user0_1]));
3050                         }
3051                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user0_1, 0);
3052                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user0_0, 0);
3053                 }
3054                 if (r->user0) {
3055                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->user0, r->entries_read));
3056                 }
3057         }
3058         return NDR_ERR_SUCCESS;
3059 }
3060
3061 _PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsersCtr0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaEnumUsersCtr0 *r)
3062 {
3063         uint32_t cntr_user0_1;
3064         ndr_print_struct(ndr, name, "wkssvc_NetWkstaEnumUsersCtr0");
3065         ndr->depth++;
3066         ndr_print_uint32(ndr, "entries_read", r->entries_read);
3067         ndr_print_ptr(ndr, "user0", r->user0);
3068         ndr->depth++;
3069         if (r->user0) {
3070                 ndr->print(ndr, "%s: ARRAY(%d)", "user0", (int)r->entries_read);
3071                 ndr->depth++;
3072                 for (cntr_user0_1=0;cntr_user0_1<r->entries_read;cntr_user0_1++) {
3073                         char *idx_1=NULL;
3074                         if (asprintf(&idx_1, "[%d]", cntr_user0_1) != -1) {
3075                                 ndr_print_wkssvc_NetrWkstaUserInfo0(ndr, "user0", &r->user0[cntr_user0_1]);
3076                                 free(idx_1);
3077                         }
3078                 }
3079                 ndr->depth--;
3080         }
3081         ndr->depth--;
3082         ndr->depth--;
3083 }
3084
3085 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserInfo1(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrWkstaUserInfo1 *r)
3086 {
3087         if (ndr_flags & NDR_SCALARS) {
3088                 NDR_CHECK(ndr_push_align(ndr, 4));
3089                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
3090                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->logon_domain));
3091                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->other_domains));
3092                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->logon_server));
3093         }
3094         if (ndr_flags & NDR_BUFFERS) {
3095                 if (r->user_name) {
3096                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
3097                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3098                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
3099                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3100                 }
3101                 if (r->logon_domain) {
3102                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->logon_domain, CH_UTF16)));
3103                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3104                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->logon_domain, CH_UTF16)));
3105                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->logon_domain, ndr_charset_length(r->logon_domain, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3106                 }
3107                 if (r->other_domains) {
3108                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->other_domains, CH_UTF16)));
3109                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3110                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->other_domains, CH_UTF16)));
3111                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->other_domains, ndr_charset_length(r->other_domains, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3112                 }
3113                 if (r->logon_server) {
3114                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->logon_server, CH_UTF16)));
3115                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3116                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->logon_server, CH_UTF16)));
3117                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->logon_server, ndr_charset_length(r->logon_server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3118                 }
3119         }
3120         return NDR_ERR_SUCCESS;
3121 }
3122
3123 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserInfo1(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrWkstaUserInfo1 *r)
3124 {
3125         uint32_t _ptr_user_name;
3126         TALLOC_CTX *_mem_save_user_name_0;
3127         uint32_t _ptr_logon_domain;
3128         TALLOC_CTX *_mem_save_logon_domain_0;
3129         uint32_t _ptr_other_domains;
3130         TALLOC_CTX *_mem_save_other_domains_0;
3131         uint32_t _ptr_logon_server;
3132         TALLOC_CTX *_mem_save_logon_server_0;
3133         if (ndr_flags & NDR_SCALARS) {
3134                 NDR_CHECK(ndr_pull_align(ndr, 4));
3135                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3136                 if (_ptr_user_name) {
3137                         NDR_PULL_ALLOC(ndr, r->user_name);
3138                 } else {
3139                         r->user_name = NULL;
3140                 }
3141                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_logon_domain));
3142                 if (_ptr_logon_domain) {
3143                         NDR_PULL_ALLOC(ndr, r->logon_domain);
3144                 } else {
3145                         r->logon_domain = NULL;
3146                 }
3147                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_other_domains));
3148                 if (_ptr_other_domains) {
3149                         NDR_PULL_ALLOC(ndr, r->other_domains);
3150                 } else {
3151                         r->other_domains = NULL;
3152                 }
3153                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_logon_server));
3154                 if (_ptr_logon_server) {
3155                         NDR_PULL_ALLOC(ndr, r->logon_server);
3156                 } else {
3157                         r->logon_server = NULL;
3158                 }
3159         }
3160         if (ndr_flags & NDR_BUFFERS) {
3161                 if (r->user_name) {
3162                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3163                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3164                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
3165                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
3166                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
3167                                 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));
3168                         }
3169                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
3170                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
3171                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3172                 }
3173                 if (r->logon_domain) {
3174                         _mem_save_logon_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
3175                         NDR_PULL_SET_MEM_CTX(ndr, r->logon_domain, 0);
3176                         NDR_CHECK(ndr_pull_array_size(ndr, &r->logon_domain));
3177                         NDR_CHECK(ndr_pull_array_length(ndr, &r->logon_domain));
3178                         if (ndr_get_array_length(ndr, &r->logon_domain) > ndr_get_array_size(ndr, &r->logon_domain)) {
3179                                 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));
3180                         }
3181                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->logon_domain), sizeof(uint16_t)));
3182                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->logon_domain, ndr_get_array_length(ndr, &r->logon_domain), sizeof(uint16_t), CH_UTF16));
3183                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_logon_domain_0, 0);
3184                 }
3185                 if (r->other_domains) {
3186                         _mem_save_other_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
3187                         NDR_PULL_SET_MEM_CTX(ndr, r->other_domains, 0);
3188                         NDR_CHECK(ndr_pull_array_size(ndr, &r->other_domains));
3189                         NDR_CHECK(ndr_pull_array_length(ndr, &r->other_domains));
3190                         if (ndr_get_array_length(ndr, &r->other_domains) > ndr_get_array_size(ndr, &r->other_domains)) {
3191                                 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));
3192                         }
3193                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->other_domains), sizeof(uint16_t)));
3194                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->other_domains, ndr_get_array_length(ndr, &r->other_domains), sizeof(uint16_t), CH_UTF16));
3195                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_other_domains_0, 0);
3196                 }
3197                 if (r->logon_server) {
3198                         _mem_save_logon_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
3199                         NDR_PULL_SET_MEM_CTX(ndr, r->logon_server, 0);
3200                         NDR_CHECK(ndr_pull_array_size(ndr, &r->logon_server));
3201                         NDR_CHECK(ndr_pull_array_length(ndr, &r->logon_server));
3202                         if (ndr_get_array_length(ndr, &r->logon_server) > ndr_get_array_size(ndr, &r->logon_server)) {
3203                                 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));
3204                         }
3205                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->logon_server), sizeof(uint16_t)));
3206                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->logon_server, ndr_get_array_length(ndr, &r->logon_server), sizeof(uint16_t), CH_UTF16));
3207                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_logon_server_0, 0);
3208                 }
3209         }
3210         return NDR_ERR_SUCCESS;
3211 }
3212
3213 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserInfo1(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrWkstaUserInfo1 *r)
3214 {
3215         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaUserInfo1");
3216         ndr->depth++;
3217         ndr_print_ptr(ndr, "user_name", r->user_name);
3218         ndr->depth++;
3219         if (r->user_name) {
3220                 ndr_print_string(ndr, "user_name", r->user_name);
3221         }
3222         ndr->depth--;
3223         ndr_print_ptr(ndr, "logon_domain", r->logon_domain);
3224         ndr->depth++;
3225         if (r->logon_domain) {
3226                 ndr_print_string(ndr, "logon_domain", r->logon_domain);
3227         }
3228         ndr->depth--;
3229         ndr_print_ptr(ndr, "other_domains", r->other_domains);
3230         ndr->depth++;
3231         if (r->other_domains) {
3232                 ndr_print_string(ndr, "other_domains", r->other_domains);
3233         }
3234         ndr->depth--;
3235         ndr_print_ptr(ndr, "logon_server", r->logon_server);
3236         ndr->depth++;
3237         if (r->logon_server) {
3238                 ndr_print_string(ndr, "logon_server", r->logon_server);
3239         }
3240         ndr->depth--;
3241         ndr->depth--;
3242 }
3243
3244 static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsersCtr1(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaEnumUsersCtr1 *r)
3245 {
3246         uint32_t cntr_user1_1;
3247         if (ndr_flags & NDR_SCALARS) {
3248                 NDR_CHECK(ndr_push_align(ndr, 4));
3249                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->entries_read));
3250                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user1));
3251         }
3252         if (ndr_flags & NDR_BUFFERS) {
3253                 if (r->user1) {
3254                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->entries_read));
3255                         for (cntr_user1_1 = 0; cntr_user1_1 < r->entries_read; cntr_user1_1++) {
3256                                 NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo1(ndr, NDR_SCALARS, &r->user1[cntr_user1_1]));
3257                         }
3258                         for (cntr_user1_1 = 0; cntr_user1_1 < r->entries_read; cntr_user1_1++) {
3259                                 NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo1(ndr, NDR_BUFFERS, &r->user1[cntr_user1_1]));
3260                         }
3261                 }
3262         }
3263         return NDR_ERR_SUCCESS;
3264 }
3265
3266 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsersCtr1(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaEnumUsersCtr1 *r)
3267 {
3268         uint32_t _ptr_user1;
3269         uint32_t cntr_user1_1;
3270         TALLOC_CTX *_mem_save_user1_0;
3271         TALLOC_CTX *_mem_save_user1_1;
3272         if (ndr_flags & NDR_SCALARS) {
3273                 NDR_CHECK(ndr_pull_align(ndr, 4));
3274                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->entries_read));
3275                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user1));
3276                 if (_ptr_user1) {
3277                         NDR_PULL_ALLOC(ndr, r->user1);
3278                 } else {
3279                         r->user1 = NULL;
3280                 }
3281         }
3282         if (ndr_flags & NDR_BUFFERS) {
3283                 if (r->user1) {
3284                         _mem_save_user1_0 = NDR_PULL_GET_MEM_CTX(ndr);
3285                         NDR_PULL_SET_MEM_CTX(ndr, r->user1, 0);
3286                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user1));
3287                         NDR_PULL_ALLOC_N(ndr, r->user1, ndr_get_array_size(ndr, &r->user1));
3288                         _mem_save_user1_1 = NDR_PULL_GET_MEM_CTX(ndr);
3289                         NDR_PULL_SET_MEM_CTX(ndr, r->user1, 0);
3290                         for (cntr_user1_1 = 0; cntr_user1_1 < r->entries_read; cntr_user1_1++) {
3291                                 NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo1(ndr, NDR_SCALARS, &r->user1[cntr_user1_1]));
3292                         }
3293                         for (cntr_user1_1 = 0; cntr_user1_1 < r->entries_read; cntr_user1_1++) {
3294                                 NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo1(ndr, NDR_BUFFERS, &r->user1[cntr_user1_1]));
3295                         }
3296                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user1_1, 0);
3297                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user1_0, 0);
3298                 }
3299                 if (r->user1) {
3300                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->user1, r->entries_read));
3301                 }
3302         }
3303         return NDR_ERR_SUCCESS;
3304 }
3305
3306 _PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsersCtr1(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaEnumUsersCtr1 *r)
3307 {
3308         uint32_t cntr_user1_1;
3309         ndr_print_struct(ndr, name, "wkssvc_NetWkstaEnumUsersCtr1");
3310         ndr->depth++;
3311         ndr_print_uint32(ndr, "entries_read", r->entries_read);
3312         ndr_print_ptr(ndr, "user1", r->user1);
3313         ndr->depth++;
3314         if (r->user1) {
3315                 ndr->print(ndr, "%s: ARRAY(%d)", "user1", (int)r->entries_read);
3316                 ndr->depth++;
3317                 for (cntr_user1_1=0;cntr_user1_1<r->entries_read;cntr_user1_1++) {
3318                         char *idx_1=NULL;
3319                         if (asprintf(&idx_1, "[%d]", cntr_user1_1) != -1) {
3320                                 ndr_print_wkssvc_NetrWkstaUserInfo1(ndr, "user1", &r->user1[cntr_user1_1]);
3321                                 free(idx_1);
3322                         }
3323                 }
3324                 ndr->depth--;
3325         }
3326         ndr->depth--;
3327         ndr->depth--;
3328 }
3329
3330 static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsersCtr(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetWkstaEnumUsersCtr *r)
3331 {
3332         if (ndr_flags & NDR_SCALARS) {
3333                 int level = ndr_push_get_switch_value(ndr, r);
3334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
3335                 switch (level) {
3336                         case 0: {
3337                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user0));
3338                         break; }
3339
3340                         case 1: {
3341                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user1));
3342                         break; }
3343
3344                         default:
3345                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3346                 }
3347         }
3348         if (ndr_flags & NDR_BUFFERS) {
3349                 int level = ndr_push_get_switch_value(ndr, r);
3350                 switch (level) {
3351                         case 0:
3352                                 if (r->user0) {
3353                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->user0));
3354                                 }
3355                         break;
3356
3357                         case 1:
3358                                 if (r->user1) {
3359                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->user1));
3360                                 }
3361                         break;
3362
3363                         default:
3364                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3365                 }
3366         }
3367         return NDR_ERR_SUCCESS;
3368 }
3369
3370 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsersCtr(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetWkstaEnumUsersCtr *r)
3371 {
3372         int level;
3373         uint32_t _level;
3374         TALLOC_CTX *_mem_save_user0_0;
3375         TALLOC_CTX *_mem_save_user1_0;
3376         level = ndr_pull_get_switch_value(ndr, r);
3377         if (ndr_flags & NDR_SCALARS) {
3378                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
3379                 if (_level != level) {
3380                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
3381                 }
3382                 switch (level) {
3383                         case 0: {
3384                                 uint32_t _ptr_user0;
3385                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user0));
3386                                 if (_ptr_user0) {
3387                                         NDR_PULL_ALLOC(ndr, r->user0);
3388                                 } else {
3389                                         r->user0 = NULL;
3390                                 }
3391                         break; }
3392
3393                         case 1: {
3394                                 uint32_t _ptr_user1;
3395                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user1));
3396                                 if (_ptr_user1) {
3397                                         NDR_PULL_ALLOC(ndr, r->user1);
3398                                 } else {
3399                                         r->user1 = NULL;
3400                                 }
3401                         break; }
3402
3403                         default:
3404                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3405                 }
3406         }
3407         if (ndr_flags & NDR_BUFFERS) {
3408                 switch (level) {
3409                         case 0:
3410                                 if (r->user0) {
3411                                         _mem_save_user0_0 = NDR_PULL_GET_MEM_CTX(ndr);
3412                                         NDR_PULL_SET_MEM_CTX(ndr, r->user0, 0);
3413                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->user0));
3414                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user0_0, 0);
3415                                 }
3416                         break;
3417
3418                         case 1:
3419                                 if (r->user1) {
3420                                         _mem_save_user1_0 = NDR_PULL_GET_MEM_CTX(ndr);
3421                                         NDR_PULL_SET_MEM_CTX(ndr, r->user1, 0);
3422                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->user1));
3423                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user1_0, 0);
3424                                 }
3425                         break;
3426
3427                         default:
3428                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3429                 }
3430         }
3431         return NDR_ERR_SUCCESS;
3432 }
3433
3434 _PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsersCtr(struct ndr_print *ndr, const char *name, const union wkssvc_NetWkstaEnumUsersCtr *r)
3435 {
3436         int level;
3437         level = ndr_print_get_switch_value(ndr, r);
3438         ndr_print_union(ndr, name, level, "wkssvc_NetWkstaEnumUsersCtr");
3439         switch (level) {
3440                 case 0:
3441                         ndr_print_ptr(ndr, "user0", r->user0);
3442                         ndr->depth++;
3443                         if (r->user0) {
3444                                 ndr_print_wkssvc_NetWkstaEnumUsersCtr0(ndr, "user0", r->user0);
3445                         }
3446                         ndr->depth--;
3447                 break;
3448
3449                 case 1:
3450                         ndr_print_ptr(ndr, "user1", r->user1);
3451                         ndr->depth++;
3452                         if (r->user1) {
3453                                 ndr_print_wkssvc_NetWkstaEnumUsersCtr1(ndr, "user1", r->user1);
3454                         }
3455                         ndr->depth--;
3456                 break;
3457
3458                 default:
3459                         ndr_print_bad_level(ndr, name, level);
3460         }
3461 }
3462
3463 static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsersInfo(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaEnumUsersInfo *r)
3464 {
3465         if (ndr_flags & NDR_SCALARS) {
3466                 NDR_CHECK(ndr_push_align(ndr, 4));
3467                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
3468                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
3469                 NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersCtr(ndr, NDR_SCALARS, &r->ctr));
3470         }
3471         if (ndr_flags & NDR_BUFFERS) {
3472                 NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersCtr(ndr, NDR_BUFFERS, &r->ctr));
3473         }
3474         return NDR_ERR_SUCCESS;
3475 }
3476
3477 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsersInfo(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaEnumUsersInfo *r)
3478 {
3479         if (ndr_flags & NDR_SCALARS) {
3480                 NDR_CHECK(ndr_pull_align(ndr, 4));
3481                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
3482                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
3483                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersCtr(ndr, NDR_SCALARS, &r->ctr));
3484         }
3485         if (ndr_flags & NDR_BUFFERS) {
3486                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersCtr(ndr, NDR_BUFFERS, &r->ctr));
3487         }
3488         return NDR_ERR_SUCCESS;
3489 }
3490
3491 _PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsersInfo(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaEnumUsersInfo *r)
3492 {
3493         ndr_print_struct(ndr, name, "wkssvc_NetWkstaEnumUsersInfo");
3494         ndr->depth++;
3495         ndr_print_uint32(ndr, "level", r->level);
3496         ndr_print_set_switch_value(ndr, &r->ctr, r->level);
3497         ndr_print_wkssvc_NetWkstaEnumUsersCtr(ndr, "ctr", &r->ctr);
3498         ndr->depth--;
3499 }
3500
3501 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserInfo1101(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrWkstaUserInfo1101 *r)
3502 {
3503         if (ndr_flags & NDR_SCALARS) {
3504                 NDR_CHECK(ndr_push_align(ndr, 4));
3505                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->other_domains));
3506         }
3507         if (ndr_flags & NDR_BUFFERS) {
3508                 if (r->other_domains) {
3509                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->other_domains, CH_UTF16)));
3510                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3511                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->other_domains, CH_UTF16)));
3512                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->other_domains, ndr_charset_length(r->other_domains, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3513                 }
3514         }
3515         return NDR_ERR_SUCCESS;
3516 }
3517
3518 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserInfo1101(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrWkstaUserInfo1101 *r)
3519 {
3520         uint32_t _ptr_other_domains;
3521         TALLOC_CTX *_mem_save_other_domains_0;
3522         if (ndr_flags & NDR_SCALARS) {
3523                 NDR_CHECK(ndr_pull_align(ndr, 4));
3524                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_other_domains));
3525                 if (_ptr_other_domains) {
3526                         NDR_PULL_ALLOC(ndr, r->other_domains);
3527                 } else {
3528                         r->other_domains = NULL;
3529                 }
3530         }
3531         if (ndr_flags & NDR_BUFFERS) {
3532                 if (r->other_domains) {
3533                         _mem_save_other_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
3534                         NDR_PULL_SET_MEM_CTX(ndr, r->other_domains, 0);
3535                         NDR_CHECK(ndr_pull_array_size(ndr, &r->other_domains));
3536                         NDR_CHECK(ndr_pull_array_length(ndr, &r->other_domains));
3537                         if (ndr_get_array_length(ndr, &r->other_domains) > ndr_get_array_size(ndr, &r->other_domains)) {
3538                                 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));
3539                         }
3540                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->other_domains), sizeof(uint16_t)));
3541                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->other_domains, ndr_get_array_length(ndr, &r->other_domains), sizeof(uint16_t), CH_UTF16));
3542                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_other_domains_0, 0);
3543                 }
3544         }
3545         return NDR_ERR_SUCCESS;
3546 }
3547
3548 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserInfo1101(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrWkstaUserInfo1101 *r)
3549 {
3550         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaUserInfo1101");
3551         ndr->depth++;
3552         ndr_print_ptr(ndr, "other_domains", r->other_domains);
3553         ndr->depth++;
3554         if (r->other_domains) {
3555                 ndr_print_string(ndr, "other_domains", r->other_domains);
3556         }
3557         ndr->depth--;
3558         ndr->depth--;
3559 }
3560
3561 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserInfo(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetrWkstaUserInfo *r)
3562 {
3563         if (ndr_flags & NDR_SCALARS) {
3564                 int level = ndr_push_get_switch_value(ndr, r);
3565                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
3566                 switch (level) {
3567                         case 0: {
3568                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
3569                         break; }
3570
3571                         case 1: {
3572                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
3573                         break; }
3574
3575                         case 1101: {
3576                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1101));
3577                         break; }
3578
3579                         default:
3580                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3581                 }
3582         }
3583         if (ndr_flags & NDR_BUFFERS) {
3584                 int level = ndr_push_get_switch_value(ndr, r);
3585                 switch (level) {
3586                         case 0:
3587                                 if (r->info0) {
3588                                         NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
3589                                 }
3590                         break;
3591
3592                         case 1:
3593                                 if (r->info1) {
3594                                         NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
3595                                 }
3596                         break;
3597
3598                         case 1101:
3599                                 if (r->info1101) {
3600                                         NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo1101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1101));
3601                                 }
3602                         break;
3603
3604                         default:
3605                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3606                 }
3607         }
3608         return NDR_ERR_SUCCESS;
3609 }
3610
3611 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserInfo(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetrWkstaUserInfo *r)
3612 {
3613         int level;
3614         uint32_t _level;
3615         TALLOC_CTX *_mem_save_info0_0;
3616         TALLOC_CTX *_mem_save_info1_0;
3617         TALLOC_CTX *_mem_save_info1101_0;
3618         level = ndr_pull_get_switch_value(ndr, r);
3619         if (ndr_flags & NDR_SCALARS) {
3620                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
3621                 if (_level != level) {
3622                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
3623                 }
3624                 switch (level) {
3625                         case 0: {
3626                                 uint32_t _ptr_info0;
3627                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
3628                                 if (_ptr_info0) {
3629                                         NDR_PULL_ALLOC(ndr, r->info0);
3630                                 } else {
3631                                         r->info0 = NULL;
3632                                 }
3633                         break; }
3634
3635                         case 1: {
3636                                 uint32_t _ptr_info1;
3637                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
3638                                 if (_ptr_info1) {
3639                                         NDR_PULL_ALLOC(ndr, r->info1);
3640                                 } else {
3641                                         r->info1 = NULL;
3642                                 }
3643                         break; }
3644
3645                         case 1101: {
3646                                 uint32_t _ptr_info1101;
3647                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1101));
3648                                 if (_ptr_info1101) {
3649                                         NDR_PULL_ALLOC(ndr, r->info1101);
3650                                 } else {
3651                                         r->info1101 = NULL;
3652                                 }
3653                         break; }
3654
3655                         default:
3656                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3657                 }
3658         }
3659         if (ndr_flags & NDR_BUFFERS) {
3660                 switch (level) {
3661                         case 0:
3662                                 if (r->info0) {
3663                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
3664                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
3665                                         NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
3666                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
3667                                 }
3668                         break;
3669
3670                         case 1:
3671                                 if (r->info1) {
3672                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
3673                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
3674                                         NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
3675                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
3676                                 }
3677                         break;
3678
3679                         case 1101:
3680                                 if (r->info1101) {
3681                                         _mem_save_info1101_0 = NDR_PULL_GET_MEM_CTX(ndr);
3682                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1101, 0);
3683                                         NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo1101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1101));
3684                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1101_0, 0);
3685                                 }
3686                         break;
3687
3688                         default:
3689                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3690                 }
3691         }
3692         return NDR_ERR_SUCCESS;
3693 }
3694
3695 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserInfo(struct ndr_print *ndr, const char *name, const union wkssvc_NetrWkstaUserInfo *r)
3696 {
3697         int level;
3698         level = ndr_print_get_switch_value(ndr, r);
3699         ndr_print_union(ndr, name, level, "wkssvc_NetrWkstaUserInfo");
3700         switch (level) {
3701                 case 0:
3702                         ndr_print_ptr(ndr, "info0", r->info0);
3703                         ndr->depth++;
3704                         if (r->info0) {
3705                                 ndr_print_wkssvc_NetrWkstaUserInfo0(ndr, "info0", r->info0);
3706                         }
3707                         ndr->depth--;
3708                 break;
3709
3710                 case 1:
3711                         ndr_print_ptr(ndr, "info1", r->info1);
3712                         ndr->depth++;
3713                         if (r->info1) {
3714                                 ndr_print_wkssvc_NetrWkstaUserInfo1(ndr, "info1", r->info1);
3715                         }
3716                         ndr->depth--;
3717                 break;
3718
3719                 case 1101:
3720                         ndr_print_ptr(ndr, "info1101", r->info1101);
3721                         ndr->depth++;
3722                         if (r->info1101) {
3723                                 ndr_print_wkssvc_NetrWkstaUserInfo1101(ndr, "info1101", r->info1101);
3724                         }
3725                         ndr->depth--;
3726                 break;
3727
3728                 default:
3729                         ndr_print_bad_level(ndr, name, level);
3730         }
3731 }
3732
3733 static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportInfo0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaTransportInfo0 *r)
3734 {
3735         if (ndr_flags & NDR_SCALARS) {
3736                 NDR_CHECK(ndr_push_align(ndr, 4));
3737                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->quality_of_service));
3738                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->vc_count));
3739                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
3740                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->address));
3741                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->wan_link));
3742         }
3743         if (ndr_flags & NDR_BUFFERS) {
3744                 if (r->name) {
3745                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
3746                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3747                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
3748                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3749                 }
3750                 if (r->address) {
3751                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->address, CH_UTF16)));
3752                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3753                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->address, CH_UTF16)));
3754                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->address, ndr_charset_length(r->address, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3755                 }
3756         }
3757         return NDR_ERR_SUCCESS;
3758 }
3759
3760 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportInfo0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaTransportInfo0 *r)
3761 {
3762         uint32_t _ptr_name;
3763         TALLOC_CTX *_mem_save_name_0;
3764         uint32_t _ptr_address;
3765         TALLOC_CTX *_mem_save_address_0;
3766         if (ndr_flags & NDR_SCALARS) {
3767                 NDR_CHECK(ndr_pull_align(ndr, 4));
3768                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->quality_of_service));
3769                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->vc_count));
3770                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
3771                 if (_ptr_name) {
3772                         NDR_PULL_ALLOC(ndr, r->name);
3773                 } else {
3774                         r->name = NULL;
3775                 }
3776                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_address));
3777                 if (_ptr_address) {
3778                         NDR_PULL_ALLOC(ndr, r->address);
3779                 } else {
3780                         r->address = NULL;
3781                 }
3782                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->wan_link));
3783         }
3784         if (ndr_flags & NDR_BUFFERS) {
3785                 if (r->name) {
3786                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3787                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
3788                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
3789                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
3790                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
3791                                 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));
3792                         }
3793                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
3794                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
3795                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
3796                 }
3797                 if (r->address) {
3798                         _mem_save_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
3799                         NDR_PULL_SET_MEM_CTX(ndr, r->address, 0);
3800                         NDR_CHECK(ndr_pull_array_size(ndr, &r->address));
3801                         NDR_CHECK(ndr_pull_array_length(ndr, &r->address));
3802                         if (ndr_get_array_length(ndr, &r->address) > ndr_get_array_size(ndr, &r->address)) {
3803                                 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));
3804                         }
3805                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->address), sizeof(uint16_t)));
3806                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->address, ndr_get_array_length(ndr, &r->address), sizeof(uint16_t), CH_UTF16));
3807                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_address_0, 0);
3808                 }
3809         }
3810         return NDR_ERR_SUCCESS;
3811 }
3812
3813 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportInfo0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaTransportInfo0 *r)
3814 {
3815         ndr_print_struct(ndr, name, "wkssvc_NetWkstaTransportInfo0");
3816         ndr->depth++;
3817         ndr_print_uint32(ndr, "quality_of_service", r->quality_of_service);
3818         ndr_print_uint32(ndr, "vc_count", r->vc_count);
3819         ndr_print_ptr(ndr, "name", r->name);
3820         ndr->depth++;
3821         if (r->name) {
3822                 ndr_print_string(ndr, "name", r->name);
3823         }
3824         ndr->depth--;
3825         ndr_print_ptr(ndr, "address", r->address);
3826         ndr->depth++;
3827         if (r->address) {
3828                 ndr_print_string(ndr, "address", r->address);
3829         }
3830         ndr->depth--;
3831         ndr_print_uint32(ndr, "wan_link", r->wan_link);
3832         ndr->depth--;
3833 }
3834
3835 static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportCtr0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaTransportCtr0 *r)
3836 {
3837         uint32_t cntr_array_1;
3838         if (ndr_flags & NDR_SCALARS) {
3839                 NDR_CHECK(ndr_push_align(ndr, 4));
3840                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3841                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
3842         }
3843         if (ndr_flags & NDR_BUFFERS) {
3844                 if (r->array) {
3845                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3846                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3847                                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
3848                         }
3849                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3850                                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
3851                         }
3852                 }
3853         }
3854         return NDR_ERR_SUCCESS;
3855 }
3856
3857 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportCtr0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaTransportCtr0 *r)
3858 {
3859         uint32_t _ptr_array;
3860         uint32_t cntr_array_1;
3861         TALLOC_CTX *_mem_save_array_0;
3862         TALLOC_CTX *_mem_save_array_1;
3863         if (ndr_flags & NDR_SCALARS) {
3864                 NDR_CHECK(ndr_pull_align(ndr, 4));
3865                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3866                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
3867                 if (_ptr_array) {
3868                         NDR_PULL_ALLOC(ndr, r->array);
3869                 } else {
3870                         r->array = NULL;
3871                 }
3872         }
3873         if (ndr_flags & NDR_BUFFERS) {
3874                 if (r->array) {
3875                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
3876                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
3877                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
3878                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
3879                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
3880                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
3881                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3882                                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
3883                         }
3884                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3885                                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
3886                         }
3887                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
3888                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
3889                 }
3890                 if (r->array) {
3891                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
3892                 }
3893         }
3894         return NDR_ERR_SUCCESS;
3895 }
3896
3897 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportCtr0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaTransportCtr0 *r)
3898 {
3899         uint32_t cntr_array_1;
3900         ndr_print_struct(ndr, name, "wkssvc_NetWkstaTransportCtr0");
3901         ndr->depth++;
3902         ndr_print_uint32(ndr, "count", r->count);
3903         ndr_print_ptr(ndr, "array", r->array);
3904         ndr->depth++;
3905         if (r->array) {
3906                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
3907                 ndr->depth++;
3908                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
3909                         char *idx_1=NULL;
3910                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
3911                                 ndr_print_wkssvc_NetWkstaTransportInfo0(ndr, "array", &r->array[cntr_array_1]);
3912                                 free(idx_1);
3913                         }
3914                 }
3915                 ndr->depth--;
3916         }
3917         ndr->depth--;
3918         ndr->depth--;
3919 }
3920
3921 static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportCtr(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetWkstaTransportCtr *r)
3922 {
3923         if (ndr_flags & NDR_SCALARS) {
3924                 int level = ndr_push_get_switch_value(ndr, r);
3925                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
3926                 switch (level) {
3927                         case 0: {
3928                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
3929                         break; }
3930
3931                         default:
3932                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3933                 }
3934         }
3935         if (ndr_flags & NDR_BUFFERS) {
3936                 int level = ndr_push_get_switch_value(ndr, r);
3937                 switch (level) {
3938                         case 0:
3939                                 if (r->ctr0) {
3940                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
3941                                 }
3942                         break;
3943
3944                         default:
3945                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3946                 }
3947         }
3948         return NDR_ERR_SUCCESS;
3949 }
3950
3951 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportCtr(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetWkstaTransportCtr *r)
3952 {
3953         int level;
3954         uint32_t _level;
3955         TALLOC_CTX *_mem_save_ctr0_0;
3956         level = ndr_pull_get_switch_value(ndr, r);
3957         if (ndr_flags & NDR_SCALARS) {
3958                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
3959                 if (_level != level) {
3960                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
3961                 }
3962                 switch (level) {
3963                         case 0: {
3964                                 uint32_t _ptr_ctr0;
3965                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));
3966                                 if (_ptr_ctr0) {
3967                                         NDR_PULL_ALLOC(ndr, r->ctr0);
3968                                 } else {
3969                                         r->ctr0 = NULL;
3970                                 }
3971                         break; }
3972
3973                         default:
3974                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3975                 }
3976         }
3977         if (ndr_flags & NDR_BUFFERS) {
3978                 switch (level) {
3979                         case 0:
3980                                 if (r->ctr0) {
3981                                         _mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);
3982                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr0, 0);
3983                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
3984                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);
3985                                 }
3986                         break;
3987
3988                         default:
3989                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3990                 }
3991         }
3992         return NDR_ERR_SUCCESS;
3993 }
3994
3995 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportCtr(struct ndr_print *ndr, const char *name, const union wkssvc_NetWkstaTransportCtr *r)
3996 {
3997         int level;
3998         level = ndr_print_get_switch_value(ndr, r);
3999         ndr_print_union(ndr, name, level, "wkssvc_NetWkstaTransportCtr");
4000         switch (level) {
4001                 case 0:
4002                         ndr_print_ptr(ndr, "ctr0", r->ctr0);
4003                         ndr->depth++;
4004                         if (r->ctr0) {
4005                                 ndr_print_wkssvc_NetWkstaTransportCtr0(ndr, "ctr0", r->ctr0);
4006                         }
4007                         ndr->depth--;
4008                 break;
4009
4010                 default:
4011                         ndr_print_bad_level(ndr, name, level);
4012         }
4013 }
4014
4015 static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportInfo(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaTransportInfo *r)
4016 {
4017         if (ndr_flags & NDR_SCALARS) {
4018                 NDR_CHECK(ndr_push_align(ndr, 4));
4019                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
4020                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
4021                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportCtr(ndr, NDR_SCALARS, &r->ctr));
4022         }
4023         if (ndr_flags & NDR_BUFFERS) {
4024                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportCtr(ndr, NDR_BUFFERS, &r->ctr));
4025         }
4026         return NDR_ERR_SUCCESS;
4027 }
4028
4029 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportInfo(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaTransportInfo *r)
4030 {
4031         if (ndr_flags & NDR_SCALARS) {
4032                 NDR_CHECK(ndr_pull_align(ndr, 4));
4033                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
4034                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
4035                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportCtr(ndr, NDR_SCALARS, &r->ctr));
4036         }
4037         if (ndr_flags & NDR_BUFFERS) {
4038                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportCtr(ndr, NDR_BUFFERS, &r->ctr));
4039         }
4040         return NDR_ERR_SUCCESS;
4041 }
4042
4043 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportInfo(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaTransportInfo *r)
4044 {
4045         ndr_print_struct(ndr, name, "wkssvc_NetWkstaTransportInfo");
4046         ndr->depth++;
4047         ndr_print_uint32(ndr, "level", r->level);
4048         ndr_print_set_switch_value(ndr, &r->ctr, r->level);
4049         ndr_print_wkssvc_NetWkstaTransportCtr(ndr, "ctr", &r->ctr);
4050         ndr->depth--;
4051 }
4052
4053 static enum ndr_err_code ndr_push_wkssvc_NetrUseInfo3(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseInfo3 *r)
4054 {
4055         if (ndr_flags & NDR_SCALARS) {
4056                 NDR_CHECK(ndr_push_align(ndr, 4));
4057                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->unknown1));
4058                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->unknown2));
4059         }
4060         if (ndr_flags & NDR_BUFFERS) {
4061                 if (r->unknown1) {
4062                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->unknown1, CH_UTF16)));
4063                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4064                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->unknown1, CH_UTF16)));
4065                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->unknown1, ndr_charset_length(r->unknown1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4066                 }
4067                 if (r->unknown2) {
4068                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->unknown2, CH_UTF16)));
4069                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4070                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->unknown2, CH_UTF16)));
4071                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->unknown2, ndr_charset_length(r->unknown2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4072                 }
4073         }
4074         return NDR_ERR_SUCCESS;
4075 }
4076
4077 static enum ndr_err_code ndr_pull_wkssvc_NetrUseInfo3(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseInfo3 *r)
4078 {
4079         uint32_t _ptr_unknown1;
4080         TALLOC_CTX *_mem_save_unknown1_0;
4081         uint32_t _ptr_unknown2;
4082         TALLOC_CTX *_mem_save_unknown2_0;
4083         if (ndr_flags & NDR_SCALARS) {
4084                 NDR_CHECK(ndr_pull_align(ndr, 4));
4085                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown1));
4086                 if (_ptr_unknown1) {
4087                         NDR_PULL_ALLOC(ndr, r->unknown1);
4088                 } else {
4089                         r->unknown1 = NULL;
4090                 }
4091                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown2));
4092                 if (_ptr_unknown2) {
4093                         NDR_PULL_ALLOC(ndr, r->unknown2);
4094                 } else {
4095                         r->unknown2 = NULL;
4096                 }
4097         }
4098         if (ndr_flags & NDR_BUFFERS) {
4099                 if (r->unknown1) {
4100                         _mem_save_unknown1_0 = NDR_PULL_GET_MEM_CTX(ndr);
4101                         NDR_PULL_SET_MEM_CTX(ndr, r->unknown1, 0);
4102                         NDR_CHECK(ndr_pull_array_size(ndr, &r->unknown1));
4103                         NDR_CHECK(ndr_pull_array_length(ndr, &r->unknown1));
4104                         if (ndr_get_array_length(ndr, &r->unknown1) > ndr_get_array_size(ndr, &r->unknown1)) {
4105                                 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));
4106                         }
4107                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->unknown1), sizeof(uint16_t)));
4108                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->unknown1, ndr_get_array_length(ndr, &r->unknown1), sizeof(uint16_t), CH_UTF16));
4109                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown1_0, 0);
4110                 }
4111                 if (r->unknown2) {
4112                         _mem_save_unknown2_0 = NDR_PULL_GET_MEM_CTX(ndr);
4113                         NDR_PULL_SET_MEM_CTX(ndr, r->unknown2, 0);
4114                         NDR_CHECK(ndr_pull_array_size(ndr, &r->unknown2));
4115                         NDR_CHECK(ndr_pull_array_length(ndr, &r->unknown2));
4116                         if (ndr_get_array_length(ndr, &r->unknown2) > ndr_get_array_size(ndr, &r->unknown2)) {
4117                                 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));
4118                         }
4119                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->unknown2), sizeof(uint16_t)));
4120                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->unknown2, ndr_get_array_length(ndr, &r->unknown2), sizeof(uint16_t), CH_UTF16));
4121                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown2_0, 0);
4122                 }
4123         }
4124         return NDR_ERR_SUCCESS;
4125 }
4126
4127 _PUBLIC_ void ndr_print_wkssvc_NetrUseInfo3(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseInfo3 *r)
4128 {
4129         ndr_print_struct(ndr, name, "wkssvc_NetrUseInfo3");
4130         ndr->depth++;
4131         ndr_print_ptr(ndr, "unknown1", r->unknown1);
4132         ndr->depth++;
4133         if (r->unknown1) {
4134                 ndr_print_string(ndr, "unknown1", r->unknown1);
4135         }
4136         ndr->depth--;
4137         ndr_print_ptr(ndr, "unknown2", r->unknown2);
4138         ndr->depth++;
4139         if (r->unknown2) {
4140                 ndr_print_string(ndr, "unknown2", r->unknown2);
4141         }
4142         ndr->depth--;
4143         ndr->depth--;
4144 }
4145
4146 static enum ndr_err_code ndr_push_wkssvc_NetrUseInfo2(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseInfo2 *r)
4147 {
4148         if (ndr_flags & NDR_SCALARS) {
4149                 NDR_CHECK(ndr_push_align(ndr, 4));
4150                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->local));
4151                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote));
4152                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->password));
4153                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
4154                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->asg_type));
4155                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_count));
4156                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_count));
4157                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
4158                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
4159         }
4160         if (ndr_flags & NDR_BUFFERS) {
4161                 if (r->local) {
4162                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->local, CH_UTF16)));
4163                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4164                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->local, CH_UTF16)));
4165                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->local, ndr_charset_length(r->local, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4166                 }
4167                 if (r->remote) {
4168                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote, CH_UTF16)));
4169                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4170                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote, CH_UTF16)));
4171                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->remote, ndr_charset_length(r->remote, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4172                 }
4173                 if (r->password) {
4174                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));
4175                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4176                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));
4177                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->password, ndr_charset_length(r->password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4178                 }
4179                 if (r->user_name) {
4180                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4181                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4182                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4183                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4184                 }
4185                 if (r->domain_name) {
4186                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
4187                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4188                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
4189                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4190                 }
4191         }
4192         return NDR_ERR_SUCCESS;
4193 }
4194
4195 static enum ndr_err_code ndr_pull_wkssvc_NetrUseInfo2(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseInfo2 *r)
4196 {
4197         uint32_t _ptr_local;
4198         TALLOC_CTX *_mem_save_local_0;
4199         uint32_t _ptr_remote;
4200         TALLOC_CTX *_mem_save_remote_0;
4201         uint32_t _ptr_password;
4202         TALLOC_CTX *_mem_save_password_0;
4203         uint32_t _ptr_user_name;
4204         TALLOC_CTX *_mem_save_user_name_0;
4205         uint32_t _ptr_domain_name;
4206         TALLOC_CTX *_mem_save_domain_name_0;
4207         if (ndr_flags & NDR_SCALARS) {
4208                 NDR_CHECK(ndr_pull_align(ndr, 4));
4209                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local));
4210                 if (_ptr_local) {
4211                         NDR_PULL_ALLOC(ndr, r->local);
4212                 } else {
4213                         r->local = NULL;
4214                 }
4215                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote));
4216                 if (_ptr_remote) {
4217                         NDR_PULL_ALLOC(ndr, r->remote);
4218                 } else {
4219                         r->remote = NULL;
4220                 }
4221                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
4222                 if (_ptr_password) {
4223                         NDR_PULL_ALLOC(ndr, r->password);
4224                 } else {
4225                         r->password = NULL;
4226                 }
4227                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
4228                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->asg_type));
4229                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_count));
4230                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_count));
4231                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4232                 if (_ptr_user_name) {
4233                         NDR_PULL_ALLOC(ndr, r->user_name);
4234                 } else {
4235                         r->user_name = NULL;
4236                 }
4237                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
4238                 if (_ptr_domain_name) {
4239                         NDR_PULL_ALLOC(ndr, r->domain_name);
4240                 } else {
4241                         r->domain_name = NULL;
4242                 }
4243         }
4244         if (ndr_flags & NDR_BUFFERS) {
4245                 if (r->local) {
4246                         _mem_save_local_0 = NDR_PULL_GET_MEM_CTX(ndr);
4247                         NDR_PULL_SET_MEM_CTX(ndr, r->local, 0);
4248                         NDR_CHECK(ndr_pull_array_size(ndr, &r->local));
4249                         NDR_CHECK(ndr_pull_array_length(ndr, &r->local));
4250                         if (ndr_get_array_length(ndr, &r->local) > ndr_get_array_size(ndr, &r->local)) {
4251                                 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));
4252                         }
4253                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->local), sizeof(uint16_t)));
4254                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->local, ndr_get_array_length(ndr, &r->local), sizeof(uint16_t), CH_UTF16));
4255                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_0, 0);
4256                 }
4257                 if (r->remote) {
4258                         _mem_save_remote_0 = NDR_PULL_GET_MEM_CTX(ndr);
4259                         NDR_PULL_SET_MEM_CTX(ndr, r->remote, 0);
4260                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote));
4261                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote));
4262                         if (ndr_get_array_length(ndr, &r->remote) > ndr_get_array_size(ndr, &r->remote)) {
4263                                 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));
4264                         }
4265                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t)));
4266                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->remote, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t), CH_UTF16));
4267                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_0, 0);
4268                 }
4269                 if (r->password) {
4270                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
4271                         NDR_PULL_SET_MEM_CTX(ndr, r->password, 0);
4272                         NDR_CHECK(ndr_pull_array_size(ndr, &r->password));
4273                         NDR_CHECK(ndr_pull_array_length(ndr, &r->password));
4274                         if (ndr_get_array_length(ndr, &r->password) > ndr_get_array_size(ndr, &r->password)) {
4275                                 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));
4276                         }
4277                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t)));
4278                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->password, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t), CH_UTF16));
4279                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
4280                 }
4281                 if (r->user_name) {
4282                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4283                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4284                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
4285                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
4286                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
4287                                 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));
4288                         }
4289                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
4290                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
4291                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4292                 }
4293                 if (r->domain_name) {
4294                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4295                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
4296                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
4297                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
4298                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
4299                                 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));
4300                         }
4301                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
4302                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
4303                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
4304                 }
4305         }
4306         return NDR_ERR_SUCCESS;
4307 }
4308
4309 _PUBLIC_ void ndr_print_wkssvc_NetrUseInfo2(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseInfo2 *r)
4310 {
4311         ndr_print_struct(ndr, name, "wkssvc_NetrUseInfo2");
4312         ndr->depth++;
4313         ndr_print_ptr(ndr, "local", r->local);
4314         ndr->depth++;
4315         if (r->local) {
4316                 ndr_print_string(ndr, "local", r->local);
4317         }
4318         ndr->depth--;
4319         ndr_print_ptr(ndr, "remote", r->remote);
4320         ndr->depth++;
4321         if (r->remote) {
4322                 ndr_print_string(ndr, "remote", r->remote);
4323         }
4324         ndr->depth--;
4325         ndr_print_ptr(ndr, "password", r->password);
4326         ndr->depth++;
4327         if (r->password) {
4328                 ndr_print_string(ndr, "password", r->password);
4329         }
4330         ndr->depth--;
4331         ndr_print_uint32(ndr, "status", r->status);
4332         ndr_print_uint32(ndr, "asg_type", r->asg_type);
4333         ndr_print_uint32(ndr, "ref_count", r->ref_count);
4334         ndr_print_uint32(ndr, "use_count", r->use_count);
4335         ndr_print_ptr(ndr, "user_name", r->user_name);
4336         ndr->depth++;
4337         if (r->user_name) {
4338                 ndr_print_string(ndr, "user_name", r->user_name);
4339         }
4340         ndr->depth--;
4341         ndr_print_ptr(ndr, "domain_name", r->domain_name);
4342         ndr->depth++;
4343         if (r->domain_name) {
4344                 ndr_print_string(ndr, "domain_name", r->domain_name);
4345         }
4346         ndr->depth--;
4347         ndr->depth--;
4348 }
4349
4350 static enum ndr_err_code ndr_push_wkssvc_NetrUseInfo1(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseInfo1 *r)
4351 {
4352         if (ndr_flags & NDR_SCALARS) {
4353                 NDR_CHECK(ndr_push_align(ndr, 4));
4354                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->local));
4355                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote));
4356                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->password));
4357                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
4358                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->asg_type));
4359                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_count));
4360                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_count));
4361         }
4362         if (ndr_flags & NDR_BUFFERS) {
4363                 if (r->local) {
4364                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->local, CH_UTF16)));
4365                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4366                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->local, CH_UTF16)));
4367                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->local, ndr_charset_length(r->local, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4368                 }
4369                 if (r->remote) {
4370                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote, CH_UTF16)));
4371                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4372                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote, CH_UTF16)));
4373                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->remote, ndr_charset_length(r->remote, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4374                 }
4375                 if (r->password) {
4376                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));
4377                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4378                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));
4379                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->password, ndr_charset_length(r->password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4380                 }
4381         }
4382         return NDR_ERR_SUCCESS;
4383 }
4384
4385 static enum ndr_err_code ndr_pull_wkssvc_NetrUseInfo1(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseInfo1 *r)
4386 {
4387         uint32_t _ptr_local;
4388         TALLOC_CTX *_mem_save_local_0;
4389         uint32_t _ptr_remote;
4390         TALLOC_CTX *_mem_save_remote_0;
4391         uint32_t _ptr_password;
4392         TALLOC_CTX *_mem_save_password_0;
4393         if (ndr_flags & NDR_SCALARS) {
4394                 NDR_CHECK(ndr_pull_align(ndr, 4));
4395                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local));
4396                 if (_ptr_local) {
4397                         NDR_PULL_ALLOC(ndr, r->local);
4398                 } else {
4399                         r->local = NULL;
4400                 }
4401                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote));
4402                 if (_ptr_remote) {
4403                         NDR_PULL_ALLOC(ndr, r->remote);
4404                 } else {
4405                         r->remote = NULL;
4406                 }
4407                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
4408                 if (_ptr_password) {
4409                         NDR_PULL_ALLOC(ndr, r->password);
4410                 } else {
4411                         r->password = NULL;
4412                 }
4413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
4414                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->asg_type));
4415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_count));
4416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_count));
4417         }
4418         if (ndr_flags & NDR_BUFFERS) {
4419                 if (r->local) {
4420                         _mem_save_local_0 = NDR_PULL_GET_MEM_CTX(ndr);
4421                         NDR_PULL_SET_MEM_CTX(ndr, r->local, 0);
4422                         NDR_CHECK(ndr_pull_array_size(ndr, &r->local));
4423                         NDR_CHECK(ndr_pull_array_length(ndr, &r->local));
4424                         if (ndr_get_array_length(ndr, &r->local) > ndr_get_array_size(ndr, &r->local)) {
4425                                 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));
4426                         }
4427                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->local), sizeof(uint16_t)));
4428                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->local, ndr_get_array_length(ndr, &r->local), sizeof(uint16_t), CH_UTF16));
4429                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_0, 0);
4430                 }
4431                 if (r->remote) {
4432                         _mem_save_remote_0 = NDR_PULL_GET_MEM_CTX(ndr);
4433                         NDR_PULL_SET_MEM_CTX(ndr, r->remote, 0);
4434                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote));
4435                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote));
4436                         if (ndr_get_array_length(ndr, &r->remote) > ndr_get_array_size(ndr, &r->remote)) {
4437                                 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));
4438                         }
4439                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t)));
4440                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->remote, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t), CH_UTF16));
4441                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_0, 0);
4442                 }
4443                 if (r->password) {
4444                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
4445                         NDR_PULL_SET_MEM_CTX(ndr, r->password, 0);
4446                         NDR_CHECK(ndr_pull_array_size(ndr, &r->password));
4447                         NDR_CHECK(ndr_pull_array_length(ndr, &r->password));
4448                         if (ndr_get_array_length(ndr, &r->password) > ndr_get_array_size(ndr, &r->password)) {
4449                                 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));
4450                         }
4451                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t)));
4452                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->password, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t), CH_UTF16));
4453                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
4454                 }
4455         }
4456         return NDR_ERR_SUCCESS;
4457 }
4458
4459 _PUBLIC_ void ndr_print_wkssvc_NetrUseInfo1(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseInfo1 *r)
4460 {
4461         ndr_print_struct(ndr, name, "wkssvc_NetrUseInfo1");
4462         ndr->depth++;
4463         ndr_print_ptr(ndr, "local", r->local);
4464         ndr->depth++;
4465         if (r->local) {
4466                 ndr_print_string(ndr, "local", r->local);
4467         }
4468         ndr->depth--;
4469         ndr_print_ptr(ndr, "remote", r->remote);
4470         ndr->depth++;
4471         if (r->remote) {
4472                 ndr_print_string(ndr, "remote", r->remote);
4473         }
4474         ndr->depth--;
4475         ndr_print_ptr(ndr, "password", r->password);
4476         ndr->depth++;
4477         if (r->password) {
4478                 ndr_print_string(ndr, "password", r->password);
4479         }
4480         ndr->depth--;
4481         ndr_print_uint32(ndr, "status", r->status);
4482         ndr_print_uint32(ndr, "asg_type", r->asg_type);
4483         ndr_print_uint32(ndr, "ref_count", r->ref_count);
4484         ndr_print_uint32(ndr, "use_count", r->use_count);
4485         ndr->depth--;
4486 }
4487
4488 static enum ndr_err_code ndr_push_wkssvc_NetrUseInfo0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseInfo0 *r)
4489 {
4490         if (ndr_flags & NDR_SCALARS) {
4491                 NDR_CHECK(ndr_push_align(ndr, 4));
4492                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->local));
4493                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote));
4494         }
4495         if (ndr_flags & NDR_BUFFERS) {
4496                 if (r->local) {
4497                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->local, CH_UTF16)));
4498                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4499                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->local, CH_UTF16)));
4500                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->local, ndr_charset_length(r->local, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4501                 }
4502                 if (r->remote) {
4503                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote, CH_UTF16)));
4504                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4505                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote, CH_UTF16)));
4506                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->remote, ndr_charset_length(r->remote, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4507                 }
4508         }
4509         return NDR_ERR_SUCCESS;
4510 }
4511
4512 static enum ndr_err_code ndr_pull_wkssvc_NetrUseInfo0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseInfo0 *r)
4513 {
4514         uint32_t _ptr_local;
4515         TALLOC_CTX *_mem_save_local_0;
4516         uint32_t _ptr_remote;
4517         TALLOC_CTX *_mem_save_remote_0;
4518         if (ndr_flags & NDR_SCALARS) {
4519                 NDR_CHECK(ndr_pull_align(ndr, 4));
4520                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local));
4521                 if (_ptr_local) {
4522                         NDR_PULL_ALLOC(ndr, r->local);
4523                 } else {
4524                         r->local = NULL;
4525                 }
4526                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote));
4527                 if (_ptr_remote) {
4528                         NDR_PULL_ALLOC(ndr, r->remote);
4529                 } else {
4530                         r->remote = NULL;
4531                 }
4532         }
4533         if (ndr_flags & NDR_BUFFERS) {
4534                 if (r->local) {
4535                         _mem_save_local_0 = NDR_PULL_GET_MEM_CTX(ndr);
4536                         NDR_PULL_SET_MEM_CTX(ndr, r->local, 0);
4537                         NDR_CHECK(ndr_pull_array_size(ndr, &r->local));
4538                         NDR_CHECK(ndr_pull_array_length(ndr, &r->local));
4539                         if (ndr_get_array_length(ndr, &r->local) > ndr_get_array_size(ndr, &r->local)) {
4540                                 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));
4541                         }
4542                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->local), sizeof(uint16_t)));
4543                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->local, ndr_get_array_length(ndr, &r->local), sizeof(uint16_t), CH_UTF16));
4544                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_0, 0);
4545                 }
4546                 if (r->remote) {
4547                         _mem_save_remote_0 = NDR_PULL_GET_MEM_CTX(ndr);
4548                         NDR_PULL_SET_MEM_CTX(ndr, r->remote, 0);
4549                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote));
4550                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote));
4551                         if (ndr_get_array_length(ndr, &r->remote) > ndr_get_array_size(ndr, &r->remote)) {
4552                                 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));
4553                         }
4554                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t)));
4555                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->remote, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t), CH_UTF16));
4556                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_0, 0);
4557                 }
4558         }
4559         return NDR_ERR_SUCCESS;
4560 }
4561
4562 _PUBLIC_ void ndr_print_wkssvc_NetrUseInfo0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseInfo0 *r)
4563 {
4564         ndr_print_struct(ndr, name, "wkssvc_NetrUseInfo0");
4565         ndr->depth++;
4566         ndr_print_ptr(ndr, "local", r->local);
4567         ndr->depth++;
4568         if (r->local) {
4569                 ndr_print_string(ndr, "local", r->local);
4570         }
4571         ndr->depth--;
4572         ndr_print_ptr(ndr, "remote", r->remote);
4573         ndr->depth++;
4574         if (r->remote) {
4575                 ndr_print_string(ndr, "remote", r->remote);
4576         }
4577         ndr->depth--;
4578         ndr->depth--;
4579 }
4580
4581 static enum ndr_err_code ndr_push_wkssvc_NetrUseGetInfoCtr(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetrUseGetInfoCtr *r)
4582 {
4583         if (ndr_flags & NDR_SCALARS) {
4584                 int level = ndr_push_get_switch_value(ndr, r);
4585                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
4586                 switch (level) {
4587                         case 0: {
4588                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
4589                         break; }
4590
4591                         case 1: {
4592                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
4593                         break; }
4594
4595                         case 2: {
4596                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
4597                         break; }
4598
4599                         case 3: {
4600                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
4601                         break; }
4602
4603                         default:
4604                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4605                 }
4606         }
4607         if (ndr_flags & NDR_BUFFERS) {
4608                 int level = ndr_push_get_switch_value(ndr, r);
4609                 switch (level) {
4610                         case 0:
4611                                 if (r->info0) {
4612                                         NDR_CHECK(ndr_push_wkssvc_NetrUseInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
4613                                 }
4614                         break;
4615
4616                         case 1:
4617                                 if (r->info1) {
4618                                         NDR_CHECK(ndr_push_wkssvc_NetrUseInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
4619                                 }
4620                         break;
4621
4622                         case 2:
4623                                 if (r->info2) {
4624                                         NDR_CHECK(ndr_push_wkssvc_NetrUseInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
4625                                 }
4626                         break;
4627
4628                         case 3:
4629                                 if (r->info3) {
4630                                         NDR_CHECK(ndr_push_wkssvc_NetrUseInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
4631                                 }
4632                         break;
4633
4634                         default:
4635                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4636                 }
4637         }
4638         return NDR_ERR_SUCCESS;
4639 }
4640
4641 static enum ndr_err_code ndr_pull_wkssvc_NetrUseGetInfoCtr(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetrUseGetInfoCtr *r)
4642 {
4643         int level;
4644         uint32_t _level;
4645         TALLOC_CTX *_mem_save_info0_0;
4646         TALLOC_CTX *_mem_save_info1_0;
4647         TALLOC_CTX *_mem_save_info2_0;
4648         TALLOC_CTX *_mem_save_info3_0;
4649         level = ndr_pull_get_switch_value(ndr, r);
4650         if (ndr_flags & NDR_SCALARS) {
4651                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
4652                 if (_level != level) {
4653                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
4654                 }
4655                 switch (level) {
4656                         case 0: {
4657                                 uint32_t _ptr_info0;
4658                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
4659                                 if (_ptr_info0) {
4660                                         NDR_PULL_ALLOC(ndr, r->info0);
4661                                 } else {
4662                                         r->info0 = NULL;
4663                                 }
4664                         break; }
4665
4666                         case 1: {
4667                                 uint32_t _ptr_info1;
4668                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
4669                                 if (_ptr_info1) {
4670                                         NDR_PULL_ALLOC(ndr, r->info1);
4671                                 } else {
4672                                         r->info1 = NULL;
4673                                 }
4674                         break; }
4675
4676                         case 2: {
4677                                 uint32_t _ptr_info2;
4678                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
4679                                 if (_ptr_info2) {
4680                                         NDR_PULL_ALLOC(ndr, r->info2);
4681                                 } else {
4682                                         r->info2 = NULL;
4683                                 }
4684                         break; }
4685
4686                         case 3: {
4687                                 uint32_t _ptr_info3;
4688                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
4689                                 if (_ptr_info3) {
4690                                         NDR_PULL_ALLOC(ndr, r->info3);
4691                                 } else {
4692                                         r->info3 = NULL;
4693                                 }
4694                         break; }
4695
4696                         default:
4697                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4698                 }
4699         }
4700         if (ndr_flags & NDR_BUFFERS) {
4701                 switch (level) {
4702                         case 0:
4703                                 if (r->info0) {
4704                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
4705                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
4706                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
4707                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
4708                                 }
4709                         break;
4710
4711                         case 1:
4712                                 if (r->info1) {
4713                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
4714                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
4715                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
4716                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
4717                                 }
4718                         break;
4719
4720                         case 2:
4721                                 if (r->info2) {
4722                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
4723                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
4724                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
4725                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
4726                                 }
4727                         break;
4728
4729                         case 3:
4730                                 if (r->info3) {
4731                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
4732                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
4733                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
4734                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
4735                                 }
4736                         break;
4737
4738                         default:
4739                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4740                 }
4741         }
4742         return NDR_ERR_SUCCESS;
4743 }
4744
4745 _PUBLIC_ void ndr_print_wkssvc_NetrUseGetInfoCtr(struct ndr_print *ndr, const char *name, const union wkssvc_NetrUseGetInfoCtr *r)
4746 {
4747         int level;
4748         level = ndr_print_get_switch_value(ndr, r);
4749         ndr_print_union(ndr, name, level, "wkssvc_NetrUseGetInfoCtr");
4750         switch (level) {
4751                 case 0:
4752                         ndr_print_ptr(ndr, "info0", r->info0);
4753                         ndr->depth++;
4754                         if (r->info0) {
4755                                 ndr_print_wkssvc_NetrUseInfo0(ndr, "info0", r->info0);
4756                         }
4757                         ndr->depth--;
4758                 break;
4759
4760                 case 1:
4761                         ndr_print_ptr(ndr, "info1", r->info1);
4762                         ndr->depth++;
4763                         if (r->info1) {
4764                                 ndr_print_wkssvc_NetrUseInfo1(ndr, "info1", r->info1);
4765                         }
4766                         ndr->depth--;
4767                 break;
4768
4769                 case 2:
4770                         ndr_print_ptr(ndr, "info2", r->info2);
4771                         ndr->depth++;
4772                         if (r->info2) {
4773                                 ndr_print_wkssvc_NetrUseInfo2(ndr, "info2", r->info2);
4774                         }
4775                         ndr->depth--;
4776                 break;
4777
4778                 case 3:
4779                         ndr_print_ptr(ndr, "info3", r->info3);
4780                         ndr->depth++;
4781                         if (r->info3) {
4782                                 ndr_print_wkssvc_NetrUseInfo3(ndr, "info3", r->info3);
4783                         }
4784                         ndr->depth--;
4785                 break;
4786
4787                 default:
4788                         ndr_print_bad_level(ndr, name, level);
4789         }
4790 }
4791
4792 static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumCtr2(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseEnumCtr2 *r)
4793 {
4794         uint32_t cntr_array_1;
4795         if (ndr_flags & NDR_SCALARS) {
4796                 NDR_CHECK(ndr_push_align(ndr, 4));
4797                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4798                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
4799         }
4800         if (ndr_flags & NDR_BUFFERS) {
4801                 if (r->array) {
4802                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4803                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4804                                 NDR_CHECK(ndr_push_wkssvc_NetrUseInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4805                         }
4806                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4807                                 NDR_CHECK(ndr_push_wkssvc_NetrUseInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4808                         }
4809                 }
4810         }
4811         return NDR_ERR_SUCCESS;
4812 }
4813
4814 static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumCtr2(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseEnumCtr2 *r)
4815 {
4816         uint32_t _ptr_array;
4817         uint32_t cntr_array_1;
4818         TALLOC_CTX *_mem_save_array_0;
4819         TALLOC_CTX *_mem_save_array_1;
4820         if (ndr_flags & NDR_SCALARS) {
4821                 NDR_CHECK(ndr_pull_align(ndr, 4));
4822                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4823                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
4824                 if (_ptr_array) {
4825                         NDR_PULL_ALLOC(ndr, r->array);
4826                 } else {
4827                         r->array = NULL;
4828                 }
4829         }
4830         if (ndr_flags & NDR_BUFFERS) {
4831                 if (r->array) {
4832                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4833                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4834                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
4835                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
4836                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4837                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4838                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4839                                 NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4840                         }
4841                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4842                                 NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4843                         }
4844                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
4845                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
4846                 }
4847                 if (r->array) {
4848                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
4849                 }
4850         }
4851         return NDR_ERR_SUCCESS;
4852 }
4853
4854 _PUBLIC_ void ndr_print_wkssvc_NetrUseEnumCtr2(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseEnumCtr2 *r)
4855 {
4856         uint32_t cntr_array_1;
4857         ndr_print_struct(ndr, name, "wkssvc_NetrUseEnumCtr2");
4858         ndr->depth++;
4859         ndr_print_uint32(ndr, "count", r->count);
4860         ndr_print_ptr(ndr, "array", r->array);
4861         ndr->depth++;
4862         if (r->array) {
4863                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
4864                 ndr->depth++;
4865                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
4866                         char *idx_1=NULL;
4867                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
4868                                 ndr_print_wkssvc_NetrUseInfo2(ndr, "array", &r->array[cntr_array_1]);
4869                                 free(idx_1);
4870                         }
4871                 }
4872                 ndr->depth--;
4873         }
4874         ndr->depth--;
4875         ndr->depth--;
4876 }
4877
4878 static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumCtr1(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseEnumCtr1 *r)
4879 {
4880         uint32_t cntr_array_1;
4881         if (ndr_flags & NDR_SCALARS) {
4882                 NDR_CHECK(ndr_push_align(ndr, 4));
4883                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4884                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
4885         }
4886         if (ndr_flags & NDR_BUFFERS) {
4887                 if (r->array) {
4888                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4889                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4890                                 NDR_CHECK(ndr_push_wkssvc_NetrUseInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4891                         }
4892                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4893                                 NDR_CHECK(ndr_push_wkssvc_NetrUseInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4894                         }
4895                 }
4896         }
4897         return NDR_ERR_SUCCESS;
4898 }
4899
4900 static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumCtr1(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseEnumCtr1 *r)
4901 {
4902         uint32_t _ptr_array;
4903         uint32_t cntr_array_1;
4904         TALLOC_CTX *_mem_save_array_0;
4905         TALLOC_CTX *_mem_save_array_1;
4906         if (ndr_flags & NDR_SCALARS) {
4907                 NDR_CHECK(ndr_pull_align(ndr, 4));
4908                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4909                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
4910                 if (_ptr_array) {
4911                         NDR_PULL_ALLOC(ndr, r->array);
4912                 } else {
4913                         r->array = NULL;
4914                 }
4915         }
4916         if (ndr_flags & NDR_BUFFERS) {
4917                 if (r->array) {
4918                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4919                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4920                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
4921                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
4922                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4923                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4924                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4925                                 NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4926                         }
4927                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4928                                 NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4929                         }
4930                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
4931                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
4932                 }
4933                 if (r->array) {
4934                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
4935                 }
4936         }
4937         return NDR_ERR_SUCCESS;
4938 }
4939
4940 _PUBLIC_ void ndr_print_wkssvc_NetrUseEnumCtr1(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseEnumCtr1 *r)
4941 {
4942         uint32_t cntr_array_1;
4943         ndr_print_struct(ndr, name, "wkssvc_NetrUseEnumCtr1");
4944         ndr->depth++;
4945         ndr_print_uint32(ndr, "count", r->count);
4946         ndr_print_ptr(ndr, "array", r->array);
4947         ndr->depth++;
4948         if (r->array) {
4949                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
4950                 ndr->depth++;
4951                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
4952                         char *idx_1=NULL;
4953                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
4954                                 ndr_print_wkssvc_NetrUseInfo1(ndr, "array", &r->array[cntr_array_1]);
4955                                 free(idx_1);
4956                         }
4957                 }
4958                 ndr->depth--;
4959         }
4960         ndr->depth--;
4961         ndr->depth--;
4962 }
4963
4964 static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumCtr0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseEnumCtr0 *r)
4965 {
4966         uint32_t cntr_array_1;
4967         if (ndr_flags & NDR_SCALARS) {
4968                 NDR_CHECK(ndr_push_align(ndr, 4));
4969                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4970                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
4971         }
4972         if (ndr_flags & NDR_BUFFERS) {
4973                 if (r->array) {
4974                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4975                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4976                                 NDR_CHECK(ndr_push_wkssvc_NetrUseInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4977                         }
4978                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4979                                 NDR_CHECK(ndr_push_wkssvc_NetrUseInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4980                         }
4981                 }
4982         }
4983         return NDR_ERR_SUCCESS;
4984 }
4985
4986 static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumCtr0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseEnumCtr0 *r)
4987 {
4988         uint32_t _ptr_array;
4989         uint32_t cntr_array_1;
4990         TALLOC_CTX *_mem_save_array_0;
4991         TALLOC_CTX *_mem_save_array_1;
4992         if (ndr_flags & NDR_SCALARS) {
4993                 NDR_CHECK(ndr_pull_align(ndr, 4));
4994                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4995                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
4996                 if (_ptr_array) {
4997                         NDR_PULL_ALLOC(ndr, r->array);
4998                 } else {
4999                         r->array = NULL;
5000                 }
5001         }
5002         if (ndr_flags & NDR_BUFFERS) {
5003                 if (r->array) {
5004                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5005                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5006                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
5007                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
5008                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5009                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5010                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5011                                 NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5012                         }
5013                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5014                                 NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5015                         }
5016                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
5017                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
5018                 }
5019                 if (r->array) {
5020                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
5021                 }
5022         }
5023         return NDR_ERR_SUCCESS;
5024 }
5025
5026 _PUBLIC_ void ndr_print_wkssvc_NetrUseEnumCtr0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseEnumCtr0 *r)
5027 {
5028         uint32_t cntr_array_1;
5029         ndr_print_struct(ndr, name, "wkssvc_NetrUseEnumCtr0");
5030         ndr->depth++;
5031         ndr_print_uint32(ndr, "count", r->count);
5032         ndr_print_ptr(ndr, "array", r->array);
5033         ndr->depth++;
5034         if (r->array) {
5035                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
5036                 ndr->depth++;
5037                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
5038                         char *idx_1=NULL;
5039                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
5040                                 ndr_print_wkssvc_NetrUseInfo0(ndr, "array", &r->array[cntr_array_1]);
5041                                 free(idx_1);
5042                         }
5043                 }
5044                 ndr->depth--;
5045         }
5046         ndr->depth--;
5047         ndr->depth--;
5048 }
5049
5050 static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumCtr(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetrUseEnumCtr *r)
5051 {
5052         if (ndr_flags & NDR_SCALARS) {
5053                 int level = ndr_push_get_switch_value(ndr, r);
5054                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5055                 switch (level) {
5056                         case 0: {
5057                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
5058                         break; }
5059
5060                         case 1: {
5061                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
5062                         break; }
5063
5064                         case 2: {
5065                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr2));
5066                         break; }
5067
5068                         default:
5069                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5070                 }
5071         }
5072         if (ndr_flags & NDR_BUFFERS) {
5073                 int level = ndr_push_get_switch_value(ndr, r);
5074                 switch (level) {
5075                         case 0:
5076                                 if (r->ctr0) {
5077                                         NDR_CHECK(ndr_push_wkssvc_NetrUseEnumCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
5078                                 }
5079                         break;
5080
5081                         case 1:
5082                                 if (r->ctr1) {
5083                                         NDR_CHECK(ndr_push_wkssvc_NetrUseEnumCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
5084                                 }
5085                         break;
5086
5087                         case 2:
5088                                 if (r->ctr2) {
5089                                         NDR_CHECK(ndr_push_wkssvc_NetrUseEnumCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
5090                                 }
5091                         break;
5092
5093                         default:
5094                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5095                 }
5096         }
5097         return NDR_ERR_SUCCESS;
5098 }
5099
5100 static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumCtr(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetrUseEnumCtr *r)
5101 {
5102         int level;
5103         uint32_t _level;
5104         TALLOC_CTX *_mem_save_ctr0_0;
5105         TALLOC_CTX *_mem_save_ctr1_0;
5106         TALLOC_CTX *_mem_save_ctr2_0;
5107         level = ndr_pull_get_switch_value(ndr, r);
5108         if (ndr_flags & NDR_SCALARS) {
5109                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5110                 if (_level != level) {
5111                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5112                 }
5113                 switch (level) {
5114                         case 0: {
5115                                 uint32_t _ptr_ctr0;
5116                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));
5117                                 if (_ptr_ctr0) {
5118                                         NDR_PULL_ALLOC(ndr, r->ctr0);
5119                                 } else {
5120                                         r->ctr0 = NULL;
5121                                 }
5122                         break; }
5123
5124                         case 1: {
5125                                 uint32_t _ptr_ctr1;
5126                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
5127                                 if (_ptr_ctr1) {
5128                                         NDR_PULL_ALLOC(ndr, r->ctr1);
5129                                 } else {
5130                                         r->ctr1 = NULL;
5131                                 }
5132                         break; }
5133
5134                         case 2: {
5135                                 uint32_t _ptr_ctr2;
5136                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr2));
5137                                 if (_ptr_ctr2) {
5138                                         NDR_PULL_ALLOC(ndr, r->ctr2);
5139                                 } else {
5140                                         r->ctr2 = NULL;
5141                                 }
5142                         break; }
5143
5144                         default:
5145                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5146                 }
5147         }
5148         if (ndr_flags & NDR_BUFFERS) {
5149                 switch (level) {
5150                         case 0:
5151                                 if (r->ctr0) {
5152                                         _mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);
5153                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr0, 0);
5154                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
5155                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);
5156                                 }
5157                         break;
5158
5159                         case 1:
5160                                 if (r->ctr1) {
5161                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5162                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
5163                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
5164                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
5165                                 }
5166                         break;
5167
5168                         case 2:
5169                                 if (r->ctr2) {
5170                                         _mem_save_ctr2_0 = NDR_PULL_GET_MEM_CTX(ndr);
5171                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr2, 0);
5172                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
5173                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr2_0, 0);
5174                                 }
5175                         break;
5176
5177                         default:
5178                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5179                 }
5180         }
5181         return NDR_ERR_SUCCESS;
5182 }
5183
5184 _PUBLIC_ void ndr_print_wkssvc_NetrUseEnumCtr(struct ndr_print *ndr, const char *name, const union wkssvc_NetrUseEnumCtr *r)
5185 {
5186         int level;
5187         level = ndr_print_get_switch_value(ndr, r);
5188         ndr_print_union(ndr, name, level, "wkssvc_NetrUseEnumCtr");
5189         switch (level) {
5190                 case 0:
5191                         ndr_print_ptr(ndr, "ctr0", r->ctr0);
5192                         ndr->depth++;
5193                         if (r->ctr0) {
5194                                 ndr_print_wkssvc_NetrUseEnumCtr0(ndr, "ctr0", r->ctr0);
5195                         }
5196                         ndr->depth--;
5197                 break;
5198
5199                 case 1:
5200                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
5201                         ndr->depth++;
5202                         if (r->ctr1) {
5203                                 ndr_print_wkssvc_NetrUseEnumCtr1(ndr, "ctr1", r->ctr1);
5204                         }
5205                         ndr->depth--;
5206                 break;
5207
5208                 case 2:
5209                         ndr_print_ptr(ndr, "ctr2", r->ctr2);
5210                         ndr->depth++;
5211                         if (r->ctr2) {
5212                                 ndr_print_wkssvc_NetrUseEnumCtr2(ndr, "ctr2", r->ctr2);
5213                         }
5214                         ndr->depth--;
5215                 break;
5216
5217                 default:
5218                         ndr_print_bad_level(ndr, name, level);
5219         }
5220 }
5221
5222 static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumInfo(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseEnumInfo *r)
5223 {
5224         if (ndr_flags & NDR_SCALARS) {
5225                 NDR_CHECK(ndr_push_align(ndr, 4));
5226                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
5227                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
5228                 NDR_CHECK(ndr_push_wkssvc_NetrUseEnumCtr(ndr, NDR_SCALARS, &r->ctr));
5229         }
5230         if (ndr_flags & NDR_BUFFERS) {
5231                 NDR_CHECK(ndr_push_wkssvc_NetrUseEnumCtr(ndr, NDR_BUFFERS, &r->ctr));
5232         }
5233         return NDR_ERR_SUCCESS;
5234 }
5235
5236 static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumInfo(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseEnumInfo *r)
5237 {
5238         if (ndr_flags & NDR_SCALARS) {
5239                 NDR_CHECK(ndr_pull_align(ndr, 4));
5240                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
5241                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
5242                 NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumCtr(ndr, NDR_SCALARS, &r->ctr));
5243         }
5244         if (ndr_flags & NDR_BUFFERS) {
5245                 NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumCtr(ndr, NDR_BUFFERS, &r->ctr));
5246         }
5247         return NDR_ERR_SUCCESS;
5248 }
5249
5250 _PUBLIC_ void ndr_print_wkssvc_NetrUseEnumInfo(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseEnumInfo *r)
5251 {
5252         ndr_print_struct(ndr, name, "wkssvc_NetrUseEnumInfo");
5253         ndr->depth++;
5254         ndr_print_uint32(ndr, "level", r->level);
5255         ndr_print_set_switch_value(ndr, &r->ctr, r->level);
5256         ndr_print_wkssvc_NetrUseEnumCtr(ndr, "ctr", &r->ctr);
5257         ndr->depth--;
5258 }
5259
5260 static enum ndr_err_code ndr_push_wkssvc_NetrWorkstationStatistics(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrWorkstationStatistics *r)
5261 {
5262         if (ndr_flags & NDR_SCALARS) {
5263                 NDR_CHECK(ndr_push_align(ndr, 8));
5264                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown1));
5265                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown2));
5266                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown3));
5267                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown4));
5268                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown5));
5269                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown6));
5270                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown7));
5271                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown8));
5272                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown9));
5273                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown10));
5274                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown11));
5275                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown12));
5276                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown13));
5277                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown14));
5278                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown15));
5279                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown16));
5280                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown17));
5281                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown18));
5282                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown19));
5283                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown20));
5284                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown21));
5285                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown22));
5286                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown23));
5287                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown24));
5288                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown25));
5289                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown26));
5290                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown27));
5291                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown28));
5292                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown29));
5293                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown30));
5294                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown31));
5295                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown32));
5296                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown33));
5297                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown34));
5298                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown35));
5299                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown36));
5300                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown37));
5301                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown38));
5302                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown39));
5303                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown40));
5304         }
5305         if (ndr_flags & NDR_BUFFERS) {
5306         }
5307         return NDR_ERR_SUCCESS;
5308 }
5309
5310 static enum ndr_err_code ndr_pull_wkssvc_NetrWorkstationStatistics(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrWorkstationStatistics *r)
5311 {
5312         if (ndr_flags & NDR_SCALARS) {
5313                 NDR_CHECK(ndr_pull_align(ndr, 8));
5314                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown1));
5315                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown2));
5316                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown3));
5317                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown4));
5318                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown5));
5319                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown6));
5320                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown7));
5321                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown8));
5322                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown9));
5323                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown10));
5324                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown11));
5325                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown12));
5326                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown13));
5327                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown14));
5328                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown15));
5329                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown16));
5330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown17));
5331                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown18));
5332                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown19));
5333                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown20));
5334                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown21));
5335                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown22));
5336                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown23));
5337                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown24));
5338                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown25));
5339                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown26));
5340                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown27));
5341                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown28));
5342                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown29));
5343                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown30));
5344                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown31));
5345                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown32));
5346                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown33));
5347                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown34));
5348                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown35));
5349                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown36));
5350                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown37));
5351                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown38));
5352                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown39));
5353                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown40));
5354         }
5355         if (ndr_flags & NDR_BUFFERS) {
5356         }
5357         return NDR_ERR_SUCCESS;
5358 }
5359
5360 _PUBLIC_ void ndr_print_wkssvc_NetrWorkstationStatistics(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrWorkstationStatistics *r)
5361 {
5362         ndr_print_struct(ndr, name, "wkssvc_NetrWorkstationStatistics");
5363         ndr->depth++;
5364         ndr_print_hyper(ndr, "unknown1", r->unknown1);
5365         ndr_print_hyper(ndr, "unknown2", r->unknown2);
5366         ndr_print_hyper(ndr, "unknown3", r->unknown3);
5367         ndr_print_hyper(ndr, "unknown4", r->unknown4);
5368         ndr_print_hyper(ndr, "unknown5", r->unknown5);
5369         ndr_print_hyper(ndr, "unknown6", r->unknown6);
5370         ndr_print_hyper(ndr, "unknown7", r->unknown7);
5371         ndr_print_hyper(ndr, "unknown8", r->unknown8);
5372         ndr_print_hyper(ndr, "unknown9", r->unknown9);
5373         ndr_print_hyper(ndr, "unknown10", r->unknown10);
5374         ndr_print_hyper(ndr, "unknown11", r->unknown11);
5375         ndr_print_hyper(ndr, "unknown12", r->unknown12);
5376         ndr_print_hyper(ndr, "unknown13", r->unknown13);
5377         ndr_print_uint32(ndr, "unknown14", r->unknown14);
5378         ndr_print_uint32(ndr, "unknown15", r->unknown15);
5379         ndr_print_uint32(ndr, "unknown16", r->unknown16);
5380         ndr_print_uint32(ndr, "unknown17", r->unknown17);
5381         ndr_print_uint32(ndr, "unknown18", r->unknown18);
5382         ndr_print_uint32(ndr, "unknown19", r->unknown19);
5383         ndr_print_uint32(ndr, "unknown20", r->unknown20);
5384         ndr_print_uint32(ndr, "unknown21", r->unknown21);
5385         ndr_print_uint32(ndr, "unknown22", r->unknown22);
5386         ndr_print_uint32(ndr, "unknown23", r->unknown23);
5387         ndr_print_uint32(ndr, "unknown24", r->unknown24);
5388         ndr_print_uint32(ndr, "unknown25", r->unknown25);
5389         ndr_print_uint32(ndr, "unknown26", r->unknown26);
5390         ndr_print_uint32(ndr, "unknown27", r->unknown27);
5391         ndr_print_uint32(ndr, "unknown28", r->unknown28);
5392         ndr_print_uint32(ndr, "unknown29", r->unknown29);
5393         ndr_print_uint32(ndr, "unknown30", r->unknown30);
5394         ndr_print_uint32(ndr, "unknown31", r->unknown31);
5395         ndr_print_uint32(ndr, "unknown32", r->unknown32);
5396         ndr_print_uint32(ndr, "unknown33", r->unknown33);
5397         ndr_print_uint32(ndr, "unknown34", r->unknown34);
5398         ndr_print_uint32(ndr, "unknown35", r->unknown35);
5399         ndr_print_uint32(ndr, "unknown36", r->unknown36);
5400         ndr_print_uint32(ndr, "unknown37", r->unknown37);
5401         ndr_print_uint32(ndr, "unknown38", r->unknown38);
5402         ndr_print_uint32(ndr, "unknown39", r->unknown39);
5403         ndr_print_uint32(ndr, "unknown40", r->unknown40);
5404         ndr->depth--;
5405 }
5406
5407 static enum ndr_err_code ndr_push_wkssvc_renameflags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
5408 {
5409         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5410         return NDR_ERR_SUCCESS;
5411 }
5412
5413 static enum ndr_err_code ndr_pull_wkssvc_renameflags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
5414 {
5415         uint32_t v;
5416         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5417         *r = v;
5418         return NDR_ERR_SUCCESS;
5419 }
5420
5421 _PUBLIC_ void ndr_print_wkssvc_renameflags(struct ndr_print *ndr, const char *name, uint32_t r)
5422 {
5423         ndr_print_uint32(ndr, name, r);
5424         ndr->depth++;
5425         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE", WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE, r);
5426         ndr->depth--;
5427 }
5428
5429 static enum ndr_err_code ndr_push_wkssvc_NetValidateNameType(struct ndr_push *ndr, int ndr_flags, enum wkssvc_NetValidateNameType r)
5430 {
5431         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
5432         return NDR_ERR_SUCCESS;
5433 }
5434
5435 static enum ndr_err_code ndr_pull_wkssvc_NetValidateNameType(struct ndr_pull *ndr, int ndr_flags, enum wkssvc_NetValidateNameType *r)
5436 {
5437         uint16_t v;
5438         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
5439         *r = v;
5440         return NDR_ERR_SUCCESS;
5441 }
5442
5443 _PUBLIC_ void ndr_print_wkssvc_NetValidateNameType(struct ndr_print *ndr, const char *name, enum wkssvc_NetValidateNameType r)
5444 {
5445         const char *val = NULL;
5446
5447         switch (r) {
5448                 case NetSetupUnknown: val = "NetSetupUnknown"; break;
5449                 case NetSetupMachine: val = "NetSetupMachine"; break;
5450                 case NetSetupWorkgroup: val = "NetSetupWorkgroup"; break;
5451                 case NetSetupDomain: val = "NetSetupDomain"; break;
5452                 case NetSetupNonExistentDomain: val = "NetSetupNonExistentDomain"; break;
5453                 case NetSetupDnsMachine: val = "NetSetupDnsMachine"; break;
5454         }
5455         ndr_print_enum(ndr, name, "ENUM", val, r);
5456 }
5457
5458 static enum ndr_err_code ndr_push_wkssvc_NetJoinStatus(struct ndr_push *ndr, int ndr_flags, enum wkssvc_NetJoinStatus r)
5459 {
5460         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
5461         return NDR_ERR_SUCCESS;
5462 }
5463
5464 static enum ndr_err_code ndr_pull_wkssvc_NetJoinStatus(struct ndr_pull *ndr, int ndr_flags, enum wkssvc_NetJoinStatus *r)
5465 {
5466         uint16_t v;
5467         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
5468         *r = v;
5469         return NDR_ERR_SUCCESS;
5470 }
5471
5472 _PUBLIC_ void ndr_print_wkssvc_NetJoinStatus(struct ndr_print *ndr, const char *name, enum wkssvc_NetJoinStatus r)
5473 {
5474         const char *val = NULL;
5475
5476         switch (r) {
5477                 case NET_SETUP_UNKNOWN_STATUS: val = "NET_SETUP_UNKNOWN_STATUS"; break;
5478                 case NET_SETUP_UNJOINED: val = "NET_SETUP_UNJOINED"; break;
5479                 case NET_SETUP_WORKGROUP_NAME: val = "NET_SETUP_WORKGROUP_NAME"; break;
5480                 case NET_SETUP_DOMAIN_NAME: val = "NET_SETUP_DOMAIN_NAME"; break;
5481         }
5482         ndr_print_enum(ndr, name, "ENUM", val, r);
5483 }
5484
5485 static enum ndr_err_code ndr_push_wkssvc_PasswordBuffer(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_PasswordBuffer *r)
5486 {
5487         {
5488                 uint32_t _flags_save_STRUCT = ndr->flags;
5489                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
5490                 if (ndr_flags & NDR_SCALARS) {
5491                         NDR_CHECK(ndr_push_align(ndr, 1));
5492                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, 524));
5493                 }
5494                 if (ndr_flags & NDR_BUFFERS) {
5495                 }
5496                 ndr->flags = _flags_save_STRUCT;
5497         }
5498         return NDR_ERR_SUCCESS;
5499 }
5500
5501 static enum ndr_err_code ndr_pull_wkssvc_PasswordBuffer(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_PasswordBuffer *r)
5502 {
5503         {
5504                 uint32_t _flags_save_STRUCT = ndr->flags;
5505                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
5506                 if (ndr_flags & NDR_SCALARS) {
5507                         NDR_CHECK(ndr_pull_align(ndr, 1));
5508                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, 524));
5509                 }
5510                 if (ndr_flags & NDR_BUFFERS) {
5511                 }
5512                 ndr->flags = _flags_save_STRUCT;
5513         }
5514         return NDR_ERR_SUCCESS;
5515 }
5516
5517 _PUBLIC_ void ndr_print_wkssvc_PasswordBuffer(struct ndr_print *ndr, const char *name, const struct wkssvc_PasswordBuffer *r)
5518 {
5519         ndr_print_struct(ndr, name, "wkssvc_PasswordBuffer");
5520         {
5521                 uint32_t _flags_save_STRUCT = ndr->flags;
5522                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
5523                 ndr->depth++;
5524                 ndr_print_array_uint8(ndr, "data", r->data, 524);
5525                 ndr->depth--;
5526                 ndr->flags = _flags_save_STRUCT;
5527         }
5528 }
5529
5530 static enum ndr_err_code ndr_push_wkssvc_joinflags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
5531 {
5532         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5533         return NDR_ERR_SUCCESS;
5534 }
5535
5536 static enum ndr_err_code ndr_pull_wkssvc_joinflags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
5537 {
5538         uint32_t v;
5539         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5540         *r = v;
5541         return NDR_ERR_SUCCESS;
5542 }
5543
5544 _PUBLIC_ void ndr_print_wkssvc_joinflags(struct ndr_print *ndr, const char *name, uint32_t r)
5545 {
5546         ndr_print_uint32(ndr, name, r);
5547         ndr->depth++;
5548         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_JOIN_WITH_NEW_NAME", WKSSVC_JOIN_FLAGS_JOIN_WITH_NEW_NAME, r);
5549         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_JOIN_DC_ACCOUNT", WKSSVC_JOIN_FLAGS_JOIN_DC_ACCOUNT, r);
5550         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_DEFER_SPN", WKSSVC_JOIN_FLAGS_DEFER_SPN, r);
5551         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_MACHINE_PWD_PASSED", WKSSVC_JOIN_FLAGS_MACHINE_PWD_PASSED, r);
5552         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_JOIN_UNSECURE", WKSSVC_JOIN_FLAGS_JOIN_UNSECURE, r);
5553         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_DOMAIN_JOIN_IF_JOINED", WKSSVC_JOIN_FLAGS_DOMAIN_JOIN_IF_JOINED, r);
5554         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_WIN9X_UPGRADE", WKSSVC_JOIN_FLAGS_WIN9X_UPGRADE, r);
5555         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_ACCOUNT_DELETE", WKSSVC_JOIN_FLAGS_ACCOUNT_DELETE, r);
5556         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE", WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE, r);
5557         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_JOIN_TYPE", WKSSVC_JOIN_FLAGS_JOIN_TYPE, r);
5558         ndr->depth--;
5559 }
5560
5561 static enum ndr_err_code ndr_push_wkssvc_ComputerNameType(struct ndr_push *ndr, int ndr_flags, enum wkssvc_ComputerNameType r)
5562 {
5563         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
5564         return NDR_ERR_SUCCESS;
5565 }
5566
5567 static enum ndr_err_code ndr_pull_wkssvc_ComputerNameType(struct ndr_pull *ndr, int ndr_flags, enum wkssvc_ComputerNameType *r)
5568 {
5569         uint16_t v;
5570         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
5571         *r = v;
5572         return NDR_ERR_SUCCESS;
5573 }
5574
5575 _PUBLIC_ void ndr_print_wkssvc_ComputerNameType(struct ndr_print *ndr, const char *name, enum wkssvc_ComputerNameType r)
5576 {
5577         const char *val = NULL;
5578
5579         switch (r) {
5580                 case NetPrimaryComputerName: val = "NetPrimaryComputerName"; break;
5581                 case NetAlternateComputerNames: val = "NetAlternateComputerNames"; break;
5582                 case NetAllComputerNames: val = "NetAllComputerNames"; break;
5583                 case NetComputerNameTypeMax: val = "NetComputerNameTypeMax"; break;
5584         }
5585         ndr_print_enum(ndr, name, "ENUM", val, r);
5586 }
5587
5588 static enum ndr_err_code ndr_push_wkssvc_ComputerNamesCtr(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_ComputerNamesCtr *r)
5589 {
5590         uint32_t cntr_computer_name_1;
5591         if (ndr_flags & NDR_SCALARS) {
5592                 NDR_CHECK(ndr_push_align(ndr, 4));
5593                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5594                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_name));
5595         }
5596         if (ndr_flags & NDR_BUFFERS) {
5597                 if (r->computer_name) {
5598                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5599                         for (cntr_computer_name_1 = 0; cntr_computer_name_1 < r->count; cntr_computer_name_1++) {
5600                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->computer_name[cntr_computer_name_1]));
5601                         }
5602                         for (cntr_computer_name_1 = 0; cntr_computer_name_1 < r->count; cntr_computer_name_1++) {
5603                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->computer_name[cntr_computer_name_1]));
5604                         }
5605                 }
5606         }
5607         return NDR_ERR_SUCCESS;
5608 }
5609
5610 static enum ndr_err_code ndr_pull_wkssvc_ComputerNamesCtr(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_ComputerNamesCtr *r)
5611 {
5612         uint32_t _ptr_computer_name;
5613         uint32_t cntr_computer_name_1;
5614         TALLOC_CTX *_mem_save_computer_name_0;
5615         TALLOC_CTX *_mem_save_computer_name_1;
5616         if (ndr_flags & NDR_SCALARS) {
5617                 NDR_CHECK(ndr_pull_align(ndr, 4));
5618                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5619                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_name));
5620                 if (_ptr_computer_name) {
5621                         NDR_PULL_ALLOC(ndr, r->computer_name);
5622                 } else {
5623                         r->computer_name = NULL;
5624                 }
5625         }
5626         if (ndr_flags & NDR_BUFFERS) {
5627                 if (r->computer_name) {
5628                         _mem_save_computer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5629                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_name, 0);
5630                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_name));
5631                         NDR_PULL_ALLOC_N(ndr, r->computer_name, ndr_get_array_size(ndr, &r->computer_name));
5632                         _mem_save_computer_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
5633                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_name, 0);
5634                         for (cntr_computer_name_1 = 0; cntr_computer_name_1 < r->count; cntr_computer_name_1++) {
5635                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->computer_name[cntr_computer_name_1]));
5636                         }
5637                         for (cntr_computer_name_1 = 0; cntr_computer_name_1 < r->count; cntr_computer_name_1++) {
5638                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->computer_name[cntr_computer_name_1]));
5639                         }
5640                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_name_1, 0);
5641                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_name_0, 0);
5642                 }
5643                 if (r->computer_name) {
5644                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->computer_name, r->count));
5645                 }
5646         }
5647         return NDR_ERR_SUCCESS;
5648 }
5649
5650 _PUBLIC_ void ndr_print_wkssvc_ComputerNamesCtr(struct ndr_print *ndr, const char *name, const struct wkssvc_ComputerNamesCtr *r)
5651 {
5652         uint32_t cntr_computer_name_1;
5653         ndr_print_struct(ndr, name, "wkssvc_ComputerNamesCtr");
5654         ndr->depth++;
5655         ndr_print_uint32(ndr, "count", r->count);
5656         ndr_print_ptr(ndr, "computer_name", r->computer_name);
5657         ndr->depth++;
5658         if (r->computer_name) {
5659                 ndr->print(ndr, "%s: ARRAY(%d)", "computer_name", (int)r->count);
5660                 ndr->depth++;
5661                 for (cntr_computer_name_1=0;cntr_computer_name_1<r->count;cntr_computer_name_1++) {
5662                         char *idx_1=NULL;
5663                         if (asprintf(&idx_1, "[%d]", cntr_computer_name_1) != -1) {
5664                                 ndr_print_lsa_String(ndr, "computer_name", &r->computer_name[cntr_computer_name_1]);
5665                                 free(idx_1);
5666                         }
5667                 }
5668                 ndr->depth--;
5669         }
5670         ndr->depth--;
5671         ndr->depth--;
5672 }
5673
5674 static enum ndr_err_code ndr_push_wkssvc_NetWkstaGetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaGetInfo *r)
5675 {
5676         if (flags & NDR_IN) {
5677                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
5678                 if (r->in.server_name) {
5679                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
5680                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5681                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
5682                         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));
5683                 }
5684                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
5685         }
5686         if (flags & NDR_OUT) {
5687                 if (r->out.info == NULL) {
5688                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5689                 }
5690                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
5691                 NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
5692                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5693         }
5694         return NDR_ERR_SUCCESS;
5695 }
5696
5697 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaGetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaGetInfo *r)
5698 {
5699         uint32_t _ptr_server_name;
5700         TALLOC_CTX *_mem_save_server_name_0;
5701         TALLOC_CTX *_mem_save_info_0;
5702         if (flags & NDR_IN) {
5703                 ZERO_STRUCT(r->out);
5704
5705                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5706                 if (_ptr_server_name) {
5707                         NDR_PULL_ALLOC(ndr, r->in.server_name);
5708                 } else {
5709                         r->in.server_name = NULL;
5710                 }
5711                 if (r->in.server_name) {
5712                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5713                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
5714                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
5715                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
5716                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
5717                                 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));
5718                         }
5719                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
5720                         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));
5721                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5722                 }
5723                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
5724                 NDR_PULL_ALLOC(ndr, r->out.info);
5725                 ZERO_STRUCTP(r->out.info);
5726         }
5727         if (flags & NDR_OUT) {
5728                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5729                         NDR_PULL_ALLOC(ndr, r->out.info);
5730                 }
5731                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
5732                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
5733                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
5734                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
5735                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
5736                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5737         }
5738         return NDR_ERR_SUCCESS;
5739 }
5740
5741 _PUBLIC_ void ndr_print_wkssvc_NetWkstaGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaGetInfo *r)
5742 {
5743         ndr_print_struct(ndr, name, "wkssvc_NetWkstaGetInfo");
5744         ndr->depth++;
5745         if (flags & NDR_SET_VALUES) {
5746                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5747         }
5748         if (flags & NDR_IN) {
5749                 ndr_print_struct(ndr, "in", "wkssvc_NetWkstaGetInfo");
5750                 ndr->depth++;
5751                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
5752                 ndr->depth++;
5753                 if (r->in.server_name) {
5754                         ndr_print_string(ndr, "server_name", r->in.server_name);
5755                 }
5756                 ndr->depth--;
5757                 ndr_print_uint32(ndr, "level", r->in.level);
5758                 ndr->depth--;
5759         }
5760         if (flags & NDR_OUT) {
5761                 ndr_print_struct(ndr, "out", "wkssvc_NetWkstaGetInfo");
5762                 ndr->depth++;
5763                 ndr_print_ptr(ndr, "info", r->out.info);
5764                 ndr->depth++;
5765                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
5766                 ndr_print_wkssvc_NetWkstaInfo(ndr, "info", r->out.info);
5767                 ndr->depth--;
5768                 ndr_print_WERROR(ndr, "result", r->out.result);
5769                 ndr->depth--;
5770         }
5771         ndr->depth--;
5772 }
5773
5774 static enum ndr_err_code ndr_push_wkssvc_NetWkstaSetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaSetInfo *r)
5775 {
5776         if (flags & NDR_IN) {
5777                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
5778                 if (r->in.server_name) {
5779                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
5780                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5781                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
5782                         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));
5783                 }
5784                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
5785                 if (r->in.info == NULL) {
5786                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5787                 }
5788                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
5789                 NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
5790                 if (r->in.parm_error == NULL) {
5791                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5792                 }
5793                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_error));
5794         }
5795         if (flags & NDR_OUT) {
5796                 if (r->out.parm_error == NULL) {
5797                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5798                 }
5799                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_error));
5800                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5801         }
5802         return NDR_ERR_SUCCESS;
5803 }
5804
5805 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaSetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaSetInfo *r)
5806 {
5807         uint32_t _ptr_server_name;
5808         TALLOC_CTX *_mem_save_server_name_0;
5809         TALLOC_CTX *_mem_save_info_0;
5810         TALLOC_CTX *_mem_save_parm_error_0;
5811         if (flags & NDR_IN) {
5812                 ZERO_STRUCT(r->out);
5813
5814                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5815                 if (_ptr_server_name) {
5816                         NDR_PULL_ALLOC(ndr, r->in.server_name);
5817                 } else {
5818                         r->in.server_name = NULL;
5819                 }
5820                 if (r->in.server_name) {
5821                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5822                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
5823                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
5824                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
5825                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
5826                                 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));
5827                         }
5828                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
5829                         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));
5830                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5831                 }
5832                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
5833                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5834                         NDR_PULL_ALLOC(ndr, r->in.info);
5835                 }
5836                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
5837                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
5838                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
5839                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
5840                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
5841                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5842                         NDR_PULL_ALLOC(ndr, r->in.parm_error);
5843                 }
5844                 _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
5845                 NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_error, LIBNDR_FLAG_REF_ALLOC);
5846                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_error));
5847                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, LIBNDR_FLAG_REF_ALLOC);
5848                 NDR_PULL_ALLOC(ndr, r->out.parm_error);
5849                 *r->out.parm_error = *r->in.parm_error;
5850         }
5851         if (flags & NDR_OUT) {
5852                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5853                         NDR_PULL_ALLOC(ndr, r->out.parm_error);
5854                 }
5855                 _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
5856                 NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_error, LIBNDR_FLAG_REF_ALLOC);
5857                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_error));
5858                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, LIBNDR_FLAG_REF_ALLOC);
5859                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5860         }
5861         return NDR_ERR_SUCCESS;
5862 }
5863
5864 _PUBLIC_ void ndr_print_wkssvc_NetWkstaSetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaSetInfo *r)
5865 {
5866         ndr_print_struct(ndr, name, "wkssvc_NetWkstaSetInfo");
5867         ndr->depth++;
5868         if (flags & NDR_SET_VALUES) {
5869                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5870         }
5871         if (flags & NDR_IN) {
5872                 ndr_print_struct(ndr, "in", "wkssvc_NetWkstaSetInfo");
5873                 ndr->depth++;
5874                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
5875                 ndr->depth++;
5876                 if (r->in.server_name) {
5877                         ndr_print_string(ndr, "server_name", r->in.server_name);
5878                 }
5879                 ndr->depth--;
5880                 ndr_print_uint32(ndr, "level", r->in.level);
5881                 ndr_print_ptr(ndr, "info", r->in.info);
5882                 ndr->depth++;
5883                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
5884                 ndr_print_wkssvc_NetWkstaInfo(ndr, "info", r->in.info);
5885                 ndr->depth--;
5886                 ndr_print_ptr(ndr, "parm_error", r->in.parm_error);
5887                 ndr->depth++;
5888                 ndr_print_uint32(ndr, "parm_error", *r->in.parm_error);
5889                 ndr->depth--;
5890                 ndr->depth--;
5891         }
5892         if (flags & NDR_OUT) {
5893                 ndr_print_struct(ndr, "out", "wkssvc_NetWkstaSetInfo");
5894                 ndr->depth++;
5895                 ndr_print_ptr(ndr, "parm_error", r->out.parm_error);
5896                 ndr->depth++;
5897                 ndr_print_uint32(ndr, "parm_error", *r->out.parm_error);
5898                 ndr->depth--;
5899                 ndr_print_WERROR(ndr, "result", r->out.result);
5900                 ndr->depth--;
5901         }
5902         ndr->depth--;
5903 }
5904
5905 static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsers(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaEnumUsers *r)
5906 {
5907         if (flags & NDR_IN) {
5908                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
5909                 if (r->in.server_name) {
5910                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
5911                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5912                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
5913                         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));
5914                 }
5915                 if (r->in.info == NULL) {
5916                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5917                 }
5918                 NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
5919                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.prefmaxlen));
5920                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
5921                 if (r->in.resume_handle) {
5922                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
5923                 }
5924         }
5925         if (flags & NDR_OUT) {
5926                 if (r->out.info == NULL) {
5927                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5928                 }
5929                 NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
5930                 if (r->out.entries_read == NULL) {
5931                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5932                 }
5933                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.entries_read));
5934                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
5935                 if (r->out.resume_handle) {
5936                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
5937                 }
5938                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5939         }
5940         return NDR_ERR_SUCCESS;
5941 }
5942
5943 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsers(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaEnumUsers *r)
5944 {
5945         uint32_t _ptr_server_name;
5946         uint32_t _ptr_resume_handle;
5947         TALLOC_CTX *_mem_save_server_name_0;
5948         TALLOC_CTX *_mem_save_info_0;
5949         TALLOC_CTX *_mem_save_entries_read_0;
5950         TALLOC_CTX *_mem_save_resume_handle_0;
5951         if (flags & NDR_IN) {
5952                 ZERO_STRUCT(r->out);
5953
5954                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5955                 if (_ptr_server_name) {
5956                         NDR_PULL_ALLOC(ndr, r->in.server_name);
5957                 } else {
5958                         r->in.server_name = NULL;
5959                 }
5960                 if (r->in.server_name) {
5961                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5962                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
5963                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
5964                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
5965                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
5966                                 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));
5967                         }
5968                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
5969                         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));
5970                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5971                 }
5972                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5973                         NDR_PULL_ALLOC(ndr, r->in.info);
5974                 }
5975                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
5976                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
5977                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
5978                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
5979                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.prefmaxlen));
5980                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
5981                 if (_ptr_resume_handle) {
5982                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
5983                 } else {
5984                         r->in.resume_handle = NULL;
5985                 }
5986                 if (r->in.resume_handle) {
5987                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5988                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
5989                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
5990                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
5991                 }
5992                 NDR_PULL_ALLOC(ndr, r->out.info);
5993                 *r->out.info = *r->in.info;
5994                 NDR_PULL_ALLOC(ndr, r->out.entries_read);
5995                 ZERO_STRUCTP(r->out.entries_read);
5996         }
5997         if (flags & NDR_OUT) {
5998                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5999                         NDR_PULL_ALLOC(ndr, r->out.info);
6000                 }
6001                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6002                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
6003                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
6004                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6005                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6006                         NDR_PULL_ALLOC(ndr, r->out.entries_read);
6007                 }
6008                 _mem_save_entries_read_0 = NDR_PULL_GET_MEM_CTX(ndr);
6009                 NDR_PULL_SET_MEM_CTX(ndr, r->out.entries_read, LIBNDR_FLAG_REF_ALLOC);
6010                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.entries_read));
6011                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_read_0, LIBNDR_FLAG_REF_ALLOC);
6012                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
6013                 if (_ptr_resume_handle) {
6014                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6015                 } else {
6016                         r->out.resume_handle = NULL;
6017                 }
6018                 if (r->out.resume_handle) {
6019                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6020                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
6021                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
6022                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
6023                 }
6024                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6025         }
6026         return NDR_ERR_SUCCESS;
6027 }
6028
6029 _PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsers(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaEnumUsers *r)
6030 {
6031         ndr_print_struct(ndr, name, "wkssvc_NetWkstaEnumUsers");
6032         ndr->depth++;
6033         if (flags & NDR_SET_VALUES) {
6034                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6035         }
6036         if (flags & NDR_IN) {
6037                 ndr_print_struct(ndr, "in", "wkssvc_NetWkstaEnumUsers");
6038                 ndr->depth++;
6039                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
6040                 ndr->depth++;
6041                 if (r->in.server_name) {
6042                         ndr_print_string(ndr, "server_name", r->in.server_name);
6043                 }
6044                 ndr->depth--;
6045                 ndr_print_ptr(ndr, "info", r->in.info);
6046                 ndr->depth++;
6047                 ndr_print_wkssvc_NetWkstaEnumUsersInfo(ndr, "info", r->in.info);
6048                 ndr->depth--;
6049                 ndr_print_uint32(ndr, "prefmaxlen", r->in.prefmaxlen);
6050                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
6051                 ndr->depth++;
6052                 if (r->in.resume_handle) {
6053                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
6054                 }
6055                 ndr->depth--;
6056                 ndr->depth--;
6057         }
6058         if (flags & NDR_OUT) {
6059                 ndr_print_struct(ndr, "out", "wkssvc_NetWkstaEnumUsers");
6060                 ndr->depth++;
6061                 ndr_print_ptr(ndr, "info", r->out.info);
6062                 ndr->depth++;
6063                 ndr_print_wkssvc_NetWkstaEnumUsersInfo(ndr, "info", r->out.info);
6064                 ndr->depth--;
6065                 ndr_print_ptr(ndr, "entries_read", r->out.entries_read);
6066                 ndr->depth++;
6067                 ndr_print_uint32(ndr, "entries_read", *r->out.entries_read);
6068                 ndr->depth--;
6069                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
6070                 ndr->depth++;
6071                 if (r->out.resume_handle) {
6072                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
6073                 }
6074                 ndr->depth--;
6075                 ndr_print_WERROR(ndr, "result", r->out.result);
6076                 ndr->depth--;
6077         }
6078         ndr->depth--;
6079 }
6080
6081 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserGetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetrWkstaUserGetInfo *r)
6082 {
6083         if (flags & NDR_IN) {
6084                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown));
6085                 if (r->in.unknown) {
6086                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));
6087                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6088                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));
6089                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.unknown, ndr_charset_length(r->in.unknown, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6090                 }
6091                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
6092         }
6093         if (flags & NDR_OUT) {
6094                 if (r->out.info == NULL) {
6095                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6096                 }
6097                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
6098                 NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
6099                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6100         }
6101         return NDR_ERR_SUCCESS;
6102 }
6103
6104 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserGetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetrWkstaUserGetInfo *r)
6105 {
6106         uint32_t _ptr_unknown;
6107         TALLOC_CTX *_mem_save_unknown_0;
6108         TALLOC_CTX *_mem_save_info_0;
6109         if (flags & NDR_IN) {
6110                 ZERO_STRUCT(r->out);
6111
6112                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown));
6113                 if (_ptr_unknown) {
6114                         NDR_PULL_ALLOC(ndr, r->in.unknown);
6115                 } else {
6116                         r->in.unknown = NULL;
6117                 }
6118                 if (r->in.unknown) {
6119                         _mem_save_unknown_0 = NDR_PULL_GET_MEM_CTX(ndr);
6120                         NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown, 0);
6121                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.unknown));
6122                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.unknown));
6123                         if (ndr_get_array_length(ndr, &r->in.unknown) > ndr_get_array_size(ndr, &r->in.unknown)) {
6124                                 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));
6125                         }
6126                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t)));
6127                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.unknown, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t), CH_UTF16));
6128                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown_0, 0);
6129                 }
6130                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
6131                 NDR_PULL_ALLOC(ndr, r->out.info);
6132                 ZERO_STRUCTP(r->out.info);
6133         }
6134         if (flags & NDR_OUT) {
6135                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6136                         NDR_PULL_ALLOC(ndr, r->out.info);
6137                 }
6138                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6139                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
6140                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
6141                 NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
6142                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6143                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6144         }
6145         return NDR_ERR_SUCCESS;
6146 }
6147
6148 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrWkstaUserGetInfo *r)
6149 {
6150         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaUserGetInfo");
6151         ndr->depth++;
6152         if (flags & NDR_SET_VALUES) {
6153                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6154         }
6155         if (flags & NDR_IN) {
6156                 ndr_print_struct(ndr, "in", "wkssvc_NetrWkstaUserGetInfo");
6157                 ndr->depth++;
6158                 ndr_print_ptr(ndr, "unknown", r->in.unknown);
6159                 ndr->depth++;
6160                 if (r->in.unknown) {
6161                         ndr_print_string(ndr, "unknown", r->in.unknown);
6162                 }
6163                 ndr->depth--;
6164                 ndr_print_uint32(ndr, "level", r->in.level);
6165                 ndr->depth--;
6166         }
6167         if (flags & NDR_OUT) {
6168                 ndr_print_struct(ndr, "out", "wkssvc_NetrWkstaUserGetInfo");
6169                 ndr->depth++;
6170                 ndr_print_ptr(ndr, "info", r->out.info);
6171                 ndr->depth++;
6172                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
6173                 ndr_print_wkssvc_NetrWkstaUserInfo(ndr, "info", r->out.info);
6174                 ndr->depth--;
6175                 ndr_print_WERROR(ndr, "result", r->out.result);
6176                 ndr->depth--;
6177         }
6178         ndr->depth--;
6179 }
6180
6181 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserSetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetrWkstaUserSetInfo *r)
6182 {
6183         if (flags & NDR_IN) {
6184                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown));
6185                 if (r->in.unknown) {
6186                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));
6187                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6188                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));
6189                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.unknown, ndr_charset_length(r->in.unknown, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6190                 }
6191                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
6192                 if (r->in.info == NULL) {
6193                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6194                 }
6195                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
6196                 NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6197                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_err));
6198                 if (r->in.parm_err) {
6199                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_err));
6200                 }
6201         }
6202         if (flags & NDR_OUT) {
6203                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_err));
6204                 if (r->out.parm_err) {
6205                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_err));
6206                 }
6207                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6208         }
6209         return NDR_ERR_SUCCESS;
6210 }
6211
6212 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserSetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetrWkstaUserSetInfo *r)
6213 {
6214         uint32_t _ptr_unknown;
6215         uint32_t _ptr_parm_err;
6216         TALLOC_CTX *_mem_save_unknown_0;
6217         TALLOC_CTX *_mem_save_info_0;
6218         TALLOC_CTX *_mem_save_parm_err_0;
6219         if (flags & NDR_IN) {
6220                 ZERO_STRUCT(r->out);
6221
6222                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown));
6223                 if (_ptr_unknown) {
6224                         NDR_PULL_ALLOC(ndr, r->in.unknown);
6225                 } else {
6226                         r->in.unknown = NULL;
6227                 }
6228                 if (r->in.unknown) {
6229                         _mem_save_unknown_0 = NDR_PULL_GET_MEM_CTX(ndr);
6230                         NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown, 0);
6231                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.unknown));
6232                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.unknown));
6233                         if (ndr_get_array_length(ndr, &r->in.unknown) > ndr_get_array_size(ndr, &r->in.unknown)) {
6234                                 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));
6235                         }
6236                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t)));
6237                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.unknown, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t), CH_UTF16));
6238                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown_0, 0);
6239                 }
6240                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
6241                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6242                         NDR_PULL_ALLOC(ndr, r->in.info);
6243                 }
6244                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6245                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
6246                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
6247                 NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6248                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6249                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));
6250                 if (_ptr_parm_err) {
6251                         NDR_PULL_ALLOC(ndr, r->in.parm_err);
6252                 } else {
6253                         r->in.parm_err = NULL;
6254                 }
6255                 if (r->in.parm_err) {
6256                         _mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);
6257                         NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_err, 0);
6258                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_err));
6259                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);
6260                 }
6261         }
6262         if (flags & NDR_OUT) {
6263                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));
6264                 if (_ptr_parm_err) {
6265                         NDR_PULL_ALLOC(ndr, r->out.parm_err);
6266                 } else {
6267                         r->out.parm_err = NULL;
6268                 }
6269                 if (r->out.parm_err) {
6270                         _mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);
6271                         NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_err, 0);
6272                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_err));
6273                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);
6274                 }
6275                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6276         }
6277         return NDR_ERR_SUCCESS;
6278 }
6279
6280 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserSetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrWkstaUserSetInfo *r)
6281 {
6282         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaUserSetInfo");
6283         ndr->depth++;
6284         if (flags & NDR_SET_VALUES) {
6285                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6286         }
6287         if (flags & NDR_IN) {
6288                 ndr_print_struct(ndr, "in", "wkssvc_NetrWkstaUserSetInfo");
6289                 ndr->depth++;
6290                 ndr_print_ptr(ndr, "unknown", r->in.unknown);
6291                 ndr->depth++;
6292                 if (r->in.unknown) {
6293                         ndr_print_string(ndr, "unknown", r->in.unknown);
6294                 }
6295                 ndr->depth--;
6296                 ndr_print_uint32(ndr, "level", r->in.level);
6297                 ndr_print_ptr(ndr, "info", r->in.info);
6298                 ndr->depth++;
6299                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
6300                 ndr_print_wkssvc_NetrWkstaUserInfo(ndr, "info", r->in.info);
6301                 ndr->depth--;
6302                 ndr_print_ptr(ndr, "parm_err", r->in.parm_err);
6303                 ndr->depth++;
6304                 if (r->in.parm_err) {
6305                         ndr_print_uint32(ndr, "parm_err", *r->in.parm_err);
6306                 }
6307                 ndr->depth--;
6308                 ndr->depth--;
6309         }
6310         if (flags & NDR_OUT) {
6311                 ndr_print_struct(ndr, "out", "wkssvc_NetrWkstaUserSetInfo");
6312                 ndr->depth++;
6313                 ndr_print_ptr(ndr, "parm_err", r->out.parm_err);
6314                 ndr->depth++;
6315                 if (r->out.parm_err) {
6316                         ndr_print_uint32(ndr, "parm_err", *r->out.parm_err);
6317                 }
6318                 ndr->depth--;
6319                 ndr_print_WERROR(ndr, "result", r->out.result);
6320                 ndr->depth--;
6321         }
6322         ndr->depth--;
6323 }
6324
6325 static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportEnum(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaTransportEnum *r)
6326 {
6327         if (flags & NDR_IN) {
6328                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
6329                 if (r->in.server_name) {
6330                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6331                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6332                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6333                         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));
6334                 }
6335                 if (r->in.info == NULL) {
6336                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6337                 }
6338                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6339                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));
6340                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
6341                 if (r->in.resume_handle) {
6342                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
6343                 }
6344         }
6345         if (flags & NDR_OUT) {
6346                 if (r->out.info == NULL) {
6347                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6348                 }
6349                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
6350                 if (r->out.total_entries == NULL) {
6351                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6352                 }
6353                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_entries));
6354                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
6355                 if (r->out.resume_handle) {
6356                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
6357                 }
6358                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6359         }
6360         return NDR_ERR_SUCCESS;
6361 }
6362
6363 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportEnum(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaTransportEnum *r)
6364 {
6365         uint32_t _ptr_server_name;
6366         uint32_t _ptr_resume_handle;
6367         TALLOC_CTX *_mem_save_server_name_0;
6368         TALLOC_CTX *_mem_save_info_0;
6369         TALLOC_CTX *_mem_save_total_entries_0;
6370         TALLOC_CTX *_mem_save_resume_handle_0;
6371         if (flags & NDR_IN) {
6372                 ZERO_STRUCT(r->out);
6373
6374                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6375                 if (_ptr_server_name) {
6376                         NDR_PULL_ALLOC(ndr, r->in.server_name);
6377                 } else {
6378                         r->in.server_name = NULL;
6379                 }
6380                 if (r->in.server_name) {
6381                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6382                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
6383                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
6384                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
6385                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
6386                                 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));
6387                         }
6388                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
6389                         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));
6390                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6391                 }
6392                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6393                         NDR_PULL_ALLOC(ndr, r->in.info);
6394                 }
6395                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6396                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
6397                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6398                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6399                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));
6400                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
6401                 if (_ptr_resume_handle) {
6402                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
6403                 } else {
6404                         r->in.resume_handle = NULL;
6405                 }
6406                 if (r->in.resume_handle) {
6407                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6408                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
6409                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
6410                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
6411                 }
6412                 NDR_PULL_ALLOC(ndr, r->out.info);
6413                 *r->out.info = *r->in.info;
6414                 NDR_PULL_ALLOC(ndr, r->out.total_entries);
6415                 ZERO_STRUCTP(r->out.total_entries);
6416         }
6417         if (flags & NDR_OUT) {
6418                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6419                         NDR_PULL_ALLOC(ndr, r->out.info);
6420                 }
6421                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6422                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
6423                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
6424                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6425                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6426                         NDR_PULL_ALLOC(ndr, r->out.total_entries);
6427                 }
6428                 _mem_save_total_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
6429                 NDR_PULL_SET_MEM_CTX(ndr, r->out.total_entries, LIBNDR_FLAG_REF_ALLOC);
6430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_entries));
6431                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_entries_0, LIBNDR_FLAG_REF_ALLOC);
6432                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
6433                 if (_ptr_resume_handle) {
6434                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6435                 } else {
6436                         r->out.resume_handle = NULL;
6437                 }
6438                 if (r->out.resume_handle) {
6439                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6440                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
6441                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
6442                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
6443                 }
6444                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6445         }
6446         return NDR_ERR_SUCCESS;
6447 }
6448
6449 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportEnum(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaTransportEnum *r)
6450 {
6451         ndr_print_struct(ndr, name, "wkssvc_NetWkstaTransportEnum");
6452         ndr->depth++;
6453         if (flags & NDR_SET_VALUES) {
6454                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6455         }
6456         if (flags & NDR_IN) {
6457                 ndr_print_struct(ndr, "in", "wkssvc_NetWkstaTransportEnum");
6458                 ndr->depth++;
6459                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
6460                 ndr->depth++;
6461                 if (r->in.server_name) {
6462                         ndr_print_string(ndr, "server_name", r->in.server_name);
6463                 }
6464                 ndr->depth--;
6465                 ndr_print_ptr(ndr, "info", r->in.info);
6466                 ndr->depth++;
6467                 ndr_print_wkssvc_NetWkstaTransportInfo(ndr, "info", r->in.info);
6468                 ndr->depth--;
6469                 ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);
6470                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
6471                 ndr->depth++;
6472                 if (r->in.resume_handle) {
6473                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
6474                 }
6475                 ndr->depth--;
6476                 ndr->depth--;
6477         }
6478         if (flags & NDR_OUT) {
6479                 ndr_print_struct(ndr, "out", "wkssvc_NetWkstaTransportEnum");
6480                 ndr->depth++;
6481                 ndr_print_ptr(ndr, "info", r->out.info);
6482                 ndr->depth++;
6483                 ndr_print_wkssvc_NetWkstaTransportInfo(ndr, "info", r->out.info);
6484                 ndr->depth--;
6485                 ndr_print_ptr(ndr, "total_entries", r->out.total_entries);
6486                 ndr->depth++;
6487                 ndr_print_uint32(ndr, "total_entries", *r->out.total_entries);
6488                 ndr->depth--;
6489                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
6490                 ndr->depth++;
6491                 if (r->out.resume_handle) {
6492                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
6493                 }
6494                 ndr->depth--;
6495                 ndr_print_WERROR(ndr, "result", r->out.result);
6496                 ndr->depth--;
6497         }
6498         ndr->depth--;
6499 }
6500
6501 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaTransportAdd(struct ndr_push *ndr, int flags, const struct wkssvc_NetrWkstaTransportAdd *r)
6502 {
6503         if (flags & NDR_IN) {
6504                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
6505                 if (r->in.server_name) {
6506                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6507                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6508                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6509                         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));
6510                 }
6511                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
6512                 if (r->in.info0 == NULL) {
6513                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6514                 }
6515                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info0));
6516                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_err));
6517                 if (r->in.parm_err) {
6518                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_err));
6519                 }
6520         }
6521         if (flags & NDR_OUT) {
6522                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_err));
6523                 if (r->out.parm_err) {
6524                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_err));
6525                 }
6526                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6527         }
6528         return NDR_ERR_SUCCESS;
6529 }
6530
6531 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaTransportAdd(struct ndr_pull *ndr, int flags, struct wkssvc_NetrWkstaTransportAdd *r)
6532 {
6533         uint32_t _ptr_server_name;
6534         uint32_t _ptr_parm_err;
6535         TALLOC_CTX *_mem_save_server_name_0;
6536         TALLOC_CTX *_mem_save_info0_0;
6537         TALLOC_CTX *_mem_save_parm_err_0;
6538         if (flags & NDR_IN) {
6539                 ZERO_STRUCT(r->out);
6540
6541                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6542                 if (_ptr_server_name) {
6543                         NDR_PULL_ALLOC(ndr, r->in.server_name);
6544                 } else {
6545                         r->in.server_name = NULL;
6546                 }
6547                 if (r->in.server_name) {
6548                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6549                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
6550                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
6551                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
6552                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
6553                                 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));
6554                         }
6555                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
6556                         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));
6557                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6558                 }
6559                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
6560                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6561                         NDR_PULL_ALLOC(ndr, r->in.info0);
6562                 }
6563                 _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
6564                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info0, LIBNDR_FLAG_REF_ALLOC);
6565                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info0));
6566                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, LIBNDR_FLAG_REF_ALLOC);
6567                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));
6568                 if (_ptr_parm_err) {
6569                         NDR_PULL_ALLOC(ndr, r->in.parm_err);
6570                 } else {
6571                         r->in.parm_err = NULL;
6572                 }
6573                 if (r->in.parm_err) {
6574                         _mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);
6575                         NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_err, 0);
6576                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_err));
6577                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);
6578                 }
6579         }
6580         if (flags & NDR_OUT) {
6581                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));
6582                 if (_ptr_parm_err) {
6583                         NDR_PULL_ALLOC(ndr, r->out.parm_err);
6584                 } else {
6585                         r->out.parm_err = NULL;
6586                 }
6587                 if (r->out.parm_err) {
6588                         _mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);
6589                         NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_err, 0);
6590                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_err));
6591                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);
6592                 }
6593                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6594         }
6595         return NDR_ERR_SUCCESS;
6596 }
6597
6598 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaTransportAdd(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrWkstaTransportAdd *r)
6599 {
6600         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaTransportAdd");
6601         ndr->depth++;
6602         if (flags & NDR_SET_VALUES) {
6603                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6604         }
6605         if (flags & NDR_IN) {
6606                 ndr_print_struct(ndr, "in", "wkssvc_NetrWkstaTransportAdd");
6607                 ndr->depth++;
6608                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
6609                 ndr->depth++;
6610                 if (r->in.server_name) {
6611                         ndr_print_string(ndr, "server_name", r->in.server_name);
6612                 }
6613                 ndr->depth--;
6614                 ndr_print_uint32(ndr, "level", r->in.level);
6615                 ndr_print_ptr(ndr, "info0", r->in.info0);
6616                 ndr->depth++;
6617                 ndr_print_wkssvc_NetWkstaTransportInfo0(ndr, "info0", r->in.info0);
6618                 ndr->depth--;
6619                 ndr_print_ptr(ndr, "parm_err", r->in.parm_err);
6620                 ndr->depth++;
6621                 if (r->in.parm_err) {
6622                         ndr_print_uint32(ndr, "parm_err", *r->in.parm_err);
6623                 }
6624                 ndr->depth--;
6625                 ndr->depth--;
6626         }
6627         if (flags & NDR_OUT) {
6628                 ndr_print_struct(ndr, "out", "wkssvc_NetrWkstaTransportAdd");
6629                 ndr->depth++;
6630                 ndr_print_ptr(ndr, "parm_err", r->out.parm_err);
6631                 ndr->depth++;
6632                 if (r->out.parm_err) {
6633                         ndr_print_uint32(ndr, "parm_err", *r->out.parm_err);
6634                 }
6635                 ndr->depth--;
6636                 ndr_print_WERROR(ndr, "result", r->out.result);
6637                 ndr->depth--;
6638         }
6639         ndr->depth--;
6640 }
6641
6642 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaTransportDel(struct ndr_push *ndr, int flags, const struct wkssvc_NetrWkstaTransportDel *r)
6643 {
6644         if (flags & NDR_IN) {
6645                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
6646                 if (r->in.server_name) {
6647                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6648                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6649                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6650                         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));
6651                 }
6652                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.transport_name));
6653                 if (r->in.transport_name) {
6654                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.transport_name, CH_UTF16)));
6655                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6656                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.transport_name, CH_UTF16)));
6657                         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));
6658                 }
6659                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown3));
6660         }
6661         if (flags & NDR_OUT) {
6662                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6663         }
6664         return NDR_ERR_SUCCESS;
6665 }
6666
6667 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaTransportDel(struct ndr_pull *ndr, int flags, struct wkssvc_NetrWkstaTransportDel *r)
6668 {
6669         uint32_t _ptr_server_name;
6670         uint32_t _ptr_transport_name;
6671         TALLOC_CTX *_mem_save_server_name_0;
6672         TALLOC_CTX *_mem_save_transport_name_0;
6673         if (flags & NDR_IN) {
6674                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6675                 if (_ptr_server_name) {
6676                         NDR_PULL_ALLOC(ndr, r->in.server_name);
6677                 } else {
6678                         r->in.server_name = NULL;
6679                 }
6680                 if (r->in.server_name) {
6681                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6682                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
6683                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
6684                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
6685                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
6686                                 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));
6687                         }
6688                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
6689                         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));
6690                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6691                 }
6692                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_name));
6693                 if (_ptr_transport_name) {
6694                         NDR_PULL_ALLOC(ndr, r->in.transport_name);
6695                 } else {
6696                         r->in.transport_name = NULL;
6697                 }
6698                 if (r->in.transport_name) {
6699                         _mem_save_transport_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6700                         NDR_PULL_SET_MEM_CTX(ndr, r->in.transport_name, 0);
6701                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.transport_name));
6702                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.transport_name));
6703                         if (ndr_get_array_length(ndr, &r->in.transport_name) > ndr_get_array_size(ndr, &r->in.transport_name)) {
6704                                 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));
6705                         }
6706                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.transport_name), sizeof(uint16_t)));
6707                         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));
6708                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_name_0, 0);
6709                 }
6710                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown3));
6711         }
6712         if (flags & NDR_OUT) {
6713                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6714         }
6715         return NDR_ERR_SUCCESS;
6716 }
6717
6718 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaTransportDel(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrWkstaTransportDel *r)
6719 {
6720         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaTransportDel");
6721         ndr->depth++;
6722         if (flags & NDR_SET_VALUES) {
6723                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6724         }
6725         if (flags & NDR_IN) {
6726                 ndr_print_struct(ndr, "in", "wkssvc_NetrWkstaTransportDel");
6727                 ndr->depth++;
6728                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
6729                 ndr->depth++;
6730                 if (r->in.server_name) {
6731                         ndr_print_string(ndr, "server_name", r->in.server_name);
6732                 }
6733                 ndr->depth--;
6734                 ndr_print_ptr(ndr, "transport_name", r->in.transport_name);
6735                 ndr->depth++;
6736                 if (r->in.transport_name) {
6737                         ndr_print_string(ndr, "transport_name", r->in.transport_name);
6738                 }
6739                 ndr->depth--;
6740                 ndr_print_uint32(ndr, "unknown3", r->in.unknown3);
6741                 ndr->depth--;
6742         }
6743         if (flags & NDR_OUT) {
6744                 ndr_print_struct(ndr, "out", "wkssvc_NetrWkstaTransportDel");
6745                 ndr->depth++;
6746                 ndr_print_WERROR(ndr, "result", r->out.result);
6747                 ndr->depth--;
6748         }
6749         ndr->depth--;
6750 }
6751
6752 static enum ndr_err_code ndr_push_wkssvc_NetrUseAdd(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUseAdd *r)
6753 {
6754         if (flags & NDR_IN) {
6755                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
6756                 if (r->in.server_name) {
6757                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6758                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6759                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6760                         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));
6761                 }
6762                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
6763                 if (r->in.ctr == NULL) {
6764                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6765                 }
6766                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.ctr, r->in.level));
6767                 NDR_CHECK(ndr_push_wkssvc_NetrUseGetInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
6768                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_err));
6769                 if (r->in.parm_err) {
6770                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_err));
6771                 }
6772         }
6773         if (flags & NDR_OUT) {
6774                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_err));
6775                 if (r->out.parm_err) {
6776                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_err));
6777                 }
6778                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6779         }
6780         return NDR_ERR_SUCCESS;
6781 }
6782
6783 static enum ndr_err_code ndr_pull_wkssvc_NetrUseAdd(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUseAdd *r)
6784 {
6785         uint32_t _ptr_server_name;
6786         uint32_t _ptr_parm_err;
6787         TALLOC_CTX *_mem_save_server_name_0;
6788         TALLOC_CTX *_mem_save_ctr_0;
6789         TALLOC_CTX *_mem_save_parm_err_0;
6790         if (flags & NDR_IN) {
6791                 ZERO_STRUCT(r->out);
6792
6793                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6794                 if (_ptr_server_name) {
6795                         NDR_PULL_ALLOC(ndr, r->in.server_name);
6796                 } else {
6797                         r->in.server_name = NULL;
6798                 }
6799                 if (r->in.server_name) {
6800                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6801                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
6802                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
6803                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
6804                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
6805                                 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));
6806                         }
6807                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
6808                         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));
6809                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6810                 }
6811                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
6812                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6813                         NDR_PULL_ALLOC(ndr, r->in.ctr);
6814                 }
6815                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
6816                 NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, LIBNDR_FLAG_REF_ALLOC);
6817                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.ctr, r->in.level));
6818                 NDR_CHECK(ndr_pull_wkssvc_NetrUseGetInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
6819                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
6820                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));
6821                 if (_ptr_parm_err) {
6822                         NDR_PULL_ALLOC(ndr, r->in.parm_err);
6823                 } else {
6824                         r->in.parm_err = NULL;
6825                 }
6826                 if (r->in.parm_err) {
6827                         _mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);
6828                         NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_err, 0);
6829                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_err));
6830                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);
6831                 }
6832         }
6833         if (flags & NDR_OUT) {
6834                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));
6835                 if (_ptr_parm_err) {
6836                         NDR_PULL_ALLOC(ndr, r->out.parm_err);
6837                 } else {
6838                         r->out.parm_err = NULL;
6839                 }
6840                 if (r->out.parm_err) {
6841                         _mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);
6842                         NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_err, 0);
6843                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_err));
6844                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);
6845                 }
6846                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6847         }
6848         return NDR_ERR_SUCCESS;
6849 }
6850
6851 _PUBLIC_ void ndr_print_wkssvc_NetrUseAdd(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUseAdd *r)
6852 {
6853         ndr_print_struct(ndr, name, "wkssvc_NetrUseAdd");
6854         ndr->depth++;
6855         if (flags & NDR_SET_VALUES) {
6856                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6857         }
6858         if (flags & NDR_IN) {
6859                 ndr_print_struct(ndr, "in", "wkssvc_NetrUseAdd");
6860                 ndr->depth++;
6861                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
6862                 ndr->depth++;
6863                 if (r->in.server_name) {
6864                         ndr_print_string(ndr, "server_name", r->in.server_name);
6865                 }
6866                 ndr->depth--;
6867                 ndr_print_uint32(ndr, "level", r->in.level);
6868                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
6869                 ndr->depth++;
6870                 ndr_print_set_switch_value(ndr, r->in.ctr, r->in.level);
6871                 ndr_print_wkssvc_NetrUseGetInfoCtr(ndr, "ctr", r->in.ctr);
6872                 ndr->depth--;
6873                 ndr_print_ptr(ndr, "parm_err", r->in.parm_err);
6874                 ndr->depth++;
6875                 if (r->in.parm_err) {
6876                         ndr_print_uint32(ndr, "parm_err", *r->in.parm_err);
6877                 }
6878                 ndr->depth--;
6879                 ndr->depth--;
6880         }
6881         if (flags & NDR_OUT) {
6882                 ndr_print_struct(ndr, "out", "wkssvc_NetrUseAdd");
6883                 ndr->depth++;
6884                 ndr_print_ptr(ndr, "parm_err", r->out.parm_err);
6885                 ndr->depth++;
6886                 if (r->out.parm_err) {
6887                         ndr_print_uint32(ndr, "parm_err", *r->out.parm_err);
6888                 }
6889                 ndr->depth--;
6890                 ndr_print_WERROR(ndr, "result", r->out.result);
6891                 ndr->depth--;
6892         }
6893         ndr->depth--;
6894 }
6895
6896 static enum ndr_err_code ndr_push_wkssvc_NetrUseGetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUseGetInfo *r)
6897 {
6898         if (flags & NDR_IN) {
6899                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
6900                 if (r->in.server_name) {
6901                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6902                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6903                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6904                         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));
6905                 }
6906                 if (r->in.use_name == NULL) {
6907                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6908                 }
6909                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.use_name, CH_UTF16)));
6910                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6911                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.use_name, CH_UTF16)));
6912                 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));
6913                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
6914         }
6915         if (flags & NDR_OUT) {
6916                 if (r->out.ctr == NULL) {
6917                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6918                 }
6919                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, r->in.level));
6920                 NDR_CHECK(ndr_push_wkssvc_NetrUseGetInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
6921                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6922         }
6923         return NDR_ERR_SUCCESS;
6924 }
6925
6926 static enum ndr_err_code ndr_pull_wkssvc_NetrUseGetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUseGetInfo *r)
6927 {
6928         uint32_t _ptr_server_name;
6929         TALLOC_CTX *_mem_save_server_name_0;
6930         TALLOC_CTX *_mem_save_ctr_0;
6931         if (flags & NDR_IN) {
6932                 ZERO_STRUCT(r->out);
6933
6934                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6935                 if (_ptr_server_name) {
6936                         NDR_PULL_ALLOC(ndr, r->in.server_name);
6937                 } else {
6938                         r->in.server_name = NULL;
6939                 }
6940                 if (r->in.server_name) {
6941                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6942                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
6943                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
6944                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
6945                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
6946                                 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));
6947                         }
6948                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
6949                         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));
6950                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6951                 }
6952                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.use_name));
6953                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.use_name));
6954                 if (ndr_get_array_length(ndr, &r->in.use_name) > ndr_get_array_size(ndr, &r->in.use_name)) {
6955                         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));
6956                 }
6957                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.use_name), sizeof(uint16_t)));
6958                 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));
6959                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
6960                 NDR_PULL_ALLOC(ndr, r->out.ctr);
6961                 ZERO_STRUCTP(r->out.ctr);
6962         }
6963         if (flags & NDR_OUT) {
6964                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6965                         NDR_PULL_ALLOC(ndr, r->out.ctr);
6966                 }
6967                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
6968                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
6969                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, r->in.level));
6970                 NDR_CHECK(ndr_pull_wkssvc_NetrUseGetInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
6971                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
6972                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6973         }
6974         return NDR_ERR_SUCCESS;
6975 }
6976
6977 _PUBLIC_ void ndr_print_wkssvc_NetrUseGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUseGetInfo *r)
6978 {
6979         ndr_print_struct(ndr, name, "wkssvc_NetrUseGetInfo");
6980         ndr->depth++;
6981         if (flags & NDR_SET_VALUES) {
6982                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6983         }
6984         if (flags & NDR_IN) {
6985                 ndr_print_struct(ndr, "in", "wkssvc_NetrUseGetInfo");
6986                 ndr->depth++;
6987                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
6988                 ndr->depth++;
6989                 if (r->in.server_name) {
6990                         ndr_print_string(ndr, "server_name", r->in.server_name);
6991                 }
6992                 ndr->depth--;
6993                 ndr_print_ptr(ndr, "use_name", r->in.use_name);
6994                 ndr->depth++;
6995                 ndr_print_string(ndr, "use_name", r->in.use_name);
6996                 ndr->depth--;
6997                 ndr_print_uint32(ndr, "level", r->in.level);
6998                 ndr->depth--;
6999         }
7000         if (flags & NDR_OUT) {
7001                 ndr_print_struct(ndr, "out", "wkssvc_NetrUseGetInfo");
7002                 ndr->depth++;
7003                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
7004                 ndr->depth++;
7005                 ndr_print_set_switch_value(ndr, r->out.ctr, r->in.level);
7006                 ndr_print_wkssvc_NetrUseGetInfoCtr(ndr, "ctr", r->out.ctr);
7007                 ndr->depth--;
7008                 ndr_print_WERROR(ndr, "result", r->out.result);
7009                 ndr->depth--;
7010         }
7011         ndr->depth--;
7012 }
7013
7014 static enum ndr_err_code ndr_push_wkssvc_NetrUseDel(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUseDel *r)
7015 {
7016         if (flags & NDR_IN) {
7017                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
7018                 if (r->in.server_name) {
7019                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7020                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7021                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7022                         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));
7023                 }
7024                 if (r->in.use_name == NULL) {
7025                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7026                 }
7027                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.use_name, CH_UTF16)));
7028                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7029                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.use_name, CH_UTF16)));
7030                 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));
7031                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.force_cond));
7032         }
7033         if (flags & NDR_OUT) {
7034                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7035         }
7036         return NDR_ERR_SUCCESS;
7037 }
7038
7039 static enum ndr_err_code ndr_pull_wkssvc_NetrUseDel(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUseDel *r)
7040 {
7041         uint32_t _ptr_server_name;
7042         TALLOC_CTX *_mem_save_server_name_0;
7043         if (flags & NDR_IN) {
7044                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
7045                 if (_ptr_server_name) {
7046                         NDR_PULL_ALLOC(ndr, r->in.server_name);
7047                 } else {
7048                         r->in.server_name = NULL;
7049                 }
7050                 if (r->in.server_name) {
7051                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7052                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
7053                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
7054                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
7055                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
7056                                 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));
7057                         }
7058                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
7059                         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));
7060                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
7061                 }
7062                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.use_name));
7063                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.use_name));
7064                 if (ndr_get_array_length(ndr, &r->in.use_name) > ndr_get_array_size(ndr, &r->in.use_name)) {
7065                         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));
7066                 }
7067                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.use_name), sizeof(uint16_t)));
7068                 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));
7069                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.force_cond));
7070         }
7071         if (flags & NDR_OUT) {
7072                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7073         }
7074         return NDR_ERR_SUCCESS;
7075 }
7076
7077 _PUBLIC_ void ndr_print_wkssvc_NetrUseDel(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUseDel *r)
7078 {
7079         ndr_print_struct(ndr, name, "wkssvc_NetrUseDel");
7080         ndr->depth++;
7081         if (flags & NDR_SET_VALUES) {
7082                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7083         }
7084         if (flags & NDR_IN) {
7085                 ndr_print_struct(ndr, "in", "wkssvc_NetrUseDel");
7086                 ndr->depth++;
7087                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
7088                 ndr->depth++;
7089                 if (r->in.server_name) {
7090                         ndr_print_string(ndr, "server_name", r->in.server_name);
7091                 }
7092                 ndr->depth--;
7093                 ndr_print_ptr(ndr, "use_name", r->in.use_name);
7094                 ndr->depth++;
7095                 ndr_print_string(ndr, "use_name", r->in.use_name);
7096                 ndr->depth--;
7097                 ndr_print_uint32(ndr, "force_cond", r->in.force_cond);
7098                 ndr->depth--;
7099         }
7100         if (flags & NDR_OUT) {
7101                 ndr_print_struct(ndr, "out", "wkssvc_NetrUseDel");
7102                 ndr->depth++;
7103                 ndr_print_WERROR(ndr, "result", r->out.result);
7104                 ndr->depth--;
7105         }
7106         ndr->depth--;
7107 }
7108
7109 static enum ndr_err_code ndr_push_wkssvc_NetrUseEnum(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUseEnum *r)
7110 {
7111         if (flags & NDR_IN) {
7112                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
7113                 if (r->in.server_name) {
7114                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7115                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7116                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7117                         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));
7118                 }
7119                 if (r->in.info == NULL) {
7120                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7121                 }
7122                 NDR_CHECK(ndr_push_wkssvc_NetrUseEnumInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
7123                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.prefmaxlen));
7124                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
7125                 if (r->in.resume_handle) {
7126                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
7127                 }
7128         }
7129         if (flags & NDR_OUT) {
7130                 if (r->out.info == NULL) {
7131                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7132                 }
7133                 NDR_CHECK(ndr_push_wkssvc_NetrUseEnumInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
7134                 if (r->out.entries_read == NULL) {
7135                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7136                 }
7137                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.entries_read));
7138                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
7139                 if (r->out.resume_handle) {
7140                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
7141                 }
7142                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7143         }
7144         return NDR_ERR_SUCCESS;
7145 }
7146
7147 static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnum(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUseEnum *r)
7148 {
7149         uint32_t _ptr_server_name;
7150         uint32_t _ptr_resume_handle;
7151         TALLOC_CTX *_mem_save_server_name_0;
7152         TALLOC_CTX *_mem_save_info_0;
7153         TALLOC_CTX *_mem_save_entries_read_0;
7154         TALLOC_CTX *_mem_save_resume_handle_0;
7155         if (flags & NDR_IN) {
7156                 ZERO_STRUCT(r->out);
7157
7158                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
7159                 if (_ptr_server_name) {
7160                         NDR_PULL_ALLOC(ndr, r->in.server_name);
7161                 } else {
7162                         r->in.server_name = NULL;
7163                 }
7164                 if (r->in.server_name) {
7165                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7166                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
7167                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
7168                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
7169                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
7170                                 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));
7171                         }
7172                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
7173                         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));
7174                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
7175                 }
7176                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7177                         NDR_PULL_ALLOC(ndr, r->in.info);
7178                 }
7179                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
7180                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
7181                 NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
7182                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
7183                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.prefmaxlen));
7184                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
7185                 if (_ptr_resume_handle) {
7186                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
7187                 } else {
7188                         r->in.resume_handle = NULL;
7189                 }
7190                 if (r->in.resume_handle) {
7191                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7192                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
7193                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
7194                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
7195                 }
7196                 NDR_PULL_ALLOC(ndr, r->out.info);
7197                 *r->out.info = *r->in.info;
7198                 NDR_PULL_ALLOC(ndr, r->out.entries_read);
7199                 ZERO_STRUCTP(r->out.entries_read);
7200         }
7201         if (flags & NDR_OUT) {
7202                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7203                         NDR_PULL_ALLOC(ndr, r->out.info);
7204                 }
7205                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
7206                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
7207                 NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
7208                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
7209                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7210                         NDR_PULL_ALLOC(ndr, r->out.entries_read);
7211                 }
7212                 _mem_save_entries_read_0 = NDR_PULL_GET_MEM_CTX(ndr);
7213                 NDR_PULL_SET_MEM_CTX(ndr, r->out.entries_read, LIBNDR_FLAG_REF_ALLOC);
7214                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.entries_read));
7215                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_read_0, LIBNDR_FLAG_REF_ALLOC);
7216                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
7217                 if (_ptr_resume_handle) {
7218                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
7219                 } else {
7220                         r->out.resume_handle = NULL;
7221                 }
7222                 if (r->out.resume_handle) {
7223                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7224                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
7225                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
7226                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
7227                 }
7228                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7229         }
7230         return NDR_ERR_SUCCESS;
7231 }
7232
7233 _PUBLIC_ void ndr_print_wkssvc_NetrUseEnum(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUseEnum *r)
7234 {
7235         ndr_print_struct(ndr, name, "wkssvc_NetrUseEnum");
7236         ndr->depth++;
7237         if (flags & NDR_SET_VALUES) {
7238                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7239         }
7240         if (flags & NDR_IN) {
7241                 ndr_print_struct(ndr, "in", "wkssvc_NetrUseEnum");
7242                 ndr->depth++;
7243                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
7244                 ndr->depth++;
7245                 if (r->in.server_name) {
7246                         ndr_print_string(ndr, "server_name", r->in.server_name);
7247                 }
7248                 ndr->depth--;
7249                 ndr_print_ptr(ndr, "info", r->in.info);
7250                 ndr->depth++;
7251                 ndr_print_wkssvc_NetrUseEnumInfo(ndr, "info", r->in.info);
7252                 ndr->depth--;
7253                 ndr_print_uint32(ndr, "prefmaxlen", r->in.prefmaxlen);
7254                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
7255                 ndr->depth++;
7256                 if (r->in.resume_handle) {
7257                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
7258                 }
7259                 ndr->depth--;
7260                 ndr->depth--;
7261         }
7262         if (flags & NDR_OUT) {
7263                 ndr_print_struct(ndr, "out", "wkssvc_NetrUseEnum");
7264                 ndr->depth++;
7265                 ndr_print_ptr(ndr, "info", r->out.info);
7266                 ndr->depth++;
7267                 ndr_print_wkssvc_NetrUseEnumInfo(ndr, "info", r->out.info);
7268                 ndr->depth--;
7269                 ndr_print_ptr(ndr, "entries_read", r->out.entries_read);
7270                 ndr->depth++;
7271                 ndr_print_uint32(ndr, "entries_read", *r->out.entries_read);
7272                 ndr->depth--;
7273                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
7274                 ndr->depth++;
7275                 if (r->out.resume_handle) {
7276                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
7277                 }
7278                 ndr->depth--;
7279                 ndr_print_WERROR(ndr, "result", r->out.result);
7280                 ndr->depth--;
7281         }
7282         ndr->depth--;
7283 }
7284
7285 static enum ndr_err_code ndr_push_wkssvc_NetrMessageBufferSend(struct ndr_push *ndr, int flags, const struct wkssvc_NetrMessageBufferSend *r)
7286 {
7287         if (flags & NDR_IN) {
7288                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
7289                 if (r->in.server_name) {
7290                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7291                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7292                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7293                         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));
7294                 }
7295                 if (r->in.message_name == NULL) {
7296                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7297                 }
7298                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.message_name, CH_UTF16)));
7299                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7300                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.message_name, CH_UTF16)));
7301                 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));
7302                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.message_sender_name));
7303                 if (r->in.message_sender_name) {
7304                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.message_sender_name, CH_UTF16)));
7305                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7306                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.message_sender_name, CH_UTF16)));
7307                         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));
7308                 }
7309                 if (r->in.message_buffer == NULL) {
7310                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7311                 }
7312                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.message_size));
7313                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.message_buffer, r->in.message_size));
7314                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.message_size));
7315         }
7316         if (flags & NDR_OUT) {
7317                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7318         }
7319         return NDR_ERR_SUCCESS;
7320 }
7321
7322 static enum ndr_err_code ndr_pull_wkssvc_NetrMessageBufferSend(struct ndr_pull *ndr, int flags, struct wkssvc_NetrMessageBufferSend *r)
7323 {
7324         uint32_t _ptr_server_name;
7325         uint32_t _ptr_message_sender_name;
7326         TALLOC_CTX *_mem_save_server_name_0;
7327         TALLOC_CTX *_mem_save_message_sender_name_0;
7328         if (flags & NDR_IN) {
7329                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
7330                 if (_ptr_server_name) {
7331                         NDR_PULL_ALLOC(ndr, r->in.server_name);
7332                 } else {
7333                         r->in.server_name = NULL;
7334                 }
7335                 if (r->in.server_name) {
7336                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7337                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
7338                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
7339                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
7340                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
7341                                 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));
7342                         }
7343                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
7344                         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));
7345                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
7346                 }
7347                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.message_name));
7348                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.message_name));
7349                 if (ndr_get_array_length(ndr, &r->in.message_name) > ndr_get_array_size(ndr, &r->in.message_name)) {
7350                         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));
7351                 }
7352                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.message_name), sizeof(uint16_t)));
7353                 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));
7354                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_message_sender_name));
7355                 if (_ptr_message_sender_name) {
7356                         NDR_PULL_ALLOC(ndr, r->in.message_sender_name);
7357                 } else {
7358                         r->in.message_sender_name = NULL;
7359                 }
7360                 if (r->in.message_sender_name) {
7361                         _mem_save_message_sender_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7362                         NDR_PULL_SET_MEM_CTX(ndr, r->in.message_sender_name, 0);
7363                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.message_sender_name));
7364                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.message_sender_name));
7365                         if (ndr_get_array_length(ndr, &r->in.message_sender_name) > ndr_get_array_size(ndr, &r->in.message_sender_name)) {
7366                                 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));
7367                         }
7368                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.message_sender_name), sizeof(uint16_t)));
7369                         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));
7370                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_message_sender_name_0, 0);
7371                 }
7372                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.message_buffer));
7373                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7374                         NDR_PULL_ALLOC_N(ndr, r->in.message_buffer, ndr_get_array_size(ndr, &r->in.message_buffer));
7375                 }
7376                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.message_buffer, ndr_get_array_size(ndr, &r->in.message_buffer)));
7377                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.message_size));
7378                 if (r->in.message_buffer) {
7379                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.message_buffer, r->in.message_size));
7380                 }
7381         }
7382         if (flags & NDR_OUT) {
7383                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7384         }
7385         return NDR_ERR_SUCCESS;
7386 }
7387
7388 _PUBLIC_ void ndr_print_wkssvc_NetrMessageBufferSend(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrMessageBufferSend *r)
7389 {
7390         ndr_print_struct(ndr, name, "wkssvc_NetrMessageBufferSend");
7391         ndr->depth++;
7392         if (flags & NDR_SET_VALUES) {
7393                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7394         }
7395         if (flags & NDR_IN) {
7396                 ndr_print_struct(ndr, "in", "wkssvc_NetrMessageBufferSend");
7397                 ndr->depth++;
7398                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
7399                 ndr->depth++;
7400                 if (r->in.server_name) {
7401                         ndr_print_string(ndr, "server_name", r->in.server_name);
7402                 }
7403                 ndr->depth--;
7404                 ndr_print_ptr(ndr, "message_name", r->in.message_name);
7405                 ndr->depth++;
7406                 ndr_print_string(ndr, "message_name", r->in.message_name);
7407                 ndr->depth--;
7408                 ndr_print_ptr(ndr, "message_sender_name", r->in.message_sender_name);
7409                 ndr->depth++;
7410                 if (r->in.message_sender_name) {
7411                         ndr_print_string(ndr, "message_sender_name", r->in.message_sender_name);
7412                 }
7413                 ndr->depth--;
7414                 ndr_print_ptr(ndr, "message_buffer", r->in.message_buffer);
7415                 ndr->depth++;
7416                 ndr_print_array_uint8(ndr, "message_buffer", r->in.message_buffer, r->in.message_size);
7417                 ndr->depth--;
7418                 ndr_print_uint32(ndr, "message_size", r->in.message_size);
7419                 ndr->depth--;
7420         }
7421         if (flags & NDR_OUT) {
7422                 ndr_print_struct(ndr, "out", "wkssvc_NetrMessageBufferSend");
7423                 ndr->depth++;
7424                 ndr_print_WERROR(ndr, "result", r->out.result);
7425                 ndr->depth--;
7426         }
7427         ndr->depth--;
7428 }
7429
7430 static enum ndr_err_code ndr_push_wkssvc_NetrWorkstationStatisticsGet(struct ndr_push *ndr, int flags, const struct wkssvc_NetrWorkstationStatisticsGet *r)
7431 {
7432         if (flags & NDR_IN) {
7433                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
7434                 if (r->in.server_name) {
7435                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7436                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7437                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7438                         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));
7439                 }
7440                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown2));
7441                 if (r->in.unknown2) {
7442                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown2, CH_UTF16)));
7443                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7444                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown2, CH_UTF16)));
7445                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.unknown2, ndr_charset_length(r->in.unknown2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7446                 }
7447                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown3));
7448                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown4));
7449         }
7450         if (flags & NDR_OUT) {
7451                 if (r->out.info == NULL) {
7452                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7453                 }
7454                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
7455                 if (*r->out.info) {
7456                         NDR_CHECK(ndr_push_wkssvc_NetrWorkstationStatistics(ndr, NDR_SCALARS, *r->out.info));
7457                 }
7458                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7459         }
7460         return NDR_ERR_SUCCESS;
7461 }
7462
7463 static enum ndr_err_code ndr_pull_wkssvc_NetrWorkstationStatisticsGet(struct ndr_pull *ndr, int flags, struct wkssvc_NetrWorkstationStatisticsGet *r)
7464 {
7465         uint32_t _ptr_server_name;
7466         uint32_t _ptr_unknown2;
7467         uint32_t _ptr_info;
7468         TALLOC_CTX *_mem_save_server_name_0;
7469         TALLOC_CTX *_mem_save_unknown2_0;
7470         TALLOC_CTX *_mem_save_info_0;
7471         TALLOC_CTX *_mem_save_info_1;
7472         if (flags & NDR_IN) {
7473                 ZERO_STRUCT(r->out);
7474
7475                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
7476                 if (_ptr_server_name) {
7477                         NDR_PULL_ALLOC(ndr, r->in.server_name);
7478                 } else {
7479                         r->in.server_name = NULL;
7480                 }
7481                 if (r->in.server_name) {
7482                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7483                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
7484                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
7485                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
7486                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
7487                                 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));
7488                         }
7489                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
7490                         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));
7491                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
7492                 }
7493                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown2));
7494                 if (_ptr_unknown2) {
7495                         NDR_PULL_ALLOC(ndr, r->in.unknown2);
7496                 } else {
7497                         r->in.unknown2 = NULL;
7498                 }
7499                 if (r->in.unknown2) {
7500                         _mem_save_unknown2_0 = NDR_PULL_GET_MEM_CTX(ndr);
7501                         NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown2, 0);
7502                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.unknown2));
7503                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.unknown2));
7504                         if (ndr_get_array_length(ndr, &r->in.unknown2) > ndr_get_array_size(ndr, &r->in.unknown2)) {
7505                                 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));
7506                         }
7507                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.unknown2), sizeof(uint16_t)));
7508                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.unknown2, ndr_get_array_length(ndr, &r->in.unknown2), sizeof(uint16_t), CH_UTF16));
7509                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown2_0, 0);
7510                 }
7511                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown3));
7512                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown4));
7513                 NDR_PULL_ALLOC(ndr, r->out.info);
7514                 ZERO_STRUCTP(r->out.info);
7515         }
7516         if (flags & NDR_OUT) {
7517                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7518                         NDR_PULL_ALLOC(ndr, r->out.info);
7519                 }
7520                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
7521                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
7522                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
7523                 if (_ptr_info) {
7524                         NDR_PULL_ALLOC(ndr, *r->out.info);
7525                 } else {
7526                         *r->out.info = NULL;
7527                 }
7528                 if (*r->out.info) {
7529                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
7530                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
7531                         NDR_CHECK(ndr_pull_wkssvc_NetrWorkstationStatistics(ndr, NDR_SCALARS, *r->out.info));
7532                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
7533                 }
7534                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
7535                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7536         }
7537         return NDR_ERR_SUCCESS;
7538 }
7539
7540 _PUBLIC_ void ndr_print_wkssvc_NetrWorkstationStatisticsGet(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrWorkstationStatisticsGet *r)
7541 {
7542         ndr_print_struct(ndr, name, "wkssvc_NetrWorkstationStatisticsGet");
7543         ndr->depth++;
7544         if (flags & NDR_SET_VALUES) {
7545                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7546         }
7547         if (flags & NDR_IN) {
7548                 ndr_print_struct(ndr, "in", "wkssvc_NetrWorkstationStatisticsGet");
7549                 ndr->depth++;
7550                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
7551                 ndr->depth++;
7552                 if (r->in.server_name) {
7553                         ndr_print_string(ndr, "server_name", r->in.server_name);
7554                 }
7555                 ndr->depth--;
7556                 ndr_print_ptr(ndr, "unknown2", r->in.unknown2);
7557                 ndr->depth++;
7558                 if (r->in.unknown2) {
7559                         ndr_print_string(ndr, "unknown2", r->in.unknown2);
7560                 }
7561                 ndr->depth--;
7562                 ndr_print_uint32(ndr, "unknown3", r->in.unknown3);
7563                 ndr_print_uint32(ndr, "unknown4", r->in.unknown4);
7564                 ndr->depth--;
7565         }
7566         if (flags & NDR_OUT) {
7567                 ndr_print_struct(ndr, "out", "wkssvc_NetrWorkstationStatisticsGet");
7568                 ndr->depth++;
7569                 ndr_print_ptr(ndr, "info", r->out.info);
7570                 ndr->depth++;
7571                 ndr_print_ptr(ndr, "info", *r->out.info);
7572                 ndr->depth++;
7573                 if (*r->out.info) {
7574                         ndr_print_wkssvc_NetrWorkstationStatistics(ndr, "info", *r->out.info);
7575                 }
7576                 ndr->depth--;
7577                 ndr->depth--;
7578                 ndr_print_WERROR(ndr, "result", r->out.result);
7579                 ndr->depth--;
7580         }
7581         ndr->depth--;
7582 }
7583
7584 static enum ndr_err_code ndr_push_wkssvc_NetrLogonDomainNameAdd(struct ndr_push *ndr, int flags, const struct wkssvc_NetrLogonDomainNameAdd *r)
7585 {
7586         if (flags & NDR_IN) {
7587                 if (r->in.domain_name == NULL) {
7588                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7589                 }
7590                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
7591                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7592                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
7593                 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));
7594         }
7595         if (flags & NDR_OUT) {
7596                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7597         }
7598         return NDR_ERR_SUCCESS;
7599 }
7600
7601 static enum ndr_err_code ndr_pull_wkssvc_NetrLogonDomainNameAdd(struct ndr_pull *ndr, int flags, struct wkssvc_NetrLogonDomainNameAdd *r)
7602 {
7603         if (flags & NDR_IN) {
7604                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
7605                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
7606                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
7607                         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));
7608                 }
7609                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
7610                 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));
7611         }
7612         if (flags & NDR_OUT) {
7613                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7614         }
7615         return NDR_ERR_SUCCESS;
7616 }
7617
7618 _PUBLIC_ void ndr_print_wkssvc_NetrLogonDomainNameAdd(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrLogonDomainNameAdd *r)
7619 {
7620         ndr_print_struct(ndr, name, "wkssvc_NetrLogonDomainNameAdd");
7621         ndr->depth++;
7622         if (flags & NDR_SET_VALUES) {
7623                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7624         }
7625         if (flags & NDR_IN) {
7626                 ndr_print_struct(ndr, "in", "wkssvc_NetrLogonDomainNameAdd");
7627                 ndr->depth++;
7628                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
7629                 ndr->depth++;
7630                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
7631                 ndr->depth--;
7632                 ndr->depth--;
7633         }
7634         if (flags & NDR_OUT) {
7635                 ndr_print_struct(ndr, "out", "wkssvc_NetrLogonDomainNameAdd");
7636                 ndr->depth++;
7637                 ndr_print_WERROR(ndr, "result", r->out.result);
7638                 ndr->depth--;
7639         }
7640         ndr->depth--;
7641 }
7642
7643 static enum ndr_err_code ndr_push_wkssvc_NetrLogonDomainNameDel(struct ndr_push *ndr, int flags, const struct wkssvc_NetrLogonDomainNameDel *r)
7644 {
7645         if (flags & NDR_IN) {
7646                 if (r->in.domain_name == NULL) {
7647                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7648                 }
7649                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
7650                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7651                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
7652                 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));
7653         }
7654         if (flags & NDR_OUT) {
7655                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7656         }
7657         return NDR_ERR_SUCCESS;
7658 }
7659
7660 static enum ndr_err_code ndr_pull_wkssvc_NetrLogonDomainNameDel(struct ndr_pull *ndr, int flags, struct wkssvc_NetrLogonDomainNameDel *r)
7661 {
7662         if (flags & NDR_IN) {
7663                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
7664                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
7665                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
7666                         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));
7667                 }
7668                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
7669                 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));
7670         }
7671         if (flags & NDR_OUT) {
7672                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7673         }
7674         return NDR_ERR_SUCCESS;
7675 }
7676
7677 _PUBLIC_ void ndr_print_wkssvc_NetrLogonDomainNameDel(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrLogonDomainNameDel *r)
7678 {
7679         ndr_print_struct(ndr, name, "wkssvc_NetrLogonDomainNameDel");
7680         ndr->depth++;
7681         if (flags & NDR_SET_VALUES) {
7682                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7683         }
7684         if (flags & NDR_IN) {
7685                 ndr_print_struct(ndr, "in", "wkssvc_NetrLogonDomainNameDel");
7686                 ndr->depth++;
7687                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
7688                 ndr->depth++;
7689                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
7690                 ndr->depth--;
7691                 ndr->depth--;
7692         }
7693         if (flags & NDR_OUT) {
7694                 ndr_print_struct(ndr, "out", "wkssvc_NetrLogonDomainNameDel");
7695                 ndr->depth++;
7696                 ndr_print_WERROR(ndr, "result", r->out.result);
7697                 ndr->depth--;
7698         }
7699         ndr->depth--;
7700 }
7701
7702 static enum ndr_err_code ndr_push_wkssvc_NetrJoinDomain(struct ndr_push *ndr, int flags, const struct wkssvc_NetrJoinDomain *r)
7703 {
7704         if (flags & NDR_IN) {
7705                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
7706                 if (r->in.server_name) {
7707                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7708                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7709                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7710                         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));
7711                 }
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_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
7716                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7717                 NDR_CHECK(ndr_push_uint32(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                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.account_ou));
7720                 if (r->in.account_ou) {
7721                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account_ou, CH_UTF16)));
7722                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7723                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account_ou, CH_UTF16)));
7724                         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));
7725                 }
7726                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
7727                 if (r->in.Account) {
7728                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
7729                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7730                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
7731                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7732                 }
7733                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
7734                 if (r->in.password) {
7735                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
7736                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7737                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
7738                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7739                 }
7740                 NDR_CHECK(ndr_push_wkssvc_joinflags(ndr, NDR_SCALARS, r->in.join_flags));
7741         }
7742         if (flags & NDR_OUT) {
7743                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7744         }
7745         return NDR_ERR_SUCCESS;
7746 }
7747
7748 static enum ndr_err_code ndr_pull_wkssvc_NetrJoinDomain(struct ndr_pull *ndr, int flags, struct wkssvc_NetrJoinDomain *r)
7749 {
7750         uint32_t _ptr_server_name;
7751         uint32_t _ptr_account_ou;
7752         uint32_t _ptr_Account;
7753         uint32_t _ptr_password;
7754         TALLOC_CTX *_mem_save_server_name_0;
7755         TALLOC_CTX *_mem_save_account_ou_0;
7756         TALLOC_CTX *_mem_save_Account_0;
7757         TALLOC_CTX *_mem_save_password_0;
7758         if (flags & NDR_IN) {
7759                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
7760                 if (_ptr_server_name) {
7761                         NDR_PULL_ALLOC(ndr, r->in.server_name);
7762                 } else {
7763                         r->in.server_name = NULL;
7764                 }
7765                 if (r->in.server_name) {
7766                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7767                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
7768                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
7769                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
7770                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
7771                                 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));
7772                         }
7773                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
7774                         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));
7775                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
7776                 }
7777                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
7778                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
7779                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
7780                         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));
7781                 }
7782                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
7783                 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));
7784                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account_ou));
7785                 if (_ptr_account_ou) {
7786                         NDR_PULL_ALLOC(ndr, r->in.account_ou);
7787                 } else {
7788                         r->in.account_ou = NULL;
7789                 }
7790                 if (r->in.account_ou) {
7791                         _mem_save_account_ou_0 = NDR_PULL_GET_MEM_CTX(ndr);
7792                         NDR_PULL_SET_MEM_CTX(ndr, r->in.account_ou, 0);
7793                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.account_ou));
7794                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.account_ou));
7795                         if (ndr_get_array_length(ndr, &r->in.account_ou) > ndr_get_array_size(ndr, &r->in.account_ou)) {
7796                                 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));
7797                         }
7798                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.account_ou), sizeof(uint16_t)));
7799                         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));
7800                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_ou_0, 0);
7801                 }
7802                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
7803                 if (_ptr_Account) {
7804                         NDR_PULL_ALLOC(ndr, r->in.Account);
7805                 } else {
7806                         r->in.Account = NULL;
7807                 }
7808                 if (r->in.Account) {
7809                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
7810                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
7811                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
7812                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
7813                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
7814                                 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));
7815                         }
7816                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
7817                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
7818                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
7819                 }
7820                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
7821                 if (_ptr_password) {
7822                         NDR_PULL_ALLOC(ndr, r->in.password);
7823                 } else {
7824                         r->in.password = NULL;
7825                 }
7826                 if (r->in.password) {
7827                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
7828                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
7829                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.password));
7830                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.password));
7831                         if (ndr_get_array_length(ndr, &r->in.password) > ndr_get_array_size(ndr, &r->in.password)) {
7832                                 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));
7833                         }
7834                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t)));
7835                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.password, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t), CH_UTF16));
7836                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
7837                 }
7838                 NDR_CHECK(ndr_pull_wkssvc_joinflags(ndr, NDR_SCALARS, &r->in.join_flags));
7839         }
7840         if (flags & NDR_OUT) {
7841                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7842         }
7843         return NDR_ERR_SUCCESS;
7844 }
7845
7846 _PUBLIC_ void ndr_print_wkssvc_NetrJoinDomain(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrJoinDomain *r)
7847 {
7848         ndr_print_struct(ndr, name, "wkssvc_NetrJoinDomain");
7849         ndr->depth++;
7850         if (flags & NDR_SET_VALUES) {
7851                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7852         }
7853         if (flags & NDR_IN) {
7854                 ndr_print_struct(ndr, "in", "wkssvc_NetrJoinDomain");
7855                 ndr->depth++;
7856                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
7857                 ndr->depth++;
7858                 if (r->in.server_name) {
7859                         ndr_print_string(ndr, "server_name", r->in.server_name);
7860                 }
7861                 ndr->depth--;
7862                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
7863                 ndr->depth++;
7864                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
7865                 ndr->depth--;
7866                 ndr_print_ptr(ndr, "account_ou", r->in.account_ou);
7867                 ndr->depth++;
7868                 if (r->in.account_ou) {
7869                         ndr_print_string(ndr, "account_ou", r->in.account_ou);
7870                 }
7871                 ndr->depth--;
7872                 ndr_print_ptr(ndr, "Account", r->in.Account);
7873                 ndr->depth++;
7874                 if (r->in.Account) {
7875                         ndr_print_string(ndr, "Account", r->in.Account);
7876                 }
7877                 ndr->depth--;
7878                 ndr_print_ptr(ndr, "password", r->in.password);
7879                 ndr->depth++;
7880                 if (r->in.password) {
7881                         ndr_print_string(ndr, "password", r->in.password);
7882                 }
7883                 ndr->depth--;
7884                 ndr_print_wkssvc_joinflags(ndr, "join_flags", r->in.join_flags);
7885                 ndr->depth--;
7886         }
7887         if (flags & NDR_OUT) {
7888                 ndr_print_struct(ndr, "out", "wkssvc_NetrJoinDomain");
7889                 ndr->depth++;
7890                 ndr_print_WERROR(ndr, "result", r->out.result);
7891                 ndr->depth--;
7892         }
7893         ndr->depth--;
7894 }
7895
7896 static enum ndr_err_code ndr_push_wkssvc_NetrUnjoinDomain(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUnjoinDomain *r)
7897 {
7898         if (flags & NDR_IN) {
7899                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
7900                 if (r->in.server_name) {
7901                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7902                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7903                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7904                         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));
7905                 }
7906                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
7907                 if (r->in.Account) {
7908                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
7909                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7910                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
7911                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7912                 }
7913                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
7914                 if (r->in.password) {
7915                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
7916                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7917                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
7918                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7919                 }
7920                 NDR_CHECK(ndr_push_wkssvc_joinflags(ndr, NDR_SCALARS, r->in.unjoin_flags));
7921         }
7922         if (flags & NDR_OUT) {
7923                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7924         }
7925         return NDR_ERR_SUCCESS;
7926 }
7927
7928 static enum ndr_err_code ndr_pull_wkssvc_NetrUnjoinDomain(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUnjoinDomain *r)
7929 {
7930         uint32_t _ptr_server_name;
7931         uint32_t _ptr_Account;
7932         uint32_t _ptr_password;
7933         TALLOC_CTX *_mem_save_server_name_0;
7934         TALLOC_CTX *_mem_save_Account_0;
7935         TALLOC_CTX *_mem_save_password_0;
7936         if (flags & NDR_IN) {
7937                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
7938                 if (_ptr_server_name) {
7939                         NDR_PULL_ALLOC(ndr, r->in.server_name);
7940                 } else {
7941                         r->in.server_name = NULL;
7942                 }
7943                 if (r->in.server_name) {
7944                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7945                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
7946                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
7947                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
7948                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
7949                                 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));
7950                         }
7951                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
7952                         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));
7953                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
7954                 }
7955                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
7956                 if (_ptr_Account) {
7957                         NDR_PULL_ALLOC(ndr, r->in.Account);
7958                 } else {
7959                         r->in.Account = NULL;
7960                 }
7961                 if (r->in.Account) {
7962                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
7963                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
7964                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
7965                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
7966                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
7967                                 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));
7968                         }
7969                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
7970                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
7971                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
7972                 }
7973                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
7974                 if (_ptr_password) {
7975                         NDR_PULL_ALLOC(ndr, r->in.password);
7976                 } else {
7977                         r->in.password = NULL;
7978                 }
7979                 if (r->in.password) {
7980                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
7981                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
7982                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.password));
7983                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.password));
7984                         if (ndr_get_array_length(ndr, &r->in.password) > ndr_get_array_size(ndr, &r->in.password)) {
7985                                 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));
7986                         }
7987                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t)));
7988                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.password, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t), CH_UTF16));
7989                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
7990                 }
7991                 NDR_CHECK(ndr_pull_wkssvc_joinflags(ndr, NDR_SCALARS, &r->in.unjoin_flags));
7992         }
7993         if (flags & NDR_OUT) {
7994                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7995         }
7996         return NDR_ERR_SUCCESS;
7997 }
7998
7999 _PUBLIC_ void ndr_print_wkssvc_NetrUnjoinDomain(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUnjoinDomain *r)
8000 {
8001         ndr_print_struct(ndr, name, "wkssvc_NetrUnjoinDomain");
8002         ndr->depth++;
8003         if (flags & NDR_SET_VALUES) {
8004                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8005         }
8006         if (flags & NDR_IN) {
8007                 ndr_print_struct(ndr, "in", "wkssvc_NetrUnjoinDomain");
8008                 ndr->depth++;
8009                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
8010                 ndr->depth++;
8011                 if (r->in.server_name) {
8012                         ndr_print_string(ndr, "server_name", r->in.server_name);
8013                 }
8014                 ndr->depth--;
8015                 ndr_print_ptr(ndr, "Account", r->in.Account);
8016                 ndr->depth++;
8017                 if (r->in.Account) {
8018                         ndr_print_string(ndr, "Account", r->in.Account);
8019                 }
8020                 ndr->depth--;
8021                 ndr_print_ptr(ndr, "password", r->in.password);
8022                 ndr->depth++;
8023                 if (r->in.password) {
8024                         ndr_print_string(ndr, "password", r->in.password);
8025                 }
8026                 ndr->depth--;
8027                 ndr_print_wkssvc_joinflags(ndr, "unjoin_flags", r->in.unjoin_flags);
8028                 ndr->depth--;
8029         }
8030         if (flags & NDR_OUT) {
8031                 ndr_print_struct(ndr, "out", "wkssvc_NetrUnjoinDomain");
8032                 ndr->depth++;
8033                 ndr_print_WERROR(ndr, "result", r->out.result);
8034                 ndr->depth--;
8035         }
8036         ndr->depth--;
8037 }
8038
8039 static enum ndr_err_code ndr_push_wkssvc_NetrRenameMachineInDomain(struct ndr_push *ndr, int flags, const struct wkssvc_NetrRenameMachineInDomain *r)
8040 {
8041         if (flags & NDR_IN) {
8042                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
8043                 if (r->in.server_name) {
8044                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8045                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8046                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8047                         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));
8048                 }
8049                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.NewMachineName));
8050                 if (r->in.NewMachineName) {
8051                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewMachineName, CH_UTF16)));
8052                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8053                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewMachineName, CH_UTF16)));
8054                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.NewMachineName, ndr_charset_length(r->in.NewMachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8055                 }
8056                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
8057                 if (r->in.Account) {
8058                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
8059                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8060                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
8061                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8062                 }
8063                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
8064                 if (r->in.password) {
8065                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
8066                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8067                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
8068                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8069                 }
8070                 NDR_CHECK(ndr_push_wkssvc_renameflags(ndr, NDR_SCALARS, r->in.RenameOptions));
8071         }
8072         if (flags & NDR_OUT) {
8073                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
8074         }
8075         return NDR_ERR_SUCCESS;
8076 }
8077
8078 static enum ndr_err_code ndr_pull_wkssvc_NetrRenameMachineInDomain(struct ndr_pull *ndr, int flags, struct wkssvc_NetrRenameMachineInDomain *r)
8079 {
8080         uint32_t _ptr_server_name;
8081         uint32_t _ptr_NewMachineName;
8082         uint32_t _ptr_Account;
8083         uint32_t _ptr_password;
8084         TALLOC_CTX *_mem_save_server_name_0;
8085         TALLOC_CTX *_mem_save_NewMachineName_0;
8086         TALLOC_CTX *_mem_save_Account_0;
8087         TALLOC_CTX *_mem_save_password_0;
8088         if (flags & NDR_IN) {
8089                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
8090                 if (_ptr_server_name) {
8091                         NDR_PULL_ALLOC(ndr, r->in.server_name);
8092                 } else {
8093                         r->in.server_name = NULL;
8094                 }
8095                 if (r->in.server_name) {
8096                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8097                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
8098                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
8099                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
8100                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
8101                                 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));
8102                         }
8103                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
8104                         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));
8105                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
8106                 }
8107                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_NewMachineName));
8108                 if (_ptr_NewMachineName) {
8109                         NDR_PULL_ALLOC(ndr, r->in.NewMachineName);
8110                 } else {
8111                         r->in.NewMachineName = NULL;
8112                 }
8113                 if (r->in.NewMachineName) {
8114                         _mem_save_NewMachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);
8115                         NDR_PULL_SET_MEM_CTX(ndr, r->in.NewMachineName, 0);
8116                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.NewMachineName));
8117                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.NewMachineName));
8118                         if (ndr_get_array_length(ndr, &r->in.NewMachineName) > ndr_get_array_size(ndr, &r->in.NewMachineName)) {
8119                                 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));
8120                         }
8121                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.NewMachineName), sizeof(uint16_t)));
8122                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.NewMachineName, ndr_get_array_length(ndr, &r->in.NewMachineName), sizeof(uint16_t), CH_UTF16));
8123                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_NewMachineName_0, 0);
8124                 }
8125                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
8126                 if (_ptr_Account) {
8127                         NDR_PULL_ALLOC(ndr, r->in.Account);
8128                 } else {
8129                         r->in.Account = NULL;
8130                 }
8131                 if (r->in.Account) {
8132                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
8133                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
8134                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
8135                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
8136                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
8137                                 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));
8138                         }
8139                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
8140                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
8141                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
8142                 }
8143                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
8144                 if (_ptr_password) {
8145                         NDR_PULL_ALLOC(ndr, r->in.password);
8146                 } else {
8147                         r->in.password = NULL;
8148                 }
8149                 if (r->in.password) {
8150                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
8151                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
8152                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.password));
8153                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.password));
8154                         if (ndr_get_array_length(ndr, &r->in.password) > ndr_get_array_size(ndr, &r->in.password)) {
8155                                 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));
8156                         }
8157                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t)));
8158                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.password, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t), CH_UTF16));
8159                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
8160                 }
8161                 NDR_CHECK(ndr_pull_wkssvc_renameflags(ndr, NDR_SCALARS, &r->in.RenameOptions));
8162         }
8163         if (flags & NDR_OUT) {
8164                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
8165         }
8166         return NDR_ERR_SUCCESS;
8167 }
8168
8169 _PUBLIC_ void ndr_print_wkssvc_NetrRenameMachineInDomain(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrRenameMachineInDomain *r)
8170 {
8171         ndr_print_struct(ndr, name, "wkssvc_NetrRenameMachineInDomain");
8172         ndr->depth++;
8173         if (flags & NDR_SET_VALUES) {
8174                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8175         }
8176         if (flags & NDR_IN) {
8177                 ndr_print_struct(ndr, "in", "wkssvc_NetrRenameMachineInDomain");
8178                 ndr->depth++;
8179                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
8180                 ndr->depth++;
8181                 if (r->in.server_name) {
8182                         ndr_print_string(ndr, "server_name", r->in.server_name);
8183                 }
8184                 ndr->depth--;
8185                 ndr_print_ptr(ndr, "NewMachineName", r->in.NewMachineName);
8186                 ndr->depth++;
8187                 if (r->in.NewMachineName) {
8188                         ndr_print_string(ndr, "NewMachineName", r->in.NewMachineName);
8189                 }
8190                 ndr->depth--;
8191                 ndr_print_ptr(ndr, "Account", r->in.Account);
8192                 ndr->depth++;
8193                 if (r->in.Account) {
8194                         ndr_print_string(ndr, "Account", r->in.Account);
8195                 }
8196                 ndr->depth--;
8197                 ndr_print_ptr(ndr, "password", r->in.password);
8198                 ndr->depth++;
8199                 if (r->in.password) {
8200                         ndr_print_string(ndr, "password", r->in.password);
8201                 }
8202                 ndr->depth--;
8203                 ndr_print_wkssvc_renameflags(ndr, "RenameOptions", r->in.RenameOptions);
8204                 ndr->depth--;
8205         }
8206         if (flags & NDR_OUT) {
8207                 ndr_print_struct(ndr, "out", "wkssvc_NetrRenameMachineInDomain");
8208                 ndr->depth++;
8209                 ndr_print_WERROR(ndr, "result", r->out.result);
8210                 ndr->depth--;
8211         }
8212         ndr->depth--;
8213 }
8214
8215 static enum ndr_err_code ndr_push_wkssvc_NetrValidateName(struct ndr_push *ndr, int flags, const struct wkssvc_NetrValidateName *r)
8216 {
8217         if (flags & NDR_IN) {
8218                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
8219                 if (r->in.server_name) {
8220                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8221                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8222                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8223                         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));
8224                 }
8225                 if (r->in.name == NULL) {
8226                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8227                 }
8228                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF16)));
8229                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8230                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF16)));
8231                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.name, ndr_charset_length(r->in.name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8232                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
8233                 if (r->in.Account) {
8234                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
8235                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8236                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
8237                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8238                 }
8239                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Password));
8240                 if (r->in.Password) {
8241                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Password, CH_UTF16)));
8242                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8243                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Password, CH_UTF16)));
8244                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Password, ndr_charset_length(r->in.Password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8245                 }
8246                 NDR_CHECK(ndr_push_wkssvc_NetValidateNameType(ndr, NDR_SCALARS, r->in.name_type));
8247         }
8248         if (flags & NDR_OUT) {
8249                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
8250         }
8251         return NDR_ERR_SUCCESS;
8252 }
8253
8254 static enum ndr_err_code ndr_pull_wkssvc_NetrValidateName(struct ndr_pull *ndr, int flags, struct wkssvc_NetrValidateName *r)
8255 {
8256         uint32_t _ptr_server_name;
8257         uint32_t _ptr_Account;
8258         uint32_t _ptr_Password;
8259         TALLOC_CTX *_mem_save_server_name_0;
8260         TALLOC_CTX *_mem_save_Account_0;
8261         TALLOC_CTX *_mem_save_Password_0;
8262         if (flags & NDR_IN) {
8263                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
8264                 if (_ptr_server_name) {
8265                         NDR_PULL_ALLOC(ndr, r->in.server_name);
8266                 } else {
8267                         r->in.server_name = NULL;
8268                 }
8269                 if (r->in.server_name) {
8270                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8271                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
8272                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
8273                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
8274                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
8275                                 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));
8276                         }
8277                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
8278                         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));
8279                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
8280                 }
8281                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.name));
8282                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.name));
8283                 if (ndr_get_array_length(ndr, &r->in.name) > ndr_get_array_size(ndr, &r->in.name)) {
8284                         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));
8285                 }
8286                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.name), sizeof(uint16_t)));
8287                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.name, ndr_get_array_length(ndr, &r->in.name), sizeof(uint16_t), CH_UTF16));
8288                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
8289                 if (_ptr_Account) {
8290                         NDR_PULL_ALLOC(ndr, r->in.Account);
8291                 } else {
8292                         r->in.Account = NULL;
8293                 }
8294                 if (r->in.Account) {
8295                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
8296                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
8297                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
8298                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
8299                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
8300                                 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));
8301                         }
8302                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
8303                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
8304                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
8305                 }
8306                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Password));
8307                 if (_ptr_Password) {
8308                         NDR_PULL_ALLOC(ndr, r->in.Password);
8309                 } else {
8310                         r->in.Password = NULL;
8311                 }
8312                 if (r->in.Password) {
8313                         _mem_save_Password_0 = NDR_PULL_GET_MEM_CTX(ndr);
8314                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Password, 0);
8315                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Password));
8316                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Password));
8317                         if (ndr_get_array_length(ndr, &r->in.Password) > ndr_get_array_size(ndr, &r->in.Password)) {
8318                                 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));
8319                         }
8320                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Password), sizeof(uint16_t)));
8321                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Password, ndr_get_array_length(ndr, &r->in.Password), sizeof(uint16_t), CH_UTF16));
8322                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Password_0, 0);
8323                 }
8324                 NDR_CHECK(ndr_pull_wkssvc_NetValidateNameType(ndr, NDR_SCALARS, &r->in.name_type));
8325         }
8326         if (flags & NDR_OUT) {
8327                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
8328         }
8329         return NDR_ERR_SUCCESS;
8330 }
8331
8332 _PUBLIC_ void ndr_print_wkssvc_NetrValidateName(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrValidateName *r)
8333 {
8334         ndr_print_struct(ndr, name, "wkssvc_NetrValidateName");
8335         ndr->depth++;
8336         if (flags & NDR_SET_VALUES) {
8337                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8338         }
8339         if (flags & NDR_IN) {
8340                 ndr_print_struct(ndr, "in", "wkssvc_NetrValidateName");
8341                 ndr->depth++;
8342                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
8343                 ndr->depth++;
8344                 if (r->in.server_name) {
8345                         ndr_print_string(ndr, "server_name", r->in.server_name);
8346                 }
8347                 ndr->depth--;
8348                 ndr_print_ptr(ndr, "name", r->in.name);
8349                 ndr->depth++;
8350                 ndr_print_string(ndr, "name", r->in.name);
8351                 ndr->depth--;
8352                 ndr_print_ptr(ndr, "Account", r->in.Account);
8353                 ndr->depth++;
8354                 if (r->in.Account) {
8355                         ndr_print_string(ndr, "Account", r->in.Account);
8356                 }
8357                 ndr->depth--;
8358                 ndr_print_ptr(ndr, "Password", r->in.Password);
8359                 ndr->depth++;
8360                 if (r->in.Password) {
8361                         ndr_print_string(ndr, "Password", r->in.Password);
8362                 }
8363                 ndr->depth--;
8364                 ndr_print_wkssvc_NetValidateNameType(ndr, "name_type", r->in.name_type);
8365                 ndr->depth--;
8366         }
8367         if (flags & NDR_OUT) {
8368                 ndr_print_struct(ndr, "out", "wkssvc_NetrValidateName");
8369                 ndr->depth++;
8370                 ndr_print_WERROR(ndr, "result", r->out.result);
8371                 ndr->depth--;
8372         }
8373         ndr->depth--;
8374 }
8375
8376 static enum ndr_err_code ndr_push_wkssvc_NetrGetJoinInformation(struct ndr_push *ndr, int flags, const struct wkssvc_NetrGetJoinInformation *r)
8377 {
8378         if (flags & NDR_IN) {
8379                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
8380                 if (r->in.server_name) {
8381                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8382                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8383                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8384                         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));
8385                 }
8386                 if (r->in.name_buffer == NULL) {
8387                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8388                 }
8389                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->in.name_buffer));
8390                 if (*r->in.name_buffer) {
8391                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->in.name_buffer, CH_UTF16)));
8392                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8393                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->in.name_buffer, CH_UTF16)));
8394                         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));
8395                 }
8396         }
8397         if (flags & NDR_OUT) {
8398                 if (r->out.name_buffer == NULL) {
8399                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8400                 }
8401                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.name_buffer));
8402                 if (*r->out.name_buffer) {
8403                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.name_buffer, CH_UTF16)));
8404                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8405                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.name_buffer, CH_UTF16)));
8406                         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));
8407                 }
8408                 if (r->out.name_type == NULL) {
8409                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8410                 }
8411                 NDR_CHECK(ndr_push_wkssvc_NetJoinStatus(ndr, NDR_SCALARS, *r->out.name_type));
8412                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
8413         }
8414         return NDR_ERR_SUCCESS;
8415 }
8416
8417 static enum ndr_err_code ndr_pull_wkssvc_NetrGetJoinInformation(struct ndr_pull *ndr, int flags, struct wkssvc_NetrGetJoinInformation *r)
8418 {
8419         uint32_t _ptr_server_name;
8420         uint32_t _ptr_name_buffer;
8421         TALLOC_CTX *_mem_save_server_name_0;
8422         TALLOC_CTX *_mem_save_name_buffer_0;
8423         TALLOC_CTX *_mem_save_name_buffer_1;
8424         TALLOC_CTX *_mem_save_name_type_0;
8425         if (flags & NDR_IN) {
8426                 ZERO_STRUCT(r->out);
8427
8428                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
8429                 if (_ptr_server_name) {
8430                         NDR_PULL_ALLOC(ndr, r->in.server_name);
8431                 } else {
8432                         r->in.server_name = NULL;
8433                 }
8434                 if (r->in.server_name) {
8435                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8436                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
8437                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
8438                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
8439                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
8440                                 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));
8441                         }
8442                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
8443                         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));
8444                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
8445                 }
8446                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8447                         NDR_PULL_ALLOC(ndr, r->in.name_buffer);
8448                 }
8449                 _mem_save_name_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
8450                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name_buffer, LIBNDR_FLAG_REF_ALLOC);
8451                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_buffer));
8452                 if (_ptr_name_buffer) {
8453                         NDR_PULL_ALLOC(ndr, *r->in.name_buffer);
8454                 } else {
8455                         *r->in.name_buffer = NULL;
8456                 }
8457                 if (*r->in.name_buffer) {
8458                         _mem_save_name_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
8459                         NDR_PULL_SET_MEM_CTX(ndr, *r->in.name_buffer, 0);
8460                         NDR_CHECK(ndr_pull_array_size(ndr, r->in.name_buffer));
8461                         NDR_CHECK(ndr_pull_array_length(ndr, r->in.name_buffer));
8462                         if (ndr_get_array_length(ndr, r->in.name_buffer) > ndr_get_array_size(ndr, r->in.name_buffer)) {
8463                                 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));
8464                         }
8465                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->in.name_buffer), sizeof(uint16_t)));
8466                         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));
8467                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_buffer_1, 0);
8468                 }
8469                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_buffer_0, LIBNDR_FLAG_REF_ALLOC);
8470                 NDR_PULL_ALLOC(ndr, r->out.name_buffer);
8471                 *r->out.name_buffer = *r->in.name_buffer;
8472                 NDR_PULL_ALLOC(ndr, r->out.name_type);
8473                 ZERO_STRUCTP(r->out.name_type);
8474         }
8475         if (flags & NDR_OUT) {
8476                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8477                         NDR_PULL_ALLOC(ndr, r->out.name_buffer);
8478                 }
8479                 _mem_save_name_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
8480                 NDR_PULL_SET_MEM_CTX(ndr, r->out.name_buffer, LIBNDR_FLAG_REF_ALLOC);
8481                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_buffer));
8482                 if (_ptr_name_buffer) {
8483                         NDR_PULL_ALLOC(ndr, *r->out.name_buffer);
8484                 } else {
8485                         *r->out.name_buffer = NULL;
8486                 }
8487                 if (*r->out.name_buffer) {
8488                         _mem_save_name_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
8489                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.name_buffer, 0);
8490                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.name_buffer));
8491                         NDR_CHECK(ndr_pull_array_length(ndr, r->out.name_buffer));
8492                         if (ndr_get_array_length(ndr, r->out.name_buffer) > ndr_get_array_size(ndr, r->out.name_buffer)) {
8493                                 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));
8494                         }
8495                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->out.name_buffer), sizeof(uint16_t)));
8496                         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));
8497                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_buffer_1, 0);
8498                 }
8499                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_buffer_0, LIBNDR_FLAG_REF_ALLOC);
8500                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8501                         NDR_PULL_ALLOC(ndr, r->out.name_type);
8502                 }
8503                 _mem_save_name_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
8504                 NDR_PULL_SET_MEM_CTX(ndr, r->out.name_type, LIBNDR_FLAG_REF_ALLOC);
8505                 NDR_CHECK(ndr_pull_wkssvc_NetJoinStatus(ndr, NDR_SCALARS, r->out.name_type));
8506                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_type_0, LIBNDR_FLAG_REF_ALLOC);
8507                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
8508         }
8509         return NDR_ERR_SUCCESS;
8510 }
8511
8512 _PUBLIC_ void ndr_print_wkssvc_NetrGetJoinInformation(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrGetJoinInformation *r)
8513 {
8514         ndr_print_struct(ndr, name, "wkssvc_NetrGetJoinInformation");
8515         ndr->depth++;
8516         if (flags & NDR_SET_VALUES) {
8517                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8518         }
8519         if (flags & NDR_IN) {
8520                 ndr_print_struct(ndr, "in", "wkssvc_NetrGetJoinInformation");
8521                 ndr->depth++;
8522                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
8523                 ndr->depth++;
8524                 if (r->in.server_name) {
8525                         ndr_print_string(ndr, "server_name", r->in.server_name);
8526                 }
8527                 ndr->depth--;
8528                 ndr_print_ptr(ndr, "name_buffer", r->in.name_buffer);
8529                 ndr->depth++;
8530                 ndr_print_ptr(ndr, "name_buffer", *r->in.name_buffer);
8531                 ndr->depth++;
8532                 if (*r->in.name_buffer) {
8533                         ndr_print_string(ndr, "name_buffer", *r->in.name_buffer);
8534                 }
8535                 ndr->depth--;
8536                 ndr->depth--;
8537                 ndr->depth--;
8538         }
8539         if (flags & NDR_OUT) {
8540                 ndr_print_struct(ndr, "out", "wkssvc_NetrGetJoinInformation");
8541                 ndr->depth++;
8542                 ndr_print_ptr(ndr, "name_buffer", r->out.name_buffer);
8543                 ndr->depth++;
8544                 ndr_print_ptr(ndr, "name_buffer", *r->out.name_buffer);
8545                 ndr->depth++;
8546                 if (*r->out.name_buffer) {
8547                         ndr_print_string(ndr, "name_buffer", *r->out.name_buffer);
8548                 }
8549                 ndr->depth--;
8550                 ndr->depth--;
8551                 ndr_print_ptr(ndr, "name_type", r->out.name_type);
8552                 ndr->depth++;
8553                 ndr_print_wkssvc_NetJoinStatus(ndr, "name_type", *r->out.name_type);
8554                 ndr->depth--;
8555                 ndr_print_WERROR(ndr, "result", r->out.result);
8556                 ndr->depth--;
8557         }
8558         ndr->depth--;
8559 }
8560
8561 static enum ndr_err_code ndr_push_wkssvc_NetrGetJoinableOus(struct ndr_push *ndr, int flags, const struct wkssvc_NetrGetJoinableOus *r)
8562 {
8563         uint32_t cntr_ous_2;
8564         if (flags & NDR_IN) {
8565                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
8566                 if (r->in.server_name) {
8567                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8568                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8569                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8570                         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));
8571                 }
8572                 if (r->in.domain_name == NULL) {
8573                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8574                 }
8575                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
8576                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8577                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
8578                 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));
8579                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
8580                 if (r->in.Account) {
8581                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
8582                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8583                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
8584                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8585                 }
8586                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown));
8587                 if (r->in.unknown) {
8588                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));
8589                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8590                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));
8591                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.unknown, ndr_charset_length(r->in.unknown, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8592                 }
8593                 if (r->in.num_ous == NULL) {
8594                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8595                 }
8596                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.num_ous));
8597         }
8598         if (flags & NDR_OUT) {
8599                 if (r->out.num_ous == NULL) {
8600                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8601                 }
8602                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_ous));
8603                 if (r->out.ous == NULL) {
8604                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8605                 }
8606                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.ous));
8607                 if (*r->out.ous) {
8608                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_ous));
8609                         for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {
8610                                 NDR_CHECK(ndr_push_unique_ptr(ndr, (*r->out.ous)[cntr_ous_2]));
8611                         }
8612                         for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {
8613                                 if ((*r->out.ous)[cntr_ous_2]) {
8614                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length((*r->out.ous)[cntr_ous_2], CH_UTF16)));
8615                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8616                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length((*r->out.ous)[cntr_ous_2], CH_UTF16)));
8617                                         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));
8618                                 }
8619                         }
8620                 }
8621                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
8622         }
8623         return NDR_ERR_SUCCESS;
8624 }
8625
8626 static enum ndr_err_code ndr_pull_wkssvc_NetrGetJoinableOus(struct ndr_pull *ndr, int flags, struct wkssvc_NetrGetJoinableOus *r)
8627 {
8628         uint32_t _ptr_server_name;
8629         uint32_t _ptr_Account;
8630         uint32_t _ptr_unknown;
8631         uint32_t _ptr_ous;
8632         uint32_t cntr_ous_2;
8633         TALLOC_CTX *_mem_save_server_name_0;
8634         TALLOC_CTX *_mem_save_Account_0;
8635         TALLOC_CTX *_mem_save_unknown_0;
8636         TALLOC_CTX *_mem_save_num_ous_0;
8637         TALLOC_CTX *_mem_save_ous_0;
8638         TALLOC_CTX *_mem_save_ous_1;
8639         TALLOC_CTX *_mem_save_ous_2;
8640         TALLOC_CTX *_mem_save_ous_3;
8641         if (flags & NDR_IN) {
8642                 ZERO_STRUCT(r->out);
8643
8644                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
8645                 if (_ptr_server_name) {
8646                         NDR_PULL_ALLOC(ndr, r->in.server_name);
8647                 } else {
8648                         r->in.server_name = NULL;
8649                 }
8650                 if (r->in.server_name) {
8651                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8652                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
8653                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
8654                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
8655                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
8656                                 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));
8657                         }
8658                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
8659                         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));
8660                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
8661                 }
8662                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
8663                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
8664                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
8665                         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));
8666                 }
8667                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
8668                 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));
8669                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
8670                 if (_ptr_Account) {
8671                         NDR_PULL_ALLOC(ndr, r->in.Account);
8672                 } else {
8673                         r->in.Account = NULL;
8674                 }
8675                 if (r->in.Account) {
8676                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
8677                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
8678                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
8679                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
8680                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
8681                                 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));
8682                         }
8683                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
8684                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
8685                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
8686                 }
8687                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown));
8688                 if (_ptr_unknown) {
8689                         NDR_PULL_ALLOC(ndr, r->in.unknown);
8690                 } else {
8691                         r->in.unknown = NULL;
8692                 }
8693                 if (r->in.unknown) {
8694                         _mem_save_unknown_0 = NDR_PULL_GET_MEM_CTX(ndr);
8695                         NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown, 0);
8696                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.unknown));
8697                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.unknown));
8698                         if (ndr_get_array_length(ndr, &r->in.unknown) > ndr_get_array_size(ndr, &r->in.unknown)) {
8699                                 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));
8700                         }
8701                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t)));
8702                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.unknown, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t), CH_UTF16));
8703                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown_0, 0);
8704                 }
8705                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8706                         NDR_PULL_ALLOC(ndr, r->in.num_ous);
8707                 }
8708                 _mem_save_num_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);
8709                 NDR_PULL_SET_MEM_CTX(ndr, r->in.num_ous, LIBNDR_FLAG_REF_ALLOC);
8710                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.num_ous));
8711                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_ous_0, LIBNDR_FLAG_REF_ALLOC);
8712                 NDR_PULL_ALLOC(ndr, r->out.num_ous);
8713                 *r->out.num_ous = *r->in.num_ous;
8714                 NDR_PULL_ALLOC(ndr, r->out.ous);
8715                 ZERO_STRUCTP(r->out.ous);
8716         }
8717         if (flags & NDR_OUT) {
8718                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8719                         NDR_PULL_ALLOC(ndr, r->out.num_ous);
8720                 }
8721                 _mem_save_num_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);
8722                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_ous, LIBNDR_FLAG_REF_ALLOC);
8723                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_ous));
8724                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_ous_0, LIBNDR_FLAG_REF_ALLOC);
8725                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8726                         NDR_PULL_ALLOC(ndr, r->out.ous);
8727                 }
8728                 _mem_save_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);
8729                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ous, LIBNDR_FLAG_REF_ALLOC);
8730                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ous));
8731                 if (_ptr_ous) {
8732                         NDR_PULL_ALLOC(ndr, *r->out.ous);
8733                 } else {
8734                         *r->out.ous = NULL;
8735                 }
8736                 if (*r->out.ous) {
8737                         _mem_save_ous_1 = NDR_PULL_GET_MEM_CTX(ndr);
8738                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.ous, 0);
8739                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.ous));
8740                         NDR_PULL_ALLOC_N(ndr, *r->out.ous, ndr_get_array_size(ndr, r->out.ous));
8741                         _mem_save_ous_2 = NDR_PULL_GET_MEM_CTX(ndr);
8742                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.ous, 0);
8743                         for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {
8744                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ous));
8745                                 if (_ptr_ous) {
8746                                         NDR_PULL_ALLOC(ndr, (*r->out.ous)[cntr_ous_2]);
8747                                 } else {
8748                                         (*r->out.ous)[cntr_ous_2] = NULL;
8749                                 }
8750                         }
8751                         for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {
8752                                 if ((*r->out.ous)[cntr_ous_2]) {
8753                                         _mem_save_ous_3 = NDR_PULL_GET_MEM_CTX(ndr);
8754                                         NDR_PULL_SET_MEM_CTX(ndr, (*r->out.ous)[cntr_ous_2], 0);
8755                                         NDR_CHECK(ndr_pull_array_size(ndr, &(*r->out.ous)[cntr_ous_2]));
8756                                         NDR_CHECK(ndr_pull_array_length(ndr, &(*r->out.ous)[cntr_ous_2]));
8757                                         if (ndr_get_array_length(ndr, &(*r->out.ous)[cntr_ous_2]) > ndr_get_array_size(ndr, &(*r->out.ous)[cntr_ous_2])) {
8758                                                 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]));
8759                                         }
8760                                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &(*r->out.ous)[cntr_ous_2]), sizeof(uint16_t)));
8761                                         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));
8762                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_3, 0);
8763                                 }
8764                         }
8765                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_2, 0);
8766                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_1, 0);
8767                 }
8768                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_0, LIBNDR_FLAG_REF_ALLOC);
8769                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
8770                 if (*r->out.ous) {
8771                         NDR_CHECK(ndr_check_array_size(ndr, (void*)r->out.ous, *r->out.num_ous));
8772                 }
8773         }
8774         return NDR_ERR_SUCCESS;
8775 }
8776
8777 _PUBLIC_ void ndr_print_wkssvc_NetrGetJoinableOus(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrGetJoinableOus *r)
8778 {
8779         uint32_t cntr_ous_2;
8780         ndr_print_struct(ndr, name, "wkssvc_NetrGetJoinableOus");
8781         ndr->depth++;
8782         if (flags & NDR_SET_VALUES) {
8783                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8784         }
8785         if (flags & NDR_IN) {
8786                 ndr_print_struct(ndr, "in", "wkssvc_NetrGetJoinableOus");
8787                 ndr->depth++;
8788                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
8789                 ndr->depth++;
8790                 if (r->in.server_name) {
8791                         ndr_print_string(ndr, "server_name", r->in.server_name);
8792                 }
8793                 ndr->depth--;
8794                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
8795                 ndr->depth++;
8796                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
8797                 ndr->depth--;
8798                 ndr_print_ptr(ndr, "Account", r->in.Account);
8799                 ndr->depth++;
8800                 if (r->in.Account) {
8801                         ndr_print_string(ndr, "Account", r->in.Account);
8802                 }
8803                 ndr->depth--;
8804                 ndr_print_ptr(ndr, "unknown", r->in.unknown);
8805                 ndr->depth++;
8806                 if (r->in.unknown) {
8807                         ndr_print_string(ndr, "unknown", r->in.unknown);
8808                 }
8809                 ndr->depth--;
8810                 ndr_print_ptr(ndr, "num_ous", r->in.num_ous);
8811                 ndr->depth++;
8812                 ndr_print_uint32(ndr, "num_ous", *r->in.num_ous);
8813                 ndr->depth--;
8814                 ndr->depth--;
8815         }
8816         if (flags & NDR_OUT) {
8817                 ndr_print_struct(ndr, "out", "wkssvc_NetrGetJoinableOus");
8818                 ndr->depth++;
8819                 ndr_print_ptr(ndr, "num_ous", r->out.num_ous);
8820                 ndr->depth++;
8821                 ndr_print_uint32(ndr, "num_ous", *r->out.num_ous);
8822                 ndr->depth--;
8823                 ndr_print_ptr(ndr, "ous", r->out.ous);
8824                 ndr->depth++;
8825                 ndr_print_ptr(ndr, "ous", *r->out.ous);
8826                 ndr->depth++;
8827                 if (*r->out.ous) {
8828                         ndr->print(ndr, "%s: ARRAY(%d)", "ous", (int)*r->out.num_ous);
8829                         ndr->depth++;
8830                         for (cntr_ous_2=0;cntr_ous_2<*r->out.num_ous;cntr_ous_2++) {
8831                                 char *idx_2=NULL;
8832                                 if (asprintf(&idx_2, "[%d]", cntr_ous_2) != -1) {
8833                                         ndr_print_ptr(ndr, "ous", (*r->out.ous)[cntr_ous_2]);
8834                                         ndr->depth++;
8835                                         if ((*r->out.ous)[cntr_ous_2]) {
8836                                                 ndr_print_string(ndr, "ous", (*r->out.ous)[cntr_ous_2]);
8837                                         }
8838                                         ndr->depth--;
8839                                         free(idx_2);
8840                                 }
8841                         }
8842                         ndr->depth--;
8843                 }
8844                 ndr->depth--;
8845                 ndr->depth--;
8846                 ndr_print_WERROR(ndr, "result", r->out.result);
8847                 ndr->depth--;
8848         }
8849         ndr->depth--;
8850 }
8851
8852 static enum ndr_err_code ndr_push_wkssvc_NetrJoinDomain2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrJoinDomain2 *r)
8853 {
8854         if (flags & NDR_IN) {
8855                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
8856                 if (r->in.server_name) {
8857                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8858                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8859                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8860                         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));
8861                 }
8862                 if (r->in.domain_name == NULL) {
8863                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8864                 }
8865                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
8866                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8867                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
8868                 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));
8869                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.account_ou));
8870                 if (r->in.account_ou) {
8871                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account_ou, CH_UTF16)));
8872                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8873                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account_ou, CH_UTF16)));
8874                         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));
8875                 }
8876                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.admin_account));
8877                 if (r->in.admin_account) {
8878                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.admin_account, CH_UTF16)));
8879                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8880                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.admin_account, CH_UTF16)));
8881                         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));
8882                 }
8883                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.encrypted_password));
8884                 if (r->in.encrypted_password) {
8885                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));
8886                 }
8887                 NDR_CHECK(ndr_push_wkssvc_joinflags(ndr, NDR_SCALARS, r->in.join_flags));
8888         }
8889         if (flags & NDR_OUT) {
8890                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
8891         }
8892         return NDR_ERR_SUCCESS;
8893 }
8894
8895 static enum ndr_err_code ndr_pull_wkssvc_NetrJoinDomain2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrJoinDomain2 *r)
8896 {
8897         uint32_t _ptr_server_name;
8898         uint32_t _ptr_account_ou;
8899         uint32_t _ptr_admin_account;
8900         uint32_t _ptr_encrypted_password;
8901         TALLOC_CTX *_mem_save_server_name_0;
8902         TALLOC_CTX *_mem_save_account_ou_0;
8903         TALLOC_CTX *_mem_save_admin_account_0;
8904         TALLOC_CTX *_mem_save_encrypted_password_0;
8905         if (flags & NDR_IN) {
8906                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
8907                 if (_ptr_server_name) {
8908                         NDR_PULL_ALLOC(ndr, r->in.server_name);
8909                 } else {
8910                         r->in.server_name = NULL;
8911                 }
8912                 if (r->in.server_name) {
8913                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8914                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
8915                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
8916                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
8917                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
8918                                 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));
8919                         }
8920                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
8921                         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));
8922                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
8923                 }
8924                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
8925                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
8926                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
8927                         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));
8928                 }
8929                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
8930                 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));
8931                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account_ou));
8932                 if (_ptr_account_ou) {
8933                         NDR_PULL_ALLOC(ndr, r->in.account_ou);
8934                 } else {
8935                         r->in.account_ou = NULL;
8936                 }
8937                 if (r->in.account_ou) {
8938                         _mem_save_account_ou_0 = NDR_PULL_GET_MEM_CTX(ndr);
8939                         NDR_PULL_SET_MEM_CTX(ndr, r->in.account_ou, 0);
8940                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.account_ou));
8941                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.account_ou));
8942                         if (ndr_get_array_length(ndr, &r->in.account_ou) > ndr_get_array_size(ndr, &r->in.account_ou)) {
8943                                 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));
8944                         }
8945                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.account_ou), sizeof(uint16_t)));
8946                         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));
8947                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_ou_0, 0);
8948                 }
8949                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_admin_account));
8950                 if (_ptr_admin_account) {
8951                         NDR_PULL_ALLOC(ndr, r->in.admin_account);
8952                 } else {
8953                         r->in.admin_account = NULL;
8954                 }
8955                 if (r->in.admin_account) {
8956                         _mem_save_admin_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
8957                         NDR_PULL_SET_MEM_CTX(ndr, r->in.admin_account, 0);
8958                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.admin_account));
8959                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.admin_account));
8960                         if (ndr_get_array_length(ndr, &r->in.admin_account) > ndr_get_array_size(ndr, &r->in.admin_account)) {
8961                                 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));
8962                         }
8963                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.admin_account), sizeof(uint16_t)));
8964                         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));
8965                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_admin_account_0, 0);
8966                 }
8967                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_encrypted_password));
8968                 if (_ptr_encrypted_password) {
8969                         NDR_PULL_ALLOC(ndr, r->in.encrypted_password);
8970                 } else {
8971                         r->in.encrypted_password = NULL;
8972                 }
8973                 if (r->in.encrypted_password) {
8974                         _mem_save_encrypted_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
8975                         NDR_PULL_SET_MEM_CTX(ndr, r->in.encrypted_password, 0);
8976                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));
8977                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_encrypted_password_0, 0);
8978                 }
8979                 NDR_CHECK(ndr_pull_wkssvc_joinflags(ndr, NDR_SCALARS, &r->in.join_flags));
8980         }
8981         if (flags & NDR_OUT) {
8982                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
8983         }
8984         return NDR_ERR_SUCCESS;
8985 }
8986
8987 _PUBLIC_ void ndr_print_wkssvc_NetrJoinDomain2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrJoinDomain2 *r)
8988 {
8989         ndr_print_struct(ndr, name, "wkssvc_NetrJoinDomain2");
8990         ndr->depth++;
8991         if (flags & NDR_SET_VALUES) {
8992                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8993         }
8994         if (flags & NDR_IN) {
8995                 ndr_print_struct(ndr, "in", "wkssvc_NetrJoinDomain2");
8996                 ndr->depth++;
8997                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
8998                 ndr->depth++;
8999                 if (r->in.server_name) {
9000                         ndr_print_string(ndr, "server_name", r->in.server_name);
9001                 }
9002                 ndr->depth--;
9003                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
9004                 ndr->depth++;
9005                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
9006                 ndr->depth--;
9007                 ndr_print_ptr(ndr, "account_ou", r->in.account_ou);
9008                 ndr->depth++;
9009                 if (r->in.account_ou) {
9010                         ndr_print_string(ndr, "account_ou", r->in.account_ou);
9011                 }
9012                 ndr->depth--;
9013                 ndr_print_ptr(ndr, "admin_account", r->in.admin_account);
9014                 ndr->depth++;
9015                 if (r->in.admin_account) {
9016                         ndr_print_string(ndr, "admin_account", r->in.admin_account);
9017                 }
9018                 ndr->depth--;
9019                 ndr_print_ptr(ndr, "encrypted_password", r->in.encrypted_password);
9020                 ndr->depth++;
9021                 if (r->in.encrypted_password) {
9022                         ndr_print_wkssvc_PasswordBuffer(ndr, "encrypted_password", r->in.encrypted_password);
9023                 }
9024                 ndr->depth--;
9025                 ndr_print_wkssvc_joinflags(ndr, "join_flags", r->in.join_flags);
9026                 ndr->depth--;
9027         }
9028         if (flags & NDR_OUT) {
9029                 ndr_print_struct(ndr, "out", "wkssvc_NetrJoinDomain2");
9030                 ndr->depth++;
9031                 ndr_print_WERROR(ndr, "result", r->out.result);
9032                 ndr->depth--;
9033         }
9034         ndr->depth--;
9035 }
9036
9037 static enum ndr_err_code ndr_push_wkssvc_NetrUnjoinDomain2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUnjoinDomain2 *r)
9038 {
9039         if (flags & NDR_IN) {
9040                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
9041                 if (r->in.server_name) {
9042                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9043                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9044                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9045                         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));
9046                 }
9047                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.account));
9048                 if (r->in.account) {
9049                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account, CH_UTF16)));
9050                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9051                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account, CH_UTF16)));
9052                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.account, ndr_charset_length(r->in.account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9053                 }
9054                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.encrypted_password));
9055                 if (r->in.encrypted_password) {
9056                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));
9057                 }
9058                 NDR_CHECK(ndr_push_wkssvc_joinflags(ndr, NDR_SCALARS, r->in.unjoin_flags));
9059         }
9060         if (flags & NDR_OUT) {
9061                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9062         }
9063         return NDR_ERR_SUCCESS;
9064 }
9065
9066 static enum ndr_err_code ndr_pull_wkssvc_NetrUnjoinDomain2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUnjoinDomain2 *r)
9067 {
9068         uint32_t _ptr_server_name;
9069         uint32_t _ptr_account;
9070         uint32_t _ptr_encrypted_password;
9071         TALLOC_CTX *_mem_save_server_name_0;
9072         TALLOC_CTX *_mem_save_account_0;
9073         TALLOC_CTX *_mem_save_encrypted_password_0;
9074         if (flags & NDR_IN) {
9075                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
9076                 if (_ptr_server_name) {
9077                         NDR_PULL_ALLOC(ndr, r->in.server_name);
9078                 } else {
9079                         r->in.server_name = NULL;
9080                 }
9081                 if (r->in.server_name) {
9082                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9083                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
9084                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
9085                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
9086                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
9087                                 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));
9088                         }
9089                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
9090                         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));
9091                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
9092                 }
9093                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account));
9094                 if (_ptr_account) {
9095                         NDR_PULL_ALLOC(ndr, r->in.account);
9096                 } else {
9097                         r->in.account = NULL;
9098                 }
9099                 if (r->in.account) {
9100                         _mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
9101                         NDR_PULL_SET_MEM_CTX(ndr, r->in.account, 0);
9102                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.account));
9103                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.account));
9104                         if (ndr_get_array_length(ndr, &r->in.account) > ndr_get_array_size(ndr, &r->in.account)) {
9105                                 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));
9106                         }
9107                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.account), sizeof(uint16_t)));
9108                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.account, ndr_get_array_length(ndr, &r->in.account), sizeof(uint16_t), CH_UTF16));
9109                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, 0);
9110                 }
9111                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_encrypted_password));
9112                 if (_ptr_encrypted_password) {
9113                         NDR_PULL_ALLOC(ndr, r->in.encrypted_password);
9114                 } else {
9115                         r->in.encrypted_password = NULL;
9116                 }
9117                 if (r->in.encrypted_password) {
9118                         _mem_save_encrypted_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
9119                         NDR_PULL_SET_MEM_CTX(ndr, r->in.encrypted_password, 0);
9120                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));
9121                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_encrypted_password_0, 0);
9122                 }
9123                 NDR_CHECK(ndr_pull_wkssvc_joinflags(ndr, NDR_SCALARS, &r->in.unjoin_flags));
9124         }
9125         if (flags & NDR_OUT) {
9126                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9127         }
9128         return NDR_ERR_SUCCESS;
9129 }
9130
9131 _PUBLIC_ void ndr_print_wkssvc_NetrUnjoinDomain2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUnjoinDomain2 *r)
9132 {
9133         ndr_print_struct(ndr, name, "wkssvc_NetrUnjoinDomain2");
9134         ndr->depth++;
9135         if (flags & NDR_SET_VALUES) {
9136                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9137         }
9138         if (flags & NDR_IN) {
9139                 ndr_print_struct(ndr, "in", "wkssvc_NetrUnjoinDomain2");
9140                 ndr->depth++;
9141                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
9142                 ndr->depth++;
9143                 if (r->in.server_name) {
9144                         ndr_print_string(ndr, "server_name", r->in.server_name);
9145                 }
9146                 ndr->depth--;
9147                 ndr_print_ptr(ndr, "account", r->in.account);
9148                 ndr->depth++;
9149                 if (r->in.account) {
9150                         ndr_print_string(ndr, "account", r->in.account);
9151                 }
9152                 ndr->depth--;
9153                 ndr_print_ptr(ndr, "encrypted_password", r->in.encrypted_password);
9154                 ndr->depth++;
9155                 if (r->in.encrypted_password) {
9156                         ndr_print_wkssvc_PasswordBuffer(ndr, "encrypted_password", r->in.encrypted_password);
9157                 }
9158                 ndr->depth--;
9159                 ndr_print_wkssvc_joinflags(ndr, "unjoin_flags", r->in.unjoin_flags);
9160                 ndr->depth--;
9161         }
9162         if (flags & NDR_OUT) {
9163                 ndr_print_struct(ndr, "out", "wkssvc_NetrUnjoinDomain2");
9164                 ndr->depth++;
9165                 ndr_print_WERROR(ndr, "result", r->out.result);
9166                 ndr->depth--;
9167         }
9168         ndr->depth--;
9169 }
9170
9171 static enum ndr_err_code ndr_push_wkssvc_NetrRenameMachineInDomain2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrRenameMachineInDomain2 *r)
9172 {
9173         if (flags & NDR_IN) {
9174                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
9175                 if (r->in.server_name) {
9176                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9177                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9178                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9179                         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));
9180                 }
9181                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.NewMachineName));
9182                 if (r->in.NewMachineName) {
9183                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewMachineName, CH_UTF16)));
9184                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9185                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewMachineName, CH_UTF16)));
9186                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.NewMachineName, ndr_charset_length(r->in.NewMachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9187                 }
9188                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
9189                 if (r->in.Account) {
9190                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9191                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9192                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9193                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9194                 }
9195                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
9196                 if (r->in.EncryptedPassword) {
9197                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9198                 }
9199                 NDR_CHECK(ndr_push_wkssvc_renameflags(ndr, NDR_SCALARS, r->in.RenameOptions));
9200         }
9201         if (flags & NDR_OUT) {
9202                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9203         }
9204         return NDR_ERR_SUCCESS;
9205 }
9206
9207 static enum ndr_err_code ndr_pull_wkssvc_NetrRenameMachineInDomain2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrRenameMachineInDomain2 *r)
9208 {
9209         uint32_t _ptr_server_name;
9210         uint32_t _ptr_NewMachineName;
9211         uint32_t _ptr_Account;
9212         uint32_t _ptr_EncryptedPassword;
9213         TALLOC_CTX *_mem_save_server_name_0;
9214         TALLOC_CTX *_mem_save_NewMachineName_0;
9215         TALLOC_CTX *_mem_save_Account_0;
9216         TALLOC_CTX *_mem_save_EncryptedPassword_0;
9217         if (flags & NDR_IN) {
9218                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
9219                 if (_ptr_server_name) {
9220                         NDR_PULL_ALLOC(ndr, r->in.server_name);
9221                 } else {
9222                         r->in.server_name = NULL;
9223                 }
9224                 if (r->in.server_name) {
9225                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9226                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
9227                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
9228                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
9229                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
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.server_name), ndr_get_array_length(ndr, &r->in.server_name));
9231                         }
9232                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
9233                         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));
9234                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
9235                 }
9236                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_NewMachineName));
9237                 if (_ptr_NewMachineName) {
9238                         NDR_PULL_ALLOC(ndr, r->in.NewMachineName);
9239                 } else {
9240                         r->in.NewMachineName = NULL;
9241                 }
9242                 if (r->in.NewMachineName) {
9243                         _mem_save_NewMachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);
9244                         NDR_PULL_SET_MEM_CTX(ndr, r->in.NewMachineName, 0);
9245                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.NewMachineName));
9246                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.NewMachineName));
9247                         if (ndr_get_array_length(ndr, &r->in.NewMachineName) > ndr_get_array_size(ndr, &r->in.NewMachineName)) {
9248                                 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));
9249                         }
9250                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.NewMachineName), sizeof(uint16_t)));
9251                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.NewMachineName, ndr_get_array_length(ndr, &r->in.NewMachineName), sizeof(uint16_t), CH_UTF16));
9252                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_NewMachineName_0, 0);
9253                 }
9254                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
9255                 if (_ptr_Account) {
9256                         NDR_PULL_ALLOC(ndr, r->in.Account);
9257                 } else {
9258                         r->in.Account = NULL;
9259                 }
9260                 if (r->in.Account) {
9261                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
9262                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
9263                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
9264                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
9265                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
9266                                 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));
9267                         }
9268                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
9269                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
9270                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
9271                 }
9272                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
9273                 if (_ptr_EncryptedPassword) {
9274                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
9275                 } else {
9276                         r->in.EncryptedPassword = NULL;
9277                 }
9278                 if (r->in.EncryptedPassword) {
9279                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
9280                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
9281                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9282                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
9283                 }
9284                 NDR_CHECK(ndr_pull_wkssvc_renameflags(ndr, NDR_SCALARS, &r->in.RenameOptions));
9285         }
9286         if (flags & NDR_OUT) {
9287                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9288         }
9289         return NDR_ERR_SUCCESS;
9290 }
9291
9292 _PUBLIC_ void ndr_print_wkssvc_NetrRenameMachineInDomain2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrRenameMachineInDomain2 *r)
9293 {
9294         ndr_print_struct(ndr, name, "wkssvc_NetrRenameMachineInDomain2");
9295         ndr->depth++;
9296         if (flags & NDR_SET_VALUES) {
9297                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9298         }
9299         if (flags & NDR_IN) {
9300                 ndr_print_struct(ndr, "in", "wkssvc_NetrRenameMachineInDomain2");
9301                 ndr->depth++;
9302                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
9303                 ndr->depth++;
9304                 if (r->in.server_name) {
9305                         ndr_print_string(ndr, "server_name", r->in.server_name);
9306                 }
9307                 ndr->depth--;
9308                 ndr_print_ptr(ndr, "NewMachineName", r->in.NewMachineName);
9309                 ndr->depth++;
9310                 if (r->in.NewMachineName) {
9311                         ndr_print_string(ndr, "NewMachineName", r->in.NewMachineName);
9312                 }
9313                 ndr->depth--;
9314                 ndr_print_ptr(ndr, "Account", r->in.Account);
9315                 ndr->depth++;
9316                 if (r->in.Account) {
9317                         ndr_print_string(ndr, "Account", r->in.Account);
9318                 }
9319                 ndr->depth--;
9320                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9321                 ndr->depth++;
9322                 if (r->in.EncryptedPassword) {
9323                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9324                 }
9325                 ndr->depth--;
9326                 ndr_print_wkssvc_renameflags(ndr, "RenameOptions", r->in.RenameOptions);
9327                 ndr->depth--;
9328         }
9329         if (flags & NDR_OUT) {
9330                 ndr_print_struct(ndr, "out", "wkssvc_NetrRenameMachineInDomain2");
9331                 ndr->depth++;
9332                 ndr_print_WERROR(ndr, "result", r->out.result);
9333                 ndr->depth--;
9334         }
9335         ndr->depth--;
9336 }
9337
9338 static enum ndr_err_code ndr_push_wkssvc_NetrValidateName2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrValidateName2 *r)
9339 {
9340         if (flags & NDR_IN) {
9341                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
9342                 if (r->in.server_name) {
9343                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9344                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9345                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9346                         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));
9347                 }
9348                 if (r->in.name == NULL) {
9349                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9350                 }
9351                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF16)));
9352                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9353                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF16)));
9354                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.name, ndr_charset_length(r->in.name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9355                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
9356                 if (r->in.Account) {
9357                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9358                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9359                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9360                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9361                 }
9362                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
9363                 if (r->in.EncryptedPassword) {
9364                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9365                 }
9366                 NDR_CHECK(ndr_push_wkssvc_NetValidateNameType(ndr, NDR_SCALARS, r->in.name_type));
9367         }
9368         if (flags & NDR_OUT) {
9369                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9370         }
9371         return NDR_ERR_SUCCESS;
9372 }
9373
9374 static enum ndr_err_code ndr_pull_wkssvc_NetrValidateName2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrValidateName2 *r)
9375 {
9376         uint32_t _ptr_server_name;
9377         uint32_t _ptr_Account;
9378         uint32_t _ptr_EncryptedPassword;
9379         TALLOC_CTX *_mem_save_server_name_0;
9380         TALLOC_CTX *_mem_save_Account_0;
9381         TALLOC_CTX *_mem_save_EncryptedPassword_0;
9382         if (flags & NDR_IN) {
9383                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
9384                 if (_ptr_server_name) {
9385                         NDR_PULL_ALLOC(ndr, r->in.server_name);
9386                 } else {
9387                         r->in.server_name = NULL;
9388                 }
9389                 if (r->in.server_name) {
9390                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9391                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
9392                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
9393                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
9394                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
9395                                 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));
9396                         }
9397                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
9398                         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));
9399                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
9400                 }
9401                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.name));
9402                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.name));
9403                 if (ndr_get_array_length(ndr, &r->in.name) > ndr_get_array_size(ndr, &r->in.name)) {
9404                         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));
9405                 }
9406                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.name), sizeof(uint16_t)));
9407                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.name, ndr_get_array_length(ndr, &r->in.name), sizeof(uint16_t), CH_UTF16));
9408                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
9409                 if (_ptr_Account) {
9410                         NDR_PULL_ALLOC(ndr, r->in.Account);
9411                 } else {
9412                         r->in.Account = NULL;
9413                 }
9414                 if (r->in.Account) {
9415                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
9416                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
9417                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
9418                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
9419                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
9420                                 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));
9421                         }
9422                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
9423                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
9424                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
9425                 }
9426                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
9427                 if (_ptr_EncryptedPassword) {
9428                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
9429                 } else {
9430                         r->in.EncryptedPassword = NULL;
9431                 }
9432                 if (r->in.EncryptedPassword) {
9433                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
9434                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
9435                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9436                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
9437                 }
9438                 NDR_CHECK(ndr_pull_wkssvc_NetValidateNameType(ndr, NDR_SCALARS, &r->in.name_type));
9439         }
9440         if (flags & NDR_OUT) {
9441                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9442         }
9443         return NDR_ERR_SUCCESS;
9444 }
9445
9446 _PUBLIC_ void ndr_print_wkssvc_NetrValidateName2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrValidateName2 *r)
9447 {
9448         ndr_print_struct(ndr, name, "wkssvc_NetrValidateName2");
9449         ndr->depth++;
9450         if (flags & NDR_SET_VALUES) {
9451                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9452         }
9453         if (flags & NDR_IN) {
9454                 ndr_print_struct(ndr, "in", "wkssvc_NetrValidateName2");
9455                 ndr->depth++;
9456                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
9457                 ndr->depth++;
9458                 if (r->in.server_name) {
9459                         ndr_print_string(ndr, "server_name", r->in.server_name);
9460                 }
9461                 ndr->depth--;
9462                 ndr_print_ptr(ndr, "name", r->in.name);
9463                 ndr->depth++;
9464                 ndr_print_string(ndr, "name", r->in.name);
9465                 ndr->depth--;
9466                 ndr_print_ptr(ndr, "Account", r->in.Account);
9467                 ndr->depth++;
9468                 if (r->in.Account) {
9469                         ndr_print_string(ndr, "Account", r->in.Account);
9470                 }
9471                 ndr->depth--;
9472                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9473                 ndr->depth++;
9474                 if (r->in.EncryptedPassword) {
9475                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9476                 }
9477                 ndr->depth--;
9478                 ndr_print_wkssvc_NetValidateNameType(ndr, "name_type", r->in.name_type);
9479                 ndr->depth--;
9480         }
9481         if (flags & NDR_OUT) {
9482                 ndr_print_struct(ndr, "out", "wkssvc_NetrValidateName2");
9483                 ndr->depth++;
9484                 ndr_print_WERROR(ndr, "result", r->out.result);
9485                 ndr->depth--;
9486         }
9487         ndr->depth--;
9488 }
9489
9490 static enum ndr_err_code ndr_push_wkssvc_NetrGetJoinableOus2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrGetJoinableOus2 *r)
9491 {
9492         uint32_t cntr_ous_2;
9493         if (flags & NDR_IN) {
9494                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
9495                 if (r->in.server_name) {
9496                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9497                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9498                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9499                         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));
9500                 }
9501                 if (r->in.domain_name == NULL) {
9502                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9503                 }
9504                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
9505                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9506                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
9507                 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));
9508                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
9509                 if (r->in.Account) {
9510                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9511                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9512                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9513                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9514                 }
9515                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
9516                 if (r->in.EncryptedPassword) {
9517                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9518                 }
9519                 if (r->in.num_ous == NULL) {
9520                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9521                 }
9522                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.num_ous));
9523         }
9524         if (flags & NDR_OUT) {
9525                 if (r->out.num_ous == NULL) {
9526                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9527                 }
9528                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_ous));
9529                 if (r->out.ous == NULL) {
9530                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9531                 }
9532                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.ous));
9533                 if (*r->out.ous) {
9534                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_ous));
9535                         for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {
9536                                 NDR_CHECK(ndr_push_unique_ptr(ndr, (*r->out.ous)[cntr_ous_2]));
9537                         }
9538                         for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {
9539                                 if ((*r->out.ous)[cntr_ous_2]) {
9540                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length((*r->out.ous)[cntr_ous_2], CH_UTF16)));
9541                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9542                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length((*r->out.ous)[cntr_ous_2], CH_UTF16)));
9543                                         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));
9544                                 }
9545                         }
9546                 }
9547                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9548         }
9549         return NDR_ERR_SUCCESS;
9550 }
9551
9552 static enum ndr_err_code ndr_pull_wkssvc_NetrGetJoinableOus2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrGetJoinableOus2 *r)
9553 {
9554         uint32_t _ptr_server_name;
9555         uint32_t _ptr_Account;
9556         uint32_t _ptr_EncryptedPassword;
9557         uint32_t _ptr_ous;
9558         uint32_t cntr_ous_2;
9559         TALLOC_CTX *_mem_save_server_name_0;
9560         TALLOC_CTX *_mem_save_Account_0;
9561         TALLOC_CTX *_mem_save_EncryptedPassword_0;
9562         TALLOC_CTX *_mem_save_num_ous_0;
9563         TALLOC_CTX *_mem_save_ous_0;
9564         TALLOC_CTX *_mem_save_ous_1;
9565         TALLOC_CTX *_mem_save_ous_2;
9566         TALLOC_CTX *_mem_save_ous_3;
9567         if (flags & NDR_IN) {
9568                 ZERO_STRUCT(r->out);
9569
9570                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
9571                 if (_ptr_server_name) {
9572                         NDR_PULL_ALLOC(ndr, r->in.server_name);
9573                 } else {
9574                         r->in.server_name = NULL;
9575                 }
9576                 if (r->in.server_name) {
9577                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9578                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
9579                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
9580                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
9581                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
9582                                 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));
9583                         }
9584                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
9585                         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));
9586                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
9587                 }
9588                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
9589                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
9590                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
9591                         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));
9592                 }
9593                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
9594                 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));
9595                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
9596                 if (_ptr_Account) {
9597                         NDR_PULL_ALLOC(ndr, r->in.Account);
9598                 } else {
9599                         r->in.Account = NULL;
9600                 }
9601                 if (r->in.Account) {
9602                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
9603                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
9604                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
9605                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
9606                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
9607                                 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));
9608                         }
9609                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
9610                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
9611                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
9612                 }
9613                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
9614                 if (_ptr_EncryptedPassword) {
9615                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
9616                 } else {
9617                         r->in.EncryptedPassword = NULL;
9618                 }
9619                 if (r->in.EncryptedPassword) {
9620                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
9621                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
9622                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9623                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
9624                 }
9625                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9626                         NDR_PULL_ALLOC(ndr, r->in.num_ous);
9627                 }
9628                 _mem_save_num_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);
9629                 NDR_PULL_SET_MEM_CTX(ndr, r->in.num_ous, LIBNDR_FLAG_REF_ALLOC);
9630                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.num_ous));
9631                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_ous_0, LIBNDR_FLAG_REF_ALLOC);
9632                 NDR_PULL_ALLOC(ndr, r->out.num_ous);
9633                 *r->out.num_ous = *r->in.num_ous;
9634                 NDR_PULL_ALLOC(ndr, r->out.ous);
9635                 ZERO_STRUCTP(r->out.ous);
9636         }
9637         if (flags & NDR_OUT) {
9638                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9639                         NDR_PULL_ALLOC(ndr, r->out.num_ous);
9640                 }
9641                 _mem_save_num_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);
9642                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_ous, LIBNDR_FLAG_REF_ALLOC);
9643                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_ous));
9644                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_ous_0, LIBNDR_FLAG_REF_ALLOC);
9645                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9646                         NDR_PULL_ALLOC(ndr, r->out.ous);
9647                 }
9648                 _mem_save_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);
9649                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ous, LIBNDR_FLAG_REF_ALLOC);
9650                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ous));
9651                 if (_ptr_ous) {
9652                         NDR_PULL_ALLOC(ndr, *r->out.ous);
9653                 } else {
9654                         *r->out.ous = NULL;
9655                 }
9656                 if (*r->out.ous) {
9657                         _mem_save_ous_1 = NDR_PULL_GET_MEM_CTX(ndr);
9658                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.ous, 0);
9659                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.ous));
9660                         NDR_PULL_ALLOC_N(ndr, *r->out.ous, ndr_get_array_size(ndr, r->out.ous));
9661                         _mem_save_ous_2 = NDR_PULL_GET_MEM_CTX(ndr);
9662                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.ous, 0);
9663                         for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {
9664                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ous));
9665                                 if (_ptr_ous) {
9666                                         NDR_PULL_ALLOC(ndr, (*r->out.ous)[cntr_ous_2]);
9667                                 } else {
9668                                         (*r->out.ous)[cntr_ous_2] = NULL;
9669                                 }
9670                         }
9671                         for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {
9672                                 if ((*r->out.ous)[cntr_ous_2]) {
9673                                         _mem_save_ous_3 = NDR_PULL_GET_MEM_CTX(ndr);
9674                                         NDR_PULL_SET_MEM_CTX(ndr, (*r->out.ous)[cntr_ous_2], 0);
9675                                         NDR_CHECK(ndr_pull_array_size(ndr, &(*r->out.ous)[cntr_ous_2]));
9676                                         NDR_CHECK(ndr_pull_array_length(ndr, &(*r->out.ous)[cntr_ous_2]));
9677                                         if (ndr_get_array_length(ndr, &(*r->out.ous)[cntr_ous_2]) > ndr_get_array_size(ndr, &(*r->out.ous)[cntr_ous_2])) {
9678                                                 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]));
9679                                         }
9680                                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &(*r->out.ous)[cntr_ous_2]), sizeof(uint16_t)));
9681                                         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));
9682                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_3, 0);
9683                                 }
9684                         }
9685                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_2, 0);
9686                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_1, 0);
9687                 }
9688                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_0, LIBNDR_FLAG_REF_ALLOC);
9689                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9690                 if (*r->out.ous) {
9691                         NDR_CHECK(ndr_check_array_size(ndr, (void*)r->out.ous, *r->out.num_ous));
9692                 }
9693         }
9694         return NDR_ERR_SUCCESS;
9695 }
9696
9697 _PUBLIC_ void ndr_print_wkssvc_NetrGetJoinableOus2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrGetJoinableOus2 *r)
9698 {
9699         uint32_t cntr_ous_2;
9700         ndr_print_struct(ndr, name, "wkssvc_NetrGetJoinableOus2");
9701         ndr->depth++;
9702         if (flags & NDR_SET_VALUES) {
9703                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9704         }
9705         if (flags & NDR_IN) {
9706                 ndr_print_struct(ndr, "in", "wkssvc_NetrGetJoinableOus2");
9707                 ndr->depth++;
9708                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
9709                 ndr->depth++;
9710                 if (r->in.server_name) {
9711                         ndr_print_string(ndr, "server_name", r->in.server_name);
9712                 }
9713                 ndr->depth--;
9714                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
9715                 ndr->depth++;
9716                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
9717                 ndr->depth--;
9718                 ndr_print_ptr(ndr, "Account", r->in.Account);
9719                 ndr->depth++;
9720                 if (r->in.Account) {
9721                         ndr_print_string(ndr, "Account", r->in.Account);
9722                 }
9723                 ndr->depth--;
9724                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9725                 ndr->depth++;
9726                 if (r->in.EncryptedPassword) {
9727                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9728                 }
9729                 ndr->depth--;
9730                 ndr_print_ptr(ndr, "num_ous", r->in.num_ous);
9731                 ndr->depth++;
9732                 ndr_print_uint32(ndr, "num_ous", *r->in.num_ous);
9733                 ndr->depth--;
9734                 ndr->depth--;
9735         }
9736         if (flags & NDR_OUT) {
9737                 ndr_print_struct(ndr, "out", "wkssvc_NetrGetJoinableOus2");
9738                 ndr->depth++;
9739                 ndr_print_ptr(ndr, "num_ous", r->out.num_ous);
9740                 ndr->depth++;
9741                 ndr_print_uint32(ndr, "num_ous", *r->out.num_ous);
9742                 ndr->depth--;
9743                 ndr_print_ptr(ndr, "ous", r->out.ous);
9744                 ndr->depth++;
9745                 ndr_print_ptr(ndr, "ous", *r->out.ous);
9746                 ndr->depth++;
9747                 if (*r->out.ous) {
9748                         ndr->print(ndr, "%s: ARRAY(%d)", "ous", (int)*r->out.num_ous);
9749                         ndr->depth++;
9750                         for (cntr_ous_2=0;cntr_ous_2<*r->out.num_ous;cntr_ous_2++) {
9751                                 char *idx_2=NULL;
9752                                 if (asprintf(&idx_2, "[%d]", cntr_ous_2) != -1) {
9753                                         ndr_print_ptr(ndr, "ous", (*r->out.ous)[cntr_ous_2]);
9754                                         ndr->depth++;
9755                                         if ((*r->out.ous)[cntr_ous_2]) {
9756                                                 ndr_print_string(ndr, "ous", (*r->out.ous)[cntr_ous_2]);
9757                                         }
9758                                         ndr->depth--;
9759                                         free(idx_2);
9760                                 }
9761                         }
9762                         ndr->depth--;
9763                 }
9764                 ndr->depth--;
9765                 ndr->depth--;
9766                 ndr_print_WERROR(ndr, "result", r->out.result);
9767                 ndr->depth--;
9768         }
9769         ndr->depth--;
9770 }
9771
9772 static enum ndr_err_code ndr_push_wkssvc_NetrAddAlternateComputerName(struct ndr_push *ndr, int flags, const struct wkssvc_NetrAddAlternateComputerName *r)
9773 {
9774         if (flags & NDR_IN) {
9775                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
9776                 if (r->in.server_name) {
9777                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9778                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9779                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9780                         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));
9781                 }
9782                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.NewAlternateMachineName));
9783                 if (r->in.NewAlternateMachineName) {
9784                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewAlternateMachineName, CH_UTF16)));
9785                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9786                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewAlternateMachineName, CH_UTF16)));
9787                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.NewAlternateMachineName, ndr_charset_length(r->in.NewAlternateMachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9788                 }
9789                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
9790                 if (r->in.Account) {
9791                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9792                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9793                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9794                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9795                 }
9796                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
9797                 if (r->in.EncryptedPassword) {
9798                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9799                 }
9800                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Reserved));
9801         }
9802         if (flags & NDR_OUT) {
9803                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9804         }
9805         return NDR_ERR_SUCCESS;
9806 }
9807
9808 static enum ndr_err_code ndr_pull_wkssvc_NetrAddAlternateComputerName(struct ndr_pull *ndr, int flags, struct wkssvc_NetrAddAlternateComputerName *r)
9809 {
9810         uint32_t _ptr_server_name;
9811         uint32_t _ptr_NewAlternateMachineName;
9812         uint32_t _ptr_Account;
9813         uint32_t _ptr_EncryptedPassword;
9814         TALLOC_CTX *_mem_save_server_name_0;
9815         TALLOC_CTX *_mem_save_NewAlternateMachineName_0;
9816         TALLOC_CTX *_mem_save_Account_0;
9817         TALLOC_CTX *_mem_save_EncryptedPassword_0;
9818         if (flags & NDR_IN) {
9819                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
9820                 if (_ptr_server_name) {
9821                         NDR_PULL_ALLOC(ndr, r->in.server_name);
9822                 } else {
9823                         r->in.server_name = NULL;
9824                 }
9825                 if (r->in.server_name) {
9826                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9827                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
9828                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
9829                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
9830                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
9831                                 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));
9832                         }
9833                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
9834                         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));
9835                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
9836                 }
9837                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_NewAlternateMachineName));
9838                 if (_ptr_NewAlternateMachineName) {
9839                         NDR_PULL_ALLOC(ndr, r->in.NewAlternateMachineName);
9840                 } else {
9841                         r->in.NewAlternateMachineName = NULL;
9842                 }
9843                 if (r->in.NewAlternateMachineName) {
9844                         _mem_save_NewAlternateMachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);
9845                         NDR_PULL_SET_MEM_CTX(ndr, r->in.NewAlternateMachineName, 0);
9846                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.NewAlternateMachineName));
9847                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.NewAlternateMachineName));
9848                         if (ndr_get_array_length(ndr, &r->in.NewAlternateMachineName) > ndr_get_array_size(ndr, &r->in.NewAlternateMachineName)) {
9849                                 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));
9850                         }
9851                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.NewAlternateMachineName), sizeof(uint16_t)));
9852                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.NewAlternateMachineName, ndr_get_array_length(ndr, &r->in.NewAlternateMachineName), sizeof(uint16_t), CH_UTF16));
9853                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_NewAlternateMachineName_0, 0);
9854                 }
9855                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
9856                 if (_ptr_Account) {
9857                         NDR_PULL_ALLOC(ndr, r->in.Account);
9858                 } else {
9859                         r->in.Account = NULL;
9860                 }
9861                 if (r->in.Account) {
9862                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
9863                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
9864                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
9865                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
9866                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
9867                                 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));
9868                         }
9869                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
9870                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
9871                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
9872                 }
9873                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
9874                 if (_ptr_EncryptedPassword) {
9875                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
9876                 } else {
9877                         r->in.EncryptedPassword = NULL;
9878                 }
9879                 if (r->in.EncryptedPassword) {
9880                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
9881                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
9882                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9883                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
9884                 }
9885                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Reserved));
9886         }
9887         if (flags & NDR_OUT) {
9888                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9889         }
9890         return NDR_ERR_SUCCESS;
9891 }
9892
9893 _PUBLIC_ void ndr_print_wkssvc_NetrAddAlternateComputerName(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrAddAlternateComputerName *r)
9894 {
9895         ndr_print_struct(ndr, name, "wkssvc_NetrAddAlternateComputerName");
9896         ndr->depth++;
9897         if (flags & NDR_SET_VALUES) {
9898                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9899         }
9900         if (flags & NDR_IN) {
9901                 ndr_print_struct(ndr, "in", "wkssvc_NetrAddAlternateComputerName");
9902                 ndr->depth++;
9903                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
9904                 ndr->depth++;
9905                 if (r->in.server_name) {
9906                         ndr_print_string(ndr, "server_name", r->in.server_name);
9907                 }
9908                 ndr->depth--;
9909                 ndr_print_ptr(ndr, "NewAlternateMachineName", r->in.NewAlternateMachineName);
9910                 ndr->depth++;
9911                 if (r->in.NewAlternateMachineName) {
9912                         ndr_print_string(ndr, "NewAlternateMachineName", r->in.NewAlternateMachineName);
9913                 }
9914                 ndr->depth--;
9915                 ndr_print_ptr(ndr, "Account", r->in.Account);
9916                 ndr->depth++;
9917                 if (r->in.Account) {
9918                         ndr_print_string(ndr, "Account", r->in.Account);
9919                 }
9920                 ndr->depth--;
9921                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9922                 ndr->depth++;
9923                 if (r->in.EncryptedPassword) {
9924                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9925                 }
9926                 ndr->depth--;
9927                 ndr_print_uint32(ndr, "Reserved", r->in.Reserved);
9928                 ndr->depth--;
9929         }
9930         if (flags & NDR_OUT) {
9931                 ndr_print_struct(ndr, "out", "wkssvc_NetrAddAlternateComputerName");
9932                 ndr->depth++;
9933                 ndr_print_WERROR(ndr, "result", r->out.result);
9934                 ndr->depth--;
9935         }
9936         ndr->depth--;
9937 }
9938
9939 static enum ndr_err_code ndr_push_wkssvc_NetrRemoveAlternateComputerName(struct ndr_push *ndr, int flags, const struct wkssvc_NetrRemoveAlternateComputerName *r)
9940 {
9941         if (flags & NDR_IN) {
9942                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
9943                 if (r->in.server_name) {
9944                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9945                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9946                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9947                         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));
9948                 }
9949                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.AlternateMachineNameToRemove));
9950                 if (r->in.AlternateMachineNameToRemove) {
9951                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.AlternateMachineNameToRemove, CH_UTF16)));
9952                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9953                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.AlternateMachineNameToRemove, CH_UTF16)));
9954                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.AlternateMachineNameToRemove, ndr_charset_length(r->in.AlternateMachineNameToRemove, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9955                 }
9956                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
9957                 if (r->in.Account) {
9958                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9959                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9960                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9961                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9962                 }
9963                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
9964                 if (r->in.EncryptedPassword) {
9965                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9966                 }
9967                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Reserved));
9968         }
9969         if (flags & NDR_OUT) {
9970                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9971         }
9972         return NDR_ERR_SUCCESS;
9973 }
9974
9975 static enum ndr_err_code ndr_pull_wkssvc_NetrRemoveAlternateComputerName(struct ndr_pull *ndr, int flags, struct wkssvc_NetrRemoveAlternateComputerName *r)
9976 {
9977         uint32_t _ptr_server_name;
9978         uint32_t _ptr_AlternateMachineNameToRemove;
9979         uint32_t _ptr_Account;
9980         uint32_t _ptr_EncryptedPassword;
9981         TALLOC_CTX *_mem_save_server_name_0;
9982         TALLOC_CTX *_mem_save_AlternateMachineNameToRemove_0;
9983         TALLOC_CTX *_mem_save_Account_0;
9984         TALLOC_CTX *_mem_save_EncryptedPassword_0;
9985         if (flags & NDR_IN) {
9986                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
9987                 if (_ptr_server_name) {
9988                         NDR_PULL_ALLOC(ndr, r->in.server_name);
9989                 } else {
9990                         r->in.server_name = NULL;
9991                 }
9992                 if (r->in.server_name) {
9993                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9994                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
9995                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
9996                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
9997                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
9998                                 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));
9999                         }
10000                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
10001                         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));
10002                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
10003                 }
10004                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_AlternateMachineNameToRemove));
10005                 if (_ptr_AlternateMachineNameToRemove) {
10006                         NDR_PULL_ALLOC(ndr, r->in.AlternateMachineNameToRemove);
10007                 } else {
10008                         r->in.AlternateMachineNameToRemove = NULL;
10009                 }
10010                 if (r->in.AlternateMachineNameToRemove) {
10011                         _mem_save_AlternateMachineNameToRemove_0 = NDR_PULL_GET_MEM_CTX(ndr);
10012                         NDR_PULL_SET_MEM_CTX(ndr, r->in.AlternateMachineNameToRemove, 0);
10013                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.AlternateMachineNameToRemove));
10014                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.AlternateMachineNameToRemove));
10015                         if (ndr_get_array_length(ndr, &r->in.AlternateMachineNameToRemove) > ndr_get_array_size(ndr, &r->in.AlternateMachineNameToRemove)) {
10016                                 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));
10017                         }
10018                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.AlternateMachineNameToRemove), sizeof(uint16_t)));
10019                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.AlternateMachineNameToRemove, ndr_get_array_length(ndr, &r->in.AlternateMachineNameToRemove), sizeof(uint16_t), CH_UTF16));
10020                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_AlternateMachineNameToRemove_0, 0);
10021                 }
10022                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
10023                 if (_ptr_Account) {
10024                         NDR_PULL_ALLOC(ndr, r->in.Account);
10025                 } else {
10026                         r->in.Account = NULL;
10027                 }
10028                 if (r->in.Account) {
10029                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
10030                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
10031                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
10032                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
10033                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
10034                                 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));
10035                         }
10036                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
10037                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
10038                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
10039                 }
10040                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
10041                 if (_ptr_EncryptedPassword) {
10042                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
10043                 } else {
10044                         r->in.EncryptedPassword = NULL;
10045                 }
10046                 if (r->in.EncryptedPassword) {
10047                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
10048                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
10049                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
10050                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
10051                 }
10052                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Reserved));
10053         }
10054         if (flags & NDR_OUT) {
10055                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
10056         }
10057         return NDR_ERR_SUCCESS;
10058 }
10059
10060 _PUBLIC_ void ndr_print_wkssvc_NetrRemoveAlternateComputerName(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrRemoveAlternateComputerName *r)
10061 {
10062         ndr_print_struct(ndr, name, "wkssvc_NetrRemoveAlternateComputerName");
10063         ndr->depth++;
10064         if (flags & NDR_SET_VALUES) {
10065                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10066         }
10067         if (flags & NDR_IN) {
10068                 ndr_print_struct(ndr, "in", "wkssvc_NetrRemoveAlternateComputerName");
10069                 ndr->depth++;
10070                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
10071                 ndr->depth++;
10072                 if (r->in.server_name) {
10073                         ndr_print_string(ndr, "server_name", r->in.server_name);
10074                 }
10075                 ndr->depth--;
10076                 ndr_print_ptr(ndr, "AlternateMachineNameToRemove", r->in.AlternateMachineNameToRemove);
10077                 ndr->depth++;
10078                 if (r->in.AlternateMachineNameToRemove) {
10079                         ndr_print_string(ndr, "AlternateMachineNameToRemove", r->in.AlternateMachineNameToRemove);
10080                 }
10081                 ndr->depth--;
10082                 ndr_print_ptr(ndr, "Account", r->in.Account);
10083                 ndr->depth++;
10084                 if (r->in.Account) {
10085                         ndr_print_string(ndr, "Account", r->in.Account);
10086                 }
10087                 ndr->depth--;
10088                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
10089                 ndr->depth++;
10090                 if (r->in.EncryptedPassword) {
10091                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
10092                 }
10093                 ndr->depth--;
10094                 ndr_print_uint32(ndr, "Reserved", r->in.Reserved);
10095                 ndr->depth--;
10096         }
10097         if (flags & NDR_OUT) {
10098                 ndr_print_struct(ndr, "out", "wkssvc_NetrRemoveAlternateComputerName");
10099                 ndr->depth++;
10100                 ndr_print_WERROR(ndr, "result", r->out.result);
10101                 ndr->depth--;
10102         }
10103         ndr->depth--;
10104 }
10105
10106 static enum ndr_err_code ndr_push_wkssvc_NetrSetPrimaryComputername(struct ndr_push *ndr, int flags, const struct wkssvc_NetrSetPrimaryComputername *r)
10107 {
10108         if (flags & NDR_IN) {
10109                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
10110                 if (r->in.server_name) {
10111                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
10112                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10113                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
10114                         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));
10115                 }
10116                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.primary_name));
10117                 if (r->in.primary_name) {
10118                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.primary_name, CH_UTF16)));
10119                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10120                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.primary_name, CH_UTF16)));
10121                         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));
10122                 }
10123                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
10124                 if (r->in.Account) {
10125                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
10126                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10127                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
10128                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10129                 }
10130                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
10131                 if (r->in.EncryptedPassword) {
10132                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
10133                 }
10134                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Reserved));
10135         }
10136         if (flags & NDR_OUT) {
10137                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
10138         }
10139         return NDR_ERR_SUCCESS;
10140 }
10141
10142 static enum ndr_err_code ndr_pull_wkssvc_NetrSetPrimaryComputername(struct ndr_pull *ndr, int flags, struct wkssvc_NetrSetPrimaryComputername *r)
10143 {
10144         uint32_t _ptr_server_name;
10145         uint32_t _ptr_primary_name;
10146         uint32_t _ptr_Account;
10147         uint32_t _ptr_EncryptedPassword;
10148         TALLOC_CTX *_mem_save_server_name_0;
10149         TALLOC_CTX *_mem_save_primary_name_0;
10150         TALLOC_CTX *_mem_save_Account_0;
10151         TALLOC_CTX *_mem_save_EncryptedPassword_0;
10152         if (flags & NDR_IN) {
10153                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
10154                 if (_ptr_server_name) {
10155                         NDR_PULL_ALLOC(ndr, r->in.server_name);
10156                 } else {
10157                         r->in.server_name = NULL;
10158                 }
10159                 if (r->in.server_name) {
10160                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10161                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
10162                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
10163                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
10164                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
10165                                 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));
10166                         }
10167                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
10168                         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));
10169                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
10170                 }
10171                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_primary_name));
10172                 if (_ptr_primary_name) {
10173                         NDR_PULL_ALLOC(ndr, r->in.primary_name);
10174                 } else {
10175                         r->in.primary_name = NULL;
10176                 }
10177                 if (r->in.primary_name) {
10178                         _mem_save_primary_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10179                         NDR_PULL_SET_MEM_CTX(ndr, r->in.primary_name, 0);
10180                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.primary_name));
10181                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.primary_name));
10182                         if (ndr_get_array_length(ndr, &r->in.primary_name) > ndr_get_array_size(ndr, &r->in.primary_name)) {
10183                                 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));
10184                         }
10185                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.primary_name), sizeof(uint16_t)));
10186                         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));
10187                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_primary_name_0, 0);
10188                 }
10189                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
10190                 if (_ptr_Account) {
10191                         NDR_PULL_ALLOC(ndr, r->in.Account);
10192                 } else {
10193                         r->in.Account = NULL;
10194                 }
10195                 if (r->in.Account) {
10196                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
10197                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
10198                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
10199                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
10200                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
10201                                 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));
10202                         }
10203                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
10204                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
10205                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
10206                 }
10207                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
10208                 if (_ptr_EncryptedPassword) {
10209                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
10210                 } else {
10211                         r->in.EncryptedPassword = NULL;
10212                 }
10213                 if (r->in.EncryptedPassword) {
10214                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
10215                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
10216                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
10217                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
10218                 }
10219                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Reserved));
10220         }
10221         if (flags & NDR_OUT) {
10222                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
10223         }
10224         return NDR_ERR_SUCCESS;
10225 }
10226
10227 _PUBLIC_ void ndr_print_wkssvc_NetrSetPrimaryComputername(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrSetPrimaryComputername *r)
10228 {
10229         ndr_print_struct(ndr, name, "wkssvc_NetrSetPrimaryComputername");
10230         ndr->depth++;
10231         if (flags & NDR_SET_VALUES) {
10232                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10233         }
10234         if (flags & NDR_IN) {
10235                 ndr_print_struct(ndr, "in", "wkssvc_NetrSetPrimaryComputername");
10236                 ndr->depth++;
10237                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
10238                 ndr->depth++;
10239                 if (r->in.server_name) {
10240                         ndr_print_string(ndr, "server_name", r->in.server_name);
10241                 }
10242                 ndr->depth--;
10243                 ndr_print_ptr(ndr, "primary_name", r->in.primary_name);
10244                 ndr->depth++;
10245                 if (r->in.primary_name) {
10246                         ndr_print_string(ndr, "primary_name", r->in.primary_name);
10247                 }
10248                 ndr->depth--;
10249                 ndr_print_ptr(ndr, "Account", r->in.Account);
10250                 ndr->depth++;
10251                 if (r->in.Account) {
10252                         ndr_print_string(ndr, "Account", r->in.Account);
10253                 }
10254                 ndr->depth--;
10255                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
10256                 ndr->depth++;
10257                 if (r->in.EncryptedPassword) {
10258                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
10259                 }
10260                 ndr->depth--;
10261                 ndr_print_uint32(ndr, "Reserved", r->in.Reserved);
10262                 ndr->depth--;
10263         }
10264         if (flags & NDR_OUT) {
10265                 ndr_print_struct(ndr, "out", "wkssvc_NetrSetPrimaryComputername");
10266                 ndr->depth++;
10267                 ndr_print_WERROR(ndr, "result", r->out.result);
10268                 ndr->depth--;
10269         }
10270         ndr->depth--;
10271 }
10272
10273 static enum ndr_err_code ndr_push_wkssvc_NetrEnumerateComputerNames(struct ndr_push *ndr, int flags, const struct wkssvc_NetrEnumerateComputerNames *r)
10274 {
10275         if (flags & NDR_IN) {
10276                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
10277                 if (r->in.server_name) {
10278                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
10279                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10280                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
10281                         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));
10282                 }
10283                 NDR_CHECK(ndr_push_wkssvc_ComputerNameType(ndr, NDR_SCALARS, r->in.name_type));
10284                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Reserved));
10285         }
10286         if (flags & NDR_OUT) {
10287                 if (r->out.ctr == NULL) {
10288                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10289                 }
10290                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.ctr));
10291                 if (*r->out.ctr) {
10292                         NDR_CHECK(ndr_push_wkssvc_ComputerNamesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.ctr));
10293                 }
10294                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
10295         }
10296         return NDR_ERR_SUCCESS;
10297 }
10298
10299 static enum ndr_err_code ndr_pull_wkssvc_NetrEnumerateComputerNames(struct ndr_pull *ndr, int flags, struct wkssvc_NetrEnumerateComputerNames *r)
10300 {
10301         uint32_t _ptr_server_name;
10302         uint32_t _ptr_ctr;
10303         TALLOC_CTX *_mem_save_server_name_0;
10304         TALLOC_CTX *_mem_save_ctr_0;
10305         TALLOC_CTX *_mem_save_ctr_1;
10306         if (flags & NDR_IN) {
10307                 ZERO_STRUCT(r->out);
10308
10309                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
10310                 if (_ptr_server_name) {
10311                         NDR_PULL_ALLOC(ndr, r->in.server_name);
10312                 } else {
10313                         r->in.server_name = NULL;
10314                 }
10315                 if (r->in.server_name) {
10316                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10317                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
10318                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
10319                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
10320                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
10321                                 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));
10322                         }
10323                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
10324                         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));
10325                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
10326                 }
10327                 NDR_CHECK(ndr_pull_wkssvc_ComputerNameType(ndr, NDR_SCALARS, &r->in.name_type));
10328                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Reserved));
10329                 NDR_PULL_ALLOC(ndr, r->out.ctr);
10330                 ZERO_STRUCTP(r->out.ctr);
10331         }
10332         if (flags & NDR_OUT) {
10333                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10334                         NDR_PULL_ALLOC(ndr, r->out.ctr);
10335                 }
10336                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
10337                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
10338                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
10339                 if (_ptr_ctr) {
10340                         NDR_PULL_ALLOC(ndr, *r->out.ctr);
10341                 } else {
10342                         *r->out.ctr = NULL;
10343                 }
10344                 if (*r->out.ctr) {
10345                         _mem_save_ctr_1 = NDR_PULL_GET_MEM_CTX(ndr);
10346                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.ctr, 0);
10347                         NDR_CHECK(ndr_pull_wkssvc_ComputerNamesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.ctr));
10348                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_1, 0);
10349                 }
10350                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
10351                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
10352         }
10353         return NDR_ERR_SUCCESS;
10354 }
10355
10356 _PUBLIC_ void ndr_print_wkssvc_NetrEnumerateComputerNames(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrEnumerateComputerNames *r)
10357 {
10358         ndr_print_struct(ndr, name, "wkssvc_NetrEnumerateComputerNames");
10359         ndr->depth++;
10360         if (flags & NDR_SET_VALUES) {
10361                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10362         }
10363         if (flags & NDR_IN) {
10364                 ndr_print_struct(ndr, "in", "wkssvc_NetrEnumerateComputerNames");
10365                 ndr->depth++;
10366                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
10367                 ndr->depth++;
10368                 if (r->in.server_name) {
10369                         ndr_print_string(ndr, "server_name", r->in.server_name);
10370                 }
10371                 ndr->depth--;
10372                 ndr_print_wkssvc_ComputerNameType(ndr, "name_type", r->in.name_type);
10373                 ndr_print_uint32(ndr, "Reserved", r->in.Reserved);
10374                 ndr->depth--;
10375         }
10376         if (flags & NDR_OUT) {
10377                 ndr_print_struct(ndr, "out", "wkssvc_NetrEnumerateComputerNames");
10378                 ndr->depth++;
10379                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
10380                 ndr->depth++;
10381                 ndr_print_ptr(ndr, "ctr", *r->out.ctr);
10382                 ndr->depth++;
10383                 if (*r->out.ctr) {
10384                         ndr_print_wkssvc_ComputerNamesCtr(ndr, "ctr", *r->out.ctr);
10385                 }
10386                 ndr->depth--;
10387                 ndr->depth--;
10388                 ndr_print_WERROR(ndr, "result", r->out.result);
10389                 ndr->depth--;
10390         }
10391         ndr->depth--;
10392 }
10393
10394 static const struct ndr_interface_call wkssvc_calls[] = {
10395         {
10396                 "wkssvc_NetWkstaGetInfo",
10397                 sizeof(struct wkssvc_NetWkstaGetInfo),
10398                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaGetInfo,
10399                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaGetInfo,
10400                 (ndr_print_function_t) ndr_print_wkssvc_NetWkstaGetInfo,
10401                 false,
10402         },
10403         {
10404                 "wkssvc_NetWkstaSetInfo",
10405                 sizeof(struct wkssvc_NetWkstaSetInfo),
10406                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaSetInfo,
10407                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaSetInfo,
10408                 (ndr_print_function_t) ndr_print_wkssvc_NetWkstaSetInfo,
10409                 false,
10410         },
10411         {
10412                 "wkssvc_NetWkstaEnumUsers",
10413                 sizeof(struct wkssvc_NetWkstaEnumUsers),
10414                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaEnumUsers,
10415                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaEnumUsers,
10416                 (ndr_print_function_t) ndr_print_wkssvc_NetWkstaEnumUsers,
10417                 false,
10418         },
10419         {
10420                 "wkssvc_NetrWkstaUserGetInfo",
10421                 sizeof(struct wkssvc_NetrWkstaUserGetInfo),
10422                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrWkstaUserGetInfo,
10423                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrWkstaUserGetInfo,
10424                 (ndr_print_function_t) ndr_print_wkssvc_NetrWkstaUserGetInfo,
10425                 false,
10426         },
10427         {
10428                 "wkssvc_NetrWkstaUserSetInfo",
10429                 sizeof(struct wkssvc_NetrWkstaUserSetInfo),
10430                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrWkstaUserSetInfo,
10431                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrWkstaUserSetInfo,
10432                 (ndr_print_function_t) ndr_print_wkssvc_NetrWkstaUserSetInfo,
10433                 false,
10434         },
10435         {
10436                 "wkssvc_NetWkstaTransportEnum",
10437                 sizeof(struct wkssvc_NetWkstaTransportEnum),
10438                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaTransportEnum,
10439                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaTransportEnum,
10440                 (ndr_print_function_t) ndr_print_wkssvc_NetWkstaTransportEnum,
10441                 false,
10442         },
10443         {
10444                 "wkssvc_NetrWkstaTransportAdd",
10445                 sizeof(struct wkssvc_NetrWkstaTransportAdd),
10446                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrWkstaTransportAdd,
10447                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrWkstaTransportAdd,
10448                 (ndr_print_function_t) ndr_print_wkssvc_NetrWkstaTransportAdd,
10449                 false,
10450         },
10451         {
10452                 "wkssvc_NetrWkstaTransportDel",
10453                 sizeof(struct wkssvc_NetrWkstaTransportDel),
10454                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrWkstaTransportDel,
10455                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrWkstaTransportDel,
10456                 (ndr_print_function_t) ndr_print_wkssvc_NetrWkstaTransportDel,
10457                 false,
10458         },
10459         {
10460                 "wkssvc_NetrUseAdd",
10461                 sizeof(struct wkssvc_NetrUseAdd),
10462                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUseAdd,
10463                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUseAdd,
10464                 (ndr_print_function_t) ndr_print_wkssvc_NetrUseAdd,
10465                 false,
10466         },
10467         {
10468                 "wkssvc_NetrUseGetInfo",
10469                 sizeof(struct wkssvc_NetrUseGetInfo),
10470                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUseGetInfo,
10471                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUseGetInfo,
10472                 (ndr_print_function_t) ndr_print_wkssvc_NetrUseGetInfo,
10473                 false,
10474         },
10475         {
10476                 "wkssvc_NetrUseDel",
10477                 sizeof(struct wkssvc_NetrUseDel),
10478                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUseDel,
10479                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUseDel,
10480                 (ndr_print_function_t) ndr_print_wkssvc_NetrUseDel,
10481                 false,
10482         },
10483         {
10484                 "wkssvc_NetrUseEnum",
10485                 sizeof(struct wkssvc_NetrUseEnum),
10486                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUseEnum,
10487                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUseEnum,
10488                 (ndr_print_function_t) ndr_print_wkssvc_NetrUseEnum,
10489                 false,
10490         },
10491         {
10492                 "wkssvc_NetrMessageBufferSend",
10493                 sizeof(struct wkssvc_NetrMessageBufferSend),
10494                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrMessageBufferSend,
10495                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrMessageBufferSend,
10496                 (ndr_print_function_t) ndr_print_wkssvc_NetrMessageBufferSend,
10497                 false,
10498         },
10499         {
10500                 "wkssvc_NetrWorkstationStatisticsGet",
10501                 sizeof(struct wkssvc_NetrWorkstationStatisticsGet),
10502                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrWorkstationStatisticsGet,
10503                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrWorkstationStatisticsGet,
10504                 (ndr_print_function_t) ndr_print_wkssvc_NetrWorkstationStatisticsGet,
10505                 false,
10506         },
10507         {
10508                 "wkssvc_NetrLogonDomainNameAdd",
10509                 sizeof(struct wkssvc_NetrLogonDomainNameAdd),
10510                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrLogonDomainNameAdd,
10511                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrLogonDomainNameAdd,
10512                 (ndr_print_function_t) ndr_print_wkssvc_NetrLogonDomainNameAdd,
10513                 false,
10514         },
10515         {
10516                 "wkssvc_NetrLogonDomainNameDel",
10517                 sizeof(struct wkssvc_NetrLogonDomainNameDel),
10518                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrLogonDomainNameDel,
10519                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrLogonDomainNameDel,
10520                 (ndr_print_function_t) ndr_print_wkssvc_NetrLogonDomainNameDel,
10521                 false,
10522         },
10523         {
10524                 "wkssvc_NetrJoinDomain",
10525                 sizeof(struct wkssvc_NetrJoinDomain),
10526                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrJoinDomain,
10527                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrJoinDomain,
10528                 (ndr_print_function_t) ndr_print_wkssvc_NetrJoinDomain,
10529                 false,
10530         },
10531         {
10532                 "wkssvc_NetrUnjoinDomain",
10533                 sizeof(struct wkssvc_NetrUnjoinDomain),
10534                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUnjoinDomain,
10535                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUnjoinDomain,
10536                 (ndr_print_function_t) ndr_print_wkssvc_NetrUnjoinDomain,
10537                 false,
10538         },
10539         {
10540                 "wkssvc_NetrRenameMachineInDomain",
10541                 sizeof(struct wkssvc_NetrRenameMachineInDomain),
10542                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrRenameMachineInDomain,
10543                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrRenameMachineInDomain,
10544                 (ndr_print_function_t) ndr_print_wkssvc_NetrRenameMachineInDomain,
10545                 false,
10546         },
10547         {
10548                 "wkssvc_NetrValidateName",
10549                 sizeof(struct wkssvc_NetrValidateName),
10550                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrValidateName,
10551                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrValidateName,
10552                 (ndr_print_function_t) ndr_print_wkssvc_NetrValidateName,
10553                 false,
10554         },
10555         {
10556                 "wkssvc_NetrGetJoinInformation",
10557                 sizeof(struct wkssvc_NetrGetJoinInformation),
10558                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrGetJoinInformation,
10559                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrGetJoinInformation,
10560                 (ndr_print_function_t) ndr_print_wkssvc_NetrGetJoinInformation,
10561                 false,
10562         },
10563         {
10564                 "wkssvc_NetrGetJoinableOus",
10565                 sizeof(struct wkssvc_NetrGetJoinableOus),
10566                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrGetJoinableOus,
10567                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrGetJoinableOus,
10568                 (ndr_print_function_t) ndr_print_wkssvc_NetrGetJoinableOus,
10569                 false,
10570         },
10571         {
10572                 "wkssvc_NetrJoinDomain2",
10573                 sizeof(struct wkssvc_NetrJoinDomain2),
10574                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrJoinDomain2,
10575                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrJoinDomain2,
10576                 (ndr_print_function_t) ndr_print_wkssvc_NetrJoinDomain2,
10577                 false,
10578         },
10579         {
10580                 "wkssvc_NetrUnjoinDomain2",
10581                 sizeof(struct wkssvc_NetrUnjoinDomain2),
10582                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUnjoinDomain2,
10583                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUnjoinDomain2,
10584                 (ndr_print_function_t) ndr_print_wkssvc_NetrUnjoinDomain2,
10585                 false,
10586         },
10587         {
10588                 "wkssvc_NetrRenameMachineInDomain2",
10589                 sizeof(struct wkssvc_NetrRenameMachineInDomain2),
10590                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrRenameMachineInDomain2,
10591                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrRenameMachineInDomain2,
10592                 (ndr_print_function_t) ndr_print_wkssvc_NetrRenameMachineInDomain2,
10593                 false,
10594         },
10595         {
10596                 "wkssvc_NetrValidateName2",
10597                 sizeof(struct wkssvc_NetrValidateName2),
10598                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrValidateName2,
10599                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrValidateName2,
10600                 (ndr_print_function_t) ndr_print_wkssvc_NetrValidateName2,
10601                 false,
10602         },
10603         {
10604                 "wkssvc_NetrGetJoinableOus2",
10605                 sizeof(struct wkssvc_NetrGetJoinableOus2),
10606                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrGetJoinableOus2,
10607                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrGetJoinableOus2,
10608                 (ndr_print_function_t) ndr_print_wkssvc_NetrGetJoinableOus2,
10609                 false,
10610         },
10611         {
10612                 "wkssvc_NetrAddAlternateComputerName",
10613                 sizeof(struct wkssvc_NetrAddAlternateComputerName),
10614                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrAddAlternateComputerName,
10615                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrAddAlternateComputerName,
10616                 (ndr_print_function_t) ndr_print_wkssvc_NetrAddAlternateComputerName,
10617                 false,
10618         },
10619         {
10620                 "wkssvc_NetrRemoveAlternateComputerName",
10621                 sizeof(struct wkssvc_NetrRemoveAlternateComputerName),
10622                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrRemoveAlternateComputerName,
10623                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrRemoveAlternateComputerName,
10624                 (ndr_print_function_t) ndr_print_wkssvc_NetrRemoveAlternateComputerName,
10625                 false,
10626         },
10627         {
10628                 "wkssvc_NetrSetPrimaryComputername",
10629                 sizeof(struct wkssvc_NetrSetPrimaryComputername),
10630                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrSetPrimaryComputername,
10631                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrSetPrimaryComputername,
10632                 (ndr_print_function_t) ndr_print_wkssvc_NetrSetPrimaryComputername,
10633                 false,
10634         },
10635         {
10636                 "wkssvc_NetrEnumerateComputerNames",
10637                 sizeof(struct wkssvc_NetrEnumerateComputerNames),
10638                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrEnumerateComputerNames,
10639                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrEnumerateComputerNames,
10640                 (ndr_print_function_t) ndr_print_wkssvc_NetrEnumerateComputerNames,
10641                 false,
10642         },
10643         { NULL, 0, NULL, NULL, NULL, false }
10644 };
10645
10646 static const char * const wkssvc_endpoint_strings[] = {
10647         "ncacn_np:[\\pipe\\wkssvc]",
10648         "ncacn_ip_tcp:",
10649         "ncalrpc:",
10650 };
10651
10652 static const struct ndr_interface_string_array wkssvc_endpoints = {
10653         .count  = 3,
10654         .names  = wkssvc_endpoint_strings
10655 };
10656
10657 static const char * const wkssvc_authservice_strings[] = {
10658         "host",
10659 };
10660
10661 static const struct ndr_interface_string_array wkssvc_authservices = {
10662         .count  = 1,
10663         .names  = wkssvc_authservice_strings
10664 };
10665
10666
10667 const struct ndr_interface_table ndr_table_wkssvc = {
10668         .name           = "wkssvc",
10669         .syntax_id      = {
10670                 {0x6bffd098,0xa112,0x3610,{0x98,0x33},{0x46,0xc3,0xf8,0x7e,0x34,0x5a}},
10671                 NDR_WKSSVC_VERSION
10672         },
10673         .helpstring     = NDR_WKSSVC_HELPSTRING,
10674         .num_calls      = 31,
10675         .calls          = wkssvc_calls,
10676         .endpoints      = &wkssvc_endpoints,
10677         .authservices   = &wkssvc_authservices
10678 };
10679