librpc/gen_ndr/ndr_wkssvc.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_wkssvc.h"
   5
   6 #include "librpc/gen_ndr/ndr_srvsvc.h"
   7 #include "librpc/gen_ndr/ndr_lsa.h"
   8 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo100(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo100 *r)
   9 {
  10         if (ndr_flags & NDR_SCALARS) {
  11                 NDR_CHECK(ndr_push_align(ndr, 5));
  12                 NDR_CHECK(ndr_push_srvsvc_PlatformId(ndr, NDR_SCALARS, r->platform_id));
  13                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
  14                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
  15                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_major));
  16                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_minor));
  17         }
  18         if (ndr_flags & NDR_BUFFERS) {
  19                 if (r->server_name) {
  20                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
  21                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
  22                         NDR_CHECK(ndr_push_uint3264(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_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
  27                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
  28                         NDR_CHECK(ndr_push_uint3264(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, 5));
  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, 5));
 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_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
 124                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 125                         NDR_CHECK(ndr_push_uint3264(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_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
 130                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 131                         NDR_CHECK(ndr_push_uint3264(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_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lan_root, CH_UTF16)));
 136                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 137                         NDR_CHECK(ndr_push_uint3264(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, 5));
 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, 5));
 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_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
 260                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 261                         NDR_CHECK(ndr_push_uint3264(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_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
 266                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 267                         NDR_CHECK(ndr_push_uint3264(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_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lan_root, CH_UTF16)));
 272                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 273                         NDR_CHECK(ndr_push_uint3264(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, 5));
 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                 NDR_CHECK(ndr_push_union_align(ndr, 5));
1481                 switch (level) {
1482                         case 100: {
1483                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info100));
1484                         break; }
1485
1486                         case 101: {
1487                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info101));
1488                         break; }
1489
1490                         case 102: {
1491                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info102));
1492                         break; }
1493
1494                         case 502: {
1495                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info502));
1496                         break; }
1497
1498                         case 1010: {
1499                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1010));
1500                         break; }
1501
1502                         case 1011: {
1503                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1011));
1504                         break; }
1505
1506                         case 1012: {
1507                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1012));
1508                         break; }
1509
1510                         case 1013: {
1511                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1013));
1512                         break; }
1513
1514                         case 1018: {
1515                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1018));
1516                         break; }
1517
1518                         case 1023: {
1519                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1023));
1520                         break; }
1521
1522                         case 1027: {
1523                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1027));
1524                         break; }
1525
1526                         case 1028: {
1527                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1028));
1528                         break; }
1529
1530                         case 1032: {
1531                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1032));
1532                         break; }
1533
1534                         case 1033: {
1535                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1033));
1536                         break; }
1537
1538                         case 1041: {
1539                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1041));
1540                         break; }
1541
1542                         case 1042: {
1543                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1042));
1544                         break; }
1545
1546                         case 1043: {
1547                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1043));
1548                         break; }
1549
1550                         case 1044: {
1551                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1044));
1552                         break; }
1553
1554                         case 1045: {
1555                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1045));
1556                         break; }
1557
1558                         case 1046: {
1559                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1046));
1560                         break; }
1561
1562                         case 1047: {
1563                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1047));
1564                         break; }
1565
1566                         case 1048: {
1567                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1048));
1568                         break; }
1569
1570                         case 1049: {
1571                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1049));
1572                         break; }
1573
1574                         case 1050: {
1575                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1050));
1576                         break; }
1577
1578                         case 1051: {
1579                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1051));
1580                         break; }
1581
1582                         case 1052: {
1583                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1052));
1584                         break; }
1585
1586                         case 1053: {
1587                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1053));
1588                         break; }
1589
1590                         case 1054: {
1591                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1054));
1592                         break; }
1593
1594                         case 1055: {
1595                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1055));
1596                         break; }
1597
1598                         case 1056: {
1599                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1056));
1600                         break; }
1601
1602                         case 1057: {
1603                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1057));
1604                         break; }
1605
1606                         case 1058: {
1607                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1058));
1608                         break; }
1609
1610                         case 1059: {
1611                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1059));
1612                         break; }
1613
1614                         case 1060: {
1615                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1060));
1616                         break; }
1617
1618                         case 1061: {
1619                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1061));
1620                         break; }
1621
1622                         case 1062: {
1623                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1062));
1624                         break; }
1625
1626                         default: {
1627                         break; }
1628
1629                 }
1630         }
1631         if (ndr_flags & NDR_BUFFERS) {
1632                 int level = ndr_push_get_switch_value(ndr, r);
1633                 switch (level) {
1634                         case 100:
1635                                 if (r->info100) {
1636                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo100(ndr, NDR_SCALARS|NDR_BUFFERS, r->info100));
1637                                 }
1638                         break;
1639
1640                         case 101:
1641                                 if (r->info101) {
1642                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info101));
1643                                 }
1644                         break;
1645
1646                         case 102:
1647                                 if (r->info102) {
1648                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo102(ndr, NDR_SCALARS|NDR_BUFFERS, r->info102));
1649                                 }
1650                         break;
1651
1652                         case 502:
1653                                 if (r->info502) {
1654                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo502(ndr, NDR_SCALARS, r->info502));
1655                                 }
1656                         break;
1657
1658                         case 1010:
1659                                 if (r->info1010) {
1660                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1010(ndr, NDR_SCALARS, r->info1010));
1661                                 }
1662                         break;
1663
1664                         case 1011:
1665                                 if (r->info1011) {
1666                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1011(ndr, NDR_SCALARS, r->info1011));
1667                                 }
1668                         break;
1669
1670                         case 1012:
1671                                 if (r->info1012) {
1672                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1012(ndr, NDR_SCALARS, r->info1012));
1673                                 }
1674                         break;
1675
1676                         case 1013:
1677                                 if (r->info1013) {
1678                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1013(ndr, NDR_SCALARS, r->info1013));
1679                                 }
1680                         break;
1681
1682                         case 1018:
1683                                 if (r->info1018) {
1684                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1018(ndr, NDR_SCALARS, r->info1018));
1685                                 }
1686                         break;
1687
1688                         case 1023:
1689                                 if (r->info1023) {
1690                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1023(ndr, NDR_SCALARS, r->info1023));
1691                                 }
1692                         break;
1693
1694                         case 1027:
1695                                 if (r->info1027) {
1696                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1027(ndr, NDR_SCALARS, r->info1027));
1697                                 }
1698                         break;
1699
1700                         case 1028:
1701                                 if (r->info1028) {
1702                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1028(ndr, NDR_SCALARS, r->info1028));
1703                                 }
1704                         break;
1705
1706                         case 1032:
1707                                 if (r->info1032) {
1708                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1032(ndr, NDR_SCALARS, r->info1032));
1709                                 }
1710                         break;
1711
1712                         case 1033:
1713                                 if (r->info1033) {
1714                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1033(ndr, NDR_SCALARS, r->info1033));
1715                                 }
1716                         break;
1717
1718                         case 1041:
1719                                 if (r->info1041) {
1720                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1041(ndr, NDR_SCALARS, r->info1041));
1721                                 }
1722                         break;
1723
1724                         case 1042:
1725                                 if (r->info1042) {
1726                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1042(ndr, NDR_SCALARS, r->info1042));
1727                                 }
1728                         break;
1729
1730                         case 1043:
1731                                 if (r->info1043) {
1732                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1043(ndr, NDR_SCALARS, r->info1043));
1733                                 }
1734                         break;
1735
1736                         case 1044:
1737                                 if (r->info1044) {
1738                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1044(ndr, NDR_SCALARS, r->info1044));
1739                                 }
1740                         break;
1741
1742                         case 1045:
1743                                 if (r->info1045) {
1744                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1045(ndr, NDR_SCALARS, r->info1045));
1745                                 }
1746                         break;
1747
1748                         case 1046:
1749                                 if (r->info1046) {
1750                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1046(ndr, NDR_SCALARS, r->info1046));
1751                                 }
1752                         break;
1753
1754                         case 1047:
1755                                 if (r->info1047) {
1756                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1047(ndr, NDR_SCALARS, r->info1047));
1757                                 }
1758                         break;
1759
1760                         case 1048:
1761                                 if (r->info1048) {
1762                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1048(ndr, NDR_SCALARS, r->info1048));
1763                                 }
1764                         break;
1765
1766                         case 1049:
1767                                 if (r->info1049) {
1768                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1049(ndr, NDR_SCALARS, r->info1049));
1769                                 }
1770                         break;
1771
1772                         case 1050:
1773                                 if (r->info1050) {
1774                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1050(ndr, NDR_SCALARS, r->info1050));
1775                                 }
1776                         break;
1777
1778                         case 1051:
1779                                 if (r->info1051) {
1780                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1051(ndr, NDR_SCALARS, r->info1051));
1781                                 }
1782                         break;
1783
1784                         case 1052:
1785                                 if (r->info1052) {
1786                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1052(ndr, NDR_SCALARS, r->info1052));
1787                                 }
1788                         break;
1789
1790                         case 1053:
1791                                 if (r->info1053) {
1792                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1053(ndr, NDR_SCALARS, r->info1053));
1793                                 }
1794                         break;
1795
1796                         case 1054:
1797                                 if (r->info1054) {
1798                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1054(ndr, NDR_SCALARS, r->info1054));
1799                                 }
1800                         break;
1801
1802                         case 1055:
1803                                 if (r->info1055) {
1804                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1055(ndr, NDR_SCALARS, r->info1055));
1805                                 }
1806                         break;
1807
1808                         case 1056:
1809                                 if (r->info1056) {
1810                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1056(ndr, NDR_SCALARS, r->info1056));
1811                                 }
1812                         break;
1813
1814                         case 1057:
1815                                 if (r->info1057) {
1816                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1057(ndr, NDR_SCALARS, r->info1057));
1817                                 }
1818                         break;
1819
1820                         case 1058:
1821                                 if (r->info1058) {
1822                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1058(ndr, NDR_SCALARS, r->info1058));
1823                                 }
1824                         break;
1825
1826                         case 1059:
1827                                 if (r->info1059) {
1828                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1059(ndr, NDR_SCALARS, r->info1059));
1829                                 }
1830                         break;
1831
1832                         case 1060:
1833                                 if (r->info1060) {
1834                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1060(ndr, NDR_SCALARS, r->info1060));
1835                                 }
1836                         break;
1837
1838                         case 1061:
1839                                 if (r->info1061) {
1840                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1061(ndr, NDR_SCALARS, r->info1061));
1841                                 }
1842                         break;
1843
1844                         case 1062:
1845                                 if (r->info1062) {
1846                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1062(ndr, NDR_SCALARS, r->info1062));
1847                                 }
1848                         break;
1849
1850                         default:
1851                         break;
1852
1853                 }
1854         }
1855         return NDR_ERR_SUCCESS;
1856 }
1857
1858 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetWkstaInfo *r)
1859 {
1860         int level;
1861         uint32_t _level;
1862         TALLOC_CTX *_mem_save_info100_0;
1863         TALLOC_CTX *_mem_save_info101_0;
1864         TALLOC_CTX *_mem_save_info102_0;
1865         TALLOC_CTX *_mem_save_info502_0;
1866         TALLOC_CTX *_mem_save_info1010_0;
1867         TALLOC_CTX *_mem_save_info1011_0;
1868         TALLOC_CTX *_mem_save_info1012_0;
1869         TALLOC_CTX *_mem_save_info1013_0;
1870         TALLOC_CTX *_mem_save_info1018_0;
1871         TALLOC_CTX *_mem_save_info1023_0;
1872         TALLOC_CTX *_mem_save_info1027_0;
1873         TALLOC_CTX *_mem_save_info1028_0;
1874         TALLOC_CTX *_mem_save_info1032_0;
1875         TALLOC_CTX *_mem_save_info1033_0;
1876         TALLOC_CTX *_mem_save_info1041_0;
1877         TALLOC_CTX *_mem_save_info1042_0;
1878         TALLOC_CTX *_mem_save_info1043_0;
1879         TALLOC_CTX *_mem_save_info1044_0;
1880         TALLOC_CTX *_mem_save_info1045_0;
1881         TALLOC_CTX *_mem_save_info1046_0;
1882         TALLOC_CTX *_mem_save_info1047_0;
1883         TALLOC_CTX *_mem_save_info1048_0;
1884         TALLOC_CTX *_mem_save_info1049_0;
1885         TALLOC_CTX *_mem_save_info1050_0;
1886         TALLOC_CTX *_mem_save_info1051_0;
1887         TALLOC_CTX *_mem_save_info1052_0;
1888         TALLOC_CTX *_mem_save_info1053_0;
1889         TALLOC_CTX *_mem_save_info1054_0;
1890         TALLOC_CTX *_mem_save_info1055_0;
1891         TALLOC_CTX *_mem_save_info1056_0;
1892         TALLOC_CTX *_mem_save_info1057_0;
1893         TALLOC_CTX *_mem_save_info1058_0;
1894         TALLOC_CTX *_mem_save_info1059_0;
1895         TALLOC_CTX *_mem_save_info1060_0;
1896         TALLOC_CTX *_mem_save_info1061_0;
1897         TALLOC_CTX *_mem_save_info1062_0;
1898         level = ndr_pull_get_switch_value(ndr, r);
1899         if (ndr_flags & NDR_SCALARS) {
1900                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
1901                 if (_level != level) {
1902                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
1903                 }
1904                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
1905                 switch (level) {
1906                         case 100: {
1907                                 uint32_t _ptr_info100;
1908                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info100));
1909                                 if (_ptr_info100) {
1910                                         NDR_PULL_ALLOC(ndr, r->info100);
1911                                 } else {
1912                                         r->info100 = NULL;
1913                                 }
1914                         break; }
1915
1916                         case 101: {
1917                                 uint32_t _ptr_info101;
1918                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info101));
1919                                 if (_ptr_info101) {
1920                                         NDR_PULL_ALLOC(ndr, r->info101);
1921                                 } else {
1922                                         r->info101 = NULL;
1923                                 }
1924                         break; }
1925
1926                         case 102: {
1927                                 uint32_t _ptr_info102;
1928                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info102));
1929                                 if (_ptr_info102) {
1930                                         NDR_PULL_ALLOC(ndr, r->info102);
1931                                 } else {
1932                                         r->info102 = NULL;
1933                                 }
1934                         break; }
1935
1936                         case 502: {
1937                                 uint32_t _ptr_info502;
1938                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info502));
1939                                 if (_ptr_info502) {
1940                                         NDR_PULL_ALLOC(ndr, r->info502);
1941                                 } else {
1942                                         r->info502 = NULL;
1943                                 }
1944                         break; }
1945
1946                         case 1010: {
1947                                 uint32_t _ptr_info1010;
1948                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1010));
1949                                 if (_ptr_info1010) {
1950                                         NDR_PULL_ALLOC(ndr, r->info1010);
1951                                 } else {
1952                                         r->info1010 = NULL;
1953                                 }
1954                         break; }
1955
1956                         case 1011: {
1957                                 uint32_t _ptr_info1011;
1958                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1011));
1959                                 if (_ptr_info1011) {
1960                                         NDR_PULL_ALLOC(ndr, r->info1011);
1961                                 } else {
1962                                         r->info1011 = NULL;
1963                                 }
1964                         break; }
1965
1966                         case 1012: {
1967                                 uint32_t _ptr_info1012;
1968                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1012));
1969                                 if (_ptr_info1012) {
1970                                         NDR_PULL_ALLOC(ndr, r->info1012);
1971                                 } else {
1972                                         r->info1012 = NULL;
1973                                 }
1974                         break; }
1975
1976                         case 1013: {
1977                                 uint32_t _ptr_info1013;
1978                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1013));
1979                                 if (_ptr_info1013) {
1980                                         NDR_PULL_ALLOC(ndr, r->info1013);
1981                                 } else {
1982                                         r->info1013 = NULL;
1983                                 }
1984                         break; }
1985
1986                         case 1018: {
1987                                 uint32_t _ptr_info1018;
1988                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1018));
1989                                 if (_ptr_info1018) {
1990                                         NDR_PULL_ALLOC(ndr, r->info1018);
1991                                 } else {
1992                                         r->info1018 = NULL;
1993                                 }
1994                         break; }
1995
1996                         case 1023: {
1997                                 uint32_t _ptr_info1023;
1998                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1023));
1999                                 if (_ptr_info1023) {
2000                                         NDR_PULL_ALLOC(ndr, r->info1023);
2001                                 } else {
2002                                         r->info1023 = NULL;
2003                                 }
2004                         break; }
2005
2006                         case 1027: {
2007                                 uint32_t _ptr_info1027;
2008                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1027));
2009                                 if (_ptr_info1027) {
2010                                         NDR_PULL_ALLOC(ndr, r->info1027);
2011                                 } else {
2012                                         r->info1027 = NULL;
2013                                 }
2014                         break; }
2015
2016                         case 1028: {
2017                                 uint32_t _ptr_info1028;
2018                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1028));
2019                                 if (_ptr_info1028) {
2020                                         NDR_PULL_ALLOC(ndr, r->info1028);
2021                                 } else {
2022                                         r->info1028 = NULL;
2023                                 }
2024                         break; }
2025
2026                         case 1032: {
2027                                 uint32_t _ptr_info1032;
2028                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1032));
2029                                 if (_ptr_info1032) {
2030                                         NDR_PULL_ALLOC(ndr, r->info1032);
2031                                 } else {
2032                                         r->info1032 = NULL;
2033                                 }
2034                         break; }
2035
2036                         case 1033: {
2037                                 uint32_t _ptr_info1033;
2038                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1033));
2039                                 if (_ptr_info1033) {
2040                                         NDR_PULL_ALLOC(ndr, r->info1033);
2041                                 } else {
2042                                         r->info1033 = NULL;
2043                                 }
2044                         break; }
2045
2046                         case 1041: {
2047                                 uint32_t _ptr_info1041;
2048                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1041));
2049                                 if (_ptr_info1041) {
2050                                         NDR_PULL_ALLOC(ndr, r->info1041);
2051                                 } else {
2052                                         r->info1041 = NULL;
2053                                 }
2054                         break; }
2055
2056                         case 1042: {
2057                                 uint32_t _ptr_info1042;
2058                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1042));
2059                                 if (_ptr_info1042) {
2060                                         NDR_PULL_ALLOC(ndr, r->info1042);
2061                                 } else {
2062                                         r->info1042 = NULL;
2063                                 }
2064                         break; }
2065
2066                         case 1043: {
2067                                 uint32_t _ptr_info1043;
2068                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1043));
2069                                 if (_ptr_info1043) {
2070                                         NDR_PULL_ALLOC(ndr, r->info1043);
2071                                 } else {
2072                                         r->info1043 = NULL;
2073                                 }
2074                         break; }
2075
2076                         case 1044: {
2077                                 uint32_t _ptr_info1044;
2078                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1044));
2079                                 if (_ptr_info1044) {
2080                                         NDR_PULL_ALLOC(ndr, r->info1044);
2081                                 } else {
2082                                         r->info1044 = NULL;
2083                                 }
2084                         break; }
2085
2086                         case 1045: {
2087                                 uint32_t _ptr_info1045;
2088                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1045));
2089                                 if (_ptr_info1045) {
2090                                         NDR_PULL_ALLOC(ndr, r->info1045);
2091                                 } else {
2092                                         r->info1045 = NULL;
2093                                 }
2094                         break; }
2095
2096                         case 1046: {
2097                                 uint32_t _ptr_info1046;
2098                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1046));
2099                                 if (_ptr_info1046) {
2100                                         NDR_PULL_ALLOC(ndr, r->info1046);
2101                                 } else {
2102                                         r->info1046 = NULL;
2103                                 }
2104                         break; }
2105
2106                         case 1047: {
2107                                 uint32_t _ptr_info1047;
2108                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1047));
2109                                 if (_ptr_info1047) {
2110                                         NDR_PULL_ALLOC(ndr, r->info1047);
2111                                 } else {
2112                                         r->info1047 = NULL;
2113                                 }
2114                         break; }
2115
2116                         case 1048: {
2117                                 uint32_t _ptr_info1048;
2118                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1048));
2119                                 if (_ptr_info1048) {
2120                                         NDR_PULL_ALLOC(ndr, r->info1048);
2121                                 } else {
2122                                         r->info1048 = NULL;
2123                                 }
2124                         break; }
2125
2126                         case 1049: {
2127                                 uint32_t _ptr_info1049;
2128                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1049));
2129                                 if (_ptr_info1049) {
2130                                         NDR_PULL_ALLOC(ndr, r->info1049);
2131                                 } else {
2132                                         r->info1049 = NULL;
2133                                 }
2134                         break; }
2135
2136                         case 1050: {
2137                                 uint32_t _ptr_info1050;
2138                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1050));
2139                                 if (_ptr_info1050) {
2140                                         NDR_PULL_ALLOC(ndr, r->info1050);
2141                                 } else {
2142                                         r->info1050 = NULL;
2143                                 }
2144                         break; }
2145
2146                         case 1051: {
2147                                 uint32_t _ptr_info1051;
2148                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1051));
2149                                 if (_ptr_info1051) {
2150                                         NDR_PULL_ALLOC(ndr, r->info1051);
2151                                 } else {
2152                                         r->info1051 = NULL;
2153                                 }
2154                         break; }
2155
2156                         case 1052: {
2157                                 uint32_t _ptr_info1052;
2158                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1052));
2159                                 if (_ptr_info1052) {
2160                                         NDR_PULL_ALLOC(ndr, r->info1052);
2161                                 } else {
2162                                         r->info1052 = NULL;
2163                                 }
2164                         break; }
2165
2166                         case 1053: {
2167                                 uint32_t _ptr_info1053;
2168                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1053));
2169                                 if (_ptr_info1053) {
2170                                         NDR_PULL_ALLOC(ndr, r->info1053);
2171                                 } else {
2172                                         r->info1053 = NULL;
2173                                 }
2174                         break; }
2175
2176                         case 1054: {
2177                                 uint32_t _ptr_info1054;
2178                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1054));
2179                                 if (_ptr_info1054) {
2180                                         NDR_PULL_ALLOC(ndr, r->info1054);
2181                                 } else {
2182                                         r->info1054 = NULL;
2183                                 }
2184                         break; }
2185
2186                         case 1055: {
2187                                 uint32_t _ptr_info1055;
2188                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1055));
2189                                 if (_ptr_info1055) {
2190                                         NDR_PULL_ALLOC(ndr, r->info1055);
2191                                 } else {
2192                                         r->info1055 = NULL;
2193                                 }
2194                         break; }
2195
2196                         case 1056: {
2197                                 uint32_t _ptr_info1056;
2198                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1056));
2199                                 if (_ptr_info1056) {
2200                                         NDR_PULL_ALLOC(ndr, r->info1056);
2201                                 } else {
2202                                         r->info1056 = NULL;
2203                                 }
2204                         break; }
2205
2206                         case 1057: {
2207                                 uint32_t _ptr_info1057;
2208                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1057));
2209                                 if (_ptr_info1057) {
2210                                         NDR_PULL_ALLOC(ndr, r->info1057);
2211                                 } else {
2212                                         r->info1057 = NULL;
2213                                 }
2214                         break; }
2215
2216                         case 1058: {
2217                                 uint32_t _ptr_info1058;
2218                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1058));
2219                                 if (_ptr_info1058) {
2220                                         NDR_PULL_ALLOC(ndr, r->info1058);
2221                                 } else {
2222                                         r->info1058 = NULL;
2223                                 }
2224                         break; }
2225
2226                         case 1059: {
2227                                 uint32_t _ptr_info1059;
2228                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1059));
2229                                 if (_ptr_info1059) {
2230                                         NDR_PULL_ALLOC(ndr, r->info1059);
2231                                 } else {
2232                                         r->info1059 = NULL;
2233                                 }
2234                         break; }
2235
2236                         case 1060: {
2237                                 uint32_t _ptr_info1060;
2238                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1060));
2239                                 if (_ptr_info1060) {
2240                                         NDR_PULL_ALLOC(ndr, r->info1060);
2241                                 } else {
2242                                         r->info1060 = NULL;
2243                                 }
2244                         break; }
2245
2246                         case 1061: {
2247                                 uint32_t _ptr_info1061;
2248                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1061));
2249                                 if (_ptr_info1061) {
2250                                         NDR_PULL_ALLOC(ndr, r->info1061);
2251                                 } else {
2252                                         r->info1061 = NULL;
2253                                 }
2254                         break; }
2255
2256                         case 1062: {
2257                                 uint32_t _ptr_info1062;
2258                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1062));
2259                                 if (_ptr_info1062) {
2260                                         NDR_PULL_ALLOC(ndr, r->info1062);
2261                                 } else {
2262                                         r->info1062 = NULL;
2263                                 }
2264                         break; }
2265
2266                         default: {
2267                         break; }
2268
2269                 }
2270         }
2271         if (ndr_flags & NDR_BUFFERS) {
2272                 switch (level) {
2273                         case 100:
2274                                 if (r->info100) {
2275                                         _mem_save_info100_0 = NDR_PULL_GET_MEM_CTX(ndr);
2276                                         NDR_PULL_SET_MEM_CTX(ndr, r->info100, 0);
2277                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo100(ndr, NDR_SCALARS|NDR_BUFFERS, r->info100));
2278                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info100_0, 0);
2279                                 }
2280                         break;
2281
2282                         case 101:
2283                                 if (r->info101) {
2284                                         _mem_save_info101_0 = NDR_PULL_GET_MEM_CTX(ndr);
2285                                         NDR_PULL_SET_MEM_CTX(ndr, r->info101, 0);
2286                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info101));
2287                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info101_0, 0);
2288                                 }
2289                         break;
2290
2291                         case 102:
2292                                 if (r->info102) {
2293                                         _mem_save_info102_0 = NDR_PULL_GET_MEM_CTX(ndr);
2294                                         NDR_PULL_SET_MEM_CTX(ndr, r->info102, 0);
2295                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo102(ndr, NDR_SCALARS|NDR_BUFFERS, r->info102));
2296                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info102_0, 0);
2297                                 }
2298                         break;
2299
2300                         case 502:
2301                                 if (r->info502) {
2302                                         _mem_save_info502_0 = NDR_PULL_GET_MEM_CTX(ndr);
2303                                         NDR_PULL_SET_MEM_CTX(ndr, r->info502, 0);
2304                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo502(ndr, NDR_SCALARS, r->info502));
2305                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info502_0, 0);
2306                                 }
2307                         break;
2308
2309                         case 1010:
2310                                 if (r->info1010) {
2311                                         _mem_save_info1010_0 = NDR_PULL_GET_MEM_CTX(ndr);
2312                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1010, 0);
2313                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1010(ndr, NDR_SCALARS, r->info1010));
2314                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1010_0, 0);
2315                                 }
2316                         break;
2317
2318                         case 1011:
2319                                 if (r->info1011) {
2320                                         _mem_save_info1011_0 = NDR_PULL_GET_MEM_CTX(ndr);
2321                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1011, 0);
2322                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1011(ndr, NDR_SCALARS, r->info1011));
2323                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1011_0, 0);
2324                                 }
2325                         break;
2326
2327                         case 1012:
2328                                 if (r->info1012) {
2329                                         _mem_save_info1012_0 = NDR_PULL_GET_MEM_CTX(ndr);
2330                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1012, 0);
2331                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1012(ndr, NDR_SCALARS, r->info1012));
2332                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1012_0, 0);
2333                                 }
2334                         break;
2335
2336                         case 1013:
2337                                 if (r->info1013) {
2338                                         _mem_save_info1013_0 = NDR_PULL_GET_MEM_CTX(ndr);
2339                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1013, 0);
2340                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1013(ndr, NDR_SCALARS, r->info1013));
2341                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1013_0, 0);
2342                                 }
2343                         break;
2344
2345                         case 1018:
2346                                 if (r->info1018) {
2347                                         _mem_save_info1018_0 = NDR_PULL_GET_MEM_CTX(ndr);
2348                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1018, 0);
2349                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1018(ndr, NDR_SCALARS, r->info1018));
2350                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1018_0, 0);
2351                                 }
2352                         break;
2353
2354                         case 1023:
2355                                 if (r->info1023) {
2356                                         _mem_save_info1023_0 = NDR_PULL_GET_MEM_CTX(ndr);
2357                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1023, 0);
2358                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1023(ndr, NDR_SCALARS, r->info1023));
2359                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1023_0, 0);
2360                                 }
2361                         break;
2362
2363                         case 1027:
2364                                 if (r->info1027) {
2365                                         _mem_save_info1027_0 = NDR_PULL_GET_MEM_CTX(ndr);
2366                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1027, 0);
2367                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1027(ndr, NDR_SCALARS, r->info1027));
2368                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1027_0, 0);
2369                                 }
2370                         break;
2371
2372                         case 1028:
2373                                 if (r->info1028) {
2374                                         _mem_save_info1028_0 = NDR_PULL_GET_MEM_CTX(ndr);
2375                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1028, 0);
2376                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1028(ndr, NDR_SCALARS, r->info1028));
2377                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1028_0, 0);
2378                                 }
2379                         break;
2380
2381                         case 1032:
2382                                 if (r->info1032) {
2383                                         _mem_save_info1032_0 = NDR_PULL_GET_MEM_CTX(ndr);
2384                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1032, 0);
2385                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1032(ndr, NDR_SCALARS, r->info1032));
2386                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1032_0, 0);
2387                                 }
2388                         break;
2389
2390                         case 1033:
2391                                 if (r->info1033) {
2392                                         _mem_save_info1033_0 = NDR_PULL_GET_MEM_CTX(ndr);
2393                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1033, 0);
2394                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1033(ndr, NDR_SCALARS, r->info1033));
2395                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1033_0, 0);
2396                                 }
2397                         break;
2398
2399                         case 1041:
2400                                 if (r->info1041) {
2401                                         _mem_save_info1041_0 = NDR_PULL_GET_MEM_CTX(ndr);
2402                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1041, 0);
2403                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1041(ndr, NDR_SCALARS, r->info1041));
2404                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1041_0, 0);
2405                                 }
2406                         break;
2407
2408                         case 1042:
2409                                 if (r->info1042) {
2410                                         _mem_save_info1042_0 = NDR_PULL_GET_MEM_CTX(ndr);
2411                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1042, 0);
2412                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1042(ndr, NDR_SCALARS, r->info1042));
2413                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1042_0, 0);
2414                                 }
2415                         break;
2416
2417                         case 1043:
2418                                 if (r->info1043) {
2419                                         _mem_save_info1043_0 = NDR_PULL_GET_MEM_CTX(ndr);
2420                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1043, 0);
2421                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1043(ndr, NDR_SCALARS, r->info1043));
2422                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1043_0, 0);
2423                                 }
2424                         break;
2425
2426                         case 1044:
2427                                 if (r->info1044) {
2428                                         _mem_save_info1044_0 = NDR_PULL_GET_MEM_CTX(ndr);
2429                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1044, 0);
2430                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1044(ndr, NDR_SCALARS, r->info1044));
2431                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1044_0, 0);
2432                                 }
2433                         break;
2434
2435                         case 1045:
2436                                 if (r->info1045) {
2437                                         _mem_save_info1045_0 = NDR_PULL_GET_MEM_CTX(ndr);
2438                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1045, 0);
2439                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1045(ndr, NDR_SCALARS, r->info1045));
2440                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1045_0, 0);
2441                                 }
2442                         break;
2443
2444                         case 1046:
2445                                 if (r->info1046) {
2446                                         _mem_save_info1046_0 = NDR_PULL_GET_MEM_CTX(ndr);
2447                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1046, 0);
2448                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1046(ndr, NDR_SCALARS, r->info1046));
2449                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1046_0, 0);
2450                                 }
2451                         break;
2452
2453                         case 1047:
2454                                 if (r->info1047) {
2455                                         _mem_save_info1047_0 = NDR_PULL_GET_MEM_CTX(ndr);
2456                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1047, 0);
2457                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1047(ndr, NDR_SCALARS, r->info1047));
2458                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1047_0, 0);
2459                                 }
2460                         break;
2461
2462                         case 1048:
2463                                 if (r->info1048) {
2464                                         _mem_save_info1048_0 = NDR_PULL_GET_MEM_CTX(ndr);
2465                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1048, 0);
2466                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1048(ndr, NDR_SCALARS, r->info1048));
2467                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1048_0, 0);
2468                                 }
2469                         break;
2470
2471                         case 1049:
2472                                 if (r->info1049) {
2473                                         _mem_save_info1049_0 = NDR_PULL_GET_MEM_CTX(ndr);
2474                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1049, 0);
2475                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1049(ndr, NDR_SCALARS, r->info1049));
2476                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1049_0, 0);
2477                                 }
2478                         break;
2479
2480                         case 1050:
2481                                 if (r->info1050) {
2482                                         _mem_save_info1050_0 = NDR_PULL_GET_MEM_CTX(ndr);
2483                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1050, 0);
2484                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1050(ndr, NDR_SCALARS, r->info1050));
2485                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1050_0, 0);
2486                                 }
2487                         break;
2488
2489                         case 1051:
2490                                 if (r->info1051) {
2491                                         _mem_save_info1051_0 = NDR_PULL_GET_MEM_CTX(ndr);
2492                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1051, 0);
2493                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1051(ndr, NDR_SCALARS, r->info1051));
2494                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1051_0, 0);
2495                                 }
2496                         break;
2497
2498                         case 1052:
2499                                 if (r->info1052) {
2500                                         _mem_save_info1052_0 = NDR_PULL_GET_MEM_CTX(ndr);
2501                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1052, 0);
2502                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1052(ndr, NDR_SCALARS, r->info1052));
2503                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1052_0, 0);
2504                                 }
2505                         break;
2506
2507                         case 1053:
2508                                 if (r->info1053) {
2509                                         _mem_save_info1053_0 = NDR_PULL_GET_MEM_CTX(ndr);
2510                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1053, 0);
2511                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1053(ndr, NDR_SCALARS, r->info1053));
2512                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1053_0, 0);
2513                                 }
2514                         break;
2515
2516                         case 1054:
2517                                 if (r->info1054) {
2518                                         _mem_save_info1054_0 = NDR_PULL_GET_MEM_CTX(ndr);
2519                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1054, 0);
2520                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1054(ndr, NDR_SCALARS, r->info1054));
2521                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1054_0, 0);
2522                                 }
2523                         break;
2524
2525                         case 1055:
2526                                 if (r->info1055) {
2527                                         _mem_save_info1055_0 = NDR_PULL_GET_MEM_CTX(ndr);
2528                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1055, 0);
2529                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1055(ndr, NDR_SCALARS, r->info1055));
2530                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1055_0, 0);
2531                                 }
2532                         break;
2533
2534                         case 1056:
2535                                 if (r->info1056) {
2536                                         _mem_save_info1056_0 = NDR_PULL_GET_MEM_CTX(ndr);
2537                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1056, 0);
2538                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1056(ndr, NDR_SCALARS, r->info1056));
2539                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1056_0, 0);
2540                                 }
2541                         break;
2542
2543                         case 1057:
2544                                 if (r->info1057) {
2545                                         _mem_save_info1057_0 = NDR_PULL_GET_MEM_CTX(ndr);
2546                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1057, 0);
2547                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1057(ndr, NDR_SCALARS, r->info1057));
2548                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1057_0, 0);
2549                                 }
2550                         break;
2551
2552                         case 1058:
2553                                 if (r->info1058) {
2554                                         _mem_save_info1058_0 = NDR_PULL_GET_MEM_CTX(ndr);
2555                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1058, 0);
2556                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1058(ndr, NDR_SCALARS, r->info1058));
2557                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1058_0, 0);
2558                                 }
2559                         break;
2560
2561                         case 1059:
2562                                 if (r->info1059) {
2563                                         _mem_save_info1059_0 = NDR_PULL_GET_MEM_CTX(ndr);
2564                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1059, 0);
2565                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1059(ndr, NDR_SCALARS, r->info1059));
2566                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1059_0, 0);
2567                                 }
2568                         break;
2569
2570                         case 1060:
2571                                 if (r->info1060) {
2572                                         _mem_save_info1060_0 = NDR_PULL_GET_MEM_CTX(ndr);
2573                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1060, 0);
2574                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1060(ndr, NDR_SCALARS, r->info1060));
2575                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1060_0, 0);
2576                                 }
2577                         break;
2578
2579                         case 1061:
2580                                 if (r->info1061) {
2581                                         _mem_save_info1061_0 = NDR_PULL_GET_MEM_CTX(ndr);
2582                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1061, 0);
2583                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1061(ndr, NDR_SCALARS, r->info1061));
2584                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1061_0, 0);
2585                                 }
2586                         break;
2587
2588                         case 1062:
2589                                 if (r->info1062) {
2590                                         _mem_save_info1062_0 = NDR_PULL_GET_MEM_CTX(ndr);
2591                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1062, 0);
2592                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1062(ndr, NDR_SCALARS, r->info1062));
2593                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1062_0, 0);
2594                                 }
2595                         break;
2596
2597                         default:
2598                         break;
2599
2600                 }
2601         }
2602         return NDR_ERR_SUCCESS;
2603 }
2604
2605 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo(struct ndr_print *ndr, const char *name, const union wkssvc_NetWkstaInfo *r)
2606 {
2607         int level;
2608         level = ndr_print_get_switch_value(ndr, r);
2609         ndr_print_union(ndr, name, level, "wkssvc_NetWkstaInfo");
2610         switch (level) {
2611                 case 100:
2612                         ndr_print_ptr(ndr, "info100", r->info100);
2613                         ndr->depth++;
2614                         if (r->info100) {
2615                                 ndr_print_wkssvc_NetWkstaInfo100(ndr, "info100", r->info100);
2616                         }
2617                         ndr->depth--;
2618                 break;
2619
2620                 case 101:
2621                         ndr_print_ptr(ndr, "info101", r->info101);
2622                         ndr->depth++;
2623                         if (r->info101) {
2624                                 ndr_print_wkssvc_NetWkstaInfo101(ndr, "info101", r->info101);
2625                         }
2626                         ndr->depth--;
2627                 break;
2628
2629                 case 102:
2630                         ndr_print_ptr(ndr, "info102", r->info102);
2631                         ndr->depth++;
2632                         if (r->info102) {
2633                                 ndr_print_wkssvc_NetWkstaInfo102(ndr, "info102", r->info102);
2634                         }
2635                         ndr->depth--;
2636                 break;
2637
2638                 case 502:
2639                         ndr_print_ptr(ndr, "info502", r->info502);
2640                         ndr->depth++;
2641                         if (r->info502) {
2642                                 ndr_print_wkssvc_NetWkstaInfo502(ndr, "info502", r->info502);
2643                         }
2644                         ndr->depth--;
2645                 break;
2646
2647                 case 1010:
2648                         ndr_print_ptr(ndr, "info1010", r->info1010);
2649                         ndr->depth++;
2650                         if (r->info1010) {
2651                                 ndr_print_wkssvc_NetWkstaInfo1010(ndr, "info1010", r->info1010);
2652                         }
2653                         ndr->depth--;
2654                 break;
2655
2656                 case 1011:
2657                         ndr_print_ptr(ndr, "info1011", r->info1011);
2658                         ndr->depth++;
2659                         if (r->info1011) {
2660                                 ndr_print_wkssvc_NetWkstaInfo1011(ndr, "info1011", r->info1011);
2661                         }
2662                         ndr->depth--;
2663                 break;
2664
2665                 case 1012:
2666                         ndr_print_ptr(ndr, "info1012", r->info1012);
2667                         ndr->depth++;
2668                         if (r->info1012) {
2669                                 ndr_print_wkssvc_NetWkstaInfo1012(ndr, "info1012", r->info1012);
2670                         }
2671                         ndr->depth--;
2672                 break;
2673
2674                 case 1013:
2675                         ndr_print_ptr(ndr, "info1013", r->info1013);
2676                         ndr->depth++;
2677                         if (r->info1013) {
2678                                 ndr_print_wkssvc_NetWkstaInfo1013(ndr, "info1013", r->info1013);
2679                         }
2680                         ndr->depth--;
2681                 break;
2682
2683                 case 1018:
2684                         ndr_print_ptr(ndr, "info1018", r->info1018);
2685                         ndr->depth++;
2686                         if (r->info1018) {
2687                                 ndr_print_wkssvc_NetWkstaInfo1018(ndr, "info1018", r->info1018);
2688                         }
2689                         ndr->depth--;
2690                 break;
2691
2692                 case 1023:
2693                         ndr_print_ptr(ndr, "info1023", r->info1023);
2694                         ndr->depth++;
2695                         if (r->info1023) {
2696                                 ndr_print_wkssvc_NetWkstaInfo1023(ndr, "info1023", r->info1023);
2697                         }
2698                         ndr->depth--;
2699                 break;
2700
2701                 case 1027:
2702                         ndr_print_ptr(ndr, "info1027", r->info1027);
2703                         ndr->depth++;
2704                         if (r->info1027) {
2705                                 ndr_print_wkssvc_NetWkstaInfo1027(ndr, "info1027", r->info1027);
2706                         }
2707                         ndr->depth--;
2708                 break;
2709
2710                 case 1028:
2711                         ndr_print_ptr(ndr, "info1028", r->info1028);
2712                         ndr->depth++;
2713                         if (r->info1028) {
2714                                 ndr_print_wkssvc_NetWkstaInfo1028(ndr, "info1028", r->info1028);
2715                         }
2716                         ndr->depth--;
2717                 break;
2718
2719                 case 1032:
2720                         ndr_print_ptr(ndr, "info1032", r->info1032);
2721                         ndr->depth++;
2722                         if (r->info1032) {
2723                                 ndr_print_wkssvc_NetWkstaInfo1032(ndr, "info1032", r->info1032);
2724                         }
2725                         ndr->depth--;
2726                 break;
2727
2728                 case 1033:
2729                         ndr_print_ptr(ndr, "info1033", r->info1033);
2730                         ndr->depth++;
2731                         if (r->info1033) {
2732                                 ndr_print_wkssvc_NetWkstaInfo1033(ndr, "info1033", r->info1033);
2733                         }
2734                         ndr->depth--;
2735                 break;
2736
2737                 case 1041:
2738                         ndr_print_ptr(ndr, "info1041", r->info1041);
2739                         ndr->depth++;
2740                         if (r->info1041) {
2741                                 ndr_print_wkssvc_NetWkstaInfo1041(ndr, "info1041", r->info1041);
2742                         }
2743                         ndr->depth--;
2744                 break;
2745
2746                 case 1042:
2747                         ndr_print_ptr(ndr, "info1042", r->info1042);
2748                         ndr->depth++;
2749                         if (r->info1042) {
2750                                 ndr_print_wkssvc_NetWkstaInfo1042(ndr, "info1042", r->info1042);
2751                         }
2752                         ndr->depth--;
2753                 break;
2754
2755                 case 1043:
2756                         ndr_print_ptr(ndr, "info1043", r->info1043);
2757                         ndr->depth++;
2758                         if (r->info1043) {
2759                                 ndr_print_wkssvc_NetWkstaInfo1043(ndr, "info1043", r->info1043);
2760                         }
2761                         ndr->depth--;
2762                 break;
2763
2764                 case 1044:
2765                         ndr_print_ptr(ndr, "info1044", r->info1044);
2766                         ndr->depth++;
2767                         if (r->info1044) {
2768                                 ndr_print_wkssvc_NetWkstaInfo1044(ndr, "info1044", r->info1044);
2769                         }
2770                         ndr->depth--;
2771                 break;
2772
2773                 case 1045:
2774                         ndr_print_ptr(ndr, "info1045", r->info1045);
2775                         ndr->depth++;
2776                         if (r->info1045) {
2777                                 ndr_print_wkssvc_NetWkstaInfo1045(ndr, "info1045", r->info1045);
2778                         }
2779                         ndr->depth--;
2780                 break;
2781
2782                 case 1046:
2783                         ndr_print_ptr(ndr, "info1046", r->info1046);
2784                         ndr->depth++;
2785                         if (r->info1046) {
2786                                 ndr_print_wkssvc_NetWkstaInfo1046(ndr, "info1046", r->info1046);
2787                         }
2788                         ndr->depth--;
2789                 break;
2790
2791                 case 1047:
2792                         ndr_print_ptr(ndr, "info1047", r->info1047);
2793                         ndr->depth++;
2794                         if (r->info1047) {
2795                                 ndr_print_wkssvc_NetWkstaInfo1047(ndr, "info1047", r->info1047);
2796                         }
2797                         ndr->depth--;
2798                 break;
2799
2800                 case 1048:
2801                         ndr_print_ptr(ndr, "info1048", r->info1048);
2802                         ndr->depth++;
2803                         if (r->info1048) {
2804                                 ndr_print_wkssvc_NetWkstaInfo1048(ndr, "info1048", r->info1048);
2805                         }
2806                         ndr->depth--;
2807                 break;
2808
2809                 case 1049:
2810                         ndr_print_ptr(ndr, "info1049", r->info1049);
2811                         ndr->depth++;
2812                         if (r->info1049) {
2813                                 ndr_print_wkssvc_NetWkstaInfo1049(ndr, "info1049", r->info1049);
2814                         }
2815                         ndr->depth--;
2816                 break;
2817
2818                 case 1050:
2819                         ndr_print_ptr(ndr, "info1050", r->info1050);
2820                         ndr->depth++;
2821                         if (r->info1050) {
2822                                 ndr_print_wkssvc_NetWkstaInfo1050(ndr, "info1050", r->info1050);
2823                         }
2824                         ndr->depth--;
2825                 break;
2826
2827                 case 1051:
2828                         ndr_print_ptr(ndr, "info1051", r->info1051);
2829                         ndr->depth++;
2830                         if (r->info1051) {
2831                                 ndr_print_wkssvc_NetWkstaInfo1051(ndr, "info1051", r->info1051);
2832                         }
2833                         ndr->depth--;
2834                 break;
2835
2836                 case 1052:
2837                         ndr_print_ptr(ndr, "info1052", r->info1052);
2838                         ndr->depth++;
2839                         if (r->info1052) {
2840                                 ndr_print_wkssvc_NetWkstaInfo1052(ndr, "info1052", r->info1052);
2841                         }
2842                         ndr->depth--;
2843                 break;
2844
2845                 case 1053:
2846                         ndr_print_ptr(ndr, "info1053", r->info1053);
2847                         ndr->depth++;
2848                         if (r->info1053) {
2849                                 ndr_print_wkssvc_NetWkstaInfo1053(ndr, "info1053", r->info1053);
2850                         }
2851                         ndr->depth--;
2852                 break;
2853
2854                 case 1054:
2855                         ndr_print_ptr(ndr, "info1054", r->info1054);
2856                         ndr->depth++;
2857                         if (r->info1054) {
2858                                 ndr_print_wkssvc_NetWkstaInfo1054(ndr, "info1054", r->info1054);
2859                         }
2860                         ndr->depth--;
2861                 break;
2862
2863                 case 1055:
2864                         ndr_print_ptr(ndr, "info1055", r->info1055);
2865                         ndr->depth++;
2866                         if (r->info1055) {
2867                                 ndr_print_wkssvc_NetWkstaInfo1055(ndr, "info1055", r->info1055);
2868                         }
2869                         ndr->depth--;
2870                 break;
2871
2872                 case 1056:
2873                         ndr_print_ptr(ndr, "info1056", r->info1056);
2874                         ndr->depth++;
2875                         if (r->info1056) {
2876                                 ndr_print_wkssvc_NetWkstaInfo1056(ndr, "info1056", r->info1056);
2877                         }
2878                         ndr->depth--;
2879                 break;
2880
2881                 case 1057:
2882                         ndr_print_ptr(ndr, "info1057", r->info1057);
2883                         ndr->depth++;
2884                         if (r->info1057) {
2885                                 ndr_print_wkssvc_NetWkstaInfo1057(ndr, "info1057", r->info1057);
2886                         }
2887                         ndr->depth--;
2888                 break;
2889
2890                 case 1058:
2891                         ndr_print_ptr(ndr, "info1058", r->info1058);
2892                         ndr->depth++;
2893                         if (r->info1058) {
2894                                 ndr_print_wkssvc_NetWkstaInfo1058(ndr, "info1058", r->info1058);
2895                         }
2896                         ndr->depth--;
2897                 break;
2898
2899                 case 1059:
2900                         ndr_print_ptr(ndr, "info1059", r->info1059);
2901                         ndr->depth++;
2902                         if (r->info1059) {
2903                                 ndr_print_wkssvc_NetWkstaInfo1059(ndr, "info1059", r->info1059);
2904                         }
2905                         ndr->depth--;
2906                 break;
2907
2908                 case 1060:
2909                         ndr_print_ptr(ndr, "info1060", r->info1060);
2910                         ndr->depth++;
2911                         if (r->info1060) {
2912                                 ndr_print_wkssvc_NetWkstaInfo1060(ndr, "info1060", r->info1060);
2913                         }
2914                         ndr->depth--;
2915                 break;
2916
2917                 case 1061:
2918                         ndr_print_ptr(ndr, "info1061", r->info1061);
2919                         ndr->depth++;
2920                         if (r->info1061) {
2921                                 ndr_print_wkssvc_NetWkstaInfo1061(ndr, "info1061", r->info1061);
2922                         }
2923                         ndr->depth--;
2924                 break;
2925
2926                 case 1062:
2927                         ndr_print_ptr(ndr, "info1062", r->info1062);
2928                         ndr->depth++;
2929                         if (r->info1062) {
2930                                 ndr_print_wkssvc_NetWkstaInfo1062(ndr, "info1062", r->info1062);
2931                         }
2932                         ndr->depth--;
2933                 break;
2934
2935                 default:
2936                 break;
2937
2938         }
2939 }
2940
2941 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserInfo0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrWkstaUserInfo0 *r)
2942 {
2943         if (ndr_flags & NDR_SCALARS) {
2944                 NDR_CHECK(ndr_push_align(ndr, 5));
2945                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
2946         }
2947         if (ndr_flags & NDR_BUFFERS) {
2948                 if (r->user_name) {
2949                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
2950                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2951                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
2952                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2953                 }
2954         }
2955         return NDR_ERR_SUCCESS;
2956 }
2957
2958 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserInfo0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrWkstaUserInfo0 *r)
2959 {
2960         uint32_t _ptr_user_name;
2961         TALLOC_CTX *_mem_save_user_name_0;
2962         if (ndr_flags & NDR_SCALARS) {
2963                 NDR_CHECK(ndr_pull_align(ndr, 5));
2964                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
2965                 if (_ptr_user_name) {
2966                         NDR_PULL_ALLOC(ndr, r->user_name);
2967                 } else {
2968                         r->user_name = NULL;
2969                 }
2970         }
2971         if (ndr_flags & NDR_BUFFERS) {
2972                 if (r->user_name) {
2973                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2974                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
2975                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
2976                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
2977                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
2978                                 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));
2979                         }
2980                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
2981                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
2982                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
2983                 }
2984         }
2985         return NDR_ERR_SUCCESS;
2986 }
2987
2988 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserInfo0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrWkstaUserInfo0 *r)
2989 {
2990         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaUserInfo0");
2991         ndr->depth++;
2992         ndr_print_ptr(ndr, "user_name", r->user_name);
2993         ndr->depth++;
2994         if (r->user_name) {
2995                 ndr_print_string(ndr, "user_name", r->user_name);
2996         }
2997         ndr->depth--;
2998         ndr->depth--;
2999 }
3000
3001 static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsersCtr0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaEnumUsersCtr0 *r)
3002 {
3003         uint32_t cntr_user0_1;
3004         if (ndr_flags & NDR_SCALARS) {
3005                 NDR_CHECK(ndr_push_align(ndr, 5));
3006                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->entries_read));
3007                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user0));
3008         }
3009         if (ndr_flags & NDR_BUFFERS) {
3010                 if (r->user0) {
3011                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->entries_read));
3012                         for (cntr_user0_1 = 0; cntr_user0_1 < r->entries_read; cntr_user0_1++) {
3013                                 NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo0(ndr, NDR_SCALARS, &r->user0[cntr_user0_1]));
3014                         }
3015                         for (cntr_user0_1 = 0; cntr_user0_1 < r->entries_read; cntr_user0_1++) {
3016                                 NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo0(ndr, NDR_BUFFERS, &r->user0[cntr_user0_1]));
3017                         }
3018                 }
3019         }
3020         return NDR_ERR_SUCCESS;
3021 }
3022
3023 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsersCtr0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaEnumUsersCtr0 *r)
3024 {
3025         uint32_t _ptr_user0;
3026         uint32_t cntr_user0_1;
3027         TALLOC_CTX *_mem_save_user0_0;
3028         TALLOC_CTX *_mem_save_user0_1;
3029         if (ndr_flags & NDR_SCALARS) {
3030                 NDR_CHECK(ndr_pull_align(ndr, 5));
3031                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->entries_read));
3032                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user0));
3033                 if (_ptr_user0) {
3034                         NDR_PULL_ALLOC(ndr, r->user0);
3035                 } else {
3036                         r->user0 = NULL;
3037                 }
3038         }
3039         if (ndr_flags & NDR_BUFFERS) {
3040                 if (r->user0) {
3041                         _mem_save_user0_0 = NDR_PULL_GET_MEM_CTX(ndr);
3042                         NDR_PULL_SET_MEM_CTX(ndr, r->user0, 0);
3043                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user0));
3044                         NDR_PULL_ALLOC_N(ndr, r->user0, ndr_get_array_size(ndr, &r->user0));
3045                         _mem_save_user0_1 = NDR_PULL_GET_MEM_CTX(ndr);
3046                         NDR_PULL_SET_MEM_CTX(ndr, r->user0, 0);
3047                         for (cntr_user0_1 = 0; cntr_user0_1 < r->entries_read; cntr_user0_1++) {
3048                                 NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo0(ndr, NDR_SCALARS, &r->user0[cntr_user0_1]));
3049                         }
3050                         for (cntr_user0_1 = 0; cntr_user0_1 < r->entries_read; cntr_user0_1++) {
3051                                 NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo0(ndr, NDR_BUFFERS, &r->user0[cntr_user0_1]));
3052                         }
3053                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user0_1, 0);
3054                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user0_0, 0);
3055                 }
3056                 if (r->user0) {
3057                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->user0, r->entries_read));
3058                 }
3059         }
3060         return NDR_ERR_SUCCESS;
3061 }
3062
3063 _PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsersCtr0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaEnumUsersCtr0 *r)
3064 {
3065         uint32_t cntr_user0_1;
3066         ndr_print_struct(ndr, name, "wkssvc_NetWkstaEnumUsersCtr0");
3067         ndr->depth++;
3068         ndr_print_uint32(ndr, "entries_read", r->entries_read);
3069         ndr_print_ptr(ndr, "user0", r->user0);
3070         ndr->depth++;
3071         if (r->user0) {
3072                 ndr->print(ndr, "%s: ARRAY(%d)", "user0", (int)r->entries_read);
3073                 ndr->depth++;
3074                 for (cntr_user0_1=0;cntr_user0_1<r->entries_read;cntr_user0_1++) {
3075                         char *idx_1=NULL;
3076                         if (asprintf(&idx_1, "[%d]", cntr_user0_1) != -1) {
3077                                 ndr_print_wkssvc_NetrWkstaUserInfo0(ndr, "user0", &r->user0[cntr_user0_1]);
3078                                 free(idx_1);
3079                         }
3080                 }
3081                 ndr->depth--;
3082         }
3083         ndr->depth--;
3084         ndr->depth--;
3085 }
3086
3087 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserInfo1(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrWkstaUserInfo1 *r)
3088 {
3089         if (ndr_flags & NDR_SCALARS) {
3090                 NDR_CHECK(ndr_push_align(ndr, 5));
3091                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
3092                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->logon_domain));
3093                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->other_domains));
3094                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->logon_server));
3095         }
3096         if (ndr_flags & NDR_BUFFERS) {
3097                 if (r->user_name) {
3098                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
3099                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3100                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
3101                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3102                 }
3103                 if (r->logon_domain) {
3104                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->logon_domain, CH_UTF16)));
3105                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3106                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->logon_domain, CH_UTF16)));
3107                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->logon_domain, ndr_charset_length(r->logon_domain, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3108                 }
3109                 if (r->other_domains) {
3110                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->other_domains, CH_UTF16)));
3111                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3112                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->other_domains, CH_UTF16)));
3113                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->other_domains, ndr_charset_length(r->other_domains, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3114                 }
3115                 if (r->logon_server) {
3116                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->logon_server, CH_UTF16)));
3117                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3118                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->logon_server, CH_UTF16)));
3119                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->logon_server, ndr_charset_length(r->logon_server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3120                 }
3121         }
3122         return NDR_ERR_SUCCESS;
3123 }
3124
3125 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserInfo1(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrWkstaUserInfo1 *r)
3126 {
3127         uint32_t _ptr_user_name;
3128         TALLOC_CTX *_mem_save_user_name_0;
3129         uint32_t _ptr_logon_domain;
3130         TALLOC_CTX *_mem_save_logon_domain_0;
3131         uint32_t _ptr_other_domains;
3132         TALLOC_CTX *_mem_save_other_domains_0;
3133         uint32_t _ptr_logon_server;
3134         TALLOC_CTX *_mem_save_logon_server_0;
3135         if (ndr_flags & NDR_SCALARS) {
3136                 NDR_CHECK(ndr_pull_align(ndr, 5));
3137                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3138                 if (_ptr_user_name) {
3139                         NDR_PULL_ALLOC(ndr, r->user_name);
3140                 } else {
3141                         r->user_name = NULL;
3142                 }
3143                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_logon_domain));
3144                 if (_ptr_logon_domain) {
3145                         NDR_PULL_ALLOC(ndr, r->logon_domain);
3146                 } else {
3147                         r->logon_domain = NULL;
3148                 }
3149                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_other_domains));
3150                 if (_ptr_other_domains) {
3151                         NDR_PULL_ALLOC(ndr, r->other_domains);
3152                 } else {
3153                         r->other_domains = NULL;
3154                 }
3155                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_logon_server));
3156                 if (_ptr_logon_server) {
3157                         NDR_PULL_ALLOC(ndr, r->logon_server);
3158                 } else {
3159                         r->logon_server = NULL;
3160                 }
3161         }
3162         if (ndr_flags & NDR_BUFFERS) {
3163                 if (r->user_name) {
3164                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3165                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3166                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
3167                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
3168                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
3169                                 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));
3170                         }
3171                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
3172                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
3173                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3174                 }
3175                 if (r->logon_domain) {
3176                         _mem_save_logon_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
3177                         NDR_PULL_SET_MEM_CTX(ndr, r->logon_domain, 0);
3178                         NDR_CHECK(ndr_pull_array_size(ndr, &r->logon_domain));
3179                         NDR_CHECK(ndr_pull_array_length(ndr, &r->logon_domain));
3180                         if (ndr_get_array_length(ndr, &r->logon_domain) > ndr_get_array_size(ndr, &r->logon_domain)) {
3181                                 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));
3182                         }
3183                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->logon_domain), sizeof(uint16_t)));
3184                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->logon_domain, ndr_get_array_length(ndr, &r->logon_domain), sizeof(uint16_t), CH_UTF16));
3185                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_logon_domain_0, 0);
3186                 }
3187                 if (r->other_domains) {
3188                         _mem_save_other_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
3189                         NDR_PULL_SET_MEM_CTX(ndr, r->other_domains, 0);
3190                         NDR_CHECK(ndr_pull_array_size(ndr, &r->other_domains));
3191                         NDR_CHECK(ndr_pull_array_length(ndr, &r->other_domains));
3192                         if (ndr_get_array_length(ndr, &r->other_domains) > ndr_get_array_size(ndr, &r->other_domains)) {
3193                                 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));
3194                         }
3195                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->other_domains), sizeof(uint16_t)));
3196                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->other_domains, ndr_get_array_length(ndr, &r->other_domains), sizeof(uint16_t), CH_UTF16));
3197                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_other_domains_0, 0);
3198                 }
3199                 if (r->logon_server) {
3200                         _mem_save_logon_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
3201                         NDR_PULL_SET_MEM_CTX(ndr, r->logon_server, 0);
3202                         NDR_CHECK(ndr_pull_array_size(ndr, &r->logon_server));
3203                         NDR_CHECK(ndr_pull_array_length(ndr, &r->logon_server));
3204                         if (ndr_get_array_length(ndr, &r->logon_server) > ndr_get_array_size(ndr, &r->logon_server)) {
3205                                 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));
3206                         }
3207                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->logon_server), sizeof(uint16_t)));
3208                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->logon_server, ndr_get_array_length(ndr, &r->logon_server), sizeof(uint16_t), CH_UTF16));
3209                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_logon_server_0, 0);
3210                 }
3211         }
3212         return NDR_ERR_SUCCESS;
3213 }
3214
3215 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserInfo1(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrWkstaUserInfo1 *r)
3216 {
3217         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaUserInfo1");
3218         ndr->depth++;
3219         ndr_print_ptr(ndr, "user_name", r->user_name);
3220         ndr->depth++;
3221         if (r->user_name) {
3222                 ndr_print_string(ndr, "user_name", r->user_name);
3223         }
3224         ndr->depth--;
3225         ndr_print_ptr(ndr, "logon_domain", r->logon_domain);
3226         ndr->depth++;
3227         if (r->logon_domain) {
3228                 ndr_print_string(ndr, "logon_domain", r->logon_domain);
3229         }
3230         ndr->depth--;
3231         ndr_print_ptr(ndr, "other_domains", r->other_domains);
3232         ndr->depth++;
3233         if (r->other_domains) {
3234                 ndr_print_string(ndr, "other_domains", r->other_domains);
3235         }
3236         ndr->depth--;
3237         ndr_print_ptr(ndr, "logon_server", r->logon_server);
3238         ndr->depth++;
3239         if (r->logon_server) {
3240                 ndr_print_string(ndr, "logon_server", r->logon_server);
3241         }
3242         ndr->depth--;
3243         ndr->depth--;
3244 }
3245
3246 static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsersCtr1(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaEnumUsersCtr1 *r)
3247 {
3248         uint32_t cntr_user1_1;
3249         if (ndr_flags & NDR_SCALARS) {
3250                 NDR_CHECK(ndr_push_align(ndr, 5));
3251                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->entries_read));
3252                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user1));
3253         }
3254         if (ndr_flags & NDR_BUFFERS) {
3255                 if (r->user1) {
3256                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->entries_read));
3257                         for (cntr_user1_1 = 0; cntr_user1_1 < r->entries_read; cntr_user1_1++) {
3258                                 NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo1(ndr, NDR_SCALARS, &r->user1[cntr_user1_1]));
3259                         }
3260                         for (cntr_user1_1 = 0; cntr_user1_1 < r->entries_read; cntr_user1_1++) {
3261                                 NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo1(ndr, NDR_BUFFERS, &r->user1[cntr_user1_1]));
3262                         }
3263                 }
3264         }
3265         return NDR_ERR_SUCCESS;
3266 }
3267
3268 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsersCtr1(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaEnumUsersCtr1 *r)
3269 {
3270         uint32_t _ptr_user1;
3271         uint32_t cntr_user1_1;
3272         TALLOC_CTX *_mem_save_user1_0;
3273         TALLOC_CTX *_mem_save_user1_1;
3274         if (ndr_flags & NDR_SCALARS) {
3275                 NDR_CHECK(ndr_pull_align(ndr, 5));
3276                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->entries_read));
3277                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user1));
3278                 if (_ptr_user1) {
3279                         NDR_PULL_ALLOC(ndr, r->user1);
3280                 } else {
3281                         r->user1 = NULL;
3282                 }
3283         }
3284         if (ndr_flags & NDR_BUFFERS) {
3285                 if (r->user1) {
3286                         _mem_save_user1_0 = NDR_PULL_GET_MEM_CTX(ndr);
3287                         NDR_PULL_SET_MEM_CTX(ndr, r->user1, 0);
3288                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user1));
3289                         NDR_PULL_ALLOC_N(ndr, r->user1, ndr_get_array_size(ndr, &r->user1));
3290                         _mem_save_user1_1 = NDR_PULL_GET_MEM_CTX(ndr);
3291                         NDR_PULL_SET_MEM_CTX(ndr, r->user1, 0);
3292                         for (cntr_user1_1 = 0; cntr_user1_1 < r->entries_read; cntr_user1_1++) {
3293                                 NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo1(ndr, NDR_SCALARS, &r->user1[cntr_user1_1]));
3294                         }
3295                         for (cntr_user1_1 = 0; cntr_user1_1 < r->entries_read; cntr_user1_1++) {
3296                                 NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo1(ndr, NDR_BUFFERS, &r->user1[cntr_user1_1]));
3297                         }
3298                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user1_1, 0);
3299                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user1_0, 0);
3300                 }
3301                 if (r->user1) {
3302                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->user1, r->entries_read));
3303                 }
3304         }
3305         return NDR_ERR_SUCCESS;
3306 }
3307
3308 _PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsersCtr1(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaEnumUsersCtr1 *r)
3309 {
3310         uint32_t cntr_user1_1;
3311         ndr_print_struct(ndr, name, "wkssvc_NetWkstaEnumUsersCtr1");
3312         ndr->depth++;
3313         ndr_print_uint32(ndr, "entries_read", r->entries_read);
3314         ndr_print_ptr(ndr, "user1", r->user1);
3315         ndr->depth++;
3316         if (r->user1) {
3317                 ndr->print(ndr, "%s: ARRAY(%d)", "user1", (int)r->entries_read);
3318                 ndr->depth++;
3319                 for (cntr_user1_1=0;cntr_user1_1<r->entries_read;cntr_user1_1++) {
3320                         char *idx_1=NULL;
3321                         if (asprintf(&idx_1, "[%d]", cntr_user1_1) != -1) {
3322                                 ndr_print_wkssvc_NetrWkstaUserInfo1(ndr, "user1", &r->user1[cntr_user1_1]);
3323                                 free(idx_1);
3324                         }
3325                 }
3326                 ndr->depth--;
3327         }
3328         ndr->depth--;
3329         ndr->depth--;
3330 }
3331
3332 static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsersCtr(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetWkstaEnumUsersCtr *r)
3333 {
3334         if (ndr_flags & NDR_SCALARS) {
3335                 int level = ndr_push_get_switch_value(ndr, r);
3336                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
3337                 NDR_CHECK(ndr_push_union_align(ndr, 5));
3338                 switch (level) {
3339                         case 0: {
3340                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user0));
3341                         break; }
3342
3343                         case 1: {
3344                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user1));
3345                         break; }
3346
3347                         default:
3348                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3349                 }
3350         }
3351         if (ndr_flags & NDR_BUFFERS) {
3352                 int level = ndr_push_get_switch_value(ndr, r);
3353                 switch (level) {
3354                         case 0:
3355                                 if (r->user0) {
3356                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->user0));
3357                                 }
3358                         break;
3359
3360                         case 1:
3361                                 if (r->user1) {
3362                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->user1));
3363                                 }
3364                         break;
3365
3366                         default:
3367                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3368                 }
3369         }
3370         return NDR_ERR_SUCCESS;
3371 }
3372
3373 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsersCtr(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetWkstaEnumUsersCtr *r)
3374 {
3375         int level;
3376         uint32_t _level;
3377         TALLOC_CTX *_mem_save_user0_0;
3378         TALLOC_CTX *_mem_save_user1_0;
3379         level = ndr_pull_get_switch_value(ndr, r);
3380         if (ndr_flags & NDR_SCALARS) {
3381                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
3382                 if (_level != level) {
3383                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3384                 }
3385                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
3386                 switch (level) {
3387                         case 0: {
3388                                 uint32_t _ptr_user0;
3389                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user0));
3390                                 if (_ptr_user0) {
3391                                         NDR_PULL_ALLOC(ndr, r->user0);
3392                                 } else {
3393                                         r->user0 = NULL;
3394                                 }
3395                         break; }
3396
3397                         case 1: {
3398                                 uint32_t _ptr_user1;
3399                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user1));
3400                                 if (_ptr_user1) {
3401                                         NDR_PULL_ALLOC(ndr, r->user1);
3402                                 } else {
3403                                         r->user1 = NULL;
3404                                 }
3405                         break; }
3406
3407                         default:
3408                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3409                 }
3410         }
3411         if (ndr_flags & NDR_BUFFERS) {
3412                 switch (level) {
3413                         case 0:
3414                                 if (r->user0) {
3415                                         _mem_save_user0_0 = NDR_PULL_GET_MEM_CTX(ndr);
3416                                         NDR_PULL_SET_MEM_CTX(ndr, r->user0, 0);
3417                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->user0));
3418                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user0_0, 0);
3419                                 }
3420                         break;
3421
3422                         case 1:
3423                                 if (r->user1) {
3424                                         _mem_save_user1_0 = NDR_PULL_GET_MEM_CTX(ndr);
3425                                         NDR_PULL_SET_MEM_CTX(ndr, r->user1, 0);
3426                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->user1));
3427                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user1_0, 0);
3428                                 }
3429                         break;
3430
3431                         default:
3432                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3433                 }
3434         }
3435         return NDR_ERR_SUCCESS;
3436 }
3437
3438 _PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsersCtr(struct ndr_print *ndr, const char *name, const union wkssvc_NetWkstaEnumUsersCtr *r)
3439 {
3440         int level;
3441         level = ndr_print_get_switch_value(ndr, r);
3442         ndr_print_union(ndr, name, level, "wkssvc_NetWkstaEnumUsersCtr");
3443         switch (level) {
3444                 case 0:
3445                         ndr_print_ptr(ndr, "user0", r->user0);
3446                         ndr->depth++;
3447                         if (r->user0) {
3448                                 ndr_print_wkssvc_NetWkstaEnumUsersCtr0(ndr, "user0", r->user0);
3449                         }
3450                         ndr->depth--;
3451                 break;
3452
3453                 case 1:
3454                         ndr_print_ptr(ndr, "user1", r->user1);
3455                         ndr->depth++;
3456                         if (r->user1) {
3457                                 ndr_print_wkssvc_NetWkstaEnumUsersCtr1(ndr, "user1", r->user1);
3458                         }
3459                         ndr->depth--;
3460                 break;
3461
3462                 default:
3463                         ndr_print_bad_level(ndr, name, level);
3464         }
3465 }
3466
3467 static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsersInfo(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaEnumUsersInfo *r)
3468 {
3469         if (ndr_flags & NDR_SCALARS) {
3470                 NDR_CHECK(ndr_push_align(ndr, 5));
3471                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
3472                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
3473                 NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersCtr(ndr, NDR_SCALARS, &r->ctr));
3474         }
3475         if (ndr_flags & NDR_BUFFERS) {
3476                 NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersCtr(ndr, NDR_BUFFERS, &r->ctr));
3477         }
3478         return NDR_ERR_SUCCESS;
3479 }
3480
3481 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsersInfo(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaEnumUsersInfo *r)
3482 {
3483         if (ndr_flags & NDR_SCALARS) {
3484                 NDR_CHECK(ndr_pull_align(ndr, 5));
3485                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
3486                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
3487                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersCtr(ndr, NDR_SCALARS, &r->ctr));
3488         }
3489         if (ndr_flags & NDR_BUFFERS) {
3490                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersCtr(ndr, NDR_BUFFERS, &r->ctr));
3491         }
3492         return NDR_ERR_SUCCESS;
3493 }
3494
3495 _PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsersInfo(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaEnumUsersInfo *r)
3496 {
3497         ndr_print_struct(ndr, name, "wkssvc_NetWkstaEnumUsersInfo");
3498         ndr->depth++;
3499         ndr_print_uint32(ndr, "level", r->level);
3500         ndr_print_set_switch_value(ndr, &r->ctr, r->level);
3501         ndr_print_wkssvc_NetWkstaEnumUsersCtr(ndr, "ctr", &r->ctr);
3502         ndr->depth--;
3503 }
3504
3505 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserInfo1101(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrWkstaUserInfo1101 *r)
3506 {
3507         if (ndr_flags & NDR_SCALARS) {
3508                 NDR_CHECK(ndr_push_align(ndr, 5));
3509                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->other_domains));
3510         }
3511         if (ndr_flags & NDR_BUFFERS) {
3512                 if (r->other_domains) {
3513                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->other_domains, CH_UTF16)));
3514                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3515                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->other_domains, CH_UTF16)));
3516                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->other_domains, ndr_charset_length(r->other_domains, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3517                 }
3518         }
3519         return NDR_ERR_SUCCESS;
3520 }
3521
3522 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserInfo1101(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrWkstaUserInfo1101 *r)
3523 {
3524         uint32_t _ptr_other_domains;
3525         TALLOC_CTX *_mem_save_other_domains_0;
3526         if (ndr_flags & NDR_SCALARS) {
3527                 NDR_CHECK(ndr_pull_align(ndr, 5));
3528                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_other_domains));
3529                 if (_ptr_other_domains) {
3530                         NDR_PULL_ALLOC(ndr, r->other_domains);
3531                 } else {
3532                         r->other_domains = NULL;
3533                 }
3534         }
3535         if (ndr_flags & NDR_BUFFERS) {
3536                 if (r->other_domains) {
3537                         _mem_save_other_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
3538                         NDR_PULL_SET_MEM_CTX(ndr, r->other_domains, 0);
3539                         NDR_CHECK(ndr_pull_array_size(ndr, &r->other_domains));
3540                         NDR_CHECK(ndr_pull_array_length(ndr, &r->other_domains));
3541                         if (ndr_get_array_length(ndr, &r->other_domains) > ndr_get_array_size(ndr, &r->other_domains)) {
3542                                 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));
3543                         }
3544                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->other_domains), sizeof(uint16_t)));
3545                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->other_domains, ndr_get_array_length(ndr, &r->other_domains), sizeof(uint16_t), CH_UTF16));
3546                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_other_domains_0, 0);
3547                 }
3548         }
3549         return NDR_ERR_SUCCESS;
3550 }
3551
3552 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserInfo1101(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrWkstaUserInfo1101 *r)
3553 {
3554         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaUserInfo1101");
3555         ndr->depth++;
3556         ndr_print_ptr(ndr, "other_domains", r->other_domains);
3557         ndr->depth++;
3558         if (r->other_domains) {
3559                 ndr_print_string(ndr, "other_domains", r->other_domains);
3560         }
3561         ndr->depth--;
3562         ndr->depth--;
3563 }
3564
3565 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserInfo(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetrWkstaUserInfo *r)
3566 {
3567         if (ndr_flags & NDR_SCALARS) {
3568                 int level = ndr_push_get_switch_value(ndr, r);
3569                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
3570                 NDR_CHECK(ndr_push_union_align(ndr, 5));
3571                 switch (level) {
3572                         case 0: {
3573                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
3574                         break; }
3575
3576                         case 1: {
3577                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
3578                         break; }
3579
3580                         case 1101: {
3581                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1101));
3582                         break; }
3583
3584                         default:
3585                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3586                 }
3587         }
3588         if (ndr_flags & NDR_BUFFERS) {
3589                 int level = ndr_push_get_switch_value(ndr, r);
3590                 switch (level) {
3591                         case 0:
3592                                 if (r->info0) {
3593                                         NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
3594                                 }
3595                         break;
3596
3597                         case 1:
3598                                 if (r->info1) {
3599                                         NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
3600                                 }
3601                         break;
3602
3603                         case 1101:
3604                                 if (r->info1101) {
3605                                         NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo1101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1101));
3606                                 }
3607                         break;
3608
3609                         default:
3610                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3611                 }
3612         }
3613         return NDR_ERR_SUCCESS;
3614 }
3615
3616 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserInfo(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetrWkstaUserInfo *r)
3617 {
3618         int level;
3619         uint32_t _level;
3620         TALLOC_CTX *_mem_save_info0_0;
3621         TALLOC_CTX *_mem_save_info1_0;
3622         TALLOC_CTX *_mem_save_info1101_0;
3623         level = ndr_pull_get_switch_value(ndr, r);
3624         if (ndr_flags & NDR_SCALARS) {
3625                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
3626                 if (_level != level) {
3627                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3628                 }
3629                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
3630                 switch (level) {
3631                         case 0: {
3632                                 uint32_t _ptr_info0;
3633                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
3634                                 if (_ptr_info0) {
3635                                         NDR_PULL_ALLOC(ndr, r->info0);
3636                                 } else {
3637                                         r->info0 = NULL;
3638                                 }
3639                         break; }
3640
3641                         case 1: {
3642                                 uint32_t _ptr_info1;
3643                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
3644                                 if (_ptr_info1) {
3645                                         NDR_PULL_ALLOC(ndr, r->info1);
3646                                 } else {
3647                                         r->info1 = NULL;
3648                                 }
3649                         break; }
3650
3651                         case 1101: {
3652                                 uint32_t _ptr_info1101;
3653                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1101));
3654                                 if (_ptr_info1101) {
3655                                         NDR_PULL_ALLOC(ndr, r->info1101);
3656                                 } else {
3657                                         r->info1101 = NULL;
3658                                 }
3659                         break; }
3660
3661                         default:
3662                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3663                 }
3664         }
3665         if (ndr_flags & NDR_BUFFERS) {
3666                 switch (level) {
3667                         case 0:
3668                                 if (r->info0) {
3669                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
3670                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
3671                                         NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
3672                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
3673                                 }
3674                         break;
3675
3676                         case 1:
3677                                 if (r->info1) {
3678                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
3679                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
3680                                         NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
3681                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
3682                                 }
3683                         break;
3684
3685                         case 1101:
3686                                 if (r->info1101) {
3687                                         _mem_save_info1101_0 = NDR_PULL_GET_MEM_CTX(ndr);
3688                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1101, 0);
3689                                         NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo1101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1101));
3690                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1101_0, 0);
3691                                 }
3692                         break;
3693
3694                         default:
3695                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3696                 }
3697         }
3698         return NDR_ERR_SUCCESS;
3699 }
3700
3701 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserInfo(struct ndr_print *ndr, const char *name, const union wkssvc_NetrWkstaUserInfo *r)
3702 {
3703         int level;
3704         level = ndr_print_get_switch_value(ndr, r);
3705         ndr_print_union(ndr, name, level, "wkssvc_NetrWkstaUserInfo");
3706         switch (level) {
3707                 case 0:
3708                         ndr_print_ptr(ndr, "info0", r->info0);
3709                         ndr->depth++;
3710                         if (r->info0) {
3711                                 ndr_print_wkssvc_NetrWkstaUserInfo0(ndr, "info0", r->info0);
3712                         }
3713                         ndr->depth--;
3714                 break;
3715
3716                 case 1:
3717                         ndr_print_ptr(ndr, "info1", r->info1);
3718                         ndr->depth++;
3719                         if (r->info1) {
3720                                 ndr_print_wkssvc_NetrWkstaUserInfo1(ndr, "info1", r->info1);
3721                         }
3722                         ndr->depth--;
3723                 break;
3724
3725                 case 1101:
3726                         ndr_print_ptr(ndr, "info1101", r->info1101);
3727                         ndr->depth++;
3728                         if (r->info1101) {
3729                                 ndr_print_wkssvc_NetrWkstaUserInfo1101(ndr, "info1101", r->info1101);
3730                         }
3731                         ndr->depth--;
3732                 break;
3733
3734                 default:
3735                         ndr_print_bad_level(ndr, name, level);
3736         }
3737 }
3738
3739 static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportInfo0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaTransportInfo0 *r)
3740 {
3741         if (ndr_flags & NDR_SCALARS) {
3742                 NDR_CHECK(ndr_push_align(ndr, 5));
3743                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->quality_of_service));
3744                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->vc_count));
3745                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
3746                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->address));
3747                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->wan_link));
3748         }
3749         if (ndr_flags & NDR_BUFFERS) {
3750                 if (r->name) {
3751                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
3752                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3753                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
3754                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3755                 }
3756                 if (r->address) {
3757                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->address, CH_UTF16)));
3758                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3759                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->address, CH_UTF16)));
3760                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->address, ndr_charset_length(r->address, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3761                 }
3762         }
3763         return NDR_ERR_SUCCESS;
3764 }
3765
3766 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportInfo0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaTransportInfo0 *r)
3767 {
3768         uint32_t _ptr_name;
3769         TALLOC_CTX *_mem_save_name_0;
3770         uint32_t _ptr_address;
3771         TALLOC_CTX *_mem_save_address_0;
3772         if (ndr_flags & NDR_SCALARS) {
3773                 NDR_CHECK(ndr_pull_align(ndr, 5));
3774                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->quality_of_service));
3775                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->vc_count));
3776                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
3777                 if (_ptr_name) {
3778                         NDR_PULL_ALLOC(ndr, r->name);
3779                 } else {
3780                         r->name = NULL;
3781                 }
3782                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_address));
3783                 if (_ptr_address) {
3784                         NDR_PULL_ALLOC(ndr, r->address);
3785                 } else {
3786                         r->address = NULL;
3787                 }
3788                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->wan_link));
3789         }
3790         if (ndr_flags & NDR_BUFFERS) {
3791                 if (r->name) {
3792                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3793                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
3794                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
3795                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
3796                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
3797                                 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));
3798                         }
3799                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
3800                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
3801                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
3802                 }
3803                 if (r->address) {
3804                         _mem_save_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
3805                         NDR_PULL_SET_MEM_CTX(ndr, r->address, 0);
3806                         NDR_CHECK(ndr_pull_array_size(ndr, &r->address));
3807                         NDR_CHECK(ndr_pull_array_length(ndr, &r->address));
3808                         if (ndr_get_array_length(ndr, &r->address) > ndr_get_array_size(ndr, &r->address)) {
3809                                 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));
3810                         }
3811                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->address), sizeof(uint16_t)));
3812                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->address, ndr_get_array_length(ndr, &r->address), sizeof(uint16_t), CH_UTF16));
3813                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_address_0, 0);
3814                 }
3815         }
3816         return NDR_ERR_SUCCESS;
3817 }
3818
3819 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportInfo0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaTransportInfo0 *r)
3820 {
3821         ndr_print_struct(ndr, name, "wkssvc_NetWkstaTransportInfo0");
3822         ndr->depth++;
3823         ndr_print_uint32(ndr, "quality_of_service", r->quality_of_service);
3824         ndr_print_uint32(ndr, "vc_count", r->vc_count);
3825         ndr_print_ptr(ndr, "name", r->name);
3826         ndr->depth++;
3827         if (r->name) {
3828                 ndr_print_string(ndr, "name", r->name);
3829         }
3830         ndr->depth--;
3831         ndr_print_ptr(ndr, "address", r->address);
3832         ndr->depth++;
3833         if (r->address) {
3834                 ndr_print_string(ndr, "address", r->address);
3835         }
3836         ndr->depth--;
3837         ndr_print_uint32(ndr, "wan_link", r->wan_link);
3838         ndr->depth--;
3839 }
3840
3841 static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportCtr0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaTransportCtr0 *r)
3842 {
3843         uint32_t cntr_array_1;
3844         if (ndr_flags & NDR_SCALARS) {
3845                 NDR_CHECK(ndr_push_align(ndr, 5));
3846                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3847                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
3848         }
3849         if (ndr_flags & NDR_BUFFERS) {
3850                 if (r->array) {
3851                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
3852                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3853                                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
3854                         }
3855                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3856                                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
3857                         }
3858                 }
3859         }
3860         return NDR_ERR_SUCCESS;
3861 }
3862
3863 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportCtr0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaTransportCtr0 *r)
3864 {
3865         uint32_t _ptr_array;
3866         uint32_t cntr_array_1;
3867         TALLOC_CTX *_mem_save_array_0;
3868         TALLOC_CTX *_mem_save_array_1;
3869         if (ndr_flags & NDR_SCALARS) {
3870                 NDR_CHECK(ndr_pull_align(ndr, 5));
3871                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3872                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
3873                 if (_ptr_array) {
3874                         NDR_PULL_ALLOC(ndr, r->array);
3875                 } else {
3876                         r->array = NULL;
3877                 }
3878         }
3879         if (ndr_flags & NDR_BUFFERS) {
3880                 if (r->array) {
3881                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
3882                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
3883                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
3884                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
3885                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
3886                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
3887                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3888                                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
3889                         }
3890                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3891                                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
3892                         }
3893                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
3894                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
3895                 }
3896                 if (r->array) {
3897                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
3898                 }
3899         }
3900         return NDR_ERR_SUCCESS;
3901 }
3902
3903 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportCtr0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaTransportCtr0 *r)
3904 {
3905         uint32_t cntr_array_1;
3906         ndr_print_struct(ndr, name, "wkssvc_NetWkstaTransportCtr0");
3907         ndr->depth++;
3908         ndr_print_uint32(ndr, "count", r->count);
3909         ndr_print_ptr(ndr, "array", r->array);
3910         ndr->depth++;
3911         if (r->array) {
3912                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
3913                 ndr->depth++;
3914                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
3915                         char *idx_1=NULL;
3916                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
3917                                 ndr_print_wkssvc_NetWkstaTransportInfo0(ndr, "array", &r->array[cntr_array_1]);
3918                                 free(idx_1);
3919                         }
3920                 }
3921                 ndr->depth--;
3922         }
3923         ndr->depth--;
3924         ndr->depth--;
3925 }
3926
3927 static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportCtr(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetWkstaTransportCtr *r)
3928 {
3929         if (ndr_flags & NDR_SCALARS) {
3930                 int level = ndr_push_get_switch_value(ndr, r);
3931                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
3932                 NDR_CHECK(ndr_push_union_align(ndr, 5));
3933                 switch (level) {
3934                         case 0: {
3935                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
3936                         break; }
3937
3938                         default:
3939                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3940                 }
3941         }
3942         if (ndr_flags & NDR_BUFFERS) {
3943                 int level = ndr_push_get_switch_value(ndr, r);
3944                 switch (level) {
3945                         case 0:
3946                                 if (r->ctr0) {
3947                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
3948                                 }
3949                         break;
3950
3951                         default:
3952                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3953                 }
3954         }
3955         return NDR_ERR_SUCCESS;
3956 }
3957
3958 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportCtr(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetWkstaTransportCtr *r)
3959 {
3960         int level;
3961         uint32_t _level;
3962         TALLOC_CTX *_mem_save_ctr0_0;
3963         level = ndr_pull_get_switch_value(ndr, r);
3964         if (ndr_flags & NDR_SCALARS) {
3965                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
3966                 if (_level != level) {
3967                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3968                 }
3969                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
3970                 switch (level) {
3971                         case 0: {
3972                                 uint32_t _ptr_ctr0;
3973                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));
3974                                 if (_ptr_ctr0) {
3975                                         NDR_PULL_ALLOC(ndr, r->ctr0);
3976                                 } else {
3977                                         r->ctr0 = NULL;
3978                                 }
3979                         break; }
3980
3981                         default:
3982                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3983                 }
3984         }
3985         if (ndr_flags & NDR_BUFFERS) {
3986                 switch (level) {
3987                         case 0:
3988                                 if (r->ctr0) {
3989                                         _mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);
3990                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr0, 0);
3991                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
3992                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);
3993                                 }
3994                         break;
3995
3996                         default:
3997                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3998                 }
3999         }
4000         return NDR_ERR_SUCCESS;
4001 }
4002
4003 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportCtr(struct ndr_print *ndr, const char *name, const union wkssvc_NetWkstaTransportCtr *r)
4004 {
4005         int level;
4006         level = ndr_print_get_switch_value(ndr, r);
4007         ndr_print_union(ndr, name, level, "wkssvc_NetWkstaTransportCtr");
4008         switch (level) {
4009                 case 0:
4010                         ndr_print_ptr(ndr, "ctr0", r->ctr0);
4011                         ndr->depth++;
4012                         if (r->ctr0) {
4013                                 ndr_print_wkssvc_NetWkstaTransportCtr0(ndr, "ctr0", r->ctr0);
4014                         }
4015                         ndr->depth--;
4016                 break;
4017
4018                 default:
4019                         ndr_print_bad_level(ndr, name, level);
4020         }
4021 }
4022
4023 static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportInfo(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaTransportInfo *r)
4024 {
4025         if (ndr_flags & NDR_SCALARS) {
4026                 NDR_CHECK(ndr_push_align(ndr, 5));
4027                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
4028                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
4029                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportCtr(ndr, NDR_SCALARS, &r->ctr));
4030         }
4031         if (ndr_flags & NDR_BUFFERS) {
4032                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportCtr(ndr, NDR_BUFFERS, &r->ctr));
4033         }
4034         return NDR_ERR_SUCCESS;
4035 }
4036
4037 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportInfo(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaTransportInfo *r)
4038 {
4039         if (ndr_flags & NDR_SCALARS) {
4040                 NDR_CHECK(ndr_pull_align(ndr, 5));
4041                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
4042                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
4043                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportCtr(ndr, NDR_SCALARS, &r->ctr));
4044         }
4045         if (ndr_flags & NDR_BUFFERS) {
4046                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportCtr(ndr, NDR_BUFFERS, &r->ctr));
4047         }
4048         return NDR_ERR_SUCCESS;
4049 }
4050
4051 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportInfo(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaTransportInfo *r)
4052 {
4053         ndr_print_struct(ndr, name, "wkssvc_NetWkstaTransportInfo");
4054         ndr->depth++;
4055         ndr_print_uint32(ndr, "level", r->level);
4056         ndr_print_set_switch_value(ndr, &r->ctr, r->level);
4057         ndr_print_wkssvc_NetWkstaTransportCtr(ndr, "ctr", &r->ctr);
4058         ndr->depth--;
4059 }
4060
4061 static enum ndr_err_code ndr_push_wkssvc_NetrUseInfo3(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseInfo3 *r)
4062 {
4063         if (ndr_flags & NDR_SCALARS) {
4064                 NDR_CHECK(ndr_push_align(ndr, 5));
4065                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->unknown1));
4066                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->unknown2));
4067         }
4068         if (ndr_flags & NDR_BUFFERS) {
4069                 if (r->unknown1) {
4070                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->unknown1, CH_UTF16)));
4071                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4072                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->unknown1, CH_UTF16)));
4073                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->unknown1, ndr_charset_length(r->unknown1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4074                 }
4075                 if (r->unknown2) {
4076                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->unknown2, CH_UTF16)));
4077                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4078                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->unknown2, CH_UTF16)));
4079                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->unknown2, ndr_charset_length(r->unknown2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4080                 }
4081         }
4082         return NDR_ERR_SUCCESS;
4083 }
4084
4085 static enum ndr_err_code ndr_pull_wkssvc_NetrUseInfo3(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseInfo3 *r)
4086 {
4087         uint32_t _ptr_unknown1;
4088         TALLOC_CTX *_mem_save_unknown1_0;
4089         uint32_t _ptr_unknown2;
4090         TALLOC_CTX *_mem_save_unknown2_0;
4091         if (ndr_flags & NDR_SCALARS) {
4092                 NDR_CHECK(ndr_pull_align(ndr, 5));
4093                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown1));
4094                 if (_ptr_unknown1) {
4095                         NDR_PULL_ALLOC(ndr, r->unknown1);
4096                 } else {
4097                         r->unknown1 = NULL;
4098                 }
4099                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown2));
4100                 if (_ptr_unknown2) {
4101                         NDR_PULL_ALLOC(ndr, r->unknown2);
4102                 } else {
4103                         r->unknown2 = NULL;
4104                 }
4105         }
4106         if (ndr_flags & NDR_BUFFERS) {
4107                 if (r->unknown1) {
4108                         _mem_save_unknown1_0 = NDR_PULL_GET_MEM_CTX(ndr);
4109                         NDR_PULL_SET_MEM_CTX(ndr, r->unknown1, 0);
4110                         NDR_CHECK(ndr_pull_array_size(ndr, &r->unknown1));
4111                         NDR_CHECK(ndr_pull_array_length(ndr, &r->unknown1));
4112                         if (ndr_get_array_length(ndr, &r->unknown1) > ndr_get_array_size(ndr, &r->unknown1)) {
4113                                 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));
4114                         }
4115                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->unknown1), sizeof(uint16_t)));
4116                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->unknown1, ndr_get_array_length(ndr, &r->unknown1), sizeof(uint16_t), CH_UTF16));
4117                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown1_0, 0);
4118                 }
4119                 if (r->unknown2) {
4120                         _mem_save_unknown2_0 = NDR_PULL_GET_MEM_CTX(ndr);
4121                         NDR_PULL_SET_MEM_CTX(ndr, r->unknown2, 0);
4122                         NDR_CHECK(ndr_pull_array_size(ndr, &r->unknown2));
4123                         NDR_CHECK(ndr_pull_array_length(ndr, &r->unknown2));
4124                         if (ndr_get_array_length(ndr, &r->unknown2) > ndr_get_array_size(ndr, &r->unknown2)) {
4125                                 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));
4126                         }
4127                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->unknown2), sizeof(uint16_t)));
4128                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->unknown2, ndr_get_array_length(ndr, &r->unknown2), sizeof(uint16_t), CH_UTF16));
4129                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown2_0, 0);
4130                 }
4131         }
4132         return NDR_ERR_SUCCESS;
4133 }
4134
4135 _PUBLIC_ void ndr_print_wkssvc_NetrUseInfo3(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseInfo3 *r)
4136 {
4137         ndr_print_struct(ndr, name, "wkssvc_NetrUseInfo3");
4138         ndr->depth++;
4139         ndr_print_ptr(ndr, "unknown1", r->unknown1);
4140         ndr->depth++;
4141         if (r->unknown1) {
4142                 ndr_print_string(ndr, "unknown1", r->unknown1);
4143         }
4144         ndr->depth--;
4145         ndr_print_ptr(ndr, "unknown2", r->unknown2);
4146         ndr->depth++;
4147         if (r->unknown2) {
4148                 ndr_print_string(ndr, "unknown2", r->unknown2);
4149         }
4150         ndr->depth--;
4151         ndr->depth--;
4152 }
4153
4154 static enum ndr_err_code ndr_push_wkssvc_NetrUseInfo2(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseInfo2 *r)
4155 {
4156         if (ndr_flags & NDR_SCALARS) {
4157                 NDR_CHECK(ndr_push_align(ndr, 5));
4158                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->local));
4159                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote));
4160                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->password));
4161                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
4162                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->asg_type));
4163                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_count));
4164                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_count));
4165                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
4166                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
4167         }
4168         if (ndr_flags & NDR_BUFFERS) {
4169                 if (r->local) {
4170                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->local, CH_UTF16)));
4171                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4172                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->local, CH_UTF16)));
4173                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->local, ndr_charset_length(r->local, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4174                 }
4175                 if (r->remote) {
4176                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote, CH_UTF16)));
4177                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4178                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote, CH_UTF16)));
4179                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->remote, ndr_charset_length(r->remote, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4180                 }
4181                 if (r->password) {
4182                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));
4183                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4184                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));
4185                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->password, ndr_charset_length(r->password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4186                 }
4187                 if (r->user_name) {
4188                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4189                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4190                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4191                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4192                 }
4193                 if (r->domain_name) {
4194                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
4195                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4196                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
4197                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4198                 }
4199         }
4200         return NDR_ERR_SUCCESS;
4201 }
4202
4203 static enum ndr_err_code ndr_pull_wkssvc_NetrUseInfo2(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseInfo2 *r)
4204 {
4205         uint32_t _ptr_local;
4206         TALLOC_CTX *_mem_save_local_0;
4207         uint32_t _ptr_remote;
4208         TALLOC_CTX *_mem_save_remote_0;
4209         uint32_t _ptr_password;
4210         TALLOC_CTX *_mem_save_password_0;
4211         uint32_t _ptr_user_name;
4212         TALLOC_CTX *_mem_save_user_name_0;
4213         uint32_t _ptr_domain_name;
4214         TALLOC_CTX *_mem_save_domain_name_0;
4215         if (ndr_flags & NDR_SCALARS) {
4216                 NDR_CHECK(ndr_pull_align(ndr, 5));
4217                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local));
4218                 if (_ptr_local) {
4219                         NDR_PULL_ALLOC(ndr, r->local);
4220                 } else {
4221                         r->local = NULL;
4222                 }
4223                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote));
4224                 if (_ptr_remote) {
4225                         NDR_PULL_ALLOC(ndr, r->remote);
4226                 } else {
4227                         r->remote = NULL;
4228                 }
4229                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
4230                 if (_ptr_password) {
4231                         NDR_PULL_ALLOC(ndr, r->password);
4232                 } else {
4233                         r->password = NULL;
4234                 }
4235                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
4236                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->asg_type));
4237                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_count));
4238                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_count));
4239                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4240                 if (_ptr_user_name) {
4241                         NDR_PULL_ALLOC(ndr, r->user_name);
4242                 } else {
4243                         r->user_name = NULL;
4244                 }
4245                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
4246                 if (_ptr_domain_name) {
4247                         NDR_PULL_ALLOC(ndr, r->domain_name);
4248                 } else {
4249                         r->domain_name = NULL;
4250                 }
4251         }
4252         if (ndr_flags & NDR_BUFFERS) {
4253                 if (r->local) {
4254                         _mem_save_local_0 = NDR_PULL_GET_MEM_CTX(ndr);
4255                         NDR_PULL_SET_MEM_CTX(ndr, r->local, 0);
4256                         NDR_CHECK(ndr_pull_array_size(ndr, &r->local));
4257                         NDR_CHECK(ndr_pull_array_length(ndr, &r->local));
4258                         if (ndr_get_array_length(ndr, &r->local) > ndr_get_array_size(ndr, &r->local)) {
4259                                 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));
4260                         }
4261                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->local), sizeof(uint16_t)));
4262                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->local, ndr_get_array_length(ndr, &r->local), sizeof(uint16_t), CH_UTF16));
4263                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_0, 0);
4264                 }
4265                 if (r->remote) {
4266                         _mem_save_remote_0 = NDR_PULL_GET_MEM_CTX(ndr);
4267                         NDR_PULL_SET_MEM_CTX(ndr, r->remote, 0);
4268                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote));
4269                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote));
4270                         if (ndr_get_array_length(ndr, &r->remote) > ndr_get_array_size(ndr, &r->remote)) {
4271                                 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));
4272                         }
4273                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t)));
4274                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->remote, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t), CH_UTF16));
4275                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_0, 0);
4276                 }
4277                 if (r->password) {
4278                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
4279                         NDR_PULL_SET_MEM_CTX(ndr, r->password, 0);
4280                         NDR_CHECK(ndr_pull_array_size(ndr, &r->password));
4281                         NDR_CHECK(ndr_pull_array_length(ndr, &r->password));
4282                         if (ndr_get_array_length(ndr, &r->password) > ndr_get_array_size(ndr, &r->password)) {
4283                                 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));
4284                         }
4285                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t)));
4286                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->password, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t), CH_UTF16));
4287                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
4288                 }
4289                 if (r->user_name) {
4290                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4291                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4292                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
4293                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
4294                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
4295                                 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));
4296                         }
4297                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
4298                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
4299                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4300                 }
4301                 if (r->domain_name) {
4302                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4303                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
4304                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
4305                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
4306                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
4307                                 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));
4308                         }
4309                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
4310                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
4311                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
4312                 }
4313         }
4314         return NDR_ERR_SUCCESS;
4315 }
4316
4317 _PUBLIC_ void ndr_print_wkssvc_NetrUseInfo2(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseInfo2 *r)
4318 {
4319         ndr_print_struct(ndr, name, "wkssvc_NetrUseInfo2");
4320         ndr->depth++;
4321         ndr_print_ptr(ndr, "local", r->local);
4322         ndr->depth++;
4323         if (r->local) {
4324                 ndr_print_string(ndr, "local", r->local);
4325         }
4326         ndr->depth--;
4327         ndr_print_ptr(ndr, "remote", r->remote);
4328         ndr->depth++;
4329         if (r->remote) {
4330                 ndr_print_string(ndr, "remote", r->remote);
4331         }
4332         ndr->depth--;
4333         ndr_print_ptr(ndr, "password", r->password);
4334         ndr->depth++;
4335         if (r->password) {
4336                 ndr_print_string(ndr, "password", r->password);
4337         }
4338         ndr->depth--;
4339         ndr_print_uint32(ndr, "status", r->status);
4340         ndr_print_uint32(ndr, "asg_type", r->asg_type);
4341         ndr_print_uint32(ndr, "ref_count", r->ref_count);
4342         ndr_print_uint32(ndr, "use_count", r->use_count);
4343         ndr_print_ptr(ndr, "user_name", r->user_name);
4344         ndr->depth++;
4345         if (r->user_name) {
4346                 ndr_print_string(ndr, "user_name", r->user_name);
4347         }
4348         ndr->depth--;
4349         ndr_print_ptr(ndr, "domain_name", r->domain_name);
4350         ndr->depth++;
4351         if (r->domain_name) {
4352                 ndr_print_string(ndr, "domain_name", r->domain_name);
4353         }
4354         ndr->depth--;
4355         ndr->depth--;
4356 }
4357
4358 static enum ndr_err_code ndr_push_wkssvc_NetrUseInfo1(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseInfo1 *r)
4359 {
4360         if (ndr_flags & NDR_SCALARS) {
4361                 NDR_CHECK(ndr_push_align(ndr, 5));
4362                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->local));
4363                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote));
4364                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->password));
4365                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
4366                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->asg_type));
4367                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_count));
4368                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_count));
4369         }
4370         if (ndr_flags & NDR_BUFFERS) {
4371                 if (r->local) {
4372                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->local, CH_UTF16)));
4373                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4374                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->local, CH_UTF16)));
4375                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->local, ndr_charset_length(r->local, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4376                 }
4377                 if (r->remote) {
4378                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote, CH_UTF16)));
4379                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4380                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote, CH_UTF16)));
4381                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->remote, ndr_charset_length(r->remote, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4382                 }
4383                 if (r->password) {
4384                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));
4385                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4386                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));
4387                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->password, ndr_charset_length(r->password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4388                 }
4389         }
4390         return NDR_ERR_SUCCESS;
4391 }
4392
4393 static enum ndr_err_code ndr_pull_wkssvc_NetrUseInfo1(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseInfo1 *r)
4394 {
4395         uint32_t _ptr_local;
4396         TALLOC_CTX *_mem_save_local_0;
4397         uint32_t _ptr_remote;
4398         TALLOC_CTX *_mem_save_remote_0;
4399         uint32_t _ptr_password;
4400         TALLOC_CTX *_mem_save_password_0;
4401         if (ndr_flags & NDR_SCALARS) {
4402                 NDR_CHECK(ndr_pull_align(ndr, 5));
4403                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local));
4404                 if (_ptr_local) {
4405                         NDR_PULL_ALLOC(ndr, r->local);
4406                 } else {
4407                         r->local = NULL;
4408                 }
4409                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote));
4410                 if (_ptr_remote) {
4411                         NDR_PULL_ALLOC(ndr, r->remote);
4412                 } else {
4413                         r->remote = NULL;
4414                 }
4415                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
4416                 if (_ptr_password) {
4417                         NDR_PULL_ALLOC(ndr, r->password);
4418                 } else {
4419                         r->password = NULL;
4420                 }
4421                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
4422                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->asg_type));
4423                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_count));
4424                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_count));
4425         }
4426         if (ndr_flags & NDR_BUFFERS) {
4427                 if (r->local) {
4428                         _mem_save_local_0 = NDR_PULL_GET_MEM_CTX(ndr);
4429                         NDR_PULL_SET_MEM_CTX(ndr, r->local, 0);
4430                         NDR_CHECK(ndr_pull_array_size(ndr, &r->local));
4431                         NDR_CHECK(ndr_pull_array_length(ndr, &r->local));
4432                         if (ndr_get_array_length(ndr, &r->local) > ndr_get_array_size(ndr, &r->local)) {
4433                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->local), ndr_get_array_length(ndr, &r->local));
4434                         }
4435                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->local), sizeof(uint16_t)));
4436                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->local, ndr_get_array_length(ndr, &r->local), sizeof(uint16_t), CH_UTF16));
4437                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_0, 0);
4438                 }
4439                 if (r->remote) {
4440                         _mem_save_remote_0 = NDR_PULL_GET_MEM_CTX(ndr);
4441                         NDR_PULL_SET_MEM_CTX(ndr, r->remote, 0);
4442                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote));
4443                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote));
4444                         if (ndr_get_array_length(ndr, &r->remote) > ndr_get_array_size(ndr, &r->remote)) {
4445                                 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));
4446                         }
4447                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t)));
4448                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->remote, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t), CH_UTF16));
4449                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_0, 0);
4450                 }
4451                 if (r->password) {
4452                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
4453                         NDR_PULL_SET_MEM_CTX(ndr, r->password, 0);
4454                         NDR_CHECK(ndr_pull_array_size(ndr, &r->password));
4455                         NDR_CHECK(ndr_pull_array_length(ndr, &r->password));
4456                         if (ndr_get_array_length(ndr, &r->password) > ndr_get_array_size(ndr, &r->password)) {
4457                                 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));
4458                         }
4459                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t)));
4460                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->password, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t), CH_UTF16));
4461                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
4462                 }
4463         }
4464         return NDR_ERR_SUCCESS;
4465 }
4466
4467 _PUBLIC_ void ndr_print_wkssvc_NetrUseInfo1(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseInfo1 *r)
4468 {
4469         ndr_print_struct(ndr, name, "wkssvc_NetrUseInfo1");
4470         ndr->depth++;
4471         ndr_print_ptr(ndr, "local", r->local);
4472         ndr->depth++;
4473         if (r->local) {
4474                 ndr_print_string(ndr, "local", r->local);
4475         }
4476         ndr->depth--;
4477         ndr_print_ptr(ndr, "remote", r->remote);
4478         ndr->depth++;
4479         if (r->remote) {
4480                 ndr_print_string(ndr, "remote", r->remote);
4481         }
4482         ndr->depth--;
4483         ndr_print_ptr(ndr, "password", r->password);
4484         ndr->depth++;
4485         if (r->password) {
4486                 ndr_print_string(ndr, "password", r->password);
4487         }
4488         ndr->depth--;
4489         ndr_print_uint32(ndr, "status", r->status);
4490         ndr_print_uint32(ndr, "asg_type", r->asg_type);
4491         ndr_print_uint32(ndr, "ref_count", r->ref_count);
4492         ndr_print_uint32(ndr, "use_count", r->use_count);
4493         ndr->depth--;
4494 }
4495
4496 static enum ndr_err_code ndr_push_wkssvc_NetrUseInfo0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseInfo0 *r)
4497 {
4498         if (ndr_flags & NDR_SCALARS) {
4499                 NDR_CHECK(ndr_push_align(ndr, 5));
4500                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->local));
4501                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote));
4502         }
4503         if (ndr_flags & NDR_BUFFERS) {
4504                 if (r->local) {
4505                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->local, CH_UTF16)));
4506                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4507                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->local, CH_UTF16)));
4508                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->local, ndr_charset_length(r->local, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4509                 }
4510                 if (r->remote) {
4511                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote, CH_UTF16)));
4512                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4513                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote, CH_UTF16)));
4514                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->remote, ndr_charset_length(r->remote, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4515                 }
4516         }
4517         return NDR_ERR_SUCCESS;
4518 }
4519
4520 static enum ndr_err_code ndr_pull_wkssvc_NetrUseInfo0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseInfo0 *r)
4521 {
4522         uint32_t _ptr_local;
4523         TALLOC_CTX *_mem_save_local_0;
4524         uint32_t _ptr_remote;
4525         TALLOC_CTX *_mem_save_remote_0;
4526         if (ndr_flags & NDR_SCALARS) {
4527                 NDR_CHECK(ndr_pull_align(ndr, 5));
4528                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local));
4529                 if (_ptr_local) {
4530                         NDR_PULL_ALLOC(ndr, r->local);
4531                 } else {
4532                         r->local = NULL;
4533                 }
4534                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote));
4535                 if (_ptr_remote) {
4536                         NDR_PULL_ALLOC(ndr, r->remote);
4537                 } else {
4538                         r->remote = NULL;
4539                 }
4540         }
4541         if (ndr_flags & NDR_BUFFERS) {
4542                 if (r->local) {
4543                         _mem_save_local_0 = NDR_PULL_GET_MEM_CTX(ndr);
4544                         NDR_PULL_SET_MEM_CTX(ndr, r->local, 0);
4545                         NDR_CHECK(ndr_pull_array_size(ndr, &r->local));
4546                         NDR_CHECK(ndr_pull_array_length(ndr, &r->local));
4547                         if (ndr_get_array_length(ndr, &r->local) > ndr_get_array_size(ndr, &r->local)) {
4548                                 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));
4549                         }
4550                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->local), sizeof(uint16_t)));
4551                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->local, ndr_get_array_length(ndr, &r->local), sizeof(uint16_t), CH_UTF16));
4552                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_0, 0);
4553                 }
4554                 if (r->remote) {
4555                         _mem_save_remote_0 = NDR_PULL_GET_MEM_CTX(ndr);
4556                         NDR_PULL_SET_MEM_CTX(ndr, r->remote, 0);
4557                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote));
4558                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote));
4559                         if (ndr_get_array_length(ndr, &r->remote) > ndr_get_array_size(ndr, &r->remote)) {
4560                                 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));
4561                         }
4562                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t)));
4563                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->remote, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t), CH_UTF16));
4564                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_0, 0);
4565                 }
4566         }
4567         return NDR_ERR_SUCCESS;
4568 }
4569
4570 _PUBLIC_ void ndr_print_wkssvc_NetrUseInfo0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseInfo0 *r)
4571 {
4572         ndr_print_struct(ndr, name, "wkssvc_NetrUseInfo0");
4573         ndr->depth++;
4574         ndr_print_ptr(ndr, "local", r->local);
4575         ndr->depth++;
4576         if (r->local) {
4577                 ndr_print_string(ndr, "local", r->local);
4578         }
4579         ndr->depth--;
4580         ndr_print_ptr(ndr, "remote", r->remote);
4581         ndr->depth++;
4582         if (r->remote) {
4583                 ndr_print_string(ndr, "remote", r->remote);
4584         }
4585         ndr->depth--;
4586         ndr->depth--;
4587 }
4588
4589 static enum ndr_err_code ndr_push_wkssvc_NetrUseGetInfoCtr(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetrUseGetInfoCtr *r)
4590 {
4591         if (ndr_flags & NDR_SCALARS) {
4592                 int level = ndr_push_get_switch_value(ndr, r);
4593                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
4594                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4595                 switch (level) {
4596                         case 0: {
4597                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
4598                         break; }
4599
4600                         case 1: {
4601                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
4602                         break; }
4603
4604                         case 2: {
4605                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
4606                         break; }
4607
4608                         case 3: {
4609                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
4610                         break; }
4611
4612                         default:
4613                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4614                 }
4615         }
4616         if (ndr_flags & NDR_BUFFERS) {
4617                 int level = ndr_push_get_switch_value(ndr, r);
4618                 switch (level) {
4619                         case 0:
4620                                 if (r->info0) {
4621                                         NDR_CHECK(ndr_push_wkssvc_NetrUseInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
4622                                 }
4623                         break;
4624
4625                         case 1:
4626                                 if (r->info1) {
4627                                         NDR_CHECK(ndr_push_wkssvc_NetrUseInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
4628                                 }
4629                         break;
4630
4631                         case 2:
4632                                 if (r->info2) {
4633                                         NDR_CHECK(ndr_push_wkssvc_NetrUseInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
4634                                 }
4635                         break;
4636
4637                         case 3:
4638                                 if (r->info3) {
4639                                         NDR_CHECK(ndr_push_wkssvc_NetrUseInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
4640                                 }
4641                         break;
4642
4643                         default:
4644                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4645                 }
4646         }
4647         return NDR_ERR_SUCCESS;
4648 }
4649
4650 static enum ndr_err_code ndr_pull_wkssvc_NetrUseGetInfoCtr(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetrUseGetInfoCtr *r)
4651 {
4652         int level;
4653         uint32_t _level;
4654         TALLOC_CTX *_mem_save_info0_0;
4655         TALLOC_CTX *_mem_save_info1_0;
4656         TALLOC_CTX *_mem_save_info2_0;
4657         TALLOC_CTX *_mem_save_info3_0;
4658         level = ndr_pull_get_switch_value(ndr, r);
4659         if (ndr_flags & NDR_SCALARS) {
4660                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
4661                 if (_level != level) {
4662                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4663                 }
4664                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4665                 switch (level) {
4666                         case 0: {
4667                                 uint32_t _ptr_info0;
4668                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
4669                                 if (_ptr_info0) {
4670                                         NDR_PULL_ALLOC(ndr, r->info0);
4671                                 } else {
4672                                         r->info0 = NULL;
4673                                 }
4674                         break; }
4675
4676                         case 1: {
4677                                 uint32_t _ptr_info1;
4678                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
4679                                 if (_ptr_info1) {
4680                                         NDR_PULL_ALLOC(ndr, r->info1);
4681                                 } else {
4682                                         r->info1 = NULL;
4683                                 }
4684                         break; }
4685
4686                         case 2: {
4687                                 uint32_t _ptr_info2;
4688                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
4689                                 if (_ptr_info2) {
4690                                         NDR_PULL_ALLOC(ndr, r->info2);
4691                                 } else {
4692                                         r->info2 = NULL;
4693                                 }
4694                         break; }
4695
4696                         case 3: {
4697                                 uint32_t _ptr_info3;
4698                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
4699                                 if (_ptr_info3) {
4700                                         NDR_PULL_ALLOC(ndr, r->info3);
4701                                 } else {
4702                                         r->info3 = NULL;
4703                                 }
4704                         break; }
4705
4706                         default:
4707                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4708                 }
4709         }
4710         if (ndr_flags & NDR_BUFFERS) {
4711                 switch (level) {
4712                         case 0:
4713                                 if (r->info0) {
4714                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
4715                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
4716                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
4717                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
4718                                 }
4719                         break;
4720
4721                         case 1:
4722                                 if (r->info1) {
4723                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
4724                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
4725                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
4726                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
4727                                 }
4728                         break;
4729
4730                         case 2:
4731                                 if (r->info2) {
4732                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
4733                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
4734                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
4735                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
4736                                 }
4737                         break;
4738
4739                         case 3:
4740                                 if (r->info3) {
4741                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
4742                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
4743                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
4744                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
4745                                 }
4746                         break;
4747
4748                         default:
4749                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4750                 }
4751         }
4752         return NDR_ERR_SUCCESS;
4753 }
4754
4755 _PUBLIC_ void ndr_print_wkssvc_NetrUseGetInfoCtr(struct ndr_print *ndr, const char *name, const union wkssvc_NetrUseGetInfoCtr *r)
4756 {
4757         int level;
4758         level = ndr_print_get_switch_value(ndr, r);
4759         ndr_print_union(ndr, name, level, "wkssvc_NetrUseGetInfoCtr");
4760         switch (level) {
4761                 case 0:
4762                         ndr_print_ptr(ndr, "info0", r->info0);
4763                         ndr->depth++;
4764                         if (r->info0) {
4765                                 ndr_print_wkssvc_NetrUseInfo0(ndr, "info0", r->info0);
4766                         }
4767                         ndr->depth--;
4768                 break;
4769
4770                 case 1:
4771                         ndr_print_ptr(ndr, "info1", r->info1);
4772                         ndr->depth++;
4773                         if (r->info1) {
4774                                 ndr_print_wkssvc_NetrUseInfo1(ndr, "info1", r->info1);
4775                         }
4776                         ndr->depth--;
4777                 break;
4778
4779                 case 2:
4780                         ndr_print_ptr(ndr, "info2", r->info2);
4781                         ndr->depth++;
4782                         if (r->info2) {
4783                                 ndr_print_wkssvc_NetrUseInfo2(ndr, "info2", r->info2);
4784                         }
4785                         ndr->depth--;
4786                 break;
4787
4788                 case 3:
4789                         ndr_print_ptr(ndr, "info3", r->info3);
4790                         ndr->depth++;
4791                         if (r->info3) {
4792                                 ndr_print_wkssvc_NetrUseInfo3(ndr, "info3", r->info3);
4793                         }
4794                         ndr->depth--;
4795                 break;
4796
4797                 default:
4798                         ndr_print_bad_level(ndr, name, level);
4799         }
4800 }
4801
4802 static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumCtr2(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseEnumCtr2 *r)
4803 {
4804         uint32_t cntr_array_1;
4805         if (ndr_flags & NDR_SCALARS) {
4806                 NDR_CHECK(ndr_push_align(ndr, 5));
4807                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4808                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
4809         }
4810         if (ndr_flags & NDR_BUFFERS) {
4811                 if (r->array) {
4812                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
4813                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4814                                 NDR_CHECK(ndr_push_wkssvc_NetrUseInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4815                         }
4816                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4817                                 NDR_CHECK(ndr_push_wkssvc_NetrUseInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4818                         }
4819                 }
4820         }
4821         return NDR_ERR_SUCCESS;
4822 }
4823
4824 static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumCtr2(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseEnumCtr2 *r)
4825 {
4826         uint32_t _ptr_array;
4827         uint32_t cntr_array_1;
4828         TALLOC_CTX *_mem_save_array_0;
4829         TALLOC_CTX *_mem_save_array_1;
4830         if (ndr_flags & NDR_SCALARS) {
4831                 NDR_CHECK(ndr_pull_align(ndr, 5));
4832                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4833                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
4834                 if (_ptr_array) {
4835                         NDR_PULL_ALLOC(ndr, r->array);
4836                 } else {
4837                         r->array = NULL;
4838                 }
4839         }
4840         if (ndr_flags & NDR_BUFFERS) {
4841                 if (r->array) {
4842                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4843                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4844                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
4845                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
4846                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4847                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4848                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4849                                 NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4850                         }
4851                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4852                                 NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4853                         }
4854                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
4855                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
4856                 }
4857                 if (r->array) {
4858                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
4859                 }
4860         }
4861         return NDR_ERR_SUCCESS;
4862 }
4863
4864 _PUBLIC_ void ndr_print_wkssvc_NetrUseEnumCtr2(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseEnumCtr2 *r)
4865 {
4866         uint32_t cntr_array_1;
4867         ndr_print_struct(ndr, name, "wkssvc_NetrUseEnumCtr2");
4868         ndr->depth++;
4869         ndr_print_uint32(ndr, "count", r->count);
4870         ndr_print_ptr(ndr, "array", r->array);
4871         ndr->depth++;
4872         if (r->array) {
4873                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
4874                 ndr->depth++;
4875                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
4876                         char *idx_1=NULL;
4877                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
4878                                 ndr_print_wkssvc_NetrUseInfo2(ndr, "array", &r->array[cntr_array_1]);
4879                                 free(idx_1);
4880                         }
4881                 }
4882                 ndr->depth--;
4883         }
4884         ndr->depth--;
4885         ndr->depth--;
4886 }
4887
4888 static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumCtr1(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseEnumCtr1 *r)
4889 {
4890         uint32_t cntr_array_1;
4891         if (ndr_flags & NDR_SCALARS) {
4892                 NDR_CHECK(ndr_push_align(ndr, 5));
4893                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4894                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
4895         }
4896         if (ndr_flags & NDR_BUFFERS) {
4897                 if (r->array) {
4898                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
4899                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4900                                 NDR_CHECK(ndr_push_wkssvc_NetrUseInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4901                         }
4902                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4903                                 NDR_CHECK(ndr_push_wkssvc_NetrUseInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4904                         }
4905                 }
4906         }
4907         return NDR_ERR_SUCCESS;
4908 }
4909
4910 static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumCtr1(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseEnumCtr1 *r)
4911 {
4912         uint32_t _ptr_array;
4913         uint32_t cntr_array_1;
4914         TALLOC_CTX *_mem_save_array_0;
4915         TALLOC_CTX *_mem_save_array_1;
4916         if (ndr_flags & NDR_SCALARS) {
4917                 NDR_CHECK(ndr_pull_align(ndr, 5));
4918                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4919                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
4920                 if (_ptr_array) {
4921                         NDR_PULL_ALLOC(ndr, r->array);
4922                 } else {
4923                         r->array = NULL;
4924                 }
4925         }
4926         if (ndr_flags & NDR_BUFFERS) {
4927                 if (r->array) {
4928                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4929                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4930                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
4931                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
4932                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4933                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4934                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4935                                 NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4936                         }
4937                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4938                                 NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4939                         }
4940                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
4941                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
4942                 }
4943                 if (r->array) {
4944                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
4945                 }
4946         }
4947         return NDR_ERR_SUCCESS;
4948 }
4949
4950 _PUBLIC_ void ndr_print_wkssvc_NetrUseEnumCtr1(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseEnumCtr1 *r)
4951 {
4952         uint32_t cntr_array_1;
4953         ndr_print_struct(ndr, name, "wkssvc_NetrUseEnumCtr1");
4954         ndr->depth++;
4955         ndr_print_uint32(ndr, "count", r->count);
4956         ndr_print_ptr(ndr, "array", r->array);
4957         ndr->depth++;
4958         if (r->array) {
4959                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
4960                 ndr->depth++;
4961                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
4962                         char *idx_1=NULL;
4963                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
4964                                 ndr_print_wkssvc_NetrUseInfo1(ndr, "array", &r->array[cntr_array_1]);
4965                                 free(idx_1);
4966                         }
4967                 }
4968                 ndr->depth--;
4969         }
4970         ndr->depth--;
4971         ndr->depth--;
4972 }
4973
4974 static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumCtr0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseEnumCtr0 *r)
4975 {
4976         uint32_t cntr_array_1;
4977         if (ndr_flags & NDR_SCALARS) {
4978                 NDR_CHECK(ndr_push_align(ndr, 5));
4979                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4980                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
4981         }
4982         if (ndr_flags & NDR_BUFFERS) {
4983                 if (r->array) {
4984                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
4985                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4986                                 NDR_CHECK(ndr_push_wkssvc_NetrUseInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4987                         }
4988                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4989                                 NDR_CHECK(ndr_push_wkssvc_NetrUseInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4990                         }
4991                 }
4992         }
4993         return NDR_ERR_SUCCESS;
4994 }
4995
4996 static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumCtr0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseEnumCtr0 *r)
4997 {
4998         uint32_t _ptr_array;
4999         uint32_t cntr_array_1;
5000         TALLOC_CTX *_mem_save_array_0;
5001         TALLOC_CTX *_mem_save_array_1;
5002         if (ndr_flags & NDR_SCALARS) {
5003                 NDR_CHECK(ndr_pull_align(ndr, 5));
5004                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5005                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
5006                 if (_ptr_array) {
5007                         NDR_PULL_ALLOC(ndr, r->array);
5008                 } else {
5009                         r->array = NULL;
5010                 }
5011         }
5012         if (ndr_flags & NDR_BUFFERS) {
5013                 if (r->array) {
5014                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5015                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5016                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
5017                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
5018                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5019                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5020                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5021                                 NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5022                         }
5023                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5024                                 NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5025                         }
5026                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
5027                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
5028                 }
5029                 if (r->array) {
5030                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
5031                 }
5032         }
5033         return NDR_ERR_SUCCESS;
5034 }
5035
5036 _PUBLIC_ void ndr_print_wkssvc_NetrUseEnumCtr0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseEnumCtr0 *r)
5037 {
5038         uint32_t cntr_array_1;
5039         ndr_print_struct(ndr, name, "wkssvc_NetrUseEnumCtr0");
5040         ndr->depth++;
5041         ndr_print_uint32(ndr, "count", r->count);
5042         ndr_print_ptr(ndr, "array", r->array);
5043         ndr->depth++;
5044         if (r->array) {
5045                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
5046                 ndr->depth++;
5047                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
5048                         char *idx_1=NULL;
5049                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
5050                                 ndr_print_wkssvc_NetrUseInfo0(ndr, "array", &r->array[cntr_array_1]);
5051                                 free(idx_1);
5052                         }
5053                 }
5054                 ndr->depth--;
5055         }
5056         ndr->depth--;
5057         ndr->depth--;
5058 }
5059
5060 static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumCtr(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetrUseEnumCtr *r)
5061 {
5062         if (ndr_flags & NDR_SCALARS) {
5063                 int level = ndr_push_get_switch_value(ndr, r);
5064                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5065                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5066                 switch (level) {
5067                         case 0: {
5068                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
5069                         break; }
5070
5071                         case 1: {
5072                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
5073                         break; }
5074
5075                         case 2: {
5076                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr2));
5077                         break; }
5078
5079                         default:
5080                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5081                 }
5082         }
5083         if (ndr_flags & NDR_BUFFERS) {
5084                 int level = ndr_push_get_switch_value(ndr, r);
5085                 switch (level) {
5086                         case 0:
5087                                 if (r->ctr0) {
5088                                         NDR_CHECK(ndr_push_wkssvc_NetrUseEnumCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
5089                                 }
5090                         break;
5091
5092                         case 1:
5093                                 if (r->ctr1) {
5094                                         NDR_CHECK(ndr_push_wkssvc_NetrUseEnumCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
5095                                 }
5096                         break;
5097
5098                         case 2:
5099                                 if (r->ctr2) {
5100                                         NDR_CHECK(ndr_push_wkssvc_NetrUseEnumCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
5101                                 }
5102                         break;
5103
5104                         default:
5105                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5106                 }
5107         }
5108         return NDR_ERR_SUCCESS;
5109 }
5110
5111 static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumCtr(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetrUseEnumCtr *r)
5112 {
5113         int level;
5114         uint32_t _level;
5115         TALLOC_CTX *_mem_save_ctr0_0;
5116         TALLOC_CTX *_mem_save_ctr1_0;
5117         TALLOC_CTX *_mem_save_ctr2_0;
5118         level = ndr_pull_get_switch_value(ndr, r);
5119         if (ndr_flags & NDR_SCALARS) {
5120                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5121                 if (_level != level) {
5122                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5123                 }
5124                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5125                 switch (level) {
5126                         case 0: {
5127                                 uint32_t _ptr_ctr0;
5128                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));
5129                                 if (_ptr_ctr0) {
5130                                         NDR_PULL_ALLOC(ndr, r->ctr0);
5131                                 } else {
5132                                         r->ctr0 = NULL;
5133                                 }
5134                         break; }
5135
5136                         case 1: {
5137                                 uint32_t _ptr_ctr1;
5138                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
5139                                 if (_ptr_ctr1) {
5140                                         NDR_PULL_ALLOC(ndr, r->ctr1);
5141                                 } else {
5142                                         r->ctr1 = NULL;
5143                                 }
5144                         break; }
5145
5146                         case 2: {
5147                                 uint32_t _ptr_ctr2;
5148                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr2));
5149                                 if (_ptr_ctr2) {
5150                                         NDR_PULL_ALLOC(ndr, r->ctr2);
5151                                 } else {
5152                                         r->ctr2 = NULL;
5153                                 }
5154                         break; }
5155
5156                         default:
5157                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5158                 }
5159         }
5160         if (ndr_flags & NDR_BUFFERS) {
5161                 switch (level) {
5162                         case 0:
5163                                 if (r->ctr0) {
5164                                         _mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);
5165                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr0, 0);
5166                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
5167                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);
5168                                 }
5169                         break;
5170
5171                         case 1:
5172                                 if (r->ctr1) {
5173                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5174                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
5175                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
5176                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
5177                                 }
5178                         break;
5179
5180                         case 2:
5181                                 if (r->ctr2) {
5182                                         _mem_save_ctr2_0 = NDR_PULL_GET_MEM_CTX(ndr);
5183                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr2, 0);
5184                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
5185                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr2_0, 0);
5186                                 }
5187                         break;
5188
5189                         default:
5190                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5191                 }
5192         }
5193         return NDR_ERR_SUCCESS;
5194 }
5195
5196 _PUBLIC_ void ndr_print_wkssvc_NetrUseEnumCtr(struct ndr_print *ndr, const char *name, const union wkssvc_NetrUseEnumCtr *r)
5197 {
5198         int level;
5199         level = ndr_print_get_switch_value(ndr, r);
5200         ndr_print_union(ndr, name, level, "wkssvc_NetrUseEnumCtr");
5201         switch (level) {
5202                 case 0:
5203                         ndr_print_ptr(ndr, "ctr0", r->ctr0);
5204                         ndr->depth++;
5205                         if (r->ctr0) {
5206                                 ndr_print_wkssvc_NetrUseEnumCtr0(ndr, "ctr0", r->ctr0);
5207                         }
5208                         ndr->depth--;
5209                 break;
5210
5211                 case 1:
5212                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
5213                         ndr->depth++;
5214                         if (r->ctr1) {
5215                                 ndr_print_wkssvc_NetrUseEnumCtr1(ndr, "ctr1", r->ctr1);
5216                         }
5217                         ndr->depth--;
5218                 break;
5219
5220                 case 2:
5221                         ndr_print_ptr(ndr, "ctr2", r->ctr2);
5222                         ndr->depth++;
5223                         if (r->ctr2) {
5224                                 ndr_print_wkssvc_NetrUseEnumCtr2(ndr, "ctr2", r->ctr2);
5225                         }
5226                         ndr->depth--;
5227                 break;
5228
5229                 default:
5230                         ndr_print_bad_level(ndr, name, level);
5231         }
5232 }
5233
5234 static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumInfo(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseEnumInfo *r)
5235 {
5236         if (ndr_flags & NDR_SCALARS) {
5237                 NDR_CHECK(ndr_push_align(ndr, 5));
5238                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
5239                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
5240                 NDR_CHECK(ndr_push_wkssvc_NetrUseEnumCtr(ndr, NDR_SCALARS, &r->ctr));
5241         }
5242         if (ndr_flags & NDR_BUFFERS) {
5243                 NDR_CHECK(ndr_push_wkssvc_NetrUseEnumCtr(ndr, NDR_BUFFERS, &r->ctr));
5244         }
5245         return NDR_ERR_SUCCESS;
5246 }
5247
5248 static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumInfo(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseEnumInfo *r)
5249 {
5250         if (ndr_flags & NDR_SCALARS) {
5251                 NDR_CHECK(ndr_pull_align(ndr, 5));
5252                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
5253                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
5254                 NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumCtr(ndr, NDR_SCALARS, &r->ctr));
5255         }
5256         if (ndr_flags & NDR_BUFFERS) {
5257                 NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumCtr(ndr, NDR_BUFFERS, &r->ctr));
5258         }
5259         return NDR_ERR_SUCCESS;
5260 }
5261
5262 _PUBLIC_ void ndr_print_wkssvc_NetrUseEnumInfo(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseEnumInfo *r)
5263 {
5264         ndr_print_struct(ndr, name, "wkssvc_NetrUseEnumInfo");
5265         ndr->depth++;
5266         ndr_print_uint32(ndr, "level", r->level);
5267         ndr_print_set_switch_value(ndr, &r->ctr, r->level);
5268         ndr_print_wkssvc_NetrUseEnumCtr(ndr, "ctr", &r->ctr);
5269         ndr->depth--;
5270 }
5271
5272 static enum ndr_err_code ndr_push_wkssvc_NetrWorkstationStatistics(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrWorkstationStatistics *r)
5273 {
5274         if (ndr_flags & NDR_SCALARS) {
5275                 NDR_CHECK(ndr_push_align(ndr, 8));
5276                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown1));
5277                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown2));
5278                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown3));
5279                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown4));
5280                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown5));
5281                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown6));
5282                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown7));
5283                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown8));
5284                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown9));
5285                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown10));
5286                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown11));
5287                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown12));
5288                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown13));
5289                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown14));
5290                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown15));
5291                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown16));
5292                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown17));
5293                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown18));
5294                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown19));
5295                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown20));
5296                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown21));
5297                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown22));
5298                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown23));
5299                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown24));
5300                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown25));
5301                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown26));
5302                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown27));
5303                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown28));
5304                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown29));
5305                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown30));
5306                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown31));
5307                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown32));
5308                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown33));
5309                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown34));
5310                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown35));
5311                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown36));
5312                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown37));
5313                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown38));
5314                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown39));
5315                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown40));
5316         }
5317         if (ndr_flags & NDR_BUFFERS) {
5318         }
5319         return NDR_ERR_SUCCESS;
5320 }
5321
5322 static enum ndr_err_code ndr_pull_wkssvc_NetrWorkstationStatistics(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrWorkstationStatistics *r)
5323 {
5324         if (ndr_flags & NDR_SCALARS) {
5325                 NDR_CHECK(ndr_pull_align(ndr, 8));
5326                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown1));
5327                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown2));
5328                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown3));
5329                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown4));
5330                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown5));
5331                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown6));
5332                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown7));
5333                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown8));
5334                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown9));
5335                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown10));
5336                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown11));
5337                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown12));
5338                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown13));
5339                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown14));
5340                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown15));
5341                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown16));
5342                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown17));
5343                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown18));
5344                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown19));
5345                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown20));
5346                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown21));
5347                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown22));
5348                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown23));
5349                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown24));
5350                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown25));
5351                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown26));
5352                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown27));
5353                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown28));
5354                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown29));
5355                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown30));
5356                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown31));
5357                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown32));
5358                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown33));
5359                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown34));
5360                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown35));
5361                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown36));
5362                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown37));
5363                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown38));
5364                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown39));
5365                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown40));
5366         }
5367         if (ndr_flags & NDR_BUFFERS) {
5368         }
5369         return NDR_ERR_SUCCESS;
5370 }
5371
5372 _PUBLIC_ void ndr_print_wkssvc_NetrWorkstationStatistics(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrWorkstationStatistics *r)
5373 {
5374         ndr_print_struct(ndr, name, "wkssvc_NetrWorkstationStatistics");
5375         ndr->depth++;
5376         ndr_print_hyper(ndr, "unknown1", r->unknown1);
5377         ndr_print_hyper(ndr, "unknown2", r->unknown2);
5378         ndr_print_hyper(ndr, "unknown3", r->unknown3);
5379         ndr_print_hyper(ndr, "unknown4", r->unknown4);
5380         ndr_print_hyper(ndr, "unknown5", r->unknown5);
5381         ndr_print_hyper(ndr, "unknown6", r->unknown6);
5382         ndr_print_hyper(ndr, "unknown7", r->unknown7);
5383         ndr_print_hyper(ndr, "unknown8", r->unknown8);
5384         ndr_print_hyper(ndr, "unknown9", r->unknown9);
5385         ndr_print_hyper(ndr, "unknown10", r->unknown10);
5386         ndr_print_hyper(ndr, "unknown11", r->unknown11);
5387         ndr_print_hyper(ndr, "unknown12", r->unknown12);
5388         ndr_print_hyper(ndr, "unknown13", r->unknown13);
5389         ndr_print_uint32(ndr, "unknown14", r->unknown14);
5390         ndr_print_uint32(ndr, "unknown15", r->unknown15);
5391         ndr_print_uint32(ndr, "unknown16", r->unknown16);
5392         ndr_print_uint32(ndr, "unknown17", r->unknown17);
5393         ndr_print_uint32(ndr, "unknown18", r->unknown18);
5394         ndr_print_uint32(ndr, "unknown19", r->unknown19);
5395         ndr_print_uint32(ndr, "unknown20", r->unknown20);
5396         ndr_print_uint32(ndr, "unknown21", r->unknown21);
5397         ndr_print_uint32(ndr, "unknown22", r->unknown22);
5398         ndr_print_uint32(ndr, "unknown23", r->unknown23);
5399         ndr_print_uint32(ndr, "unknown24", r->unknown24);
5400         ndr_print_uint32(ndr, "unknown25", r->unknown25);
5401         ndr_print_uint32(ndr, "unknown26", r->unknown26);
5402         ndr_print_uint32(ndr, "unknown27", r->unknown27);
5403         ndr_print_uint32(ndr, "unknown28", r->unknown28);
5404         ndr_print_uint32(ndr, "unknown29", r->unknown29);
5405         ndr_print_uint32(ndr, "unknown30", r->unknown30);
5406         ndr_print_uint32(ndr, "unknown31", r->unknown31);
5407         ndr_print_uint32(ndr, "unknown32", r->unknown32);
5408         ndr_print_uint32(ndr, "unknown33", r->unknown33);
5409         ndr_print_uint32(ndr, "unknown34", r->unknown34);
5410         ndr_print_uint32(ndr, "unknown35", r->unknown35);
5411         ndr_print_uint32(ndr, "unknown36", r->unknown36);
5412         ndr_print_uint32(ndr, "unknown37", r->unknown37);
5413         ndr_print_uint32(ndr, "unknown38", r->unknown38);
5414         ndr_print_uint32(ndr, "unknown39", r->unknown39);
5415         ndr_print_uint32(ndr, "unknown40", r->unknown40);
5416         ndr->depth--;
5417 }
5418
5419 static enum ndr_err_code ndr_push_wkssvc_renameflags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
5420 {
5421         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5422         return NDR_ERR_SUCCESS;
5423 }
5424
5425 static enum ndr_err_code ndr_pull_wkssvc_renameflags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
5426 {
5427         uint32_t v;
5428         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5429         *r = v;
5430         return NDR_ERR_SUCCESS;
5431 }
5432
5433 _PUBLIC_ void ndr_print_wkssvc_renameflags(struct ndr_print *ndr, const char *name, uint32_t r)
5434 {
5435         ndr_print_uint32(ndr, name, r);
5436         ndr->depth++;
5437         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE", WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE, r);
5438         ndr->depth--;
5439 }
5440
5441 static enum ndr_err_code ndr_push_wkssvc_NetValidateNameType(struct ndr_push *ndr, int ndr_flags, enum wkssvc_NetValidateNameType r)
5442 {
5443         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
5444         return NDR_ERR_SUCCESS;
5445 }
5446
5447 static enum ndr_err_code ndr_pull_wkssvc_NetValidateNameType(struct ndr_pull *ndr, int ndr_flags, enum wkssvc_NetValidateNameType *r)
5448 {
5449         uint16_t v;
5450         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
5451         *r = v;
5452         return NDR_ERR_SUCCESS;
5453 }
5454
5455 _PUBLIC_ void ndr_print_wkssvc_NetValidateNameType(struct ndr_print *ndr, const char *name, enum wkssvc_NetValidateNameType r)
5456 {
5457         const char *val = NULL;
5458
5459         switch (r) {
5460                 case NetSetupUnknown: val = "NetSetupUnknown"; break;
5461                 case NetSetupMachine: val = "NetSetupMachine"; break;
5462                 case NetSetupWorkgroup: val = "NetSetupWorkgroup"; break;
5463                 case NetSetupDomain: val = "NetSetupDomain"; break;
5464                 case NetSetupNonExistentDomain: val = "NetSetupNonExistentDomain"; break;
5465                 case NetSetupDnsMachine: val = "NetSetupDnsMachine"; break;
5466         }
5467         ndr_print_enum(ndr, name, "ENUM", val, r);
5468 }
5469
5470 static enum ndr_err_code ndr_push_wkssvc_NetJoinStatus(struct ndr_push *ndr, int ndr_flags, enum wkssvc_NetJoinStatus r)
5471 {
5472         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
5473         return NDR_ERR_SUCCESS;
5474 }
5475
5476 static enum ndr_err_code ndr_pull_wkssvc_NetJoinStatus(struct ndr_pull *ndr, int ndr_flags, enum wkssvc_NetJoinStatus *r)
5477 {
5478         uint16_t v;
5479         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
5480         *r = v;
5481         return NDR_ERR_SUCCESS;
5482 }
5483
5484 _PUBLIC_ void ndr_print_wkssvc_NetJoinStatus(struct ndr_print *ndr, const char *name, enum wkssvc_NetJoinStatus r)
5485 {
5486         const char *val = NULL;
5487
5488         switch (r) {
5489                 case NET_SETUP_UNKNOWN_STATUS: val = "NET_SETUP_UNKNOWN_STATUS"; break;
5490                 case NET_SETUP_UNJOINED: val = "NET_SETUP_UNJOINED"; break;
5491                 case NET_SETUP_WORKGROUP_NAME: val = "NET_SETUP_WORKGROUP_NAME"; break;
5492                 case NET_SETUP_DOMAIN_NAME: val = "NET_SETUP_DOMAIN_NAME"; break;
5493         }
5494         ndr_print_enum(ndr, name, "ENUM", val, r);
5495 }
5496
5497 static enum ndr_err_code ndr_push_wkssvc_PasswordBuffer(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_PasswordBuffer *r)
5498 {
5499         {
5500                 uint32_t _flags_save_STRUCT = ndr->flags;
5501                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
5502                 if (ndr_flags & NDR_SCALARS) {
5503                         NDR_CHECK(ndr_push_align(ndr, 1));
5504                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, 524));
5505                 }
5506                 if (ndr_flags & NDR_BUFFERS) {
5507                 }
5508                 ndr->flags = _flags_save_STRUCT;
5509         }
5510         return NDR_ERR_SUCCESS;
5511 }
5512
5513 static enum ndr_err_code ndr_pull_wkssvc_PasswordBuffer(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_PasswordBuffer *r)
5514 {
5515         {
5516                 uint32_t _flags_save_STRUCT = ndr->flags;
5517                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
5518                 if (ndr_flags & NDR_SCALARS) {
5519                         NDR_CHECK(ndr_pull_align(ndr, 1));
5520                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, 524));
5521                 }
5522                 if (ndr_flags & NDR_BUFFERS) {
5523                 }
5524                 ndr->flags = _flags_save_STRUCT;
5525         }
5526         return NDR_ERR_SUCCESS;
5527 }
5528
5529 _PUBLIC_ void ndr_print_wkssvc_PasswordBuffer(struct ndr_print *ndr, const char *name, const struct wkssvc_PasswordBuffer *r)
5530 {
5531         ndr_print_struct(ndr, name, "wkssvc_PasswordBuffer");
5532         {
5533                 uint32_t _flags_save_STRUCT = ndr->flags;
5534                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
5535                 ndr->depth++;
5536                 ndr_print_array_uint8(ndr, "data", r->data, 524);
5537                 ndr->depth--;
5538                 ndr->flags = _flags_save_STRUCT;
5539         }
5540 }
5541
5542 static enum ndr_err_code ndr_push_wkssvc_joinflags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
5543 {
5544         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5545         return NDR_ERR_SUCCESS;
5546 }
5547
5548 static enum ndr_err_code ndr_pull_wkssvc_joinflags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
5549 {
5550         uint32_t v;
5551         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5552         *r = v;
5553         return NDR_ERR_SUCCESS;
5554 }
5555
5556 _PUBLIC_ void ndr_print_wkssvc_joinflags(struct ndr_print *ndr, const char *name, uint32_t r)
5557 {
5558         ndr_print_uint32(ndr, name, r);
5559         ndr->depth++;
5560         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_IGNORE_UNSUPPORTED_FLAGS", WKSSVC_JOIN_FLAGS_IGNORE_UNSUPPORTED_FLAGS, r);
5561         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_JOIN_WITH_NEW_NAME", WKSSVC_JOIN_FLAGS_JOIN_WITH_NEW_NAME, r);
5562         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_JOIN_DC_ACCOUNT", WKSSVC_JOIN_FLAGS_JOIN_DC_ACCOUNT, r);
5563         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_DEFER_SPN", WKSSVC_JOIN_FLAGS_DEFER_SPN, r);
5564         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_MACHINE_PWD_PASSED", WKSSVC_JOIN_FLAGS_MACHINE_PWD_PASSED, r);
5565         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_JOIN_UNSECURE", WKSSVC_JOIN_FLAGS_JOIN_UNSECURE, r);
5566         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_DOMAIN_JOIN_IF_JOINED", WKSSVC_JOIN_FLAGS_DOMAIN_JOIN_IF_JOINED, r);
5567         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_WIN9X_UPGRADE", WKSSVC_JOIN_FLAGS_WIN9X_UPGRADE, r);
5568         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_ACCOUNT_DELETE", WKSSVC_JOIN_FLAGS_ACCOUNT_DELETE, r);
5569         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE", WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE, r);
5570         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_JOIN_TYPE", WKSSVC_JOIN_FLAGS_JOIN_TYPE, r);
5571         ndr->depth--;
5572 }
5573
5574 static enum ndr_err_code ndr_push_wkssvc_ComputerNameType(struct ndr_push *ndr, int ndr_flags, enum wkssvc_ComputerNameType r)
5575 {
5576         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
5577         return NDR_ERR_SUCCESS;
5578 }
5579
5580 static enum ndr_err_code ndr_pull_wkssvc_ComputerNameType(struct ndr_pull *ndr, int ndr_flags, enum wkssvc_ComputerNameType *r)
5581 {
5582         uint16_t v;
5583         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
5584         *r = v;
5585         return NDR_ERR_SUCCESS;
5586 }
5587
5588 _PUBLIC_ void ndr_print_wkssvc_ComputerNameType(struct ndr_print *ndr, const char *name, enum wkssvc_ComputerNameType r)
5589 {
5590         const char *val = NULL;
5591
5592         switch (r) {
5593                 case NetPrimaryComputerName: val = "NetPrimaryComputerName"; break;
5594                 case NetAlternateComputerNames: val = "NetAlternateComputerNames"; break;
5595                 case NetAllComputerNames: val = "NetAllComputerNames"; break;
5596                 case NetComputerNameTypeMax: val = "NetComputerNameTypeMax"; break;
5597         }
5598         ndr_print_enum(ndr, name, "ENUM", val, r);
5599 }
5600
5601 static enum ndr_err_code ndr_push_wkssvc_ComputerNamesCtr(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_ComputerNamesCtr *r)
5602 {
5603         uint32_t cntr_computer_name_1;
5604         if (ndr_flags & NDR_SCALARS) {
5605                 NDR_CHECK(ndr_push_align(ndr, 5));
5606                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5607                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_name));
5608         }
5609         if (ndr_flags & NDR_BUFFERS) {
5610                 if (r->computer_name) {
5611                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5612                         for (cntr_computer_name_1 = 0; cntr_computer_name_1 < r->count; cntr_computer_name_1++) {
5613                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->computer_name[cntr_computer_name_1]));
5614                         }
5615                         for (cntr_computer_name_1 = 0; cntr_computer_name_1 < r->count; cntr_computer_name_1++) {
5616                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->computer_name[cntr_computer_name_1]));
5617                         }
5618                 }
5619         }
5620         return NDR_ERR_SUCCESS;
5621 }
5622
5623 static enum ndr_err_code ndr_pull_wkssvc_ComputerNamesCtr(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_ComputerNamesCtr *r)
5624 {
5625         uint32_t _ptr_computer_name;
5626         uint32_t cntr_computer_name_1;
5627         TALLOC_CTX *_mem_save_computer_name_0;
5628         TALLOC_CTX *_mem_save_computer_name_1;
5629         if (ndr_flags & NDR_SCALARS) {
5630                 NDR_CHECK(ndr_pull_align(ndr, 5));
5631                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5632                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_name));
5633                 if (_ptr_computer_name) {
5634                         NDR_PULL_ALLOC(ndr, r->computer_name);
5635                 } else {
5636                         r->computer_name = NULL;
5637                 }
5638         }
5639         if (ndr_flags & NDR_BUFFERS) {
5640                 if (r->computer_name) {
5641                         _mem_save_computer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5642                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_name, 0);
5643                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_name));
5644                         NDR_PULL_ALLOC_N(ndr, r->computer_name, ndr_get_array_size(ndr, &r->computer_name));
5645                         _mem_save_computer_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
5646                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_name, 0);
5647                         for (cntr_computer_name_1 = 0; cntr_computer_name_1 < r->count; cntr_computer_name_1++) {
5648                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->computer_name[cntr_computer_name_1]));
5649                         }
5650                         for (cntr_computer_name_1 = 0; cntr_computer_name_1 < r->count; cntr_computer_name_1++) {
5651                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->computer_name[cntr_computer_name_1]));
5652                         }
5653                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_name_1, 0);
5654                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_name_0, 0);
5655                 }
5656                 if (r->computer_name) {
5657                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->computer_name, r->count));
5658                 }
5659         }
5660         return NDR_ERR_SUCCESS;
5661 }
5662
5663 _PUBLIC_ void ndr_print_wkssvc_ComputerNamesCtr(struct ndr_print *ndr, const char *name, const struct wkssvc_ComputerNamesCtr *r)
5664 {
5665         uint32_t cntr_computer_name_1;
5666         ndr_print_struct(ndr, name, "wkssvc_ComputerNamesCtr");
5667         ndr->depth++;
5668         ndr_print_uint32(ndr, "count", r->count);
5669         ndr_print_ptr(ndr, "computer_name", r->computer_name);
5670         ndr->depth++;
5671         if (r->computer_name) {
5672                 ndr->print(ndr, "%s: ARRAY(%d)", "computer_name", (int)r->count);
5673                 ndr->depth++;
5674                 for (cntr_computer_name_1=0;cntr_computer_name_1<r->count;cntr_computer_name_1++) {
5675                         char *idx_1=NULL;
5676                         if (asprintf(&idx_1, "[%d]", cntr_computer_name_1) != -1) {
5677                                 ndr_print_lsa_String(ndr, "computer_name", &r->computer_name[cntr_computer_name_1]);
5678                                 free(idx_1);
5679                         }
5680                 }
5681                 ndr->depth--;
5682         }
5683         ndr->depth--;
5684         ndr->depth--;
5685 }
5686
5687 static enum ndr_err_code ndr_push_wkssvc_NetWkstaGetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaGetInfo *r)
5688 {
5689         if (flags & NDR_IN) {
5690                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
5691                 if (r->in.server_name) {
5692                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
5693                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5694                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
5695                         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));
5696                 }
5697                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
5698         }
5699         if (flags & NDR_OUT) {
5700                 if (r->out.info == NULL) {
5701                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5702                 }
5703                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
5704                 NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
5705                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5706         }
5707         return NDR_ERR_SUCCESS;
5708 }
5709
5710 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaGetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaGetInfo *r)
5711 {
5712         uint32_t _ptr_server_name;
5713         TALLOC_CTX *_mem_save_server_name_0;
5714         TALLOC_CTX *_mem_save_info_0;
5715         if (flags & NDR_IN) {
5716                 ZERO_STRUCT(r->out);
5717
5718                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5719                 if (_ptr_server_name) {
5720                         NDR_PULL_ALLOC(ndr, r->in.server_name);
5721                 } else {
5722                         r->in.server_name = NULL;
5723                 }
5724                 if (r->in.server_name) {
5725                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5726                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
5727                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
5728                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
5729                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
5730                                 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));
5731                         }
5732                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
5733                         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));
5734                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5735                 }
5736                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
5737                 NDR_PULL_ALLOC(ndr, r->out.info);
5738                 ZERO_STRUCTP(r->out.info);
5739         }
5740         if (flags & NDR_OUT) {
5741                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5742                         NDR_PULL_ALLOC(ndr, r->out.info);
5743                 }
5744                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
5745                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
5746                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
5747                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
5748                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
5749                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5750         }
5751         return NDR_ERR_SUCCESS;
5752 }
5753
5754 _PUBLIC_ void ndr_print_wkssvc_NetWkstaGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaGetInfo *r)
5755 {
5756         ndr_print_struct(ndr, name, "wkssvc_NetWkstaGetInfo");
5757         ndr->depth++;
5758         if (flags & NDR_SET_VALUES) {
5759                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5760         }
5761         if (flags & NDR_IN) {
5762                 ndr_print_struct(ndr, "in", "wkssvc_NetWkstaGetInfo");
5763                 ndr->depth++;
5764                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
5765                 ndr->depth++;
5766                 if (r->in.server_name) {
5767                         ndr_print_string(ndr, "server_name", r->in.server_name);
5768                 }
5769                 ndr->depth--;
5770                 ndr_print_uint32(ndr, "level", r->in.level);
5771                 ndr->depth--;
5772         }
5773         if (flags & NDR_OUT) {
5774                 ndr_print_struct(ndr, "out", "wkssvc_NetWkstaGetInfo");
5775                 ndr->depth++;
5776                 ndr_print_ptr(ndr, "info", r->out.info);
5777                 ndr->depth++;
5778                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
5779                 ndr_print_wkssvc_NetWkstaInfo(ndr, "info", r->out.info);
5780                 ndr->depth--;
5781                 ndr_print_WERROR(ndr, "result", r->out.result);
5782                 ndr->depth--;
5783         }
5784         ndr->depth--;
5785 }
5786
5787 static enum ndr_err_code ndr_push_wkssvc_NetWkstaSetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaSetInfo *r)
5788 {
5789         if (flags & NDR_IN) {
5790                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
5791                 if (r->in.server_name) {
5792                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
5793                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5794                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
5795                         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));
5796                 }
5797                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
5798                 if (r->in.info == NULL) {
5799                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5800                 }
5801                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
5802                 NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
5803                 if (r->in.parm_error == NULL) {
5804                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5805                 }
5806                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_error));
5807         }
5808         if (flags & NDR_OUT) {
5809                 if (r->out.parm_error == NULL) {
5810                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5811                 }
5812                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_error));
5813                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5814         }
5815         return NDR_ERR_SUCCESS;
5816 }
5817
5818 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaSetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaSetInfo *r)
5819 {
5820         uint32_t _ptr_server_name;
5821         TALLOC_CTX *_mem_save_server_name_0;
5822         TALLOC_CTX *_mem_save_info_0;
5823         TALLOC_CTX *_mem_save_parm_error_0;
5824         if (flags & NDR_IN) {
5825                 ZERO_STRUCT(r->out);
5826
5827                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5828                 if (_ptr_server_name) {
5829                         NDR_PULL_ALLOC(ndr, r->in.server_name);
5830                 } else {
5831                         r->in.server_name = NULL;
5832                 }
5833                 if (r->in.server_name) {
5834                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5835                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
5836                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
5837                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
5838                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
5839                                 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));
5840                         }
5841                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
5842                         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));
5843                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5844                 }
5845                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
5846                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5847                         NDR_PULL_ALLOC(ndr, r->in.info);
5848                 }
5849                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
5850                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
5851                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
5852                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
5853                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
5854                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5855                         NDR_PULL_ALLOC(ndr, r->in.parm_error);
5856                 }
5857                 _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
5858                 NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_error, LIBNDR_FLAG_REF_ALLOC);
5859                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_error));
5860                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, LIBNDR_FLAG_REF_ALLOC);
5861                 NDR_PULL_ALLOC(ndr, r->out.parm_error);
5862                 *r->out.parm_error = *r->in.parm_error;
5863         }
5864         if (flags & NDR_OUT) {
5865                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5866                         NDR_PULL_ALLOC(ndr, r->out.parm_error);
5867                 }
5868                 _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
5869                 NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_error, LIBNDR_FLAG_REF_ALLOC);
5870                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_error));
5871                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, LIBNDR_FLAG_REF_ALLOC);
5872                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5873         }
5874         return NDR_ERR_SUCCESS;
5875 }
5876
5877 _PUBLIC_ void ndr_print_wkssvc_NetWkstaSetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaSetInfo *r)
5878 {
5879         ndr_print_struct(ndr, name, "wkssvc_NetWkstaSetInfo");
5880         ndr->depth++;
5881         if (flags & NDR_SET_VALUES) {
5882                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5883         }
5884         if (flags & NDR_IN) {
5885                 ndr_print_struct(ndr, "in", "wkssvc_NetWkstaSetInfo");
5886                 ndr->depth++;
5887                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
5888                 ndr->depth++;
5889                 if (r->in.server_name) {
5890                         ndr_print_string(ndr, "server_name", r->in.server_name);
5891                 }
5892                 ndr->depth--;
5893                 ndr_print_uint32(ndr, "level", r->in.level);
5894                 ndr_print_ptr(ndr, "info", r->in.info);
5895                 ndr->depth++;
5896                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
5897                 ndr_print_wkssvc_NetWkstaInfo(ndr, "info", r->in.info);
5898                 ndr->depth--;
5899                 ndr_print_ptr(ndr, "parm_error", r->in.parm_error);
5900                 ndr->depth++;
5901                 ndr_print_uint32(ndr, "parm_error", *r->in.parm_error);
5902                 ndr->depth--;
5903                 ndr->depth--;
5904         }
5905         if (flags & NDR_OUT) {
5906                 ndr_print_struct(ndr, "out", "wkssvc_NetWkstaSetInfo");
5907                 ndr->depth++;
5908                 ndr_print_ptr(ndr, "parm_error", r->out.parm_error);
5909                 ndr->depth++;
5910                 ndr_print_uint32(ndr, "parm_error", *r->out.parm_error);
5911                 ndr->depth--;
5912                 ndr_print_WERROR(ndr, "result", r->out.result);
5913                 ndr->depth--;
5914         }
5915         ndr->depth--;
5916 }
5917
5918 static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsers(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaEnumUsers *r)
5919 {
5920         if (flags & NDR_IN) {
5921                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
5922                 if (r->in.server_name) {
5923                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
5924                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5925                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
5926                         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));
5927                 }
5928                 if (r->in.info == NULL) {
5929                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5930                 }
5931                 NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
5932                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.prefmaxlen));
5933                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
5934                 if (r->in.resume_handle) {
5935                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
5936                 }
5937         }
5938         if (flags & NDR_OUT) {
5939                 if (r->out.info == NULL) {
5940                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5941                 }
5942                 NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
5943                 if (r->out.entries_read == NULL) {
5944                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5945                 }
5946                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.entries_read));
5947                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
5948                 if (r->out.resume_handle) {
5949                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
5950                 }
5951                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5952         }
5953         return NDR_ERR_SUCCESS;
5954 }
5955
5956 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsers(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaEnumUsers *r)
5957 {
5958         uint32_t _ptr_server_name;
5959         uint32_t _ptr_resume_handle;
5960         TALLOC_CTX *_mem_save_server_name_0;
5961         TALLOC_CTX *_mem_save_info_0;
5962         TALLOC_CTX *_mem_save_entries_read_0;
5963         TALLOC_CTX *_mem_save_resume_handle_0;
5964         if (flags & NDR_IN) {
5965                 ZERO_STRUCT(r->out);
5966
5967                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5968                 if (_ptr_server_name) {
5969                         NDR_PULL_ALLOC(ndr, r->in.server_name);
5970                 } else {
5971                         r->in.server_name = NULL;
5972                 }
5973                 if (r->in.server_name) {
5974                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5975                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
5976                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
5977                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
5978                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
5979                                 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));
5980                         }
5981                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
5982                         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));
5983                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5984                 }
5985                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5986                         NDR_PULL_ALLOC(ndr, r->in.info);
5987                 }
5988                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
5989                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
5990                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
5991                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
5992                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.prefmaxlen));
5993                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
5994                 if (_ptr_resume_handle) {
5995                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
5996                 } else {
5997                         r->in.resume_handle = NULL;
5998                 }
5999                 if (r->in.resume_handle) {
6000                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6001                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
6002                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
6003                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
6004                 }
6005                 NDR_PULL_ALLOC(ndr, r->out.info);
6006                 *r->out.info = *r->in.info;
6007                 NDR_PULL_ALLOC(ndr, r->out.entries_read);
6008                 ZERO_STRUCTP(r->out.entries_read);
6009         }
6010         if (flags & NDR_OUT) {
6011                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6012                         NDR_PULL_ALLOC(ndr, r->out.info);
6013                 }
6014                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6015                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
6016                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
6017                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6018                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6019                         NDR_PULL_ALLOC(ndr, r->out.entries_read);
6020                 }
6021                 _mem_save_entries_read_0 = NDR_PULL_GET_MEM_CTX(ndr);
6022                 NDR_PULL_SET_MEM_CTX(ndr, r->out.entries_read, LIBNDR_FLAG_REF_ALLOC);
6023                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.entries_read));
6024                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_read_0, LIBNDR_FLAG_REF_ALLOC);
6025                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
6026                 if (_ptr_resume_handle) {
6027                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6028                 } else {
6029                         r->out.resume_handle = NULL;
6030                 }
6031                 if (r->out.resume_handle) {
6032                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6033                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
6034                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
6035                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
6036                 }
6037                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6038         }
6039         return NDR_ERR_SUCCESS;
6040 }
6041
6042 _PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsers(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaEnumUsers *r)
6043 {
6044         ndr_print_struct(ndr, name, "wkssvc_NetWkstaEnumUsers");
6045         ndr->depth++;
6046         if (flags & NDR_SET_VALUES) {
6047                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6048         }
6049         if (flags & NDR_IN) {
6050                 ndr_print_struct(ndr, "in", "wkssvc_NetWkstaEnumUsers");
6051                 ndr->depth++;
6052                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
6053                 ndr->depth++;
6054                 if (r->in.server_name) {
6055                         ndr_print_string(ndr, "server_name", r->in.server_name);
6056                 }
6057                 ndr->depth--;
6058                 ndr_print_ptr(ndr, "info", r->in.info);
6059                 ndr->depth++;
6060                 ndr_print_wkssvc_NetWkstaEnumUsersInfo(ndr, "info", r->in.info);
6061                 ndr->depth--;
6062                 ndr_print_uint32(ndr, "prefmaxlen", r->in.prefmaxlen);
6063                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
6064                 ndr->depth++;
6065                 if (r->in.resume_handle) {
6066                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
6067                 }
6068                 ndr->depth--;
6069                 ndr->depth--;
6070         }
6071         if (flags & NDR_OUT) {
6072                 ndr_print_struct(ndr, "out", "wkssvc_NetWkstaEnumUsers");
6073                 ndr->depth++;
6074                 ndr_print_ptr(ndr, "info", r->out.info);
6075                 ndr->depth++;
6076                 ndr_print_wkssvc_NetWkstaEnumUsersInfo(ndr, "info", r->out.info);
6077                 ndr->depth--;
6078                 ndr_print_ptr(ndr, "entries_read", r->out.entries_read);
6079                 ndr->depth++;
6080                 ndr_print_uint32(ndr, "entries_read", *r->out.entries_read);
6081                 ndr->depth--;
6082                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
6083                 ndr->depth++;
6084                 if (r->out.resume_handle) {
6085                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
6086                 }
6087                 ndr->depth--;
6088                 ndr_print_WERROR(ndr, "result", r->out.result);
6089                 ndr->depth--;
6090         }
6091         ndr->depth--;
6092 }
6093
6094 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserGetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetrWkstaUserGetInfo *r)
6095 {
6096         if (flags & NDR_IN) {
6097                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown));
6098                 if (r->in.unknown) {
6099                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));
6100                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6101                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));
6102                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.unknown, ndr_charset_length(r->in.unknown, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6103                 }
6104                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
6105         }
6106         if (flags & NDR_OUT) {
6107                 if (r->out.info == NULL) {
6108                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6109                 }
6110                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
6111                 NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
6112                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6113         }
6114         return NDR_ERR_SUCCESS;
6115 }
6116
6117 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserGetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetrWkstaUserGetInfo *r)
6118 {
6119         uint32_t _ptr_unknown;
6120         TALLOC_CTX *_mem_save_unknown_0;
6121         TALLOC_CTX *_mem_save_info_0;
6122         if (flags & NDR_IN) {
6123                 ZERO_STRUCT(r->out);
6124
6125                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown));
6126                 if (_ptr_unknown) {
6127                         NDR_PULL_ALLOC(ndr, r->in.unknown);
6128                 } else {
6129                         r->in.unknown = NULL;
6130                 }
6131                 if (r->in.unknown) {
6132                         _mem_save_unknown_0 = NDR_PULL_GET_MEM_CTX(ndr);
6133                         NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown, 0);
6134                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.unknown));
6135                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.unknown));
6136                         if (ndr_get_array_length(ndr, &r->in.unknown) > ndr_get_array_size(ndr, &r->in.unknown)) {
6137                                 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));
6138                         }
6139                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t)));
6140                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.unknown, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t), CH_UTF16));
6141                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown_0, 0);
6142                 }
6143                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
6144                 NDR_PULL_ALLOC(ndr, r->out.info);
6145                 ZERO_STRUCTP(r->out.info);
6146         }
6147         if (flags & NDR_OUT) {
6148                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6149                         NDR_PULL_ALLOC(ndr, r->out.info);
6150                 }
6151                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6152                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
6153                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
6154                 NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
6155                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6156                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6157         }
6158         return NDR_ERR_SUCCESS;
6159 }
6160
6161 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrWkstaUserGetInfo *r)
6162 {
6163         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaUserGetInfo");
6164         ndr->depth++;
6165         if (flags & NDR_SET_VALUES) {
6166                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6167         }
6168         if (flags & NDR_IN) {
6169                 ndr_print_struct(ndr, "in", "wkssvc_NetrWkstaUserGetInfo");
6170                 ndr->depth++;
6171                 ndr_print_ptr(ndr, "unknown", r->in.unknown);
6172                 ndr->depth++;
6173                 if (r->in.unknown) {
6174                         ndr_print_string(ndr, "unknown", r->in.unknown);
6175                 }
6176                 ndr->depth--;
6177                 ndr_print_uint32(ndr, "level", r->in.level);
6178                 ndr->depth--;
6179         }
6180         if (flags & NDR_OUT) {
6181                 ndr_print_struct(ndr, "out", "wkssvc_NetrWkstaUserGetInfo");
6182                 ndr->depth++;
6183                 ndr_print_ptr(ndr, "info", r->out.info);
6184                 ndr->depth++;
6185                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
6186                 ndr_print_wkssvc_NetrWkstaUserInfo(ndr, "info", r->out.info);
6187                 ndr->depth--;
6188                 ndr_print_WERROR(ndr, "result", r->out.result);
6189                 ndr->depth--;
6190         }
6191         ndr->depth--;
6192 }
6193
6194 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserSetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetrWkstaUserSetInfo *r)
6195 {
6196         if (flags & NDR_IN) {
6197                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown));
6198                 if (r->in.unknown) {
6199                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));
6200                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6201                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));
6202                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.unknown, ndr_charset_length(r->in.unknown, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6203                 }
6204                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
6205                 if (r->in.info == NULL) {
6206                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6207                 }
6208                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
6209                 NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6210                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_err));
6211                 if (r->in.parm_err) {
6212                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_err));
6213                 }
6214         }
6215         if (flags & NDR_OUT) {
6216                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_err));
6217                 if (r->out.parm_err) {
6218                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_err));
6219                 }
6220                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6221         }
6222         return NDR_ERR_SUCCESS;
6223 }
6224
6225 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserSetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetrWkstaUserSetInfo *r)
6226 {
6227         uint32_t _ptr_unknown;
6228         uint32_t _ptr_parm_err;
6229         TALLOC_CTX *_mem_save_unknown_0;
6230         TALLOC_CTX *_mem_save_info_0;
6231         TALLOC_CTX *_mem_save_parm_err_0;
6232         if (flags & NDR_IN) {
6233                 ZERO_STRUCT(r->out);
6234
6235                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown));
6236                 if (_ptr_unknown) {
6237                         NDR_PULL_ALLOC(ndr, r->in.unknown);
6238                 } else {
6239                         r->in.unknown = NULL;
6240                 }
6241                 if (r->in.unknown) {
6242                         _mem_save_unknown_0 = NDR_PULL_GET_MEM_CTX(ndr);
6243                         NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown, 0);
6244                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.unknown));
6245                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.unknown));
6246                         if (ndr_get_array_length(ndr, &r->in.unknown) > ndr_get_array_size(ndr, &r->in.unknown)) {
6247                                 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));
6248                         }
6249                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t)));
6250                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.unknown, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t), CH_UTF16));
6251                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown_0, 0);
6252                 }
6253                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
6254                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6255                         NDR_PULL_ALLOC(ndr, r->in.info);
6256                 }
6257                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6258                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
6259                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
6260                 NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6261                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6262                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));
6263                 if (_ptr_parm_err) {
6264                         NDR_PULL_ALLOC(ndr, r->in.parm_err);
6265                 } else {
6266                         r->in.parm_err = NULL;
6267                 }
6268                 if (r->in.parm_err) {
6269                         _mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);
6270                         NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_err, 0);
6271                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_err));
6272                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);
6273                 }
6274         }
6275         if (flags & NDR_OUT) {
6276                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));
6277                 if (_ptr_parm_err) {
6278                         NDR_PULL_ALLOC(ndr, r->out.parm_err);
6279                 } else {
6280                         r->out.parm_err = NULL;
6281                 }
6282                 if (r->out.parm_err) {
6283                         _mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);
6284                         NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_err, 0);
6285                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_err));
6286                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);
6287                 }
6288                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6289         }
6290         return NDR_ERR_SUCCESS;
6291 }
6292
6293 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserSetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrWkstaUserSetInfo *r)
6294 {
6295         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaUserSetInfo");
6296         ndr->depth++;
6297         if (flags & NDR_SET_VALUES) {
6298                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6299         }
6300         if (flags & NDR_IN) {
6301                 ndr_print_struct(ndr, "in", "wkssvc_NetrWkstaUserSetInfo");
6302                 ndr->depth++;
6303                 ndr_print_ptr(ndr, "unknown", r->in.unknown);
6304                 ndr->depth++;
6305                 if (r->in.unknown) {
6306                         ndr_print_string(ndr, "unknown", r->in.unknown);
6307                 }
6308                 ndr->depth--;
6309                 ndr_print_uint32(ndr, "level", r->in.level);
6310                 ndr_print_ptr(ndr, "info", r->in.info);
6311                 ndr->depth++;
6312                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
6313                 ndr_print_wkssvc_NetrWkstaUserInfo(ndr, "info", r->in.info);
6314                 ndr->depth--;
6315                 ndr_print_ptr(ndr, "parm_err", r->in.parm_err);
6316                 ndr->depth++;
6317                 if (r->in.parm_err) {
6318                         ndr_print_uint32(ndr, "parm_err", *r->in.parm_err);
6319                 }
6320                 ndr->depth--;
6321                 ndr->depth--;
6322         }
6323         if (flags & NDR_OUT) {
6324                 ndr_print_struct(ndr, "out", "wkssvc_NetrWkstaUserSetInfo");
6325                 ndr->depth++;
6326                 ndr_print_ptr(ndr, "parm_err", r->out.parm_err);
6327                 ndr->depth++;
6328                 if (r->out.parm_err) {
6329                         ndr_print_uint32(ndr, "parm_err", *r->out.parm_err);
6330                 }
6331                 ndr->depth--;
6332                 ndr_print_WERROR(ndr, "result", r->out.result);
6333                 ndr->depth--;
6334         }
6335         ndr->depth--;
6336 }
6337
6338 static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportEnum(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaTransportEnum *r)
6339 {
6340         if (flags & NDR_IN) {
6341                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
6342                 if (r->in.server_name) {
6343                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6344                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6345                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6346                         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));
6347                 }
6348                 if (r->in.info == NULL) {
6349                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6350                 }
6351                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6352                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));
6353                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
6354                 if (r->in.resume_handle) {
6355                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
6356                 }
6357         }
6358         if (flags & NDR_OUT) {
6359                 if (r->out.info == NULL) {
6360                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6361                 }
6362                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
6363                 if (r->out.total_entries == NULL) {
6364                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6365                 }
6366                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_entries));
6367                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
6368                 if (r->out.resume_handle) {
6369                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
6370                 }
6371                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6372         }
6373         return NDR_ERR_SUCCESS;
6374 }
6375
6376 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportEnum(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaTransportEnum *r)
6377 {
6378         uint32_t _ptr_server_name;
6379         uint32_t _ptr_resume_handle;
6380         TALLOC_CTX *_mem_save_server_name_0;
6381         TALLOC_CTX *_mem_save_info_0;
6382         TALLOC_CTX *_mem_save_total_entries_0;
6383         TALLOC_CTX *_mem_save_resume_handle_0;
6384         if (flags & NDR_IN) {
6385                 ZERO_STRUCT(r->out);
6386
6387                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6388                 if (_ptr_server_name) {
6389                         NDR_PULL_ALLOC(ndr, r->in.server_name);
6390                 } else {
6391                         r->in.server_name = NULL;
6392                 }
6393                 if (r->in.server_name) {
6394                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6395                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
6396                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
6397                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
6398                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
6399                                 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));
6400                         }
6401                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
6402                         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));
6403                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6404                 }
6405                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6406                         NDR_PULL_ALLOC(ndr, r->in.info);
6407                 }
6408                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6409                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
6410                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6411                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6412                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));
6413                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
6414                 if (_ptr_resume_handle) {
6415                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
6416                 } else {
6417                         r->in.resume_handle = NULL;
6418                 }
6419                 if (r->in.resume_handle) {
6420                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6421                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
6422                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
6423                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
6424                 }
6425                 NDR_PULL_ALLOC(ndr, r->out.info);
6426                 *r->out.info = *r->in.info;
6427                 NDR_PULL_ALLOC(ndr, r->out.total_entries);
6428                 ZERO_STRUCTP(r->out.total_entries);
6429         }
6430         if (flags & NDR_OUT) {
6431                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6432                         NDR_PULL_ALLOC(ndr, r->out.info);
6433                 }
6434                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6435                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
6436                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
6437                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6438                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6439                         NDR_PULL_ALLOC(ndr, r->out.total_entries);
6440                 }
6441                 _mem_save_total_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
6442                 NDR_PULL_SET_MEM_CTX(ndr, r->out.total_entries, LIBNDR_FLAG_REF_ALLOC);
6443                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_entries));
6444                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_entries_0, LIBNDR_FLAG_REF_ALLOC);
6445                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
6446                 if (_ptr_resume_handle) {
6447                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6448                 } else {
6449                         r->out.resume_handle = NULL;
6450                 }
6451                 if (r->out.resume_handle) {
6452                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6453                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
6454                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
6455                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
6456                 }
6457                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6458         }
6459         return NDR_ERR_SUCCESS;
6460 }
6461
6462 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportEnum(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaTransportEnum *r)
6463 {
6464         ndr_print_struct(ndr, name, "wkssvc_NetWkstaTransportEnum");
6465         ndr->depth++;
6466         if (flags & NDR_SET_VALUES) {
6467                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6468         }
6469         if (flags & NDR_IN) {
6470                 ndr_print_struct(ndr, "in", "wkssvc_NetWkstaTransportEnum");
6471                 ndr->depth++;
6472                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
6473                 ndr->depth++;
6474                 if (r->in.server_name) {
6475                         ndr_print_string(ndr, "server_name", r->in.server_name);
6476                 }
6477                 ndr->depth--;
6478                 ndr_print_ptr(ndr, "info", r->in.info);
6479                 ndr->depth++;
6480                 ndr_print_wkssvc_NetWkstaTransportInfo(ndr, "info", r->in.info);
6481                 ndr->depth--;
6482                 ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);
6483                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
6484                 ndr->depth++;
6485                 if (r->in.resume_handle) {
6486                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
6487                 }
6488                 ndr->depth--;
6489                 ndr->depth--;
6490         }
6491         if (flags & NDR_OUT) {
6492                 ndr_print_struct(ndr, "out", "wkssvc_NetWkstaTransportEnum");
6493                 ndr->depth++;
6494                 ndr_print_ptr(ndr, "info", r->out.info);
6495                 ndr->depth++;
6496                 ndr_print_wkssvc_NetWkstaTransportInfo(ndr, "info", r->out.info);
6497                 ndr->depth--;
6498                 ndr_print_ptr(ndr, "total_entries", r->out.total_entries);
6499                 ndr->depth++;
6500                 ndr_print_uint32(ndr, "total_entries", *r->out.total_entries);
6501                 ndr->depth--;
6502                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
6503                 ndr->depth++;
6504                 if (r->out.resume_handle) {
6505                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
6506                 }
6507                 ndr->depth--;
6508                 ndr_print_WERROR(ndr, "result", r->out.result);
6509                 ndr->depth--;
6510         }
6511         ndr->depth--;
6512 }
6513
6514 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaTransportAdd(struct ndr_push *ndr, int flags, const struct wkssvc_NetrWkstaTransportAdd *r)
6515 {
6516         if (flags & NDR_IN) {
6517                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
6518                 if (r->in.server_name) {
6519                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6520                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6521                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6522                         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));
6523                 }
6524                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
6525                 if (r->in.info0 == NULL) {
6526                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6527                 }
6528                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info0));
6529                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_err));
6530                 if (r->in.parm_err) {
6531                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_err));
6532                 }
6533         }
6534         if (flags & NDR_OUT) {
6535                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_err));
6536                 if (r->out.parm_err) {
6537                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_err));
6538                 }
6539                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6540         }
6541         return NDR_ERR_SUCCESS;
6542 }
6543
6544 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaTransportAdd(struct ndr_pull *ndr, int flags, struct wkssvc_NetrWkstaTransportAdd *r)
6545 {
6546         uint32_t _ptr_server_name;
6547         uint32_t _ptr_parm_err;
6548         TALLOC_CTX *_mem_save_server_name_0;
6549         TALLOC_CTX *_mem_save_info0_0;
6550         TALLOC_CTX *_mem_save_parm_err_0;
6551         if (flags & NDR_IN) {
6552                 ZERO_STRUCT(r->out);
6553
6554                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6555                 if (_ptr_server_name) {
6556                         NDR_PULL_ALLOC(ndr, r->in.server_name);
6557                 } else {
6558                         r->in.server_name = NULL;
6559                 }
6560                 if (r->in.server_name) {
6561                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6562                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
6563                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
6564                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
6565                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
6566                                 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));
6567                         }
6568                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
6569                         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));
6570                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6571                 }
6572                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
6573                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6574                         NDR_PULL_ALLOC(ndr, r->in.info0);
6575                 }
6576                 _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
6577                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info0, LIBNDR_FLAG_REF_ALLOC);
6578                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info0));
6579                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, LIBNDR_FLAG_REF_ALLOC);
6580                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));
6581                 if (_ptr_parm_err) {
6582                         NDR_PULL_ALLOC(ndr, r->in.parm_err);
6583                 } else {
6584                         r->in.parm_err = NULL;
6585                 }
6586                 if (r->in.parm_err) {
6587                         _mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);
6588                         NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_err, 0);
6589                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_err));
6590                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);
6591                 }
6592         }
6593         if (flags & NDR_OUT) {
6594                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));
6595                 if (_ptr_parm_err) {
6596                         NDR_PULL_ALLOC(ndr, r->out.parm_err);
6597                 } else {
6598                         r->out.parm_err = NULL;
6599                 }
6600                 if (r->out.parm_err) {
6601                         _mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);
6602                         NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_err, 0);
6603                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_err));
6604                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);
6605                 }
6606                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6607         }
6608         return NDR_ERR_SUCCESS;
6609 }
6610
6611 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaTransportAdd(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrWkstaTransportAdd *r)
6612 {
6613         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaTransportAdd");
6614         ndr->depth++;
6615         if (flags & NDR_SET_VALUES) {
6616                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6617         }
6618         if (flags & NDR_IN) {
6619                 ndr_print_struct(ndr, "in", "wkssvc_NetrWkstaTransportAdd");
6620                 ndr->depth++;
6621                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
6622                 ndr->depth++;
6623                 if (r->in.server_name) {
6624                         ndr_print_string(ndr, "server_name", r->in.server_name);
6625                 }
6626                 ndr->depth--;
6627                 ndr_print_uint32(ndr, "level", r->in.level);
6628                 ndr_print_ptr(ndr, "info0", r->in.info0);
6629                 ndr->depth++;
6630                 ndr_print_wkssvc_NetWkstaTransportInfo0(ndr, "info0", r->in.info0);
6631                 ndr->depth--;
6632                 ndr_print_ptr(ndr, "parm_err", r->in.parm_err);
6633                 ndr->depth++;
6634                 if (r->in.parm_err) {
6635                         ndr_print_uint32(ndr, "parm_err", *r->in.parm_err);
6636                 }
6637                 ndr->depth--;
6638                 ndr->depth--;
6639         }
6640         if (flags & NDR_OUT) {
6641                 ndr_print_struct(ndr, "out", "wkssvc_NetrWkstaTransportAdd");
6642                 ndr->depth++;
6643                 ndr_print_ptr(ndr, "parm_err", r->out.parm_err);
6644                 ndr->depth++;
6645                 if (r->out.parm_err) {
6646                         ndr_print_uint32(ndr, "parm_err", *r->out.parm_err);
6647                 }
6648                 ndr->depth--;
6649                 ndr_print_WERROR(ndr, "result", r->out.result);
6650                 ndr->depth--;
6651         }
6652         ndr->depth--;
6653 }
6654
6655 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaTransportDel(struct ndr_push *ndr, int flags, const struct wkssvc_NetrWkstaTransportDel *r)
6656 {
6657         if (flags & NDR_IN) {
6658                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
6659                 if (r->in.server_name) {
6660                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6661                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6662                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6663                         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));
6664                 }
6665                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.transport_name));
6666                 if (r->in.transport_name) {
6667                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.transport_name, CH_UTF16)));
6668                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6669                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.transport_name, CH_UTF16)));
6670                         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));
6671                 }
6672                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown3));
6673         }
6674         if (flags & NDR_OUT) {
6675                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6676         }
6677         return NDR_ERR_SUCCESS;
6678 }
6679
6680 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaTransportDel(struct ndr_pull *ndr, int flags, struct wkssvc_NetrWkstaTransportDel *r)
6681 {
6682         uint32_t _ptr_server_name;
6683         uint32_t _ptr_transport_name;
6684         TALLOC_CTX *_mem_save_server_name_0;
6685         TALLOC_CTX *_mem_save_transport_name_0;
6686         if (flags & NDR_IN) {
6687                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6688                 if (_ptr_server_name) {
6689                         NDR_PULL_ALLOC(ndr, r->in.server_name);
6690                 } else {
6691                         r->in.server_name = NULL;
6692                 }
6693                 if (r->in.server_name) {
6694                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6695                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
6696                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
6697                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
6698                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
6699                                 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));
6700                         }
6701                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
6702                         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));
6703                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6704                 }
6705                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_name));
6706                 if (_ptr_transport_name) {
6707                         NDR_PULL_ALLOC(ndr, r->in.transport_name);
6708                 } else {
6709                         r->in.transport_name = NULL;
6710                 }
6711                 if (r->in.transport_name) {
6712                         _mem_save_transport_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6713                         NDR_PULL_SET_MEM_CTX(ndr, r->in.transport_name, 0);
6714                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.transport_name));
6715                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.transport_name));
6716                         if (ndr_get_array_length(ndr, &r->in.transport_name) > ndr_get_array_size(ndr, &r->in.transport_name)) {
6717                                 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));
6718                         }
6719                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.transport_name), sizeof(uint16_t)));
6720                         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));
6721                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_name_0, 0);
6722                 }
6723                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown3));
6724         }
6725         if (flags & NDR_OUT) {
6726                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6727         }
6728         return NDR_ERR_SUCCESS;
6729 }
6730
6731 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaTransportDel(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrWkstaTransportDel *r)
6732 {
6733         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaTransportDel");
6734         ndr->depth++;
6735         if (flags & NDR_SET_VALUES) {
6736                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6737         }
6738         if (flags & NDR_IN) {
6739                 ndr_print_struct(ndr, "in", "wkssvc_NetrWkstaTransportDel");
6740                 ndr->depth++;
6741                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
6742                 ndr->depth++;
6743                 if (r->in.server_name) {
6744                         ndr_print_string(ndr, "server_name", r->in.server_name);
6745                 }
6746                 ndr->depth--;
6747                 ndr_print_ptr(ndr, "transport_name", r->in.transport_name);
6748                 ndr->depth++;
6749                 if (r->in.transport_name) {
6750                         ndr_print_string(ndr, "transport_name", r->in.transport_name);
6751                 }
6752                 ndr->depth--;
6753                 ndr_print_uint32(ndr, "unknown3", r->in.unknown3);
6754                 ndr->depth--;
6755         }
6756         if (flags & NDR_OUT) {
6757                 ndr_print_struct(ndr, "out", "wkssvc_NetrWkstaTransportDel");
6758                 ndr->depth++;
6759                 ndr_print_WERROR(ndr, "result", r->out.result);
6760                 ndr->depth--;
6761         }
6762         ndr->depth--;
6763 }
6764
6765 static enum ndr_err_code ndr_push_wkssvc_NetrUseAdd(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUseAdd *r)
6766 {
6767         if (flags & NDR_IN) {
6768                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
6769                 if (r->in.server_name) {
6770                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6771                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6772                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6773                         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));
6774                 }
6775                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
6776                 if (r->in.ctr == NULL) {
6777                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6778                 }
6779                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.ctr, r->in.level));
6780                 NDR_CHECK(ndr_push_wkssvc_NetrUseGetInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
6781                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_err));
6782                 if (r->in.parm_err) {
6783                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_err));
6784                 }
6785         }
6786         if (flags & NDR_OUT) {
6787                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_err));
6788                 if (r->out.parm_err) {
6789                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_err));
6790                 }
6791                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6792         }
6793         return NDR_ERR_SUCCESS;
6794 }
6795
6796 static enum ndr_err_code ndr_pull_wkssvc_NetrUseAdd(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUseAdd *r)
6797 {
6798         uint32_t _ptr_server_name;
6799         uint32_t _ptr_parm_err;
6800         TALLOC_CTX *_mem_save_server_name_0;
6801         TALLOC_CTX *_mem_save_ctr_0;
6802         TALLOC_CTX *_mem_save_parm_err_0;
6803         if (flags & NDR_IN) {
6804                 ZERO_STRUCT(r->out);
6805
6806                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6807                 if (_ptr_server_name) {
6808                         NDR_PULL_ALLOC(ndr, r->in.server_name);
6809                 } else {
6810                         r->in.server_name = NULL;
6811                 }
6812                 if (r->in.server_name) {
6813                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6814                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
6815                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
6816                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
6817                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
6818                                 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));
6819                         }
6820                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
6821                         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));
6822                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6823                 }
6824                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
6825                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6826                         NDR_PULL_ALLOC(ndr, r->in.ctr);
6827                 }
6828                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
6829                 NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, LIBNDR_FLAG_REF_ALLOC);
6830                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.ctr, r->in.level));
6831                 NDR_CHECK(ndr_pull_wkssvc_NetrUseGetInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
6832                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
6833                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));
6834                 if (_ptr_parm_err) {
6835                         NDR_PULL_ALLOC(ndr, r->in.parm_err);
6836                 } else {
6837                         r->in.parm_err = NULL;
6838                 }
6839                 if (r->in.parm_err) {
6840                         _mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);
6841                         NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_err, 0);
6842                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_err));
6843                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);
6844                 }
6845         }
6846         if (flags & NDR_OUT) {
6847                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));
6848                 if (_ptr_parm_err) {
6849                         NDR_PULL_ALLOC(ndr, r->out.parm_err);
6850                 } else {
6851                         r->out.parm_err = NULL;
6852                 }
6853                 if (r->out.parm_err) {
6854                         _mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);
6855                         NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_err, 0);
6856                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_err));
6857                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);
6858                 }
6859                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6860         }
6861         return NDR_ERR_SUCCESS;
6862 }
6863
6864 _PUBLIC_ void ndr_print_wkssvc_NetrUseAdd(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUseAdd *r)
6865 {
6866         ndr_print_struct(ndr, name, "wkssvc_NetrUseAdd");
6867         ndr->depth++;
6868         if (flags & NDR_SET_VALUES) {
6869                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6870         }
6871         if (flags & NDR_IN) {
6872                 ndr_print_struct(ndr, "in", "wkssvc_NetrUseAdd");
6873                 ndr->depth++;
6874                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
6875                 ndr->depth++;
6876                 if (r->in.server_name) {
6877                         ndr_print_string(ndr, "server_name", r->in.server_name);
6878                 }
6879                 ndr->depth--;
6880                 ndr_print_uint32(ndr, "level", r->in.level);
6881                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
6882                 ndr->depth++;
6883                 ndr_print_set_switch_value(ndr, r->in.ctr, r->in.level);
6884                 ndr_print_wkssvc_NetrUseGetInfoCtr(ndr, "ctr", r->in.ctr);
6885                 ndr->depth--;
6886                 ndr_print_ptr(ndr, "parm_err", r->in.parm_err);
6887                 ndr->depth++;
6888                 if (r->in.parm_err) {
6889                         ndr_print_uint32(ndr, "parm_err", *r->in.parm_err);
6890                 }
6891                 ndr->depth--;
6892                 ndr->depth--;
6893         }
6894         if (flags & NDR_OUT) {
6895                 ndr_print_struct(ndr, "out", "wkssvc_NetrUseAdd");
6896                 ndr->depth++;
6897                 ndr_print_ptr(ndr, "parm_err", r->out.parm_err);
6898                 ndr->depth++;
6899                 if (r->out.parm_err) {
6900                         ndr_print_uint32(ndr, "parm_err", *r->out.parm_err);
6901                 }
6902                 ndr->depth--;
6903                 ndr_print_WERROR(ndr, "result", r->out.result);
6904                 ndr->depth--;
6905         }
6906         ndr->depth--;
6907 }
6908
6909 static enum ndr_err_code ndr_push_wkssvc_NetrUseGetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUseGetInfo *r)
6910 {
6911         if (flags & NDR_IN) {
6912                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
6913                 if (r->in.server_name) {
6914                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6915                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6916                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6917                         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));
6918                 }
6919                 if (r->in.use_name == NULL) {
6920                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6921                 }
6922                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.use_name, CH_UTF16)));
6923                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6924                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.use_name, CH_UTF16)));
6925                 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));
6926                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
6927         }
6928         if (flags & NDR_OUT) {
6929                 if (r->out.ctr == NULL) {
6930                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6931                 }
6932                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, r->in.level));
6933                 NDR_CHECK(ndr_push_wkssvc_NetrUseGetInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
6934                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6935         }
6936         return NDR_ERR_SUCCESS;
6937 }
6938
6939 static enum ndr_err_code ndr_pull_wkssvc_NetrUseGetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUseGetInfo *r)
6940 {
6941         uint32_t _ptr_server_name;
6942         TALLOC_CTX *_mem_save_server_name_0;
6943         TALLOC_CTX *_mem_save_ctr_0;
6944         if (flags & NDR_IN) {
6945                 ZERO_STRUCT(r->out);
6946
6947                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6948                 if (_ptr_server_name) {
6949                         NDR_PULL_ALLOC(ndr, r->in.server_name);
6950                 } else {
6951                         r->in.server_name = NULL;
6952                 }
6953                 if (r->in.server_name) {
6954                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6955                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
6956                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
6957                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
6958                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
6959                                 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));
6960                         }
6961                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
6962                         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));
6963                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6964                 }
6965                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.use_name));
6966                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.use_name));
6967                 if (ndr_get_array_length(ndr, &r->in.use_name) > ndr_get_array_size(ndr, &r->in.use_name)) {
6968                         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));
6969                 }
6970                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.use_name), sizeof(uint16_t)));
6971                 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));
6972                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
6973                 NDR_PULL_ALLOC(ndr, r->out.ctr);
6974                 ZERO_STRUCTP(r->out.ctr);
6975         }
6976         if (flags & NDR_OUT) {
6977                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6978                         NDR_PULL_ALLOC(ndr, r->out.ctr);
6979                 }
6980                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
6981                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
6982                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, r->in.level));
6983                 NDR_CHECK(ndr_pull_wkssvc_NetrUseGetInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
6984                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
6985                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6986         }
6987         return NDR_ERR_SUCCESS;
6988 }
6989
6990 _PUBLIC_ void ndr_print_wkssvc_NetrUseGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUseGetInfo *r)
6991 {
6992         ndr_print_struct(ndr, name, "wkssvc_NetrUseGetInfo");
6993         ndr->depth++;
6994         if (flags & NDR_SET_VALUES) {
6995                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6996         }
6997         if (flags & NDR_IN) {
6998                 ndr_print_struct(ndr, "in", "wkssvc_NetrUseGetInfo");
6999                 ndr->depth++;
7000                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
7001                 ndr->depth++;
7002                 if (r->in.server_name) {
7003                         ndr_print_string(ndr, "server_name", r->in.server_name);
7004                 }
7005                 ndr->depth--;
7006                 ndr_print_ptr(ndr, "use_name", r->in.use_name);
7007                 ndr->depth++;
7008                 ndr_print_string(ndr, "use_name", r->in.use_name);
7009                 ndr->depth--;
7010                 ndr_print_uint32(ndr, "level", r->in.level);
7011                 ndr->depth--;
7012         }
7013         if (flags & NDR_OUT) {
7014                 ndr_print_struct(ndr, "out", "wkssvc_NetrUseGetInfo");
7015                 ndr->depth++;
7016                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
7017                 ndr->depth++;
7018                 ndr_print_set_switch_value(ndr, r->out.ctr, r->in.level);
7019                 ndr_print_wkssvc_NetrUseGetInfoCtr(ndr, "ctr", r->out.ctr);
7020                 ndr->depth--;
7021                 ndr_print_WERROR(ndr, "result", r->out.result);
7022                 ndr->depth--;
7023         }
7024         ndr->depth--;
7025 }
7026
7027 static enum ndr_err_code ndr_push_wkssvc_NetrUseDel(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUseDel *r)
7028 {
7029         if (flags & NDR_IN) {
7030                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
7031                 if (r->in.server_name) {
7032                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7033                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7034                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7035                         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));
7036                 }
7037                 if (r->in.use_name == NULL) {
7038                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7039                 }
7040                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.use_name, CH_UTF16)));
7041                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7042                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.use_name, CH_UTF16)));
7043                 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));
7044                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.force_cond));
7045         }
7046         if (flags & NDR_OUT) {
7047                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7048         }
7049         return NDR_ERR_SUCCESS;
7050 }
7051
7052 static enum ndr_err_code ndr_pull_wkssvc_NetrUseDel(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUseDel *r)
7053 {
7054         uint32_t _ptr_server_name;
7055         TALLOC_CTX *_mem_save_server_name_0;
7056         if (flags & NDR_IN) {
7057                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
7058                 if (_ptr_server_name) {
7059                         NDR_PULL_ALLOC(ndr, r->in.server_name);
7060                 } else {
7061                         r->in.server_name = NULL;
7062                 }
7063                 if (r->in.server_name) {
7064                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7065                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
7066                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
7067                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
7068                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
7069                                 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));
7070                         }
7071                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
7072                         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));
7073                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
7074                 }
7075                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.use_name));
7076                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.use_name));
7077                 if (ndr_get_array_length(ndr, &r->in.use_name) > ndr_get_array_size(ndr, &r->in.use_name)) {
7078                         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));
7079                 }
7080                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.use_name), sizeof(uint16_t)));
7081                 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));
7082                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.force_cond));
7083         }
7084         if (flags & NDR_OUT) {
7085                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7086         }
7087         return NDR_ERR_SUCCESS;
7088 }
7089
7090 _PUBLIC_ void ndr_print_wkssvc_NetrUseDel(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUseDel *r)
7091 {
7092         ndr_print_struct(ndr, name, "wkssvc_NetrUseDel");
7093         ndr->depth++;
7094         if (flags & NDR_SET_VALUES) {
7095                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7096         }
7097         if (flags & NDR_IN) {
7098                 ndr_print_struct(ndr, "in", "wkssvc_NetrUseDel");
7099                 ndr->depth++;
7100                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
7101                 ndr->depth++;
7102                 if (r->in.server_name) {
7103                         ndr_print_string(ndr, "server_name", r->in.server_name);
7104                 }
7105                 ndr->depth--;
7106                 ndr_print_ptr(ndr, "use_name", r->in.use_name);
7107                 ndr->depth++;
7108                 ndr_print_string(ndr, "use_name", r->in.use_name);
7109                 ndr->depth--;
7110                 ndr_print_uint32(ndr, "force_cond", r->in.force_cond);
7111                 ndr->depth--;
7112         }
7113         if (flags & NDR_OUT) {
7114                 ndr_print_struct(ndr, "out", "wkssvc_NetrUseDel");
7115                 ndr->depth++;
7116                 ndr_print_WERROR(ndr, "result", r->out.result);
7117                 ndr->depth--;
7118         }
7119         ndr->depth--;
7120 }
7121
7122 static enum ndr_err_code ndr_push_wkssvc_NetrUseEnum(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUseEnum *r)
7123 {
7124         if (flags & NDR_IN) {
7125                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
7126                 if (r->in.server_name) {
7127                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7128                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7129                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7130                         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));
7131                 }
7132                 if (r->in.info == NULL) {
7133                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7134                 }
7135                 NDR_CHECK(ndr_push_wkssvc_NetrUseEnumInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
7136                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.prefmaxlen));
7137                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
7138                 if (r->in.resume_handle) {
7139                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
7140                 }
7141         }
7142         if (flags & NDR_OUT) {
7143                 if (r->out.info == NULL) {
7144                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7145                 }
7146                 NDR_CHECK(ndr_push_wkssvc_NetrUseEnumInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
7147                 if (r->out.entries_read == NULL) {
7148                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7149                 }
7150                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.entries_read));
7151                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
7152                 if (r->out.resume_handle) {
7153                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
7154                 }
7155                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7156         }
7157         return NDR_ERR_SUCCESS;
7158 }
7159
7160 static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnum(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUseEnum *r)
7161 {
7162         uint32_t _ptr_server_name;
7163         uint32_t _ptr_resume_handle;
7164         TALLOC_CTX *_mem_save_server_name_0;
7165         TALLOC_CTX *_mem_save_info_0;
7166         TALLOC_CTX *_mem_save_entries_read_0;
7167         TALLOC_CTX *_mem_save_resume_handle_0;
7168         if (flags & NDR_IN) {
7169                 ZERO_STRUCT(r->out);
7170
7171                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
7172                 if (_ptr_server_name) {
7173                         NDR_PULL_ALLOC(ndr, r->in.server_name);
7174                 } else {
7175                         r->in.server_name = NULL;
7176                 }
7177                 if (r->in.server_name) {
7178                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7179                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
7180                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
7181                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
7182                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
7183                                 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));
7184                         }
7185                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
7186                         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));
7187                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
7188                 }
7189                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7190                         NDR_PULL_ALLOC(ndr, r->in.info);
7191                 }
7192                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
7193                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
7194                 NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
7195                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
7196                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.prefmaxlen));
7197                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
7198                 if (_ptr_resume_handle) {
7199                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
7200                 } else {
7201                         r->in.resume_handle = NULL;
7202                 }
7203                 if (r->in.resume_handle) {
7204                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7205                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
7206                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
7207                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
7208                 }
7209                 NDR_PULL_ALLOC(ndr, r->out.info);
7210                 *r->out.info = *r->in.info;
7211                 NDR_PULL_ALLOC(ndr, r->out.entries_read);
7212                 ZERO_STRUCTP(r->out.entries_read);
7213         }
7214         if (flags & NDR_OUT) {
7215                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7216                         NDR_PULL_ALLOC(ndr, r->out.info);
7217                 }
7218                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
7219                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
7220                 NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
7221                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
7222                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7223                         NDR_PULL_ALLOC(ndr, r->out.entries_read);
7224                 }
7225                 _mem_save_entries_read_0 = NDR_PULL_GET_MEM_CTX(ndr);
7226                 NDR_PULL_SET_MEM_CTX(ndr, r->out.entries_read, LIBNDR_FLAG_REF_ALLOC);
7227                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.entries_read));
7228                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_read_0, LIBNDR_FLAG_REF_ALLOC);
7229                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
7230                 if (_ptr_resume_handle) {
7231                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
7232                 } else {
7233                         r->out.resume_handle = NULL;
7234                 }
7235                 if (r->out.resume_handle) {
7236                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7237                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
7238                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
7239                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
7240                 }
7241                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7242         }
7243         return NDR_ERR_SUCCESS;
7244 }
7245
7246 _PUBLIC_ void ndr_print_wkssvc_NetrUseEnum(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUseEnum *r)
7247 {
7248         ndr_print_struct(ndr, name, "wkssvc_NetrUseEnum");
7249         ndr->depth++;
7250         if (flags & NDR_SET_VALUES) {
7251                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7252         }
7253         if (flags & NDR_IN) {
7254                 ndr_print_struct(ndr, "in", "wkssvc_NetrUseEnum");
7255                 ndr->depth++;
7256                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
7257                 ndr->depth++;
7258                 if (r->in.server_name) {
7259                         ndr_print_string(ndr, "server_name", r->in.server_name);
7260                 }
7261                 ndr->depth--;
7262                 ndr_print_ptr(ndr, "info", r->in.info);
7263                 ndr->depth++;
7264                 ndr_print_wkssvc_NetrUseEnumInfo(ndr, "info", r->in.info);
7265                 ndr->depth--;
7266                 ndr_print_uint32(ndr, "prefmaxlen", r->in.prefmaxlen);
7267                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
7268                 ndr->depth++;
7269                 if (r->in.resume_handle) {
7270                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
7271                 }
7272                 ndr->depth--;
7273                 ndr->depth--;
7274         }
7275         if (flags & NDR_OUT) {
7276                 ndr_print_struct(ndr, "out", "wkssvc_NetrUseEnum");
7277                 ndr->depth++;
7278                 ndr_print_ptr(ndr, "info", r->out.info);
7279                 ndr->depth++;
7280                 ndr_print_wkssvc_NetrUseEnumInfo(ndr, "info", r->out.info);
7281                 ndr->depth--;
7282                 ndr_print_ptr(ndr, "entries_read", r->out.entries_read);
7283                 ndr->depth++;
7284                 ndr_print_uint32(ndr, "entries_read", *r->out.entries_read);
7285                 ndr->depth--;
7286                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
7287                 ndr->depth++;
7288                 if (r->out.resume_handle) {
7289                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
7290                 }
7291                 ndr->depth--;
7292                 ndr_print_WERROR(ndr, "result", r->out.result);
7293                 ndr->depth--;
7294         }
7295         ndr->depth--;
7296 }
7297
7298 static enum ndr_err_code ndr_push_wkssvc_NetrMessageBufferSend(struct ndr_push *ndr, int flags, const struct wkssvc_NetrMessageBufferSend *r)
7299 {
7300         if (flags & NDR_IN) {
7301                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
7302                 if (r->in.server_name) {
7303                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7304                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7305                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7306                         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));
7307                 }
7308                 if (r->in.message_name == NULL) {
7309                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7310                 }
7311                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.message_name, CH_UTF16)));
7312                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7313                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.message_name, CH_UTF16)));
7314                 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));
7315                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.message_sender_name));
7316                 if (r->in.message_sender_name) {
7317                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.message_sender_name, CH_UTF16)));
7318                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7319                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.message_sender_name, CH_UTF16)));
7320                         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));
7321                 }
7322                 if (r->in.message_buffer == NULL) {
7323                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7324                 }
7325                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.message_size));
7326                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.message_buffer, r->in.message_size));
7327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.message_size));
7328         }
7329         if (flags & NDR_OUT) {
7330                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7331         }
7332         return NDR_ERR_SUCCESS;
7333 }
7334
7335 static enum ndr_err_code ndr_pull_wkssvc_NetrMessageBufferSend(struct ndr_pull *ndr, int flags, struct wkssvc_NetrMessageBufferSend *r)
7336 {
7337         uint32_t _ptr_server_name;
7338         uint32_t _ptr_message_sender_name;
7339         TALLOC_CTX *_mem_save_server_name_0;
7340         TALLOC_CTX *_mem_save_message_sender_name_0;
7341         if (flags & NDR_IN) {
7342                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
7343                 if (_ptr_server_name) {
7344                         NDR_PULL_ALLOC(ndr, r->in.server_name);
7345                 } else {
7346                         r->in.server_name = NULL;
7347                 }
7348                 if (r->in.server_name) {
7349                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7350                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
7351                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
7352                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
7353                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
7354                                 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));
7355                         }
7356                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
7357                         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));
7358                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
7359                 }
7360                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.message_name));
7361                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.message_name));
7362                 if (ndr_get_array_length(ndr, &r->in.message_name) > ndr_get_array_size(ndr, &r->in.message_name)) {
7363                         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));
7364                 }
7365                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.message_name), sizeof(uint16_t)));
7366                 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));
7367                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_message_sender_name));
7368                 if (_ptr_message_sender_name) {
7369                         NDR_PULL_ALLOC(ndr, r->in.message_sender_name);
7370                 } else {
7371                         r->in.message_sender_name = NULL;
7372                 }
7373                 if (r->in.message_sender_name) {
7374                         _mem_save_message_sender_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7375                         NDR_PULL_SET_MEM_CTX(ndr, r->in.message_sender_name, 0);
7376                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.message_sender_name));
7377                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.message_sender_name));
7378                         if (ndr_get_array_length(ndr, &r->in.message_sender_name) > ndr_get_array_size(ndr, &r->in.message_sender_name)) {
7379                                 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));
7380                         }
7381                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.message_sender_name), sizeof(uint16_t)));
7382                         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));
7383                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_message_sender_name_0, 0);
7384                 }
7385                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.message_buffer));
7386                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7387                         NDR_PULL_ALLOC_N(ndr, r->in.message_buffer, ndr_get_array_size(ndr, &r->in.message_buffer));
7388                 }
7389                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.message_buffer, ndr_get_array_size(ndr, &r->in.message_buffer)));
7390                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.message_size));
7391                 if (r->in.message_buffer) {
7392                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.message_buffer, r->in.message_size));
7393                 }
7394         }
7395         if (flags & NDR_OUT) {
7396                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7397         }
7398         return NDR_ERR_SUCCESS;
7399 }
7400
7401 _PUBLIC_ void ndr_print_wkssvc_NetrMessageBufferSend(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrMessageBufferSend *r)
7402 {
7403         ndr_print_struct(ndr, name, "wkssvc_NetrMessageBufferSend");
7404         ndr->depth++;
7405         if (flags & NDR_SET_VALUES) {
7406                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7407         }
7408         if (flags & NDR_IN) {
7409                 ndr_print_struct(ndr, "in", "wkssvc_NetrMessageBufferSend");
7410                 ndr->depth++;
7411                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
7412                 ndr->depth++;
7413                 if (r->in.server_name) {
7414                         ndr_print_string(ndr, "server_name", r->in.server_name);
7415                 }
7416                 ndr->depth--;
7417                 ndr_print_ptr(ndr, "message_name", r->in.message_name);
7418                 ndr->depth++;
7419                 ndr_print_string(ndr, "message_name", r->in.message_name);
7420                 ndr->depth--;
7421                 ndr_print_ptr(ndr, "message_sender_name", r->in.message_sender_name);
7422                 ndr->depth++;
7423                 if (r->in.message_sender_name) {
7424                         ndr_print_string(ndr, "message_sender_name", r->in.message_sender_name);
7425                 }
7426                 ndr->depth--;
7427                 ndr_print_ptr(ndr, "message_buffer", r->in.message_buffer);
7428                 ndr->depth++;
7429                 ndr_print_array_uint8(ndr, "message_buffer", r->in.message_buffer, r->in.message_size);
7430                 ndr->depth--;
7431                 ndr_print_uint32(ndr, "message_size", r->in.message_size);
7432                 ndr->depth--;
7433         }
7434         if (flags & NDR_OUT) {
7435                 ndr_print_struct(ndr, "out", "wkssvc_NetrMessageBufferSend");
7436                 ndr->depth++;
7437                 ndr_print_WERROR(ndr, "result", r->out.result);
7438                 ndr->depth--;
7439         }
7440         ndr->depth--;
7441 }
7442
7443 static enum ndr_err_code ndr_push_wkssvc_NetrWorkstationStatisticsGet(struct ndr_push *ndr, int flags, const struct wkssvc_NetrWorkstationStatisticsGet *r)
7444 {
7445         if (flags & NDR_IN) {
7446                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
7447                 if (r->in.server_name) {
7448                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7449                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7450                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7451                         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));
7452                 }
7453                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown2));
7454                 if (r->in.unknown2) {
7455                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown2, CH_UTF16)));
7456                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7457                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown2, CH_UTF16)));
7458                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.unknown2, ndr_charset_length(r->in.unknown2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7459                 }
7460                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown3));
7461                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown4));
7462         }
7463         if (flags & NDR_OUT) {
7464                 if (r->out.info == NULL) {
7465                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7466                 }
7467                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
7468                 if (*r->out.info) {
7469                         NDR_CHECK(ndr_push_wkssvc_NetrWorkstationStatistics(ndr, NDR_SCALARS, *r->out.info));
7470                 }
7471                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7472         }
7473         return NDR_ERR_SUCCESS;
7474 }
7475
7476 static enum ndr_err_code ndr_pull_wkssvc_NetrWorkstationStatisticsGet(struct ndr_pull *ndr, int flags, struct wkssvc_NetrWorkstationStatisticsGet *r)
7477 {
7478         uint32_t _ptr_server_name;
7479         uint32_t _ptr_unknown2;
7480         uint32_t _ptr_info;
7481         TALLOC_CTX *_mem_save_server_name_0;
7482         TALLOC_CTX *_mem_save_unknown2_0;
7483         TALLOC_CTX *_mem_save_info_0;
7484         TALLOC_CTX *_mem_save_info_1;
7485         if (flags & NDR_IN) {
7486                 ZERO_STRUCT(r->out);
7487
7488                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
7489                 if (_ptr_server_name) {
7490                         NDR_PULL_ALLOC(ndr, r->in.server_name);
7491                 } else {
7492                         r->in.server_name = NULL;
7493                 }
7494                 if (r->in.server_name) {
7495                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7496                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
7497                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
7498                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
7499                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
7500                                 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));
7501                         }
7502                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
7503                         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));
7504                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
7505                 }
7506                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown2));
7507                 if (_ptr_unknown2) {
7508                         NDR_PULL_ALLOC(ndr, r->in.unknown2);
7509                 } else {
7510                         r->in.unknown2 = NULL;
7511                 }
7512                 if (r->in.unknown2) {
7513                         _mem_save_unknown2_0 = NDR_PULL_GET_MEM_CTX(ndr);
7514                         NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown2, 0);
7515                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.unknown2));
7516                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.unknown2));
7517                         if (ndr_get_array_length(ndr, &r->in.unknown2) > ndr_get_array_size(ndr, &r->in.unknown2)) {
7518                                 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));
7519                         }
7520                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.unknown2), sizeof(uint16_t)));
7521                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.unknown2, ndr_get_array_length(ndr, &r->in.unknown2), sizeof(uint16_t), CH_UTF16));
7522                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown2_0, 0);
7523                 }
7524                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown3));
7525                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown4));
7526                 NDR_PULL_ALLOC(ndr, r->out.info);
7527                 ZERO_STRUCTP(r->out.info);
7528         }
7529         if (flags & NDR_OUT) {
7530                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7531                         NDR_PULL_ALLOC(ndr, r->out.info);
7532                 }
7533                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
7534                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
7535                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
7536                 if (_ptr_info) {
7537                         NDR_PULL_ALLOC(ndr, *r->out.info);
7538                 } else {
7539                         *r->out.info = NULL;
7540                 }
7541                 if (*r->out.info) {
7542                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
7543                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
7544                         NDR_CHECK(ndr_pull_wkssvc_NetrWorkstationStatistics(ndr, NDR_SCALARS, *r->out.info));
7545                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
7546                 }
7547                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
7548                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7549         }
7550         return NDR_ERR_SUCCESS;
7551 }
7552
7553 _PUBLIC_ void ndr_print_wkssvc_NetrWorkstationStatisticsGet(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrWorkstationStatisticsGet *r)
7554 {
7555         ndr_print_struct(ndr, name, "wkssvc_NetrWorkstationStatisticsGet");
7556         ndr->depth++;
7557         if (flags & NDR_SET_VALUES) {
7558                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7559         }
7560         if (flags & NDR_IN) {
7561                 ndr_print_struct(ndr, "in", "wkssvc_NetrWorkstationStatisticsGet");
7562                 ndr->depth++;
7563                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
7564                 ndr->depth++;
7565                 if (r->in.server_name) {
7566                         ndr_print_string(ndr, "server_name", r->in.server_name);
7567                 }
7568                 ndr->depth--;
7569                 ndr_print_ptr(ndr, "unknown2", r->in.unknown2);
7570                 ndr->depth++;
7571                 if (r->in.unknown2) {
7572                         ndr_print_string(ndr, "unknown2", r->in.unknown2);
7573                 }
7574                 ndr->depth--;
7575                 ndr_print_uint32(ndr, "unknown3", r->in.unknown3);
7576                 ndr_print_uint32(ndr, "unknown4", r->in.unknown4);
7577                 ndr->depth--;
7578         }
7579         if (flags & NDR_OUT) {
7580                 ndr_print_struct(ndr, "out", "wkssvc_NetrWorkstationStatisticsGet");
7581                 ndr->depth++;
7582                 ndr_print_ptr(ndr, "info", r->out.info);
7583                 ndr->depth++;
7584                 ndr_print_ptr(ndr, "info", *r->out.info);
7585                 ndr->depth++;
7586                 if (*r->out.info) {
7587                         ndr_print_wkssvc_NetrWorkstationStatistics(ndr, "info", *r->out.info);
7588                 }
7589                 ndr->depth--;
7590                 ndr->depth--;
7591                 ndr_print_WERROR(ndr, "result", r->out.result);
7592                 ndr->depth--;
7593         }
7594         ndr->depth--;
7595 }
7596
7597 static enum ndr_err_code ndr_push_wkssvc_NetrLogonDomainNameAdd(struct ndr_push *ndr, int flags, const struct wkssvc_NetrLogonDomainNameAdd *r)
7598 {
7599         if (flags & NDR_IN) {
7600                 if (r->in.domain_name == NULL) {
7601                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7602                 }
7603                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
7604                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7605                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
7606                 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));
7607         }
7608         if (flags & NDR_OUT) {
7609                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7610         }
7611         return NDR_ERR_SUCCESS;
7612 }
7613
7614 static enum ndr_err_code ndr_pull_wkssvc_NetrLogonDomainNameAdd(struct ndr_pull *ndr, int flags, struct wkssvc_NetrLogonDomainNameAdd *r)
7615 {
7616         if (flags & NDR_IN) {
7617                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
7618                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
7619                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
7620                         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));
7621                 }
7622                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
7623                 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));
7624         }
7625         if (flags & NDR_OUT) {
7626                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7627         }
7628         return NDR_ERR_SUCCESS;
7629 }
7630
7631 _PUBLIC_ void ndr_print_wkssvc_NetrLogonDomainNameAdd(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrLogonDomainNameAdd *r)
7632 {
7633         ndr_print_struct(ndr, name, "wkssvc_NetrLogonDomainNameAdd");
7634         ndr->depth++;
7635         if (flags & NDR_SET_VALUES) {
7636                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7637         }
7638         if (flags & NDR_IN) {
7639                 ndr_print_struct(ndr, "in", "wkssvc_NetrLogonDomainNameAdd");
7640                 ndr->depth++;
7641                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
7642                 ndr->depth++;
7643                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
7644                 ndr->depth--;
7645                 ndr->depth--;
7646         }
7647         if (flags & NDR_OUT) {
7648                 ndr_print_struct(ndr, "out", "wkssvc_NetrLogonDomainNameAdd");
7649                 ndr->depth++;
7650                 ndr_print_WERROR(ndr, "result", r->out.result);
7651                 ndr->depth--;
7652         }
7653         ndr->depth--;
7654 }
7655
7656 static enum ndr_err_code ndr_push_wkssvc_NetrLogonDomainNameDel(struct ndr_push *ndr, int flags, const struct wkssvc_NetrLogonDomainNameDel *r)
7657 {
7658         if (flags & NDR_IN) {
7659                 if (r->in.domain_name == NULL) {
7660                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7661                 }
7662                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
7663                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7664                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
7665                 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));
7666         }
7667         if (flags & NDR_OUT) {
7668                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7669         }
7670         return NDR_ERR_SUCCESS;
7671 }
7672
7673 static enum ndr_err_code ndr_pull_wkssvc_NetrLogonDomainNameDel(struct ndr_pull *ndr, int flags, struct wkssvc_NetrLogonDomainNameDel *r)
7674 {
7675         if (flags & NDR_IN) {
7676                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
7677                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
7678                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
7679                         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));
7680                 }
7681                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
7682                 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));
7683         }
7684         if (flags & NDR_OUT) {
7685                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7686         }
7687         return NDR_ERR_SUCCESS;
7688 }
7689
7690 _PUBLIC_ void ndr_print_wkssvc_NetrLogonDomainNameDel(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrLogonDomainNameDel *r)
7691 {
7692         ndr_print_struct(ndr, name, "wkssvc_NetrLogonDomainNameDel");
7693         ndr->depth++;
7694         if (flags & NDR_SET_VALUES) {
7695                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7696         }
7697         if (flags & NDR_IN) {
7698                 ndr_print_struct(ndr, "in", "wkssvc_NetrLogonDomainNameDel");
7699                 ndr->depth++;
7700                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
7701                 ndr->depth++;
7702                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
7703                 ndr->depth--;
7704                 ndr->depth--;
7705         }
7706         if (flags & NDR_OUT) {
7707                 ndr_print_struct(ndr, "out", "wkssvc_NetrLogonDomainNameDel");
7708                 ndr->depth++;
7709                 ndr_print_WERROR(ndr, "result", r->out.result);
7710                 ndr->depth--;
7711         }
7712         ndr->depth--;
7713 }
7714
7715 static enum ndr_err_code ndr_push_wkssvc_NetrJoinDomain(struct ndr_push *ndr, int flags, const struct wkssvc_NetrJoinDomain *r)
7716 {
7717         if (flags & NDR_IN) {
7718                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
7719                 if (r->in.server_name) {
7720                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7721                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7722                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7723                         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));
7724                 }
7725                 if (r->in.domain_name == NULL) {
7726                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7727                 }
7728                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
7729                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7730                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
7731                 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));
7732                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.account_ou));
7733                 if (r->in.account_ou) {
7734                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.account_ou, CH_UTF16)));
7735                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7736                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.account_ou, CH_UTF16)));
7737                         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));
7738                 }
7739                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
7740                 if (r->in.Account) {
7741                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
7742                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7743                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
7744                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7745                 }
7746                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
7747                 if (r->in.password) {
7748                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
7749                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7750                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
7751                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7752                 }
7753                 NDR_CHECK(ndr_push_wkssvc_joinflags(ndr, NDR_SCALARS, r->in.join_flags));
7754         }
7755         if (flags & NDR_OUT) {
7756                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7757         }
7758         return NDR_ERR_SUCCESS;
7759 }
7760
7761 static enum ndr_err_code ndr_pull_wkssvc_NetrJoinDomain(struct ndr_pull *ndr, int flags, struct wkssvc_NetrJoinDomain *r)
7762 {
7763         uint32_t _ptr_server_name;
7764         uint32_t _ptr_account_ou;
7765         uint32_t _ptr_Account;
7766         uint32_t _ptr_password;
7767         TALLOC_CTX *_mem_save_server_name_0;
7768         TALLOC_CTX *_mem_save_account_ou_0;
7769         TALLOC_CTX *_mem_save_Account_0;
7770         TALLOC_CTX *_mem_save_password_0;
7771         if (flags & NDR_IN) {
7772                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
7773                 if (_ptr_server_name) {
7774                         NDR_PULL_ALLOC(ndr, r->in.server_name);
7775                 } else {
7776                         r->in.server_name = NULL;
7777                 }
7778                 if (r->in.server_name) {
7779                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7780                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
7781                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
7782                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
7783                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
7784                                 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));
7785                         }
7786                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
7787                         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));
7788                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
7789                 }
7790                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
7791                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
7792                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
7793                         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));
7794                 }
7795                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
7796                 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));
7797                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account_ou));
7798                 if (_ptr_account_ou) {
7799                         NDR_PULL_ALLOC(ndr, r->in.account_ou);
7800                 } else {
7801                         r->in.account_ou = NULL;
7802                 }
7803                 if (r->in.account_ou) {
7804                         _mem_save_account_ou_0 = NDR_PULL_GET_MEM_CTX(ndr);
7805                         NDR_PULL_SET_MEM_CTX(ndr, r->in.account_ou, 0);
7806                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.account_ou));
7807                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.account_ou));
7808                         if (ndr_get_array_length(ndr, &r->in.account_ou) > ndr_get_array_size(ndr, &r->in.account_ou)) {
7809                                 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));
7810                         }
7811                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.account_ou), sizeof(uint16_t)));
7812                         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));
7813                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_ou_0, 0);
7814                 }
7815                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
7816                 if (_ptr_Account) {
7817                         NDR_PULL_ALLOC(ndr, r->in.Account);
7818                 } else {
7819                         r->in.Account = NULL;
7820                 }
7821                 if (r->in.Account) {
7822                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
7823                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
7824                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
7825                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
7826                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
7827                                 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));
7828                         }
7829                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
7830                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
7831                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
7832                 }
7833                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
7834                 if (_ptr_password) {
7835                         NDR_PULL_ALLOC(ndr, r->in.password);
7836                 } else {
7837                         r->in.password = NULL;
7838                 }
7839                 if (r->in.password) {
7840                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
7841                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
7842                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.password));
7843                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.password));
7844                         if (ndr_get_array_length(ndr, &r->in.password) > ndr_get_array_size(ndr, &r->in.password)) {
7845                                 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));
7846                         }
7847                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t)));
7848                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.password, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t), CH_UTF16));
7849                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
7850                 }
7851                 NDR_CHECK(ndr_pull_wkssvc_joinflags(ndr, NDR_SCALARS, &r->in.join_flags));
7852         }
7853         if (flags & NDR_OUT) {
7854                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7855         }
7856         return NDR_ERR_SUCCESS;
7857 }
7858
7859 _PUBLIC_ void ndr_print_wkssvc_NetrJoinDomain(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrJoinDomain *r)
7860 {
7861         ndr_print_struct(ndr, name, "wkssvc_NetrJoinDomain");
7862         ndr->depth++;
7863         if (flags & NDR_SET_VALUES) {
7864                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7865         }
7866         if (flags & NDR_IN) {
7867                 ndr_print_struct(ndr, "in", "wkssvc_NetrJoinDomain");
7868                 ndr->depth++;
7869                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
7870                 ndr->depth++;
7871                 if (r->in.server_name) {
7872                         ndr_print_string(ndr, "server_name", r->in.server_name);
7873                 }
7874                 ndr->depth--;
7875                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
7876                 ndr->depth++;
7877                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
7878                 ndr->depth--;
7879                 ndr_print_ptr(ndr, "account_ou", r->in.account_ou);
7880                 ndr->depth++;
7881                 if (r->in.account_ou) {
7882                         ndr_print_string(ndr, "account_ou", r->in.account_ou);
7883                 }
7884                 ndr->depth--;
7885                 ndr_print_ptr(ndr, "Account", r->in.Account);
7886                 ndr->depth++;
7887                 if (r->in.Account) {
7888                         ndr_print_string(ndr, "Account", r->in.Account);
7889                 }
7890                 ndr->depth--;
7891                 ndr_print_ptr(ndr, "password", r->in.password);
7892                 ndr->depth++;
7893                 if (r->in.password) {
7894                         ndr_print_string(ndr, "password", r->in.password);
7895                 }
7896                 ndr->depth--;
7897                 ndr_print_wkssvc_joinflags(ndr, "join_flags", r->in.join_flags);
7898                 ndr->depth--;
7899         }
7900         if (flags & NDR_OUT) {
7901                 ndr_print_struct(ndr, "out", "wkssvc_NetrJoinDomain");
7902                 ndr->depth++;
7903                 ndr_print_WERROR(ndr, "result", r->out.result);
7904                 ndr->depth--;
7905         }
7906         ndr->depth--;
7907 }
7908
7909 static enum ndr_err_code ndr_push_wkssvc_NetrUnjoinDomain(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUnjoinDomain *r)
7910 {
7911         if (flags & NDR_IN) {
7912                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
7913                 if (r->in.server_name) {
7914                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7915                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7916                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7917                         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));
7918                 }
7919                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
7920                 if (r->in.Account) {
7921                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
7922                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7923                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
7924                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7925                 }
7926                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
7927                 if (r->in.password) {
7928                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
7929                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7930                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
7931                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7932                 }
7933                 NDR_CHECK(ndr_push_wkssvc_joinflags(ndr, NDR_SCALARS, r->in.unjoin_flags));
7934         }
7935         if (flags & NDR_OUT) {
7936                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7937         }
7938         return NDR_ERR_SUCCESS;
7939 }
7940
7941 static enum ndr_err_code ndr_pull_wkssvc_NetrUnjoinDomain(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUnjoinDomain *r)
7942 {
7943         uint32_t _ptr_server_name;
7944         uint32_t _ptr_Account;
7945         uint32_t _ptr_password;
7946         TALLOC_CTX *_mem_save_server_name_0;
7947         TALLOC_CTX *_mem_save_Account_0;
7948         TALLOC_CTX *_mem_save_password_0;
7949         if (flags & NDR_IN) {
7950                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
7951                 if (_ptr_server_name) {
7952                         NDR_PULL_ALLOC(ndr, r->in.server_name);
7953                 } else {
7954                         r->in.server_name = NULL;
7955                 }
7956                 if (r->in.server_name) {
7957                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7958                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
7959                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
7960                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
7961                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
7962                                 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));
7963                         }
7964                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
7965                         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));
7966                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
7967                 }
7968                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
7969                 if (_ptr_Account) {
7970                         NDR_PULL_ALLOC(ndr, r->in.Account);
7971                 } else {
7972                         r->in.Account = NULL;
7973                 }
7974                 if (r->in.Account) {
7975                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
7976                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
7977                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
7978                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
7979                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
7980                                 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));
7981                         }
7982                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
7983                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
7984                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
7985                 }
7986                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
7987                 if (_ptr_password) {
7988                         NDR_PULL_ALLOC(ndr, r->in.password);
7989                 } else {
7990                         r->in.password = NULL;
7991                 }
7992                 if (r->in.password) {
7993                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
7994                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
7995                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.password));
7996                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.password));
7997                         if (ndr_get_array_length(ndr, &r->in.password) > ndr_get_array_size(ndr, &r->in.password)) {
7998                                 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));
7999                         }
8000                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t)));
8001                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.password, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t), CH_UTF16));
8002                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
8003                 }
8004                 NDR_CHECK(ndr_pull_wkssvc_joinflags(ndr, NDR_SCALARS, &r->in.unjoin_flags));
8005         }
8006         if (flags & NDR_OUT) {
8007                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
8008         }
8009         return NDR_ERR_SUCCESS;
8010 }
8011
8012 _PUBLIC_ void ndr_print_wkssvc_NetrUnjoinDomain(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUnjoinDomain *r)
8013 {
8014         ndr_print_struct(ndr, name, "wkssvc_NetrUnjoinDomain");
8015         ndr->depth++;
8016         if (flags & NDR_SET_VALUES) {
8017                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8018         }
8019         if (flags & NDR_IN) {
8020                 ndr_print_struct(ndr, "in", "wkssvc_NetrUnjoinDomain");
8021                 ndr->depth++;
8022                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
8023                 ndr->depth++;
8024                 if (r->in.server_name) {
8025                         ndr_print_string(ndr, "server_name", r->in.server_name);
8026                 }
8027                 ndr->depth--;
8028                 ndr_print_ptr(ndr, "Account", r->in.Account);
8029                 ndr->depth++;
8030                 if (r->in.Account) {
8031                         ndr_print_string(ndr, "Account", r->in.Account);
8032                 }
8033                 ndr->depth--;
8034                 ndr_print_ptr(ndr, "password", r->in.password);
8035                 ndr->depth++;
8036                 if (r->in.password) {
8037                         ndr_print_string(ndr, "password", r->in.password);
8038                 }
8039                 ndr->depth--;
8040                 ndr_print_wkssvc_joinflags(ndr, "unjoin_flags", r->in.unjoin_flags);
8041                 ndr->depth--;
8042         }
8043         if (flags & NDR_OUT) {
8044                 ndr_print_struct(ndr, "out", "wkssvc_NetrUnjoinDomain");
8045                 ndr->depth++;
8046                 ndr_print_WERROR(ndr, "result", r->out.result);
8047                 ndr->depth--;
8048         }
8049         ndr->depth--;
8050 }
8051
8052 static enum ndr_err_code ndr_push_wkssvc_NetrRenameMachineInDomain(struct ndr_push *ndr, int flags, const struct wkssvc_NetrRenameMachineInDomain *r)
8053 {
8054         if (flags & NDR_IN) {
8055                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
8056                 if (r->in.server_name) {
8057                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8058                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8059                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8060                         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));
8061                 }
8062                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.NewMachineName));
8063                 if (r->in.NewMachineName) {
8064                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewMachineName, CH_UTF16)));
8065                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8066                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewMachineName, CH_UTF16)));
8067                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.NewMachineName, ndr_charset_length(r->in.NewMachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8068                 }
8069                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
8070                 if (r->in.Account) {
8071                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
8072                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8073                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
8074                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8075                 }
8076                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
8077                 if (r->in.password) {
8078                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
8079                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8080                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
8081                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8082                 }
8083                 NDR_CHECK(ndr_push_wkssvc_renameflags(ndr, NDR_SCALARS, r->in.RenameOptions));
8084         }
8085         if (flags & NDR_OUT) {
8086                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
8087         }
8088         return NDR_ERR_SUCCESS;
8089 }
8090
8091 static enum ndr_err_code ndr_pull_wkssvc_NetrRenameMachineInDomain(struct ndr_pull *ndr, int flags, struct wkssvc_NetrRenameMachineInDomain *r)
8092 {
8093         uint32_t _ptr_server_name;
8094         uint32_t _ptr_NewMachineName;
8095         uint32_t _ptr_Account;
8096         uint32_t _ptr_password;
8097         TALLOC_CTX *_mem_save_server_name_0;
8098         TALLOC_CTX *_mem_save_NewMachineName_0;
8099         TALLOC_CTX *_mem_save_Account_0;
8100         TALLOC_CTX *_mem_save_password_0;
8101         if (flags & NDR_IN) {
8102                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
8103                 if (_ptr_server_name) {
8104                         NDR_PULL_ALLOC(ndr, r->in.server_name);
8105                 } else {
8106                         r->in.server_name = NULL;
8107                 }
8108                 if (r->in.server_name) {
8109                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8110                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
8111                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
8112                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
8113                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
8114                                 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));
8115                         }
8116                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
8117                         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));
8118                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
8119                 }
8120                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_NewMachineName));
8121                 if (_ptr_NewMachineName) {
8122                         NDR_PULL_ALLOC(ndr, r->in.NewMachineName);
8123                 } else {
8124                         r->in.NewMachineName = NULL;
8125                 }
8126                 if (r->in.NewMachineName) {
8127                         _mem_save_NewMachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);
8128                         NDR_PULL_SET_MEM_CTX(ndr, r->in.NewMachineName, 0);
8129                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.NewMachineName));
8130                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.NewMachineName));
8131                         if (ndr_get_array_length(ndr, &r->in.NewMachineName) > ndr_get_array_size(ndr, &r->in.NewMachineName)) {
8132                                 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));
8133                         }
8134                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.NewMachineName), sizeof(uint16_t)));
8135                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.NewMachineName, ndr_get_array_length(ndr, &r->in.NewMachineName), sizeof(uint16_t), CH_UTF16));
8136                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_NewMachineName_0, 0);
8137                 }
8138                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
8139                 if (_ptr_Account) {
8140                         NDR_PULL_ALLOC(ndr, r->in.Account);
8141                 } else {
8142                         r->in.Account = NULL;
8143                 }
8144                 if (r->in.Account) {
8145                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
8146                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
8147                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
8148                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
8149                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
8150                                 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));
8151                         }
8152                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
8153                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
8154                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
8155                 }
8156                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
8157                 if (_ptr_password) {
8158                         NDR_PULL_ALLOC(ndr, r->in.password);
8159                 } else {
8160                         r->in.password = NULL;
8161                 }
8162                 if (r->in.password) {
8163                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
8164                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
8165                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.password));
8166                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.password));
8167                         if (ndr_get_array_length(ndr, &r->in.password) > ndr_get_array_size(ndr, &r->in.password)) {
8168                                 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));
8169                         }
8170                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t)));
8171                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.password, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t), CH_UTF16));
8172                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
8173                 }
8174                 NDR_CHECK(ndr_pull_wkssvc_renameflags(ndr, NDR_SCALARS, &r->in.RenameOptions));
8175         }
8176         if (flags & NDR_OUT) {
8177                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
8178         }
8179         return NDR_ERR_SUCCESS;
8180 }
8181
8182 _PUBLIC_ void ndr_print_wkssvc_NetrRenameMachineInDomain(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrRenameMachineInDomain *r)
8183 {
8184         ndr_print_struct(ndr, name, "wkssvc_NetrRenameMachineInDomain");
8185         ndr->depth++;
8186         if (flags & NDR_SET_VALUES) {
8187                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8188         }
8189         if (flags & NDR_IN) {
8190                 ndr_print_struct(ndr, "in", "wkssvc_NetrRenameMachineInDomain");
8191                 ndr->depth++;
8192                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
8193                 ndr->depth++;
8194                 if (r->in.server_name) {
8195                         ndr_print_string(ndr, "server_name", r->in.server_name);
8196                 }
8197                 ndr->depth--;
8198                 ndr_print_ptr(ndr, "NewMachineName", r->in.NewMachineName);
8199                 ndr->depth++;
8200                 if (r->in.NewMachineName) {
8201                         ndr_print_string(ndr, "NewMachineName", r->in.NewMachineName);
8202                 }
8203                 ndr->depth--;
8204                 ndr_print_ptr(ndr, "Account", r->in.Account);
8205                 ndr->depth++;
8206                 if (r->in.Account) {
8207                         ndr_print_string(ndr, "Account", r->in.Account);
8208                 }
8209                 ndr->depth--;
8210                 ndr_print_ptr(ndr, "password", r->in.password);
8211                 ndr->depth++;
8212                 if (r->in.password) {
8213                         ndr_print_string(ndr, "password", r->in.password);
8214                 }
8215                 ndr->depth--;
8216                 ndr_print_wkssvc_renameflags(ndr, "RenameOptions", r->in.RenameOptions);
8217                 ndr->depth--;
8218         }
8219         if (flags & NDR_OUT) {
8220                 ndr_print_struct(ndr, "out", "wkssvc_NetrRenameMachineInDomain");
8221                 ndr->depth++;
8222                 ndr_print_WERROR(ndr, "result", r->out.result);
8223                 ndr->depth--;
8224         }
8225         ndr->depth--;
8226 }
8227
8228 static enum ndr_err_code ndr_push_wkssvc_NetrValidateName(struct ndr_push *ndr, int flags, const struct wkssvc_NetrValidateName *r)
8229 {
8230         if (flags & NDR_IN) {
8231                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
8232                 if (r->in.server_name) {
8233                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8234                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8235                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8236                         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));
8237                 }
8238                 if (r->in.name == NULL) {
8239                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8240                 }
8241                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF16)));
8242                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8243                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF16)));
8244                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.name, ndr_charset_length(r->in.name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8245                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
8246                 if (r->in.Account) {
8247                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
8248                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8249                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
8250                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8251                 }
8252                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Password));
8253                 if (r->in.Password) {
8254                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Password, CH_UTF16)));
8255                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8256                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Password, CH_UTF16)));
8257                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Password, ndr_charset_length(r->in.Password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8258                 }
8259                 NDR_CHECK(ndr_push_wkssvc_NetValidateNameType(ndr, NDR_SCALARS, r->in.name_type));
8260         }
8261         if (flags & NDR_OUT) {
8262                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
8263         }
8264         return NDR_ERR_SUCCESS;
8265 }
8266
8267 static enum ndr_err_code ndr_pull_wkssvc_NetrValidateName(struct ndr_pull *ndr, int flags, struct wkssvc_NetrValidateName *r)
8268 {
8269         uint32_t _ptr_server_name;
8270         uint32_t _ptr_Account;
8271         uint32_t _ptr_Password;
8272         TALLOC_CTX *_mem_save_server_name_0;
8273         TALLOC_CTX *_mem_save_Account_0;
8274         TALLOC_CTX *_mem_save_Password_0;
8275         if (flags & NDR_IN) {
8276                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
8277                 if (_ptr_server_name) {
8278                         NDR_PULL_ALLOC(ndr, r->in.server_name);
8279                 } else {
8280                         r->in.server_name = NULL;
8281                 }
8282                 if (r->in.server_name) {
8283                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8284                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
8285                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
8286                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
8287                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
8288                                 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));
8289                         }
8290                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
8291                         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));
8292                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
8293                 }
8294                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.name));
8295                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.name));
8296                 if (ndr_get_array_length(ndr, &r->in.name) > ndr_get_array_size(ndr, &r->in.name)) {
8297                         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));
8298                 }
8299                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.name), sizeof(uint16_t)));
8300                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.name, ndr_get_array_length(ndr, &r->in.name), sizeof(uint16_t), CH_UTF16));
8301                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
8302                 if (_ptr_Account) {
8303                         NDR_PULL_ALLOC(ndr, r->in.Account);
8304                 } else {
8305                         r->in.Account = NULL;
8306                 }
8307                 if (r->in.Account) {
8308                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
8309                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
8310                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
8311                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
8312                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
8313                                 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));
8314                         }
8315                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
8316                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
8317                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
8318                 }
8319                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Password));
8320                 if (_ptr_Password) {
8321                         NDR_PULL_ALLOC(ndr, r->in.Password);
8322                 } else {
8323                         r->in.Password = NULL;
8324                 }
8325                 if (r->in.Password) {
8326                         _mem_save_Password_0 = NDR_PULL_GET_MEM_CTX(ndr);
8327                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Password, 0);
8328                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Password));
8329                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Password));
8330                         if (ndr_get_array_length(ndr, &r->in.Password) > ndr_get_array_size(ndr, &r->in.Password)) {
8331                                 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));
8332                         }
8333                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Password), sizeof(uint16_t)));
8334                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Password, ndr_get_array_length(ndr, &r->in.Password), sizeof(uint16_t), CH_UTF16));
8335                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Password_0, 0);
8336                 }
8337                 NDR_CHECK(ndr_pull_wkssvc_NetValidateNameType(ndr, NDR_SCALARS, &r->in.name_type));
8338         }
8339         if (flags & NDR_OUT) {
8340                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
8341         }
8342         return NDR_ERR_SUCCESS;
8343 }
8344
8345 _PUBLIC_ void ndr_print_wkssvc_NetrValidateName(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrValidateName *r)
8346 {
8347         ndr_print_struct(ndr, name, "wkssvc_NetrValidateName");
8348         ndr->depth++;
8349         if (flags & NDR_SET_VALUES) {
8350                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8351         }
8352         if (flags & NDR_IN) {
8353                 ndr_print_struct(ndr, "in", "wkssvc_NetrValidateName");
8354                 ndr->depth++;
8355                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
8356                 ndr->depth++;
8357                 if (r->in.server_name) {
8358                         ndr_print_string(ndr, "server_name", r->in.server_name);
8359                 }
8360                 ndr->depth--;
8361                 ndr_print_ptr(ndr, "name", r->in.name);
8362                 ndr->depth++;
8363                 ndr_print_string(ndr, "name", r->in.name);
8364                 ndr->depth--;
8365                 ndr_print_ptr(ndr, "Account", r->in.Account);
8366                 ndr->depth++;
8367                 if (r->in.Account) {
8368                         ndr_print_string(ndr, "Account", r->in.Account);
8369                 }
8370                 ndr->depth--;
8371                 ndr_print_ptr(ndr, "Password", r->in.Password);
8372                 ndr->depth++;
8373                 if (r->in.Password) {
8374                         ndr_print_string(ndr, "Password", r->in.Password);
8375                 }
8376                 ndr->depth--;
8377                 ndr_print_wkssvc_NetValidateNameType(ndr, "name_type", r->in.name_type);
8378                 ndr->depth--;
8379         }
8380         if (flags & NDR_OUT) {
8381                 ndr_print_struct(ndr, "out", "wkssvc_NetrValidateName");
8382                 ndr->depth++;
8383                 ndr_print_WERROR(ndr, "result", r->out.result);
8384                 ndr->depth--;
8385         }
8386         ndr->depth--;
8387 }
8388
8389 static enum ndr_err_code ndr_push_wkssvc_NetrGetJoinInformation(struct ndr_push *ndr, int flags, const struct wkssvc_NetrGetJoinInformation *r)
8390 {
8391         if (flags & NDR_IN) {
8392                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
8393                 if (r->in.server_name) {
8394                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8395                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8396                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8397                         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));
8398                 }
8399                 if (r->in.name_buffer == NULL) {
8400                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8401                 }
8402                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->in.name_buffer));
8403                 if (*r->in.name_buffer) {
8404                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->in.name_buffer, CH_UTF16)));
8405                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8406                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->in.name_buffer, CH_UTF16)));
8407                         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));
8408                 }
8409         }
8410         if (flags & NDR_OUT) {
8411                 if (r->out.name_buffer == NULL) {
8412                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8413                 }
8414                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.name_buffer));
8415                 if (*r->out.name_buffer) {
8416                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.name_buffer, CH_UTF16)));
8417                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8418                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.name_buffer, CH_UTF16)));
8419                         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));
8420                 }
8421                 if (r->out.name_type == NULL) {
8422                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8423                 }
8424                 NDR_CHECK(ndr_push_wkssvc_NetJoinStatus(ndr, NDR_SCALARS, *r->out.name_type));
8425                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
8426         }
8427         return NDR_ERR_SUCCESS;
8428 }
8429
8430 static enum ndr_err_code ndr_pull_wkssvc_NetrGetJoinInformation(struct ndr_pull *ndr, int flags, struct wkssvc_NetrGetJoinInformation *r)
8431 {
8432         uint32_t _ptr_server_name;
8433         uint32_t _ptr_name_buffer;
8434         TALLOC_CTX *_mem_save_server_name_0;
8435         TALLOC_CTX *_mem_save_name_buffer_0;
8436         TALLOC_CTX *_mem_save_name_buffer_1;
8437         TALLOC_CTX *_mem_save_name_type_0;
8438         if (flags & NDR_IN) {
8439                 ZERO_STRUCT(r->out);
8440
8441                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
8442                 if (_ptr_server_name) {
8443                         NDR_PULL_ALLOC(ndr, r->in.server_name);
8444                 } else {
8445                         r->in.server_name = NULL;
8446                 }
8447                 if (r->in.server_name) {
8448                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8449                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
8450                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
8451                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
8452                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
8453                                 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));
8454                         }
8455                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
8456                         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));
8457                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
8458                 }
8459                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8460                         NDR_PULL_ALLOC(ndr, r->in.name_buffer);
8461                 }
8462                 _mem_save_name_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
8463                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name_buffer, LIBNDR_FLAG_REF_ALLOC);
8464                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_buffer));
8465                 if (_ptr_name_buffer) {
8466                         NDR_PULL_ALLOC(ndr, *r->in.name_buffer);
8467                 } else {
8468                         *r->in.name_buffer = NULL;
8469                 }
8470                 if (*r->in.name_buffer) {
8471                         _mem_save_name_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
8472                         NDR_PULL_SET_MEM_CTX(ndr, *r->in.name_buffer, 0);
8473                         NDR_CHECK(ndr_pull_array_size(ndr, r->in.name_buffer));
8474                         NDR_CHECK(ndr_pull_array_length(ndr, r->in.name_buffer));
8475                         if (ndr_get_array_length(ndr, r->in.name_buffer) > ndr_get_array_size(ndr, r->in.name_buffer)) {
8476                                 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));
8477                         }
8478                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->in.name_buffer), sizeof(uint16_t)));
8479                         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));
8480                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_buffer_1, 0);
8481                 }
8482                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_buffer_0, LIBNDR_FLAG_REF_ALLOC);
8483                 NDR_PULL_ALLOC(ndr, r->out.name_buffer);
8484                 *r->out.name_buffer = *r->in.name_buffer;
8485                 NDR_PULL_ALLOC(ndr, r->out.name_type);
8486                 ZERO_STRUCTP(r->out.name_type);
8487         }
8488         if (flags & NDR_OUT) {
8489                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8490                         NDR_PULL_ALLOC(ndr, r->out.name_buffer);
8491                 }
8492                 _mem_save_name_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
8493                 NDR_PULL_SET_MEM_CTX(ndr, r->out.name_buffer, LIBNDR_FLAG_REF_ALLOC);
8494                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_buffer));
8495                 if (_ptr_name_buffer) {
8496                         NDR_PULL_ALLOC(ndr, *r->out.name_buffer);
8497                 } else {
8498                         *r->out.name_buffer = NULL;
8499                 }
8500                 if (*r->out.name_buffer) {
8501                         _mem_save_name_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
8502                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.name_buffer, 0);
8503                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.name_buffer));
8504                         NDR_CHECK(ndr_pull_array_length(ndr, r->out.name_buffer));
8505                         if (ndr_get_array_length(ndr, r->out.name_buffer) > ndr_get_array_size(ndr, r->out.name_buffer)) {
8506                                 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));
8507                         }
8508                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->out.name_buffer), sizeof(uint16_t)));
8509                         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));
8510                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_buffer_1, 0);
8511                 }
8512                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_buffer_0, LIBNDR_FLAG_REF_ALLOC);
8513                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8514                         NDR_PULL_ALLOC(ndr, r->out.name_type);
8515                 }
8516                 _mem_save_name_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
8517                 NDR_PULL_SET_MEM_CTX(ndr, r->out.name_type, LIBNDR_FLAG_REF_ALLOC);
8518                 NDR_CHECK(ndr_pull_wkssvc_NetJoinStatus(ndr, NDR_SCALARS, r->out.name_type));
8519                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_type_0, LIBNDR_FLAG_REF_ALLOC);
8520                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
8521         }
8522         return NDR_ERR_SUCCESS;
8523 }
8524
8525 _PUBLIC_ void ndr_print_wkssvc_NetrGetJoinInformation(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrGetJoinInformation *r)
8526 {
8527         ndr_print_struct(ndr, name, "wkssvc_NetrGetJoinInformation");
8528         ndr->depth++;
8529         if (flags & NDR_SET_VALUES) {
8530                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8531         }
8532         if (flags & NDR_IN) {
8533                 ndr_print_struct(ndr, "in", "wkssvc_NetrGetJoinInformation");
8534                 ndr->depth++;
8535                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
8536                 ndr->depth++;
8537                 if (r->in.server_name) {
8538                         ndr_print_string(ndr, "server_name", r->in.server_name);
8539                 }
8540                 ndr->depth--;
8541                 ndr_print_ptr(ndr, "name_buffer", r->in.name_buffer);
8542                 ndr->depth++;
8543                 ndr_print_ptr(ndr, "name_buffer", *r->in.name_buffer);
8544                 ndr->depth++;
8545                 if (*r->in.name_buffer) {
8546                         ndr_print_string(ndr, "name_buffer", *r->in.name_buffer);
8547                 }
8548                 ndr->depth--;
8549                 ndr->depth--;
8550                 ndr->depth--;
8551         }
8552         if (flags & NDR_OUT) {
8553                 ndr_print_struct(ndr, "out", "wkssvc_NetrGetJoinInformation");
8554                 ndr->depth++;
8555                 ndr_print_ptr(ndr, "name_buffer", r->out.name_buffer);
8556                 ndr->depth++;
8557                 ndr_print_ptr(ndr, "name_buffer", *r->out.name_buffer);
8558                 ndr->depth++;
8559                 if (*r->out.name_buffer) {
8560                         ndr_print_string(ndr, "name_buffer", *r->out.name_buffer);
8561                 }
8562                 ndr->depth--;
8563                 ndr->depth--;
8564                 ndr_print_ptr(ndr, "name_type", r->out.name_type);
8565                 ndr->depth++;
8566                 ndr_print_wkssvc_NetJoinStatus(ndr, "name_type", *r->out.name_type);
8567                 ndr->depth--;
8568                 ndr_print_WERROR(ndr, "result", r->out.result);
8569                 ndr->depth--;
8570         }
8571         ndr->depth--;
8572 }
8573
8574 static enum ndr_err_code ndr_push_wkssvc_NetrGetJoinableOus(struct ndr_push *ndr, int flags, const struct wkssvc_NetrGetJoinableOus *r)
8575 {
8576         uint32_t cntr_ous_2;
8577         if (flags & NDR_IN) {
8578                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
8579                 if (r->in.server_name) {
8580                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8581                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8582                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8583                         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));
8584                 }
8585                 if (r->in.domain_name == NULL) {
8586                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8587                 }
8588                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
8589                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8590                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
8591                 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));
8592                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
8593                 if (r->in.Account) {
8594                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
8595                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8596                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
8597                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8598                 }
8599                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown));
8600                 if (r->in.unknown) {
8601                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));
8602                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8603                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));
8604                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.unknown, ndr_charset_length(r->in.unknown, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8605                 }
8606                 if (r->in.num_ous == NULL) {
8607                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8608                 }
8609                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.num_ous));
8610         }
8611         if (flags & NDR_OUT) {
8612                 if (r->out.num_ous == NULL) {
8613                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8614                 }
8615                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_ous));
8616                 if (r->out.ous == NULL) {
8617                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8618                 }
8619                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.ous));
8620                 if (*r->out.ous) {
8621                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.num_ous));
8622                         for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {
8623                                 NDR_CHECK(ndr_push_unique_ptr(ndr, (*r->out.ous)[cntr_ous_2]));
8624                         }
8625                         for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {
8626                                 if ((*r->out.ous)[cntr_ous_2]) {
8627                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length((*r->out.ous)[cntr_ous_2], CH_UTF16)));
8628                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8629                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length((*r->out.ous)[cntr_ous_2], CH_UTF16)));
8630                                         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));
8631                                 }
8632                         }
8633                 }
8634                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
8635         }
8636         return NDR_ERR_SUCCESS;
8637 }
8638
8639 static enum ndr_err_code ndr_pull_wkssvc_NetrGetJoinableOus(struct ndr_pull *ndr, int flags, struct wkssvc_NetrGetJoinableOus *r)
8640 {
8641         uint32_t _ptr_server_name;
8642         uint32_t _ptr_Account;
8643         uint32_t _ptr_unknown;
8644         uint32_t _ptr_ous;
8645         uint32_t cntr_ous_2;
8646         TALLOC_CTX *_mem_save_server_name_0;
8647         TALLOC_CTX *_mem_save_Account_0;
8648         TALLOC_CTX *_mem_save_unknown_0;
8649         TALLOC_CTX *_mem_save_num_ous_0;
8650         TALLOC_CTX *_mem_save_ous_0;
8651         TALLOC_CTX *_mem_save_ous_1;
8652         TALLOC_CTX *_mem_save_ous_2;
8653         TALLOC_CTX *_mem_save_ous_3;
8654         if (flags & NDR_IN) {
8655                 ZERO_STRUCT(r->out);
8656
8657                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
8658                 if (_ptr_server_name) {
8659                         NDR_PULL_ALLOC(ndr, r->in.server_name);
8660                 } else {
8661                         r->in.server_name = NULL;
8662                 }
8663                 if (r->in.server_name) {
8664                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8665                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
8666                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
8667                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
8668                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
8669                                 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));
8670                         }
8671                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
8672                         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));
8673                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
8674                 }
8675                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
8676                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
8677                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
8678                         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));
8679                 }
8680                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
8681                 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));
8682                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
8683                 if (_ptr_Account) {
8684                         NDR_PULL_ALLOC(ndr, r->in.Account);
8685                 } else {
8686                         r->in.Account = NULL;
8687                 }
8688                 if (r->in.Account) {
8689                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
8690                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
8691                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
8692                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
8693                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
8694                                 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));
8695                         }
8696                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
8697                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
8698                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
8699                 }
8700                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown));
8701                 if (_ptr_unknown) {
8702                         NDR_PULL_ALLOC(ndr, r->in.unknown);
8703                 } else {
8704                         r->in.unknown = NULL;
8705                 }
8706                 if (r->in.unknown) {
8707                         _mem_save_unknown_0 = NDR_PULL_GET_MEM_CTX(ndr);
8708                         NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown, 0);
8709                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.unknown));
8710                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.unknown));
8711                         if (ndr_get_array_length(ndr, &r->in.unknown) > ndr_get_array_size(ndr, &r->in.unknown)) {
8712                                 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));
8713                         }
8714                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t)));
8715                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.unknown, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t), CH_UTF16));
8716                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown_0, 0);
8717                 }
8718                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8719                         NDR_PULL_ALLOC(ndr, r->in.num_ous);
8720                 }
8721                 _mem_save_num_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);
8722                 NDR_PULL_SET_MEM_CTX(ndr, r->in.num_ous, LIBNDR_FLAG_REF_ALLOC);
8723                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.num_ous));
8724                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_ous_0, LIBNDR_FLAG_REF_ALLOC);
8725                 NDR_PULL_ALLOC(ndr, r->out.num_ous);
8726                 *r->out.num_ous = *r->in.num_ous;
8727                 NDR_PULL_ALLOC(ndr, r->out.ous);
8728                 ZERO_STRUCTP(r->out.ous);
8729         }
8730         if (flags & NDR_OUT) {
8731                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8732                         NDR_PULL_ALLOC(ndr, r->out.num_ous);
8733                 }
8734                 _mem_save_num_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);
8735                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_ous, LIBNDR_FLAG_REF_ALLOC);
8736                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_ous));
8737                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_ous_0, LIBNDR_FLAG_REF_ALLOC);
8738                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8739                         NDR_PULL_ALLOC(ndr, r->out.ous);
8740                 }
8741                 _mem_save_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);
8742                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ous, LIBNDR_FLAG_REF_ALLOC);
8743                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ous));
8744                 if (_ptr_ous) {
8745                         NDR_PULL_ALLOC(ndr, *r->out.ous);
8746                 } else {
8747                         *r->out.ous = NULL;
8748                 }
8749                 if (*r->out.ous) {
8750                         _mem_save_ous_1 = NDR_PULL_GET_MEM_CTX(ndr);
8751                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.ous, 0);
8752                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.ous));
8753                         NDR_PULL_ALLOC_N(ndr, *r->out.ous, ndr_get_array_size(ndr, r->out.ous));
8754                         _mem_save_ous_2 = NDR_PULL_GET_MEM_CTX(ndr);
8755                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.ous, 0);
8756                         for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {
8757                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ous));
8758                                 if (_ptr_ous) {
8759                                         NDR_PULL_ALLOC(ndr, (*r->out.ous)[cntr_ous_2]);
8760                                 } else {
8761                                         (*r->out.ous)[cntr_ous_2] = NULL;
8762                                 }
8763                         }
8764                         for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {
8765                                 if ((*r->out.ous)[cntr_ous_2]) {
8766                                         _mem_save_ous_3 = NDR_PULL_GET_MEM_CTX(ndr);
8767                                         NDR_PULL_SET_MEM_CTX(ndr, (*r->out.ous)[cntr_ous_2], 0);
8768                                         NDR_CHECK(ndr_pull_array_size(ndr, &(*r->out.ous)[cntr_ous_2]));
8769                                         NDR_CHECK(ndr_pull_array_length(ndr, &(*r->out.ous)[cntr_ous_2]));
8770                                         if (ndr_get_array_length(ndr, &(*r->out.ous)[cntr_ous_2]) > ndr_get_array_size(ndr, &(*r->out.ous)[cntr_ous_2])) {
8771                                                 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]));
8772                                         }
8773                                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &(*r->out.ous)[cntr_ous_2]), sizeof(uint16_t)));
8774                                         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));
8775                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_3, 0);
8776                                 }
8777                         }
8778                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_2, 0);
8779                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_1, 0);
8780                 }
8781                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_0, LIBNDR_FLAG_REF_ALLOC);
8782                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
8783                 if (*r->out.ous) {
8784                         NDR_CHECK(ndr_check_array_size(ndr, (void*)r->out.ous, *r->out.num_ous));
8785                 }
8786         }
8787         return NDR_ERR_SUCCESS;
8788 }
8789
8790 _PUBLIC_ void ndr_print_wkssvc_NetrGetJoinableOus(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrGetJoinableOus *r)
8791 {
8792         uint32_t cntr_ous_2;
8793         ndr_print_struct(ndr, name, "wkssvc_NetrGetJoinableOus");
8794         ndr->depth++;
8795         if (flags & NDR_SET_VALUES) {
8796                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8797         }
8798         if (flags & NDR_IN) {
8799                 ndr_print_struct(ndr, "in", "wkssvc_NetrGetJoinableOus");
8800                 ndr->depth++;
8801                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
8802                 ndr->depth++;
8803                 if (r->in.server_name) {
8804                         ndr_print_string(ndr, "server_name", r->in.server_name);
8805                 }
8806                 ndr->depth--;
8807                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
8808                 ndr->depth++;
8809                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
8810                 ndr->depth--;
8811                 ndr_print_ptr(ndr, "Account", r->in.Account);
8812                 ndr->depth++;
8813                 if (r->in.Account) {
8814                         ndr_print_string(ndr, "Account", r->in.Account);
8815                 }
8816                 ndr->depth--;
8817                 ndr_print_ptr(ndr, "unknown", r->in.unknown);
8818                 ndr->depth++;
8819                 if (r->in.unknown) {
8820                         ndr_print_string(ndr, "unknown", r->in.unknown);
8821                 }
8822                 ndr->depth--;
8823                 ndr_print_ptr(ndr, "num_ous", r->in.num_ous);
8824                 ndr->depth++;
8825                 ndr_print_uint32(ndr, "num_ous", *r->in.num_ous);
8826                 ndr->depth--;
8827                 ndr->depth--;
8828         }
8829         if (flags & NDR_OUT) {
8830                 ndr_print_struct(ndr, "out", "wkssvc_NetrGetJoinableOus");
8831                 ndr->depth++;
8832                 ndr_print_ptr(ndr, "num_ous", r->out.num_ous);
8833                 ndr->depth++;
8834                 ndr_print_uint32(ndr, "num_ous", *r->out.num_ous);
8835                 ndr->depth--;
8836                 ndr_print_ptr(ndr, "ous", r->out.ous);
8837                 ndr->depth++;
8838                 ndr_print_ptr(ndr, "ous", *r->out.ous);
8839                 ndr->depth++;
8840                 if (*r->out.ous) {
8841                         ndr->print(ndr, "%s: ARRAY(%d)", "ous", (int)*r->out.num_ous);
8842                         ndr->depth++;
8843                         for (cntr_ous_2=0;cntr_ous_2<*r->out.num_ous;cntr_ous_2++) {
8844                                 char *idx_2=NULL;
8845                                 if (asprintf(&idx_2, "[%d]", cntr_ous_2) != -1) {
8846                                         ndr_print_ptr(ndr, "ous", (*r->out.ous)[cntr_ous_2]);
8847                                         ndr->depth++;
8848                                         if ((*r->out.ous)[cntr_ous_2]) {
8849                                                 ndr_print_string(ndr, "ous", (*r->out.ous)[cntr_ous_2]);
8850                                         }
8851                                         ndr->depth--;
8852                                         free(idx_2);
8853                                 }
8854                         }
8855                         ndr->depth--;
8856                 }
8857                 ndr->depth--;
8858                 ndr->depth--;
8859                 ndr_print_WERROR(ndr, "result", r->out.result);
8860                 ndr->depth--;
8861         }
8862         ndr->depth--;
8863 }
8864
8865 static enum ndr_err_code ndr_push_wkssvc_NetrJoinDomain2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrJoinDomain2 *r)
8866 {
8867         if (flags & NDR_IN) {
8868                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
8869                 if (r->in.server_name) {
8870                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8871                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8872                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8873                         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));
8874                 }
8875                 if (r->in.domain_name == NULL) {
8876                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8877                 }
8878                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
8879                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8880                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
8881                 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));
8882                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.account_ou));
8883                 if (r->in.account_ou) {
8884                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.account_ou, CH_UTF16)));
8885                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8886                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.account_ou, CH_UTF16)));
8887                         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));
8888                 }
8889                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.admin_account));
8890                 if (r->in.admin_account) {
8891                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.admin_account, CH_UTF16)));
8892                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8893                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.admin_account, CH_UTF16)));
8894                         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));
8895                 }
8896                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.encrypted_password));
8897                 if (r->in.encrypted_password) {
8898                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));
8899                 }
8900                 NDR_CHECK(ndr_push_wkssvc_joinflags(ndr, NDR_SCALARS, r->in.join_flags));
8901         }
8902         if (flags & NDR_OUT) {
8903                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
8904         }
8905         return NDR_ERR_SUCCESS;
8906 }
8907
8908 static enum ndr_err_code ndr_pull_wkssvc_NetrJoinDomain2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrJoinDomain2 *r)
8909 {
8910         uint32_t _ptr_server_name;
8911         uint32_t _ptr_account_ou;
8912         uint32_t _ptr_admin_account;
8913         uint32_t _ptr_encrypted_password;
8914         TALLOC_CTX *_mem_save_server_name_0;
8915         TALLOC_CTX *_mem_save_account_ou_0;
8916         TALLOC_CTX *_mem_save_admin_account_0;
8917         TALLOC_CTX *_mem_save_encrypted_password_0;
8918         if (flags & NDR_IN) {
8919                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
8920                 if (_ptr_server_name) {
8921                         NDR_PULL_ALLOC(ndr, r->in.server_name);
8922                 } else {
8923                         r->in.server_name = NULL;
8924                 }
8925                 if (r->in.server_name) {
8926                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8927                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
8928                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
8929                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
8930                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
8931                                 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));
8932                         }
8933                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
8934                         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));
8935                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
8936                 }
8937                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
8938                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
8939                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
8940                         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));
8941                 }
8942                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
8943                 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));
8944                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account_ou));
8945                 if (_ptr_account_ou) {
8946                         NDR_PULL_ALLOC(ndr, r->in.account_ou);
8947                 } else {
8948                         r->in.account_ou = NULL;
8949                 }
8950                 if (r->in.account_ou) {
8951                         _mem_save_account_ou_0 = NDR_PULL_GET_MEM_CTX(ndr);
8952                         NDR_PULL_SET_MEM_CTX(ndr, r->in.account_ou, 0);
8953                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.account_ou));
8954                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.account_ou));
8955                         if (ndr_get_array_length(ndr, &r->in.account_ou) > ndr_get_array_size(ndr, &r->in.account_ou)) {
8956                                 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));
8957                         }
8958                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.account_ou), sizeof(uint16_t)));
8959                         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));
8960                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_ou_0, 0);
8961                 }
8962                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_admin_account));
8963                 if (_ptr_admin_account) {
8964                         NDR_PULL_ALLOC(ndr, r->in.admin_account);
8965                 } else {
8966                         r->in.admin_account = NULL;
8967                 }
8968                 if (r->in.admin_account) {
8969                         _mem_save_admin_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
8970                         NDR_PULL_SET_MEM_CTX(ndr, r->in.admin_account, 0);
8971                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.admin_account));
8972                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.admin_account));
8973                         if (ndr_get_array_length(ndr, &r->in.admin_account) > ndr_get_array_size(ndr, &r->in.admin_account)) {
8974                                 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));
8975                         }
8976                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.admin_account), sizeof(uint16_t)));
8977                         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));
8978                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_admin_account_0, 0);
8979                 }
8980                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_encrypted_password));
8981                 if (_ptr_encrypted_password) {
8982                         NDR_PULL_ALLOC(ndr, r->in.encrypted_password);
8983                 } else {
8984                         r->in.encrypted_password = NULL;
8985                 }
8986                 if (r->in.encrypted_password) {
8987                         _mem_save_encrypted_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
8988                         NDR_PULL_SET_MEM_CTX(ndr, r->in.encrypted_password, 0);
8989                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));
8990                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_encrypted_password_0, 0);
8991                 }
8992                 NDR_CHECK(ndr_pull_wkssvc_joinflags(ndr, NDR_SCALARS, &r->in.join_flags));
8993         }
8994         if (flags & NDR_OUT) {
8995                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
8996         }
8997         return NDR_ERR_SUCCESS;
8998 }
8999
9000 _PUBLIC_ void ndr_print_wkssvc_NetrJoinDomain2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrJoinDomain2 *r)
9001 {
9002         ndr_print_struct(ndr, name, "wkssvc_NetrJoinDomain2");
9003         ndr->depth++;
9004         if (flags & NDR_SET_VALUES) {
9005                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9006         }
9007         if (flags & NDR_IN) {
9008                 ndr_print_struct(ndr, "in", "wkssvc_NetrJoinDomain2");
9009                 ndr->depth++;
9010                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
9011                 ndr->depth++;
9012                 if (r->in.server_name) {
9013                         ndr_print_string(ndr, "server_name", r->in.server_name);
9014                 }
9015                 ndr->depth--;
9016                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
9017                 ndr->depth++;
9018                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
9019                 ndr->depth--;
9020                 ndr_print_ptr(ndr, "account_ou", r->in.account_ou);
9021                 ndr->depth++;
9022                 if (r->in.account_ou) {
9023                         ndr_print_string(ndr, "account_ou", r->in.account_ou);
9024                 }
9025                 ndr->depth--;
9026                 ndr_print_ptr(ndr, "admin_account", r->in.admin_account);
9027                 ndr->depth++;
9028                 if (r->in.admin_account) {
9029                         ndr_print_string(ndr, "admin_account", r->in.admin_account);
9030                 }
9031                 ndr->depth--;
9032                 ndr_print_ptr(ndr, "encrypted_password", r->in.encrypted_password);
9033                 ndr->depth++;
9034                 if (r->in.encrypted_password) {
9035                         ndr_print_wkssvc_PasswordBuffer(ndr, "encrypted_password", r->in.encrypted_password);
9036                 }
9037                 ndr->depth--;
9038                 ndr_print_wkssvc_joinflags(ndr, "join_flags", r->in.join_flags);
9039                 ndr->depth--;
9040         }
9041         if (flags & NDR_OUT) {
9042                 ndr_print_struct(ndr, "out", "wkssvc_NetrJoinDomain2");
9043                 ndr->depth++;
9044                 ndr_print_WERROR(ndr, "result", r->out.result);
9045                 ndr->depth--;
9046         }
9047         ndr->depth--;
9048 }
9049
9050 static enum ndr_err_code ndr_push_wkssvc_NetrUnjoinDomain2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUnjoinDomain2 *r)
9051 {
9052         if (flags & NDR_IN) {
9053                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
9054                 if (r->in.server_name) {
9055                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9056                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9057                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9058                         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));
9059                 }
9060                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.account));
9061                 if (r->in.account) {
9062                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.account, CH_UTF16)));
9063                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9064                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.account, CH_UTF16)));
9065                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.account, ndr_charset_length(r->in.account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9066                 }
9067                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.encrypted_password));
9068                 if (r->in.encrypted_password) {
9069                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));
9070                 }
9071                 NDR_CHECK(ndr_push_wkssvc_joinflags(ndr, NDR_SCALARS, r->in.unjoin_flags));
9072         }
9073         if (flags & NDR_OUT) {
9074                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9075         }
9076         return NDR_ERR_SUCCESS;
9077 }
9078
9079 static enum ndr_err_code ndr_pull_wkssvc_NetrUnjoinDomain2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUnjoinDomain2 *r)
9080 {
9081         uint32_t _ptr_server_name;
9082         uint32_t _ptr_account;
9083         uint32_t _ptr_encrypted_password;
9084         TALLOC_CTX *_mem_save_server_name_0;
9085         TALLOC_CTX *_mem_save_account_0;
9086         TALLOC_CTX *_mem_save_encrypted_password_0;
9087         if (flags & NDR_IN) {
9088                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
9089                 if (_ptr_server_name) {
9090                         NDR_PULL_ALLOC(ndr, r->in.server_name);
9091                 } else {
9092                         r->in.server_name = NULL;
9093                 }
9094                 if (r->in.server_name) {
9095                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9096                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
9097                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
9098                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
9099                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
9100                                 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));
9101                         }
9102                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
9103                         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));
9104                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
9105                 }
9106                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account));
9107                 if (_ptr_account) {
9108                         NDR_PULL_ALLOC(ndr, r->in.account);
9109                 } else {
9110                         r->in.account = NULL;
9111                 }
9112                 if (r->in.account) {
9113                         _mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
9114                         NDR_PULL_SET_MEM_CTX(ndr, r->in.account, 0);
9115                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.account));
9116                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.account));
9117                         if (ndr_get_array_length(ndr, &r->in.account) > ndr_get_array_size(ndr, &r->in.account)) {
9118                                 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));
9119                         }
9120                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.account), sizeof(uint16_t)));
9121                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.account, ndr_get_array_length(ndr, &r->in.account), sizeof(uint16_t), CH_UTF16));
9122                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, 0);
9123                 }
9124                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_encrypted_password));
9125                 if (_ptr_encrypted_password) {
9126                         NDR_PULL_ALLOC(ndr, r->in.encrypted_password);
9127                 } else {
9128                         r->in.encrypted_password = NULL;
9129                 }
9130                 if (r->in.encrypted_password) {
9131                         _mem_save_encrypted_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
9132                         NDR_PULL_SET_MEM_CTX(ndr, r->in.encrypted_password, 0);
9133                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));
9134                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_encrypted_password_0, 0);
9135                 }
9136                 NDR_CHECK(ndr_pull_wkssvc_joinflags(ndr, NDR_SCALARS, &r->in.unjoin_flags));
9137         }
9138         if (flags & NDR_OUT) {
9139                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9140         }
9141         return NDR_ERR_SUCCESS;
9142 }
9143
9144 _PUBLIC_ void ndr_print_wkssvc_NetrUnjoinDomain2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUnjoinDomain2 *r)
9145 {
9146         ndr_print_struct(ndr, name, "wkssvc_NetrUnjoinDomain2");
9147         ndr->depth++;
9148         if (flags & NDR_SET_VALUES) {
9149                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9150         }
9151         if (flags & NDR_IN) {
9152                 ndr_print_struct(ndr, "in", "wkssvc_NetrUnjoinDomain2");
9153                 ndr->depth++;
9154                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
9155                 ndr->depth++;
9156                 if (r->in.server_name) {
9157                         ndr_print_string(ndr, "server_name", r->in.server_name);
9158                 }
9159                 ndr->depth--;
9160                 ndr_print_ptr(ndr, "account", r->in.account);
9161                 ndr->depth++;
9162                 if (r->in.account) {
9163                         ndr_print_string(ndr, "account", r->in.account);
9164                 }
9165                 ndr->depth--;
9166                 ndr_print_ptr(ndr, "encrypted_password", r->in.encrypted_password);
9167                 ndr->depth++;
9168                 if (r->in.encrypted_password) {
9169                         ndr_print_wkssvc_PasswordBuffer(ndr, "encrypted_password", r->in.encrypted_password);
9170                 }
9171                 ndr->depth--;
9172                 ndr_print_wkssvc_joinflags(ndr, "unjoin_flags", r->in.unjoin_flags);
9173                 ndr->depth--;
9174         }
9175         if (flags & NDR_OUT) {
9176                 ndr_print_struct(ndr, "out", "wkssvc_NetrUnjoinDomain2");
9177                 ndr->depth++;
9178                 ndr_print_WERROR(ndr, "result", r->out.result);
9179                 ndr->depth--;
9180         }
9181         ndr->depth--;
9182 }
9183
9184 static enum ndr_err_code ndr_push_wkssvc_NetrRenameMachineInDomain2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrRenameMachineInDomain2 *r)
9185 {
9186         if (flags & NDR_IN) {
9187                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
9188                 if (r->in.server_name) {
9189                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9190                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9191                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9192                         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));
9193                 }
9194                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.NewMachineName));
9195                 if (r->in.NewMachineName) {
9196                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewMachineName, CH_UTF16)));
9197                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9198                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewMachineName, CH_UTF16)));
9199                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.NewMachineName, ndr_charset_length(r->in.NewMachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9200                 }
9201                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
9202                 if (r->in.Account) {
9203                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9204                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9205                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9206                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9207                 }
9208                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
9209                 if (r->in.EncryptedPassword) {
9210                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9211                 }
9212                 NDR_CHECK(ndr_push_wkssvc_renameflags(ndr, NDR_SCALARS, r->in.RenameOptions));
9213         }
9214         if (flags & NDR_OUT) {
9215                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9216         }
9217         return NDR_ERR_SUCCESS;
9218 }
9219
9220 static enum ndr_err_code ndr_pull_wkssvc_NetrRenameMachineInDomain2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrRenameMachineInDomain2 *r)
9221 {
9222         uint32_t _ptr_server_name;
9223         uint32_t _ptr_NewMachineName;
9224         uint32_t _ptr_Account;
9225         uint32_t _ptr_EncryptedPassword;
9226         TALLOC_CTX *_mem_save_server_name_0;
9227         TALLOC_CTX *_mem_save_NewMachineName_0;
9228         TALLOC_CTX *_mem_save_Account_0;
9229         TALLOC_CTX *_mem_save_EncryptedPassword_0;
9230         if (flags & NDR_IN) {
9231                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
9232                 if (_ptr_server_name) {
9233                         NDR_PULL_ALLOC(ndr, r->in.server_name);
9234                 } else {
9235                         r->in.server_name = NULL;
9236                 }
9237                 if (r->in.server_name) {
9238                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9239                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
9240                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
9241                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
9242                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
9243                                 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));
9244                         }
9245                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
9246                         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));
9247                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
9248                 }
9249                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_NewMachineName));
9250                 if (_ptr_NewMachineName) {
9251                         NDR_PULL_ALLOC(ndr, r->in.NewMachineName);
9252                 } else {
9253                         r->in.NewMachineName = NULL;
9254                 }
9255                 if (r->in.NewMachineName) {
9256                         _mem_save_NewMachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);
9257                         NDR_PULL_SET_MEM_CTX(ndr, r->in.NewMachineName, 0);
9258                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.NewMachineName));
9259                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.NewMachineName));
9260                         if (ndr_get_array_length(ndr, &r->in.NewMachineName) > ndr_get_array_size(ndr, &r->in.NewMachineName)) {
9261                                 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));
9262                         }
9263                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.NewMachineName), sizeof(uint16_t)));
9264                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.NewMachineName, ndr_get_array_length(ndr, &r->in.NewMachineName), sizeof(uint16_t), CH_UTF16));
9265                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_NewMachineName_0, 0);
9266                 }
9267                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
9268                 if (_ptr_Account) {
9269                         NDR_PULL_ALLOC(ndr, r->in.Account);
9270                 } else {
9271                         r->in.Account = NULL;
9272                 }
9273                 if (r->in.Account) {
9274                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
9275                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
9276                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
9277                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
9278                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
9279                                 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));
9280                         }
9281                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
9282                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
9283                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
9284                 }
9285                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
9286                 if (_ptr_EncryptedPassword) {
9287                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
9288                 } else {
9289                         r->in.EncryptedPassword = NULL;
9290                 }
9291                 if (r->in.EncryptedPassword) {
9292                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
9293                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
9294                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9295                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
9296                 }
9297                 NDR_CHECK(ndr_pull_wkssvc_renameflags(ndr, NDR_SCALARS, &r->in.RenameOptions));
9298         }
9299         if (flags & NDR_OUT) {
9300                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9301         }
9302         return NDR_ERR_SUCCESS;
9303 }
9304
9305 _PUBLIC_ void ndr_print_wkssvc_NetrRenameMachineInDomain2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrRenameMachineInDomain2 *r)
9306 {
9307         ndr_print_struct(ndr, name, "wkssvc_NetrRenameMachineInDomain2");
9308         ndr->depth++;
9309         if (flags & NDR_SET_VALUES) {
9310                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9311         }
9312         if (flags & NDR_IN) {
9313                 ndr_print_struct(ndr, "in", "wkssvc_NetrRenameMachineInDomain2");
9314                 ndr->depth++;
9315                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
9316                 ndr->depth++;
9317                 if (r->in.server_name) {
9318                         ndr_print_string(ndr, "server_name", r->in.server_name);
9319                 }
9320                 ndr->depth--;
9321                 ndr_print_ptr(ndr, "NewMachineName", r->in.NewMachineName);
9322                 ndr->depth++;
9323                 if (r->in.NewMachineName) {
9324                         ndr_print_string(ndr, "NewMachineName", r->in.NewMachineName);
9325                 }
9326                 ndr->depth--;
9327                 ndr_print_ptr(ndr, "Account", r->in.Account);
9328                 ndr->depth++;
9329                 if (r->in.Account) {
9330                         ndr_print_string(ndr, "Account", r->in.Account);
9331                 }
9332                 ndr->depth--;
9333                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9334                 ndr->depth++;
9335                 if (r->in.EncryptedPassword) {
9336                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9337                 }
9338                 ndr->depth--;
9339                 ndr_print_wkssvc_renameflags(ndr, "RenameOptions", r->in.RenameOptions);
9340                 ndr->depth--;
9341         }
9342         if (flags & NDR_OUT) {
9343                 ndr_print_struct(ndr, "out", "wkssvc_NetrRenameMachineInDomain2");
9344                 ndr->depth++;
9345                 ndr_print_WERROR(ndr, "result", r->out.result);
9346                 ndr->depth--;
9347         }
9348         ndr->depth--;
9349 }
9350
9351 static enum ndr_err_code ndr_push_wkssvc_NetrValidateName2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrValidateName2 *r)
9352 {
9353         if (flags & NDR_IN) {
9354                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
9355                 if (r->in.server_name) {
9356                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9357                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9358                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9359                         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));
9360                 }
9361                 if (r->in.name == NULL) {
9362                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9363                 }
9364                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF16)));
9365                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9366                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF16)));
9367                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.name, ndr_charset_length(r->in.name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9368                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
9369                 if (r->in.Account) {
9370                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9371                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9372                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9373                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9374                 }
9375                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
9376                 if (r->in.EncryptedPassword) {
9377                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9378                 }
9379                 NDR_CHECK(ndr_push_wkssvc_NetValidateNameType(ndr, NDR_SCALARS, r->in.name_type));
9380         }
9381         if (flags & NDR_OUT) {
9382                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9383         }
9384         return NDR_ERR_SUCCESS;
9385 }
9386
9387 static enum ndr_err_code ndr_pull_wkssvc_NetrValidateName2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrValidateName2 *r)
9388 {
9389         uint32_t _ptr_server_name;
9390         uint32_t _ptr_Account;
9391         uint32_t _ptr_EncryptedPassword;
9392         TALLOC_CTX *_mem_save_server_name_0;
9393         TALLOC_CTX *_mem_save_Account_0;
9394         TALLOC_CTX *_mem_save_EncryptedPassword_0;
9395         if (flags & NDR_IN) {
9396                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
9397                 if (_ptr_server_name) {
9398                         NDR_PULL_ALLOC(ndr, r->in.server_name);
9399                 } else {
9400                         r->in.server_name = NULL;
9401                 }
9402                 if (r->in.server_name) {
9403                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9404                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
9405                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
9406                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
9407                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
9408                                 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));
9409                         }
9410                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
9411                         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));
9412                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
9413                 }
9414                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.name));
9415                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.name));
9416                 if (ndr_get_array_length(ndr, &r->in.name) > ndr_get_array_size(ndr, &r->in.name)) {
9417                         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));
9418                 }
9419                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.name), sizeof(uint16_t)));
9420                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.name, ndr_get_array_length(ndr, &r->in.name), sizeof(uint16_t), CH_UTF16));
9421                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
9422                 if (_ptr_Account) {
9423                         NDR_PULL_ALLOC(ndr, r->in.Account);
9424                 } else {
9425                         r->in.Account = NULL;
9426                 }
9427                 if (r->in.Account) {
9428                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
9429                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
9430                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
9431                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
9432                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
9433                                 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));
9434                         }
9435                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
9436                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
9437                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
9438                 }
9439                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
9440                 if (_ptr_EncryptedPassword) {
9441                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
9442                 } else {
9443                         r->in.EncryptedPassword = NULL;
9444                 }
9445                 if (r->in.EncryptedPassword) {
9446                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
9447                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
9448                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9449                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
9450                 }
9451                 NDR_CHECK(ndr_pull_wkssvc_NetValidateNameType(ndr, NDR_SCALARS, &r->in.name_type));
9452         }
9453         if (flags & NDR_OUT) {
9454                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9455         }
9456         return NDR_ERR_SUCCESS;
9457 }
9458
9459 _PUBLIC_ void ndr_print_wkssvc_NetrValidateName2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrValidateName2 *r)
9460 {
9461         ndr_print_struct(ndr, name, "wkssvc_NetrValidateName2");
9462         ndr->depth++;
9463         if (flags & NDR_SET_VALUES) {
9464                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9465         }
9466         if (flags & NDR_IN) {
9467                 ndr_print_struct(ndr, "in", "wkssvc_NetrValidateName2");
9468                 ndr->depth++;
9469                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
9470                 ndr->depth++;
9471                 if (r->in.server_name) {
9472                         ndr_print_string(ndr, "server_name", r->in.server_name);
9473                 }
9474                 ndr->depth--;
9475                 ndr_print_ptr(ndr, "name", r->in.name);
9476                 ndr->depth++;
9477                 ndr_print_string(ndr, "name", r->in.name);
9478                 ndr->depth--;
9479                 ndr_print_ptr(ndr, "Account", r->in.Account);
9480                 ndr->depth++;
9481                 if (r->in.Account) {
9482                         ndr_print_string(ndr, "Account", r->in.Account);
9483                 }
9484                 ndr->depth--;
9485                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9486                 ndr->depth++;
9487                 if (r->in.EncryptedPassword) {
9488                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9489                 }
9490                 ndr->depth--;
9491                 ndr_print_wkssvc_NetValidateNameType(ndr, "name_type", r->in.name_type);
9492                 ndr->depth--;
9493         }
9494         if (flags & NDR_OUT) {
9495                 ndr_print_struct(ndr, "out", "wkssvc_NetrValidateName2");
9496                 ndr->depth++;
9497                 ndr_print_WERROR(ndr, "result", r->out.result);
9498                 ndr->depth--;
9499         }
9500         ndr->depth--;
9501 }
9502
9503 static enum ndr_err_code ndr_push_wkssvc_NetrGetJoinableOus2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrGetJoinableOus2 *r)
9504 {
9505         uint32_t cntr_ous_2;
9506         if (flags & NDR_IN) {
9507                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
9508                 if (r->in.server_name) {
9509                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9510                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9511                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9512                         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));
9513                 }
9514                 if (r->in.domain_name == NULL) {
9515                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9516                 }
9517                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
9518                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9519                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
9520                 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));
9521                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
9522                 if (r->in.Account) {
9523                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9524                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9525                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9526                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9527                 }
9528                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
9529                 if (r->in.EncryptedPassword) {
9530                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9531                 }
9532                 if (r->in.num_ous == NULL) {
9533                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9534                 }
9535                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.num_ous));
9536         }
9537         if (flags & NDR_OUT) {
9538                 if (r->out.num_ous == NULL) {
9539                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9540                 }
9541                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_ous));
9542                 if (r->out.ous == NULL) {
9543                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9544                 }
9545                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.ous));
9546                 if (*r->out.ous) {
9547                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.num_ous));
9548                         for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {
9549                                 NDR_CHECK(ndr_push_unique_ptr(ndr, (*r->out.ous)[cntr_ous_2]));
9550                         }
9551                         for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {
9552                                 if ((*r->out.ous)[cntr_ous_2]) {
9553                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length((*r->out.ous)[cntr_ous_2], CH_UTF16)));
9554                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9555                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length((*r->out.ous)[cntr_ous_2], CH_UTF16)));
9556                                         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));
9557                                 }
9558                         }
9559                 }
9560                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9561         }
9562         return NDR_ERR_SUCCESS;
9563 }
9564
9565 static enum ndr_err_code ndr_pull_wkssvc_NetrGetJoinableOus2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrGetJoinableOus2 *r)
9566 {
9567         uint32_t _ptr_server_name;
9568         uint32_t _ptr_Account;
9569         uint32_t _ptr_EncryptedPassword;
9570         uint32_t _ptr_ous;
9571         uint32_t cntr_ous_2;
9572         TALLOC_CTX *_mem_save_server_name_0;
9573         TALLOC_CTX *_mem_save_Account_0;
9574         TALLOC_CTX *_mem_save_EncryptedPassword_0;
9575         TALLOC_CTX *_mem_save_num_ous_0;
9576         TALLOC_CTX *_mem_save_ous_0;
9577         TALLOC_CTX *_mem_save_ous_1;
9578         TALLOC_CTX *_mem_save_ous_2;
9579         TALLOC_CTX *_mem_save_ous_3;
9580         if (flags & NDR_IN) {
9581                 ZERO_STRUCT(r->out);
9582
9583                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
9584                 if (_ptr_server_name) {
9585                         NDR_PULL_ALLOC(ndr, r->in.server_name);
9586                 } else {
9587                         r->in.server_name = NULL;
9588                 }
9589                 if (r->in.server_name) {
9590                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9591                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
9592                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
9593                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
9594                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
9595                                 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));
9596                         }
9597                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
9598                         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));
9599                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
9600                 }
9601                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
9602                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
9603                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
9604                         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));
9605                 }
9606                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
9607                 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));
9608                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
9609                 if (_ptr_Account) {
9610                         NDR_PULL_ALLOC(ndr, r->in.Account);
9611                 } else {
9612                         r->in.Account = NULL;
9613                 }
9614                 if (r->in.Account) {
9615                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
9616                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
9617                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
9618                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
9619                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
9620                                 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));
9621                         }
9622                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
9623                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
9624                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
9625                 }
9626                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
9627                 if (_ptr_EncryptedPassword) {
9628                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
9629                 } else {
9630                         r->in.EncryptedPassword = NULL;
9631                 }
9632                 if (r->in.EncryptedPassword) {
9633                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
9634                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
9635                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9636                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
9637                 }
9638                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9639                         NDR_PULL_ALLOC(ndr, r->in.num_ous);
9640                 }
9641                 _mem_save_num_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);
9642                 NDR_PULL_SET_MEM_CTX(ndr, r->in.num_ous, LIBNDR_FLAG_REF_ALLOC);
9643                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.num_ous));
9644                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_ous_0, LIBNDR_FLAG_REF_ALLOC);
9645                 NDR_PULL_ALLOC(ndr, r->out.num_ous);
9646                 *r->out.num_ous = *r->in.num_ous;
9647                 NDR_PULL_ALLOC(ndr, r->out.ous);
9648                 ZERO_STRUCTP(r->out.ous);
9649         }
9650         if (flags & NDR_OUT) {
9651                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9652                         NDR_PULL_ALLOC(ndr, r->out.num_ous);
9653                 }
9654                 _mem_save_num_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);
9655                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_ous, LIBNDR_FLAG_REF_ALLOC);
9656                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_ous));
9657                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_ous_0, LIBNDR_FLAG_REF_ALLOC);
9658                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9659                         NDR_PULL_ALLOC(ndr, r->out.ous);
9660                 }
9661                 _mem_save_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);
9662                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ous, LIBNDR_FLAG_REF_ALLOC);
9663                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ous));
9664                 if (_ptr_ous) {
9665                         NDR_PULL_ALLOC(ndr, *r->out.ous);
9666                 } else {
9667                         *r->out.ous = NULL;
9668                 }
9669                 if (*r->out.ous) {
9670                         _mem_save_ous_1 = NDR_PULL_GET_MEM_CTX(ndr);
9671                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.ous, 0);
9672                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.ous));
9673                         NDR_PULL_ALLOC_N(ndr, *r->out.ous, ndr_get_array_size(ndr, r->out.ous));
9674                         _mem_save_ous_2 = NDR_PULL_GET_MEM_CTX(ndr);
9675                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.ous, 0);
9676                         for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {
9677                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ous));
9678                                 if (_ptr_ous) {
9679                                         NDR_PULL_ALLOC(ndr, (*r->out.ous)[cntr_ous_2]);
9680                                 } else {
9681                                         (*r->out.ous)[cntr_ous_2] = NULL;
9682                                 }
9683                         }
9684                         for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {
9685                                 if ((*r->out.ous)[cntr_ous_2]) {
9686                                         _mem_save_ous_3 = NDR_PULL_GET_MEM_CTX(ndr);
9687                                         NDR_PULL_SET_MEM_CTX(ndr, (*r->out.ous)[cntr_ous_2], 0);
9688                                         NDR_CHECK(ndr_pull_array_size(ndr, &(*r->out.ous)[cntr_ous_2]));
9689                                         NDR_CHECK(ndr_pull_array_length(ndr, &(*r->out.ous)[cntr_ous_2]));
9690                                         if (ndr_get_array_length(ndr, &(*r->out.ous)[cntr_ous_2]) > ndr_get_array_size(ndr, &(*r->out.ous)[cntr_ous_2])) {
9691                                                 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]));
9692                                         }
9693                                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &(*r->out.ous)[cntr_ous_2]), sizeof(uint16_t)));
9694                                         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));
9695                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_3, 0);
9696                                 }
9697                         }
9698                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_2, 0);
9699                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_1, 0);
9700                 }
9701                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_0, LIBNDR_FLAG_REF_ALLOC);
9702                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9703                 if (*r->out.ous) {
9704                         NDR_CHECK(ndr_check_array_size(ndr, (void*)r->out.ous, *r->out.num_ous));
9705                 }
9706         }
9707         return NDR_ERR_SUCCESS;
9708 }
9709
9710 _PUBLIC_ void ndr_print_wkssvc_NetrGetJoinableOus2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrGetJoinableOus2 *r)
9711 {
9712         uint32_t cntr_ous_2;
9713         ndr_print_struct(ndr, name, "wkssvc_NetrGetJoinableOus2");
9714         ndr->depth++;
9715         if (flags & NDR_SET_VALUES) {
9716                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9717         }
9718         if (flags & NDR_IN) {
9719                 ndr_print_struct(ndr, "in", "wkssvc_NetrGetJoinableOus2");
9720                 ndr->depth++;
9721                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
9722                 ndr->depth++;
9723                 if (r->in.server_name) {
9724                         ndr_print_string(ndr, "server_name", r->in.server_name);
9725                 }
9726                 ndr->depth--;
9727                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
9728                 ndr->depth++;
9729                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
9730                 ndr->depth--;
9731                 ndr_print_ptr(ndr, "Account", r->in.Account);
9732                 ndr->depth++;
9733                 if (r->in.Account) {
9734                         ndr_print_string(ndr, "Account", r->in.Account);
9735                 }
9736                 ndr->depth--;
9737                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9738                 ndr->depth++;
9739                 if (r->in.EncryptedPassword) {
9740                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9741                 }
9742                 ndr->depth--;
9743                 ndr_print_ptr(ndr, "num_ous", r->in.num_ous);
9744                 ndr->depth++;
9745                 ndr_print_uint32(ndr, "num_ous", *r->in.num_ous);
9746                 ndr->depth--;
9747                 ndr->depth--;
9748         }
9749         if (flags & NDR_OUT) {
9750                 ndr_print_struct(ndr, "out", "wkssvc_NetrGetJoinableOus2");
9751                 ndr->depth++;
9752                 ndr_print_ptr(ndr, "num_ous", r->out.num_ous);
9753                 ndr->depth++;
9754                 ndr_print_uint32(ndr, "num_ous", *r->out.num_ous);
9755                 ndr->depth--;
9756                 ndr_print_ptr(ndr, "ous", r->out.ous);
9757                 ndr->depth++;
9758                 ndr_print_ptr(ndr, "ous", *r->out.ous);
9759                 ndr->depth++;
9760                 if (*r->out.ous) {
9761                         ndr->print(ndr, "%s: ARRAY(%d)", "ous", (int)*r->out.num_ous);
9762                         ndr->depth++;
9763                         for (cntr_ous_2=0;cntr_ous_2<*r->out.num_ous;cntr_ous_2++) {
9764                                 char *idx_2=NULL;
9765                                 if (asprintf(&idx_2, "[%d]", cntr_ous_2) != -1) {
9766                                         ndr_print_ptr(ndr, "ous", (*r->out.ous)[cntr_ous_2]);
9767                                         ndr->depth++;
9768                                         if ((*r->out.ous)[cntr_ous_2]) {
9769                                                 ndr_print_string(ndr, "ous", (*r->out.ous)[cntr_ous_2]);
9770                                         }
9771                                         ndr->depth--;
9772                                         free(idx_2);
9773                                 }
9774                         }
9775                         ndr->depth--;
9776                 }
9777                 ndr->depth--;
9778                 ndr->depth--;
9779                 ndr_print_WERROR(ndr, "result", r->out.result);
9780                 ndr->depth--;
9781         }
9782         ndr->depth--;
9783 }
9784
9785 static enum ndr_err_code ndr_push_wkssvc_NetrAddAlternateComputerName(struct ndr_push *ndr, int flags, const struct wkssvc_NetrAddAlternateComputerName *r)
9786 {
9787         if (flags & NDR_IN) {
9788                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
9789                 if (r->in.server_name) {
9790                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9791                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9792                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9793                         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));
9794                 }
9795                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.NewAlternateMachineName));
9796                 if (r->in.NewAlternateMachineName) {
9797                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewAlternateMachineName, CH_UTF16)));
9798                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9799                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewAlternateMachineName, CH_UTF16)));
9800                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.NewAlternateMachineName, ndr_charset_length(r->in.NewAlternateMachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9801                 }
9802                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
9803                 if (r->in.Account) {
9804                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9805                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9806                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9807                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9808                 }
9809                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
9810                 if (r->in.EncryptedPassword) {
9811                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9812                 }
9813                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Reserved));
9814         }
9815         if (flags & NDR_OUT) {
9816                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9817         }
9818         return NDR_ERR_SUCCESS;
9819 }
9820
9821 static enum ndr_err_code ndr_pull_wkssvc_NetrAddAlternateComputerName(struct ndr_pull *ndr, int flags, struct wkssvc_NetrAddAlternateComputerName *r)
9822 {
9823         uint32_t _ptr_server_name;
9824         uint32_t _ptr_NewAlternateMachineName;
9825         uint32_t _ptr_Account;
9826         uint32_t _ptr_EncryptedPassword;
9827         TALLOC_CTX *_mem_save_server_name_0;
9828         TALLOC_CTX *_mem_save_NewAlternateMachineName_0;
9829         TALLOC_CTX *_mem_save_Account_0;
9830         TALLOC_CTX *_mem_save_EncryptedPassword_0;
9831         if (flags & NDR_IN) {
9832                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
9833                 if (_ptr_server_name) {
9834                         NDR_PULL_ALLOC(ndr, r->in.server_name);
9835                 } else {
9836                         r->in.server_name = NULL;
9837                 }
9838                 if (r->in.server_name) {
9839                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9840                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
9841                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
9842                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
9843                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
9844                                 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));
9845                         }
9846                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
9847                         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));
9848                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
9849                 }
9850                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_NewAlternateMachineName));
9851                 if (_ptr_NewAlternateMachineName) {
9852                         NDR_PULL_ALLOC(ndr, r->in.NewAlternateMachineName);
9853                 } else {
9854                         r->in.NewAlternateMachineName = NULL;
9855                 }
9856                 if (r->in.NewAlternateMachineName) {
9857                         _mem_save_NewAlternateMachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);
9858                         NDR_PULL_SET_MEM_CTX(ndr, r->in.NewAlternateMachineName, 0);
9859                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.NewAlternateMachineName));
9860                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.NewAlternateMachineName));
9861                         if (ndr_get_array_length(ndr, &r->in.NewAlternateMachineName) > ndr_get_array_size(ndr, &r->in.NewAlternateMachineName)) {
9862                                 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));
9863                         }
9864                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.NewAlternateMachineName), sizeof(uint16_t)));
9865                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.NewAlternateMachineName, ndr_get_array_length(ndr, &r->in.NewAlternateMachineName), sizeof(uint16_t), CH_UTF16));
9866                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_NewAlternateMachineName_0, 0);
9867                 }
9868                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
9869                 if (_ptr_Account) {
9870                         NDR_PULL_ALLOC(ndr, r->in.Account);
9871                 } else {
9872                         r->in.Account = NULL;
9873                 }
9874                 if (r->in.Account) {
9875                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
9876                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
9877                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
9878                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
9879                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
9880                                 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));
9881                         }
9882                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
9883                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
9884                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
9885                 }
9886                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
9887                 if (_ptr_EncryptedPassword) {
9888                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
9889                 } else {
9890                         r->in.EncryptedPassword = NULL;
9891                 }
9892                 if (r->in.EncryptedPassword) {
9893                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
9894                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
9895                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9896                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
9897                 }
9898                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Reserved));
9899         }
9900         if (flags & NDR_OUT) {
9901                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9902         }
9903         return NDR_ERR_SUCCESS;
9904 }
9905
9906 _PUBLIC_ void ndr_print_wkssvc_NetrAddAlternateComputerName(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrAddAlternateComputerName *r)
9907 {
9908         ndr_print_struct(ndr, name, "wkssvc_NetrAddAlternateComputerName");
9909         ndr->depth++;
9910         if (flags & NDR_SET_VALUES) {
9911                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9912         }
9913         if (flags & NDR_IN) {
9914                 ndr_print_struct(ndr, "in", "wkssvc_NetrAddAlternateComputerName");
9915                 ndr->depth++;
9916                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
9917                 ndr->depth++;
9918                 if (r->in.server_name) {
9919                         ndr_print_string(ndr, "server_name", r->in.server_name);
9920                 }
9921                 ndr->depth--;
9922                 ndr_print_ptr(ndr, "NewAlternateMachineName", r->in.NewAlternateMachineName);
9923                 ndr->depth++;
9924                 if (r->in.NewAlternateMachineName) {
9925                         ndr_print_string(ndr, "NewAlternateMachineName", r->in.NewAlternateMachineName);
9926                 }
9927                 ndr->depth--;
9928                 ndr_print_ptr(ndr, "Account", r->in.Account);
9929                 ndr->depth++;
9930                 if (r->in.Account) {
9931                         ndr_print_string(ndr, "Account", r->in.Account);
9932                 }
9933                 ndr->depth--;
9934                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9935                 ndr->depth++;
9936                 if (r->in.EncryptedPassword) {
9937                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9938                 }
9939                 ndr->depth--;
9940                 ndr_print_uint32(ndr, "Reserved", r->in.Reserved);
9941                 ndr->depth--;
9942         }
9943         if (flags & NDR_OUT) {
9944                 ndr_print_struct(ndr, "out", "wkssvc_NetrAddAlternateComputerName");
9945                 ndr->depth++;
9946                 ndr_print_WERROR(ndr, "result", r->out.result);
9947                 ndr->depth--;
9948         }
9949         ndr->depth--;
9950 }
9951
9952 static enum ndr_err_code ndr_push_wkssvc_NetrRemoveAlternateComputerName(struct ndr_push *ndr, int flags, const struct wkssvc_NetrRemoveAlternateComputerName *r)
9953 {
9954         if (flags & NDR_IN) {
9955                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
9956                 if (r->in.server_name) {
9957                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9958                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9959                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9960                         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));
9961                 }
9962                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.AlternateMachineNameToRemove));
9963                 if (r->in.AlternateMachineNameToRemove) {
9964                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.AlternateMachineNameToRemove, CH_UTF16)));
9965                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9966                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.AlternateMachineNameToRemove, CH_UTF16)));
9967                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.AlternateMachineNameToRemove, ndr_charset_length(r->in.AlternateMachineNameToRemove, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9968                 }
9969                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
9970                 if (r->in.Account) {
9971                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9972                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9973                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9974                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9975                 }
9976                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
9977                 if (r->in.EncryptedPassword) {
9978                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9979                 }
9980                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Reserved));
9981         }
9982         if (flags & NDR_OUT) {
9983                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9984         }
9985         return NDR_ERR_SUCCESS;
9986 }
9987
9988 static enum ndr_err_code ndr_pull_wkssvc_NetrRemoveAlternateComputerName(struct ndr_pull *ndr, int flags, struct wkssvc_NetrRemoveAlternateComputerName *r)
9989 {
9990         uint32_t _ptr_server_name;
9991         uint32_t _ptr_AlternateMachineNameToRemove;
9992         uint32_t _ptr_Account;
9993         uint32_t _ptr_EncryptedPassword;
9994         TALLOC_CTX *_mem_save_server_name_0;
9995         TALLOC_CTX *_mem_save_AlternateMachineNameToRemove_0;
9996         TALLOC_CTX *_mem_save_Account_0;
9997         TALLOC_CTX *_mem_save_EncryptedPassword_0;
9998         if (flags & NDR_IN) {
9999                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
10000                 if (_ptr_server_name) {
10001                         NDR_PULL_ALLOC(ndr, r->in.server_name);
10002                 } else {
10003                         r->in.server_name = NULL;
10004                 }
10005                 if (r->in.server_name) {
10006                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10007                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
10008                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
10009                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
10010                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
10011                                 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));
10012                         }
10013                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
10014                         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));
10015                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
10016                 }
10017                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_AlternateMachineNameToRemove));
10018                 if (_ptr_AlternateMachineNameToRemove) {
10019                         NDR_PULL_ALLOC(ndr, r->in.AlternateMachineNameToRemove);
10020                 } else {
10021                         r->in.AlternateMachineNameToRemove = NULL;
10022                 }
10023                 if (r->in.AlternateMachineNameToRemove) {
10024                         _mem_save_AlternateMachineNameToRemove_0 = NDR_PULL_GET_MEM_CTX(ndr);
10025                         NDR_PULL_SET_MEM_CTX(ndr, r->in.AlternateMachineNameToRemove, 0);
10026                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.AlternateMachineNameToRemove));
10027                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.AlternateMachineNameToRemove));
10028                         if (ndr_get_array_length(ndr, &r->in.AlternateMachineNameToRemove) > ndr_get_array_size(ndr, &r->in.AlternateMachineNameToRemove)) {
10029                                 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));
10030                         }
10031                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.AlternateMachineNameToRemove), sizeof(uint16_t)));
10032                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.AlternateMachineNameToRemove, ndr_get_array_length(ndr, &r->in.AlternateMachineNameToRemove), sizeof(uint16_t), CH_UTF16));
10033                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_AlternateMachineNameToRemove_0, 0);
10034                 }
10035                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
10036                 if (_ptr_Account) {
10037                         NDR_PULL_ALLOC(ndr, r->in.Account);
10038                 } else {
10039                         r->in.Account = NULL;
10040                 }
10041                 if (r->in.Account) {
10042                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
10043                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
10044                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
10045                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
10046                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
10047                                 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));
10048                         }
10049                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
10050                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
10051                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
10052                 }
10053                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
10054                 if (_ptr_EncryptedPassword) {
10055                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
10056                 } else {
10057                         r->in.EncryptedPassword = NULL;
10058                 }
10059                 if (r->in.EncryptedPassword) {
10060                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
10061                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
10062                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
10063                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
10064                 }
10065                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Reserved));
10066         }
10067         if (flags & NDR_OUT) {
10068                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
10069         }
10070         return NDR_ERR_SUCCESS;
10071 }
10072
10073 _PUBLIC_ void ndr_print_wkssvc_NetrRemoveAlternateComputerName(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrRemoveAlternateComputerName *r)
10074 {
10075         ndr_print_struct(ndr, name, "wkssvc_NetrRemoveAlternateComputerName");
10076         ndr->depth++;
10077         if (flags & NDR_SET_VALUES) {
10078                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10079         }
10080         if (flags & NDR_IN) {
10081                 ndr_print_struct(ndr, "in", "wkssvc_NetrRemoveAlternateComputerName");
10082                 ndr->depth++;
10083                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
10084                 ndr->depth++;
10085                 if (r->in.server_name) {
10086                         ndr_print_string(ndr, "server_name", r->in.server_name);
10087                 }
10088                 ndr->depth--;
10089                 ndr_print_ptr(ndr, "AlternateMachineNameToRemove", r->in.AlternateMachineNameToRemove);
10090                 ndr->depth++;
10091                 if (r->in.AlternateMachineNameToRemove) {
10092                         ndr_print_string(ndr, "AlternateMachineNameToRemove", r->in.AlternateMachineNameToRemove);
10093                 }
10094                 ndr->depth--;
10095                 ndr_print_ptr(ndr, "Account", r->in.Account);
10096                 ndr->depth++;
10097                 if (r->in.Account) {
10098                         ndr_print_string(ndr, "Account", r->in.Account);
10099                 }
10100                 ndr->depth--;
10101                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
10102                 ndr->depth++;
10103                 if (r->in.EncryptedPassword) {
10104                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
10105                 }
10106                 ndr->depth--;
10107                 ndr_print_uint32(ndr, "Reserved", r->in.Reserved);
10108                 ndr->depth--;
10109         }
10110         if (flags & NDR_OUT) {
10111                 ndr_print_struct(ndr, "out", "wkssvc_NetrRemoveAlternateComputerName");
10112                 ndr->depth++;
10113                 ndr_print_WERROR(ndr, "result", r->out.result);
10114                 ndr->depth--;
10115         }
10116         ndr->depth--;
10117 }
10118
10119 static enum ndr_err_code ndr_push_wkssvc_NetrSetPrimaryComputername(struct ndr_push *ndr, int flags, const struct wkssvc_NetrSetPrimaryComputername *r)
10120 {
10121         if (flags & NDR_IN) {
10122                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
10123                 if (r->in.server_name) {
10124                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
10125                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10126                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
10127                         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));
10128                 }
10129                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.primary_name));
10130                 if (r->in.primary_name) {
10131                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.primary_name, CH_UTF16)));
10132                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10133                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.primary_name, CH_UTF16)));
10134                         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));
10135                 }
10136                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
10137                 if (r->in.Account) {
10138                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
10139                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10140                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
10141                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10142                 }
10143                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
10144                 if (r->in.EncryptedPassword) {
10145                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
10146                 }
10147                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Reserved));
10148         }
10149         if (flags & NDR_OUT) {
10150                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
10151         }
10152         return NDR_ERR_SUCCESS;
10153 }
10154
10155 static enum ndr_err_code ndr_pull_wkssvc_NetrSetPrimaryComputername(struct ndr_pull *ndr, int flags, struct wkssvc_NetrSetPrimaryComputername *r)
10156 {
10157         uint32_t _ptr_server_name;
10158         uint32_t _ptr_primary_name;
10159         uint32_t _ptr_Account;
10160         uint32_t _ptr_EncryptedPassword;
10161         TALLOC_CTX *_mem_save_server_name_0;
10162         TALLOC_CTX *_mem_save_primary_name_0;
10163         TALLOC_CTX *_mem_save_Account_0;
10164         TALLOC_CTX *_mem_save_EncryptedPassword_0;
10165         if (flags & NDR_IN) {
10166                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
10167                 if (_ptr_server_name) {
10168                         NDR_PULL_ALLOC(ndr, r->in.server_name);
10169                 } else {
10170                         r->in.server_name = NULL;
10171                 }
10172                 if (r->in.server_name) {
10173                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10174                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
10175                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
10176                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
10177                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
10178                                 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));
10179                         }
10180                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
10181                         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));
10182                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
10183                 }
10184                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_primary_name));
10185                 if (_ptr_primary_name) {
10186                         NDR_PULL_ALLOC(ndr, r->in.primary_name);
10187                 } else {
10188                         r->in.primary_name = NULL;
10189                 }
10190                 if (r->in.primary_name) {
10191                         _mem_save_primary_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10192                         NDR_PULL_SET_MEM_CTX(ndr, r->in.primary_name, 0);
10193                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.primary_name));
10194                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.primary_name));
10195                         if (ndr_get_array_length(ndr, &r->in.primary_name) > ndr_get_array_size(ndr, &r->in.primary_name)) {
10196                                 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));
10197                         }
10198                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.primary_name), sizeof(uint16_t)));
10199                         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));
10200                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_primary_name_0, 0);
10201                 }
10202                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
10203                 if (_ptr_Account) {
10204                         NDR_PULL_ALLOC(ndr, r->in.Account);
10205                 } else {
10206                         r->in.Account = NULL;
10207                 }
10208                 if (r->in.Account) {
10209                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
10210                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
10211                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
10212                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
10213                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
10214                                 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));
10215                         }
10216                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
10217                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
10218                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
10219                 }
10220                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
10221                 if (_ptr_EncryptedPassword) {
10222                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
10223                 } else {
10224                         r->in.EncryptedPassword = NULL;
10225                 }
10226                 if (r->in.EncryptedPassword) {
10227                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
10228                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
10229                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
10230                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
10231                 }
10232                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Reserved));
10233         }
10234         if (flags & NDR_OUT) {
10235                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
10236         }
10237         return NDR_ERR_SUCCESS;
10238 }
10239
10240 _PUBLIC_ void ndr_print_wkssvc_NetrSetPrimaryComputername(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrSetPrimaryComputername *r)
10241 {
10242         ndr_print_struct(ndr, name, "wkssvc_NetrSetPrimaryComputername");
10243         ndr->depth++;
10244         if (flags & NDR_SET_VALUES) {
10245                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10246         }
10247         if (flags & NDR_IN) {
10248                 ndr_print_struct(ndr, "in", "wkssvc_NetrSetPrimaryComputername");
10249                 ndr->depth++;
10250                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
10251                 ndr->depth++;
10252                 if (r->in.server_name) {
10253                         ndr_print_string(ndr, "server_name", r->in.server_name);
10254                 }
10255                 ndr->depth--;
10256                 ndr_print_ptr(ndr, "primary_name", r->in.primary_name);
10257                 ndr->depth++;
10258                 if (r->in.primary_name) {
10259                         ndr_print_string(ndr, "primary_name", r->in.primary_name);
10260                 }
10261                 ndr->depth--;
10262                 ndr_print_ptr(ndr, "Account", r->in.Account);
10263                 ndr->depth++;
10264                 if (r->in.Account) {
10265                         ndr_print_string(ndr, "Account", r->in.Account);
10266                 }
10267                 ndr->depth--;
10268                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
10269                 ndr->depth++;
10270                 if (r->in.EncryptedPassword) {
10271                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
10272                 }
10273                 ndr->depth--;
10274                 ndr_print_uint32(ndr, "Reserved", r->in.Reserved);
10275                 ndr->depth--;
10276         }
10277         if (flags & NDR_OUT) {
10278                 ndr_print_struct(ndr, "out", "wkssvc_NetrSetPrimaryComputername");
10279                 ndr->depth++;
10280                 ndr_print_WERROR(ndr, "result", r->out.result);
10281                 ndr->depth--;
10282         }
10283         ndr->depth--;
10284 }
10285
10286 static enum ndr_err_code ndr_push_wkssvc_NetrEnumerateComputerNames(struct ndr_push *ndr, int flags, const struct wkssvc_NetrEnumerateComputerNames *r)
10287 {
10288         if (flags & NDR_IN) {
10289                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
10290                 if (r->in.server_name) {
10291                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
10292                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10293                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
10294                         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));
10295                 }
10296                 NDR_CHECK(ndr_push_wkssvc_ComputerNameType(ndr, NDR_SCALARS, r->in.name_type));
10297                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Reserved));
10298         }
10299         if (flags & NDR_OUT) {
10300                 if (r->out.ctr == NULL) {
10301                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10302                 }
10303                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.ctr));
10304                 if (*r->out.ctr) {
10305                         NDR_CHECK(ndr_push_wkssvc_ComputerNamesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.ctr));
10306                 }
10307                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
10308         }
10309         return NDR_ERR_SUCCESS;
10310 }
10311
10312 static enum ndr_err_code ndr_pull_wkssvc_NetrEnumerateComputerNames(struct ndr_pull *ndr, int flags, struct wkssvc_NetrEnumerateComputerNames *r)
10313 {
10314         uint32_t _ptr_server_name;
10315         uint32_t _ptr_ctr;
10316         TALLOC_CTX *_mem_save_server_name_0;
10317         TALLOC_CTX *_mem_save_ctr_0;
10318         TALLOC_CTX *_mem_save_ctr_1;
10319         if (flags & NDR_IN) {
10320                 ZERO_STRUCT(r->out);
10321
10322                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
10323                 if (_ptr_server_name) {
10324                         NDR_PULL_ALLOC(ndr, r->in.server_name);
10325                 } else {
10326                         r->in.server_name = NULL;
10327                 }
10328                 if (r->in.server_name) {
10329                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10330                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
10331                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
10332                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
10333                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
10334                                 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));
10335                         }
10336                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
10337                         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));
10338                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
10339                 }
10340                 NDR_CHECK(ndr_pull_wkssvc_ComputerNameType(ndr, NDR_SCALARS, &r->in.name_type));
10341                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Reserved));
10342                 NDR_PULL_ALLOC(ndr, r->out.ctr);
10343                 ZERO_STRUCTP(r->out.ctr);
10344         }
10345         if (flags & NDR_OUT) {
10346                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10347                         NDR_PULL_ALLOC(ndr, r->out.ctr);
10348                 }
10349                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
10350                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
10351                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
10352                 if (_ptr_ctr) {
10353                         NDR_PULL_ALLOC(ndr, *r->out.ctr);
10354                 } else {
10355                         *r->out.ctr = NULL;
10356                 }
10357                 if (*r->out.ctr) {
10358                         _mem_save_ctr_1 = NDR_PULL_GET_MEM_CTX(ndr);
10359                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.ctr, 0);
10360                         NDR_CHECK(ndr_pull_wkssvc_ComputerNamesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.ctr));
10361                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_1, 0);
10362                 }
10363                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
10364                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
10365         }
10366         return NDR_ERR_SUCCESS;
10367 }
10368
10369 _PUBLIC_ void ndr_print_wkssvc_NetrEnumerateComputerNames(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrEnumerateComputerNames *r)
10370 {
10371         ndr_print_struct(ndr, name, "wkssvc_NetrEnumerateComputerNames");
10372         ndr->depth++;
10373         if (flags & NDR_SET_VALUES) {
10374                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10375         }
10376         if (flags & NDR_IN) {
10377                 ndr_print_struct(ndr, "in", "wkssvc_NetrEnumerateComputerNames");
10378                 ndr->depth++;
10379                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
10380                 ndr->depth++;
10381                 if (r->in.server_name) {
10382                         ndr_print_string(ndr, "server_name", r->in.server_name);
10383                 }
10384                 ndr->depth--;
10385                 ndr_print_wkssvc_ComputerNameType(ndr, "name_type", r->in.name_type);
10386                 ndr_print_uint32(ndr, "Reserved", r->in.Reserved);
10387                 ndr->depth--;
10388         }
10389         if (flags & NDR_OUT) {
10390                 ndr_print_struct(ndr, "out", "wkssvc_NetrEnumerateComputerNames");
10391                 ndr->depth++;
10392                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
10393                 ndr->depth++;
10394                 ndr_print_ptr(ndr, "ctr", *r->out.ctr);
10395                 ndr->depth++;
10396                 if (*r->out.ctr) {
10397                         ndr_print_wkssvc_ComputerNamesCtr(ndr, "ctr", *r->out.ctr);
10398                 }
10399                 ndr->depth--;
10400                 ndr->depth--;
10401                 ndr_print_WERROR(ndr, "result", r->out.result);
10402                 ndr->depth--;
10403         }
10404         ndr->depth--;
10405 }
10406
10407 static const struct ndr_interface_call wkssvc_calls[] = {
10408         {
10409                 "wkssvc_NetWkstaGetInfo",
10410                 sizeof(struct wkssvc_NetWkstaGetInfo),
10411                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaGetInfo,
10412                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaGetInfo,
10413                 (ndr_print_function_t) ndr_print_wkssvc_NetWkstaGetInfo,
10414                 false,
10415         },
10416         {
10417                 "wkssvc_NetWkstaSetInfo",
10418                 sizeof(struct wkssvc_NetWkstaSetInfo),
10419                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaSetInfo,
10420                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaSetInfo,
10421                 (ndr_print_function_t) ndr_print_wkssvc_NetWkstaSetInfo,
10422                 false,
10423         },
10424         {
10425                 "wkssvc_NetWkstaEnumUsers",
10426                 sizeof(struct wkssvc_NetWkstaEnumUsers),
10427                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaEnumUsers,
10428                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaEnumUsers,
10429                 (ndr_print_function_t) ndr_print_wkssvc_NetWkstaEnumUsers,
10430                 false,
10431         },
10432         {
10433                 "wkssvc_NetrWkstaUserGetInfo",
10434                 sizeof(struct wkssvc_NetrWkstaUserGetInfo),
10435                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrWkstaUserGetInfo,
10436                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrWkstaUserGetInfo,
10437                 (ndr_print_function_t) ndr_print_wkssvc_NetrWkstaUserGetInfo,
10438                 false,
10439         },
10440         {
10441                 "wkssvc_NetrWkstaUserSetInfo",
10442                 sizeof(struct wkssvc_NetrWkstaUserSetInfo),
10443                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrWkstaUserSetInfo,
10444                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrWkstaUserSetInfo,
10445                 (ndr_print_function_t) ndr_print_wkssvc_NetrWkstaUserSetInfo,
10446                 false,
10447         },
10448         {
10449                 "wkssvc_NetWkstaTransportEnum",
10450                 sizeof(struct wkssvc_NetWkstaTransportEnum),
10451                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaTransportEnum,
10452                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaTransportEnum,
10453                 (ndr_print_function_t) ndr_print_wkssvc_NetWkstaTransportEnum,
10454                 false,
10455         },
10456         {
10457                 "wkssvc_NetrWkstaTransportAdd",
10458                 sizeof(struct wkssvc_NetrWkstaTransportAdd),
10459                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrWkstaTransportAdd,
10460                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrWkstaTransportAdd,
10461                 (ndr_print_function_t) ndr_print_wkssvc_NetrWkstaTransportAdd,
10462                 false,
10463         },
10464         {
10465                 "wkssvc_NetrWkstaTransportDel",
10466                 sizeof(struct wkssvc_NetrWkstaTransportDel),
10467                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrWkstaTransportDel,
10468                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrWkstaTransportDel,
10469                 (ndr_print_function_t) ndr_print_wkssvc_NetrWkstaTransportDel,
10470                 false,
10471         },
10472         {
10473                 "wkssvc_NetrUseAdd",
10474                 sizeof(struct wkssvc_NetrUseAdd),
10475                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUseAdd,
10476                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUseAdd,
10477                 (ndr_print_function_t) ndr_print_wkssvc_NetrUseAdd,
10478                 false,
10479         },
10480         {
10481                 "wkssvc_NetrUseGetInfo",
10482                 sizeof(struct wkssvc_NetrUseGetInfo),
10483                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUseGetInfo,
10484                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUseGetInfo,
10485                 (ndr_print_function_t) ndr_print_wkssvc_NetrUseGetInfo,
10486                 false,
10487         },
10488         {
10489                 "wkssvc_NetrUseDel",
10490                 sizeof(struct wkssvc_NetrUseDel),
10491                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUseDel,
10492                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUseDel,
10493                 (ndr_print_function_t) ndr_print_wkssvc_NetrUseDel,
10494                 false,
10495         },
10496         {
10497                 "wkssvc_NetrUseEnum",
10498                 sizeof(struct wkssvc_NetrUseEnum),
10499                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUseEnum,
10500                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUseEnum,
10501                 (ndr_print_function_t) ndr_print_wkssvc_NetrUseEnum,
10502                 false,
10503         },
10504         {
10505                 "wkssvc_NetrMessageBufferSend",
10506                 sizeof(struct wkssvc_NetrMessageBufferSend),
10507                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrMessageBufferSend,
10508                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrMessageBufferSend,
10509                 (ndr_print_function_t) ndr_print_wkssvc_NetrMessageBufferSend,
10510                 false,
10511         },
10512         {
10513                 "wkssvc_NetrWorkstationStatisticsGet",
10514                 sizeof(struct wkssvc_NetrWorkstationStatisticsGet),
10515                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrWorkstationStatisticsGet,
10516                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrWorkstationStatisticsGet,
10517                 (ndr_print_function_t) ndr_print_wkssvc_NetrWorkstationStatisticsGet,
10518                 false,
10519         },
10520         {
10521                 "wkssvc_NetrLogonDomainNameAdd",
10522                 sizeof(struct wkssvc_NetrLogonDomainNameAdd),
10523                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrLogonDomainNameAdd,
10524                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrLogonDomainNameAdd,
10525                 (ndr_print_function_t) ndr_print_wkssvc_NetrLogonDomainNameAdd,
10526                 false,
10527         },
10528         {
10529                 "wkssvc_NetrLogonDomainNameDel",
10530                 sizeof(struct wkssvc_NetrLogonDomainNameDel),
10531                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrLogonDomainNameDel,
10532                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrLogonDomainNameDel,
10533                 (ndr_print_function_t) ndr_print_wkssvc_NetrLogonDomainNameDel,
10534                 false,
10535         },
10536         {
10537                 "wkssvc_NetrJoinDomain",
10538                 sizeof(struct wkssvc_NetrJoinDomain),
10539                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrJoinDomain,
10540                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrJoinDomain,
10541                 (ndr_print_function_t) ndr_print_wkssvc_NetrJoinDomain,
10542                 false,
10543         },
10544         {
10545                 "wkssvc_NetrUnjoinDomain",
10546                 sizeof(struct wkssvc_NetrUnjoinDomain),
10547                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUnjoinDomain,
10548                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUnjoinDomain,
10549                 (ndr_print_function_t) ndr_print_wkssvc_NetrUnjoinDomain,
10550                 false,
10551         },
10552         {
10553                 "wkssvc_NetrRenameMachineInDomain",
10554                 sizeof(struct wkssvc_NetrRenameMachineInDomain),
10555                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrRenameMachineInDomain,
10556                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrRenameMachineInDomain,
10557                 (ndr_print_function_t) ndr_print_wkssvc_NetrRenameMachineInDomain,
10558                 false,
10559         },
10560         {
10561                 "wkssvc_NetrValidateName",
10562                 sizeof(struct wkssvc_NetrValidateName),
10563                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrValidateName,
10564                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrValidateName,
10565                 (ndr_print_function_t) ndr_print_wkssvc_NetrValidateName,
10566                 false,
10567         },
10568         {
10569                 "wkssvc_NetrGetJoinInformation",
10570                 sizeof(struct wkssvc_NetrGetJoinInformation),
10571                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrGetJoinInformation,
10572                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrGetJoinInformation,
10573                 (ndr_print_function_t) ndr_print_wkssvc_NetrGetJoinInformation,
10574                 false,
10575         },
10576         {
10577                 "wkssvc_NetrGetJoinableOus",
10578                 sizeof(struct wkssvc_NetrGetJoinableOus),
10579                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrGetJoinableOus,
10580                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrGetJoinableOus,
10581                 (ndr_print_function_t) ndr_print_wkssvc_NetrGetJoinableOus,
10582                 false,
10583         },
10584         {
10585                 "wkssvc_NetrJoinDomain2",
10586                 sizeof(struct wkssvc_NetrJoinDomain2),
10587                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrJoinDomain2,
10588                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrJoinDomain2,
10589                 (ndr_print_function_t) ndr_print_wkssvc_NetrJoinDomain2,
10590                 false,
10591         },
10592         {
10593                 "wkssvc_NetrUnjoinDomain2",
10594                 sizeof(struct wkssvc_NetrUnjoinDomain2),
10595                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUnjoinDomain2,
10596                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUnjoinDomain2,
10597                 (ndr_print_function_t) ndr_print_wkssvc_NetrUnjoinDomain2,
10598                 false,
10599         },
10600         {
10601                 "wkssvc_NetrRenameMachineInDomain2",
10602                 sizeof(struct wkssvc_NetrRenameMachineInDomain2),
10603                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrRenameMachineInDomain2,
10604                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrRenameMachineInDomain2,
10605                 (ndr_print_function_t) ndr_print_wkssvc_NetrRenameMachineInDomain2,
10606                 false,
10607         },
10608         {
10609                 "wkssvc_NetrValidateName2",
10610                 sizeof(struct wkssvc_NetrValidateName2),
10611                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrValidateName2,
10612                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrValidateName2,
10613                 (ndr_print_function_t) ndr_print_wkssvc_NetrValidateName2,
10614                 false,
10615         },
10616         {
10617                 "wkssvc_NetrGetJoinableOus2",
10618                 sizeof(struct wkssvc_NetrGetJoinableOus2),
10619                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrGetJoinableOus2,
10620                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrGetJoinableOus2,
10621                 (ndr_print_function_t) ndr_print_wkssvc_NetrGetJoinableOus2,
10622                 false,
10623         },
10624         {
10625                 "wkssvc_NetrAddAlternateComputerName",
10626                 sizeof(struct wkssvc_NetrAddAlternateComputerName),
10627                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrAddAlternateComputerName,
10628                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrAddAlternateComputerName,
10629                 (ndr_print_function_t) ndr_print_wkssvc_NetrAddAlternateComputerName,
10630                 false,
10631         },
10632         {
10633                 "wkssvc_NetrRemoveAlternateComputerName",
10634                 sizeof(struct wkssvc_NetrRemoveAlternateComputerName),
10635                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrRemoveAlternateComputerName,
10636                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrRemoveAlternateComputerName,
10637                 (ndr_print_function_t) ndr_print_wkssvc_NetrRemoveAlternateComputerName,
10638                 false,
10639         },
10640         {
10641                 "wkssvc_NetrSetPrimaryComputername",
10642                 sizeof(struct wkssvc_NetrSetPrimaryComputername),
10643                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrSetPrimaryComputername,
10644                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrSetPrimaryComputername,
10645                 (ndr_print_function_t) ndr_print_wkssvc_NetrSetPrimaryComputername,
10646                 false,
10647         },
10648         {
10649                 "wkssvc_NetrEnumerateComputerNames",
10650                 sizeof(struct wkssvc_NetrEnumerateComputerNames),
10651                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrEnumerateComputerNames,
10652                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrEnumerateComputerNames,
10653                 (ndr_print_function_t) ndr_print_wkssvc_NetrEnumerateComputerNames,
10654                 false,
10655         },
10656         { NULL, 0, NULL, NULL, NULL, false }
10657 };
10658
10659 static const char * const wkssvc_endpoint_strings[] = {
10660         "ncacn_np:[\\pipe\\wkssvc]",
10661         "ncacn_ip_tcp:",
10662         "ncalrpc:",
10663 };
10664
10665 static const struct ndr_interface_string_array wkssvc_endpoints = {
10666         .count  = 3,
10667         .names  = wkssvc_endpoint_strings
10668 };
10669
10670 static const char * const wkssvc_authservice_strings[] = {
10671         "host",
10672 };
10673
10674 static const struct ndr_interface_string_array wkssvc_authservices = {
10675         .count  = 1,
10676         .names  = wkssvc_authservice_strings
10677 };
10678
10679
10680 const struct ndr_interface_table ndr_table_wkssvc = {
10681         .name           = "wkssvc",
10682         .syntax_id      = {
10683                 {0x6bffd098,0xa112,0x3610,{0x98,0x33},{0x46,0xc3,0xf8,0x7e,0x34,0x5a}},
10684                 NDR_WKSSVC_VERSION
10685         },
10686         .helpstring     = NDR_WKSSVC_HELPSTRING,
10687         .num_calls      = 31,
10688         .calls          = wkssvc_calls,
10689         .endpoints      = &wkssvc_endpoints,
10690         .authservices   = &wkssvc_authservices
10691 };
10692