source3/librpc/gen_ndr/ndr_wkssvc.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "librpc/gen_ndr/ndr_wkssvc.h"
   5
   6 #include "librpc/gen_ndr/ndr_srvsvc.h"
   7 #include "librpc/gen_ndr/ndr_lsa.h"
   8 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo100(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo100 *r)
   9 {
  10         if (ndr_flags & NDR_SCALARS) {
  11                 NDR_CHECK(ndr_push_align(ndr, 4));
  12                 NDR_CHECK(ndr_push_srvsvc_PlatformId(ndr, NDR_SCALARS, r->platform_id));
  13                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
  14                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
  15                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_major));
  16                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_minor));
  17         }
  18         if (ndr_flags & NDR_BUFFERS) {
  19                 if (r->server_name) {
  20                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
  21                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  22                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
  23                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
  24                 }
  25                 if (r->domain_name) {
  26                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
  27                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  28                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
  29                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
  30                 }
  31         }
  32         return NDR_ERR_SUCCESS;
  33 }
  34
  35 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo100(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo100 *r)
  36 {
  37         uint32_t _ptr_server_name;
  38         TALLOC_CTX *_mem_save_server_name_0;
  39         uint32_t _ptr_domain_name;
  40         TALLOC_CTX *_mem_save_domain_name_0;
  41         if (ndr_flags & NDR_SCALARS) {
  42                 NDR_CHECK(ndr_pull_align(ndr, 4));
  43                 NDR_CHECK(ndr_pull_srvsvc_PlatformId(ndr, NDR_SCALARS, &r->platform_id));
  44                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
  45                 if (_ptr_server_name) {
  46                         NDR_PULL_ALLOC(ndr, r->server_name);
  47                 } else {
  48                         r->server_name = NULL;
  49                 }
  50                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
  51                 if (_ptr_domain_name) {
  52                         NDR_PULL_ALLOC(ndr, r->domain_name);
  53                 } else {
  54                         r->domain_name = NULL;
  55                 }
  56                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_major));
  57                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_minor));
  58         }
  59         if (ndr_flags & NDR_BUFFERS) {
  60                 if (r->server_name) {
  61                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
  62                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
  63                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
  64                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
  65                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
  66                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
  67                         }
  68                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
  69                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
  70                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
  71                 }
  72                 if (r->domain_name) {
  73                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
  74                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
  75                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
  76                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
  77                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
  78                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->domain_name), ndr_get_array_length(ndr, &r->domain_name));
  79                         }
  80                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
  81                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
  82                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
  83                 }
  84         }
  85         return NDR_ERR_SUCCESS;
  86 }
  87
  88 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo100(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo100 *r)
  89 {
  90         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo100");
  91         ndr->depth++;
  92         ndr_print_srvsvc_PlatformId(ndr, "platform_id", r->platform_id);
  93         ndr_print_ptr(ndr, "server_name", r->server_name);
  94         ndr->depth++;
  95         if (r->server_name) {
  96                 ndr_print_string(ndr, "server_name", r->server_name);
  97         }
  98         ndr->depth--;
  99         ndr_print_ptr(ndr, "domain_name", r->domain_name);
 100         ndr->depth++;
 101         if (r->domain_name) {
 102                 ndr_print_string(ndr, "domain_name", r->domain_name);
 103         }
 104         ndr->depth--;
 105         ndr_print_uint32(ndr, "version_major", r->version_major);
 106         ndr_print_uint32(ndr, "version_minor", r->version_minor);
 107         ndr->depth--;
 108 }
 109
 110 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo101(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo101 *r)
 111 {
 112         if (ndr_flags & NDR_SCALARS) {
 113                 NDR_CHECK(ndr_push_align(ndr, 4));
 114                 NDR_CHECK(ndr_push_srvsvc_PlatformId(ndr, NDR_SCALARS, r->platform_id));
 115                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
 116                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
 117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_major));
 118                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_minor));
 119                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->lan_root));
 120         }
 121         if (ndr_flags & NDR_BUFFERS) {
 122                 if (r->server_name) {
 123                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
 124                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 125                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
 126                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 127                 }
 128                 if (r->domain_name) {
 129                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
 130                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 131                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
 132                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 133                 }
 134                 if (r->lan_root) {
 135                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->lan_root, CH_UTF16)));
 136                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 137                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->lan_root, CH_UTF16)));
 138                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->lan_root, ndr_charset_length(r->lan_root, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 139                 }
 140         }
 141         return NDR_ERR_SUCCESS;
 142 }
 143
 144 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo101(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo101 *r)
 145 {
 146         uint32_t _ptr_server_name;
 147         TALLOC_CTX *_mem_save_server_name_0;
 148         uint32_t _ptr_domain_name;
 149         TALLOC_CTX *_mem_save_domain_name_0;
 150         uint32_t _ptr_lan_root;
 151         TALLOC_CTX *_mem_save_lan_root_0;
 152         if (ndr_flags & NDR_SCALARS) {
 153                 NDR_CHECK(ndr_pull_align(ndr, 4));
 154                 NDR_CHECK(ndr_pull_srvsvc_PlatformId(ndr, NDR_SCALARS, &r->platform_id));
 155                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
 156                 if (_ptr_server_name) {
 157                         NDR_PULL_ALLOC(ndr, r->server_name);
 158                 } else {
 159                         r->server_name = NULL;
 160                 }
 161                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
 162                 if (_ptr_domain_name) {
 163                         NDR_PULL_ALLOC(ndr, r->domain_name);
 164                 } else {
 165                         r->domain_name = NULL;
 166                 }
 167                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_major));
 168                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_minor));
 169                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lan_root));
 170                 if (_ptr_lan_root) {
 171                         NDR_PULL_ALLOC(ndr, r->lan_root);
 172                 } else {
 173                         r->lan_root = NULL;
 174                 }
 175         }
 176         if (ndr_flags & NDR_BUFFERS) {
 177                 if (r->server_name) {
 178                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 179                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
 180                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
 181                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
 182                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
 183                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
 184                         }
 185                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
 186                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
 187                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
 188                 }
 189                 if (r->domain_name) {
 190                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 191                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
 192                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
 193                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
 194                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
 195                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->domain_name), ndr_get_array_length(ndr, &r->domain_name));
 196                         }
 197                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
 198                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
 199                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
 200                 }
 201                 if (r->lan_root) {
 202                         _mem_save_lan_root_0 = NDR_PULL_GET_MEM_CTX(ndr);
 203                         NDR_PULL_SET_MEM_CTX(ndr, r->lan_root, 0);
 204                         NDR_CHECK(ndr_pull_array_size(ndr, &r->lan_root));
 205                         NDR_CHECK(ndr_pull_array_length(ndr, &r->lan_root));
 206                         if (ndr_get_array_length(ndr, &r->lan_root) > ndr_get_array_size(ndr, &r->lan_root)) {
 207                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->lan_root), ndr_get_array_length(ndr, &r->lan_root));
 208                         }
 209                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->lan_root), sizeof(uint16_t)));
 210                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->lan_root, ndr_get_array_length(ndr, &r->lan_root), sizeof(uint16_t), CH_UTF16));
 211                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lan_root_0, 0);
 212                 }
 213         }
 214         return NDR_ERR_SUCCESS;
 215 }
 216
 217 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo101(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo101 *r)
 218 {
 219         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo101");
 220         ndr->depth++;
 221         ndr_print_srvsvc_PlatformId(ndr, "platform_id", r->platform_id);
 222         ndr_print_ptr(ndr, "server_name", r->server_name);
 223         ndr->depth++;
 224         if (r->server_name) {
 225                 ndr_print_string(ndr, "server_name", r->server_name);
 226         }
 227         ndr->depth--;
 228         ndr_print_ptr(ndr, "domain_name", r->domain_name);
 229         ndr->depth++;
 230         if (r->domain_name) {
 231                 ndr_print_string(ndr, "domain_name", r->domain_name);
 232         }
 233         ndr->depth--;
 234         ndr_print_uint32(ndr, "version_major", r->version_major);
 235         ndr_print_uint32(ndr, "version_minor", r->version_minor);
 236         ndr_print_ptr(ndr, "lan_root", r->lan_root);
 237         ndr->depth++;
 238         if (r->lan_root) {
 239                 ndr_print_string(ndr, "lan_root", r->lan_root);
 240         }
 241         ndr->depth--;
 242         ndr->depth--;
 243 }
 244
 245 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo102(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo102 *r)
 246 {
 247         if (ndr_flags & NDR_SCALARS) {
 248                 NDR_CHECK(ndr_push_align(ndr, 4));
 249                 NDR_CHECK(ndr_push_srvsvc_PlatformId(ndr, NDR_SCALARS, r->platform_id));
 250                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
 251                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
 252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_major));
 253                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_minor));
 254                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->lan_root));
 255                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->logged_on_users));
 256         }
 257         if (ndr_flags & NDR_BUFFERS) {
 258                 if (r->server_name) {
 259                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
 260                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 261                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
 262                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 263                 }
 264                 if (r->domain_name) {
 265                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
 266                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 267                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
 268                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 269                 }
 270                 if (r->lan_root) {
 271                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->lan_root, CH_UTF16)));
 272                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 273                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->lan_root, CH_UTF16)));
 274                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->lan_root, ndr_charset_length(r->lan_root, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 275                 }
 276         }
 277         return NDR_ERR_SUCCESS;
 278 }
 279
 280 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo102(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo102 *r)
 281 {
 282         uint32_t _ptr_server_name;
 283         TALLOC_CTX *_mem_save_server_name_0;
 284         uint32_t _ptr_domain_name;
 285         TALLOC_CTX *_mem_save_domain_name_0;
 286         uint32_t _ptr_lan_root;
 287         TALLOC_CTX *_mem_save_lan_root_0;
 288         if (ndr_flags & NDR_SCALARS) {
 289                 NDR_CHECK(ndr_pull_align(ndr, 4));
 290                 NDR_CHECK(ndr_pull_srvsvc_PlatformId(ndr, NDR_SCALARS, &r->platform_id));
 291                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
 292                 if (_ptr_server_name) {
 293                         NDR_PULL_ALLOC(ndr, r->server_name);
 294                 } else {
 295                         r->server_name = NULL;
 296                 }
 297                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
 298                 if (_ptr_domain_name) {
 299                         NDR_PULL_ALLOC(ndr, r->domain_name);
 300                 } else {
 301                         r->domain_name = NULL;
 302                 }
 303                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_major));
 304                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_minor));
 305                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lan_root));
 306                 if (_ptr_lan_root) {
 307                         NDR_PULL_ALLOC(ndr, r->lan_root);
 308                 } else {
 309                         r->lan_root = NULL;
 310                 }
 311                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->logged_on_users));
 312         }
 313         if (ndr_flags & NDR_BUFFERS) {
 314                 if (r->server_name) {
 315                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 316                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
 317                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
 318                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
 319                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
 320                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
 321                         }
 322                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
 323                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
 324                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
 325                 }
 326                 if (r->domain_name) {
 327                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 328                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
 329                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
 330                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
 331                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
 332                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->domain_name), ndr_get_array_length(ndr, &r->domain_name));
 333                         }
 334                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
 335                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
 336                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
 337                 }
 338                 if (r->lan_root) {
 339                         _mem_save_lan_root_0 = NDR_PULL_GET_MEM_CTX(ndr);
 340                         NDR_PULL_SET_MEM_CTX(ndr, r->lan_root, 0);
 341                         NDR_CHECK(ndr_pull_array_size(ndr, &r->lan_root));
 342                         NDR_CHECK(ndr_pull_array_length(ndr, &r->lan_root));
 343                         if (ndr_get_array_length(ndr, &r->lan_root) > ndr_get_array_size(ndr, &r->lan_root)) {
 344                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->lan_root), ndr_get_array_length(ndr, &r->lan_root));
 345                         }
 346                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->lan_root), sizeof(uint16_t)));
 347                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->lan_root, ndr_get_array_length(ndr, &r->lan_root), sizeof(uint16_t), CH_UTF16));
 348                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lan_root_0, 0);
 349                 }
 350         }
 351         return NDR_ERR_SUCCESS;
 352 }
 353
 354 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo102(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo102 *r)
 355 {
 356         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo102");
 357         ndr->depth++;
 358         ndr_print_srvsvc_PlatformId(ndr, "platform_id", r->platform_id);
 359         ndr_print_ptr(ndr, "server_name", r->server_name);
 360         ndr->depth++;
 361         if (r->server_name) {
 362                 ndr_print_string(ndr, "server_name", r->server_name);
 363         }
 364         ndr->depth--;
 365         ndr_print_ptr(ndr, "domain_name", r->domain_name);
 366         ndr->depth++;
 367         if (r->domain_name) {
 368                 ndr_print_string(ndr, "domain_name", r->domain_name);
 369         }
 370         ndr->depth--;
 371         ndr_print_uint32(ndr, "version_major", r->version_major);
 372         ndr_print_uint32(ndr, "version_minor", r->version_minor);
 373         ndr_print_ptr(ndr, "lan_root", r->lan_root);
 374         ndr->depth++;
 375         if (r->lan_root) {
 376                 ndr_print_string(ndr, "lan_root", r->lan_root);
 377         }
 378         ndr->depth--;
 379         ndr_print_uint32(ndr, "logged_on_users", r->logged_on_users);
 380         ndr->depth--;
 381 }
 382
 383 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo502(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo502 *r)
 384 {
 385         if (ndr_flags & NDR_SCALARS) {
 386                 NDR_CHECK(ndr_push_align(ndr, 4));
 387                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->char_wait));
 388                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->collection_time));
 389                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maximum_collection_count));
 390                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->keep_connection));
 391                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_commands));
 392                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_timeout));
 393                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_char_buf));
 394                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_threads));
 395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_quota));
 396                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_increment));
 397                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_maximum));
 398                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pipe_increment));
 399                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pipe_maximum));
 400                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cache_file_timeout));
 401                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dormant_file_limit));
 402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->read_ahead_throughput));
 403                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_mailslot_buffers));
 404                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_srv_announce_buffers));
 405                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_illegal_dgram_events));
 406                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dgram_event_reset_freq));
 407                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->log_election_packets));
 408                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_opportunistic_locking));
 409                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_unlock_behind));
 410                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_close_behind));
 411                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_named_pipes));
 412                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_lock_read_unlock));
 413                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->utilize_nt_caching));
 414                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_raw_read));
 415                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_raw_write));
 416                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_write_raw_data));
 417                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_encryption));
 418                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_files_deny_write));
 419                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_read_only_files));
 420                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->force_core_create_mode));
 421                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_512_byte_max_transfer));
 422         }
 423         if (ndr_flags & NDR_BUFFERS) {
 424         }
 425         return NDR_ERR_SUCCESS;
 426 }
 427
 428 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo502(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo502 *r)
 429 {
 430         if (ndr_flags & NDR_SCALARS) {
 431                 NDR_CHECK(ndr_pull_align(ndr, 4));
 432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->char_wait));
 433                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->collection_time));
 434                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maximum_collection_count));
 435                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->keep_connection));
 436                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_commands));
 437                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_timeout));
 438                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_char_buf));
 439                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_threads));
 440                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_quota));
 441                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_increment));
 442                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_maximum));
 443                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pipe_increment));
 444                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pipe_maximum));
 445                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cache_file_timeout));
 446                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dormant_file_limit));
 447                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->read_ahead_throughput));
 448                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_mailslot_buffers));
 449                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_srv_announce_buffers));
 450                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_illegal_dgram_events));
 451                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dgram_event_reset_freq));
 452                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->log_election_packets));
 453                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_opportunistic_locking));
 454                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_unlock_behind));
 455                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_close_behind));
 456                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_named_pipes));
 457                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_lock_read_unlock));
 458                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->utilize_nt_caching));
 459                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_raw_read));
 460                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_raw_write));
 461                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_write_raw_data));
 462                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_encryption));
 463                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_files_deny_write));
 464                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_read_only_files));
 465                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->force_core_create_mode));
 466                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_512_byte_max_transfer));
 467         }
 468         if (ndr_flags & NDR_BUFFERS) {
 469         }
 470         return NDR_ERR_SUCCESS;
 471 }
 472
 473 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo502(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo502 *r)
 474 {
 475         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo502");
 476         ndr->depth++;
 477         ndr_print_uint32(ndr, "char_wait", r->char_wait);
 478         ndr_print_uint32(ndr, "collection_time", r->collection_time);
 479         ndr_print_uint32(ndr, "maximum_collection_count", r->maximum_collection_count);
 480         ndr_print_uint32(ndr, "keep_connection", r->keep_connection);
 481         ndr_print_uint32(ndr, "max_commands", r->max_commands);
 482         ndr_print_uint32(ndr, "session_timeout", r->session_timeout);
 483         ndr_print_uint32(ndr, "size_char_buf", r->size_char_buf);
 484         ndr_print_uint32(ndr, "max_threads", r->max_threads);
 485         ndr_print_uint32(ndr, "lock_quota", r->lock_quota);
 486         ndr_print_uint32(ndr, "lock_increment", r->lock_increment);
 487         ndr_print_uint32(ndr, "lock_maximum", r->lock_maximum);
 488         ndr_print_uint32(ndr, "pipe_increment", r->pipe_increment);
 489         ndr_print_uint32(ndr, "pipe_maximum", r->pipe_maximum);
 490         ndr_print_uint32(ndr, "cache_file_timeout", r->cache_file_timeout);
 491         ndr_print_uint32(ndr, "dormant_file_limit", r->dormant_file_limit);
 492         ndr_print_uint32(ndr, "read_ahead_throughput", r->read_ahead_throughput);
 493         ndr_print_uint32(ndr, "num_mailslot_buffers", r->num_mailslot_buffers);
 494         ndr_print_uint32(ndr, "num_srv_announce_buffers", r->num_srv_announce_buffers);
 495         ndr_print_uint32(ndr, "max_illegal_dgram_events", r->max_illegal_dgram_events);
 496         ndr_print_uint32(ndr, "dgram_event_reset_freq", r->dgram_event_reset_freq);
 497         ndr_print_uint32(ndr, "log_election_packets", r->log_election_packets);
 498         ndr_print_uint32(ndr, "use_opportunistic_locking", r->use_opportunistic_locking);
 499         ndr_print_uint32(ndr, "use_unlock_behind", r->use_unlock_behind);
 500         ndr_print_uint32(ndr, "use_close_behind", r->use_close_behind);
 501         ndr_print_uint32(ndr, "buf_named_pipes", r->buf_named_pipes);
 502         ndr_print_uint32(ndr, "use_lock_read_unlock", r->use_lock_read_unlock);
 503         ndr_print_uint32(ndr, "utilize_nt_caching", r->utilize_nt_caching);
 504         ndr_print_uint32(ndr, "use_raw_read", r->use_raw_read);
 505         ndr_print_uint32(ndr, "use_raw_write", r->use_raw_write);
 506         ndr_print_uint32(ndr, "use_write_raw_data", r->use_write_raw_data);
 507         ndr_print_uint32(ndr, "use_encryption", r->use_encryption);
 508         ndr_print_uint32(ndr, "buf_files_deny_write", r->buf_files_deny_write);
 509         ndr_print_uint32(ndr, "buf_read_only_files", r->buf_read_only_files);
 510         ndr_print_uint32(ndr, "force_core_create_mode", r->force_core_create_mode);
 511         ndr_print_uint32(ndr, "use_512_byte_max_transfer", r->use_512_byte_max_transfer);
 512         ndr->depth--;
 513 }
 514
 515 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1010(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1010 *r)
 516 {
 517         if (ndr_flags & NDR_SCALARS) {
 518                 NDR_CHECK(ndr_push_align(ndr, 4));
 519                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->char_wait));
 520         }
 521         if (ndr_flags & NDR_BUFFERS) {
 522         }
 523         return NDR_ERR_SUCCESS;
 524 }
 525
 526 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1010(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1010 *r)
 527 {
 528         if (ndr_flags & NDR_SCALARS) {
 529                 NDR_CHECK(ndr_pull_align(ndr, 4));
 530                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->char_wait));
 531         }
 532         if (ndr_flags & NDR_BUFFERS) {
 533         }
 534         return NDR_ERR_SUCCESS;
 535 }
 536
 537 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1010(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1010 *r)
 538 {
 539         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1010");
 540         ndr->depth++;
 541         ndr_print_uint32(ndr, "char_wait", r->char_wait);
 542         ndr->depth--;
 543 }
 544
 545 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1011(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1011 *r)
 546 {
 547         if (ndr_flags & NDR_SCALARS) {
 548                 NDR_CHECK(ndr_push_align(ndr, 4));
 549                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->collection_time));
 550         }
 551         if (ndr_flags & NDR_BUFFERS) {
 552         }
 553         return NDR_ERR_SUCCESS;
 554 }
 555
 556 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1011(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1011 *r)
 557 {
 558         if (ndr_flags & NDR_SCALARS) {
 559                 NDR_CHECK(ndr_pull_align(ndr, 4));
 560                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->collection_time));
 561         }
 562         if (ndr_flags & NDR_BUFFERS) {
 563         }
 564         return NDR_ERR_SUCCESS;
 565 }
 566
 567 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1011(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1011 *r)
 568 {
 569         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1011");
 570         ndr->depth++;
 571         ndr_print_uint32(ndr, "collection_time", r->collection_time);
 572         ndr->depth--;
 573 }
 574
 575 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1012(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1012 *r)
 576 {
 577         if (ndr_flags & NDR_SCALARS) {
 578                 NDR_CHECK(ndr_push_align(ndr, 4));
 579                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maximum_collection_count));
 580         }
 581         if (ndr_flags & NDR_BUFFERS) {
 582         }
 583         return NDR_ERR_SUCCESS;
 584 }
 585
 586 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1012(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1012 *r)
 587 {
 588         if (ndr_flags & NDR_SCALARS) {
 589                 NDR_CHECK(ndr_pull_align(ndr, 4));
 590                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maximum_collection_count));
 591         }
 592         if (ndr_flags & NDR_BUFFERS) {
 593         }
 594         return NDR_ERR_SUCCESS;
 595 }
 596
 597 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1012(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1012 *r)
 598 {
 599         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1012");
 600         ndr->depth++;
 601         ndr_print_uint32(ndr, "maximum_collection_count", r->maximum_collection_count);
 602         ndr->depth--;
 603 }
 604
 605 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1013(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1013 *r)
 606 {
 607         if (ndr_flags & NDR_SCALARS) {
 608                 NDR_CHECK(ndr_push_align(ndr, 4));
 609                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->keep_connection));
 610         }
 611         if (ndr_flags & NDR_BUFFERS) {
 612         }
 613         return NDR_ERR_SUCCESS;
 614 }
 615
 616 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1013(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1013 *r)
 617 {
 618         if (ndr_flags & NDR_SCALARS) {
 619                 NDR_CHECK(ndr_pull_align(ndr, 4));
 620                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->keep_connection));
 621         }
 622         if (ndr_flags & NDR_BUFFERS) {
 623         }
 624         return NDR_ERR_SUCCESS;
 625 }
 626
 627 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1013(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1013 *r)
 628 {
 629         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1013");
 630         ndr->depth++;
 631         ndr_print_uint32(ndr, "keep_connection", r->keep_connection);
 632         ndr->depth--;
 633 }
 634
 635 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1018(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1018 *r)
 636 {
 637         if (ndr_flags & NDR_SCALARS) {
 638                 NDR_CHECK(ndr_push_align(ndr, 4));
 639                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_timeout));
 640         }
 641         if (ndr_flags & NDR_BUFFERS) {
 642         }
 643         return NDR_ERR_SUCCESS;
 644 }
 645
 646 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1018(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1018 *r)
 647 {
 648         if (ndr_flags & NDR_SCALARS) {
 649                 NDR_CHECK(ndr_pull_align(ndr, 4));
 650                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_timeout));
 651         }
 652         if (ndr_flags & NDR_BUFFERS) {
 653         }
 654         return NDR_ERR_SUCCESS;
 655 }
 656
 657 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1018(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1018 *r)
 658 {
 659         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1018");
 660         ndr->depth++;
 661         ndr_print_uint32(ndr, "session_timeout", r->session_timeout);
 662         ndr->depth--;
 663 }
 664
 665 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1023(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1023 *r)
 666 {
 667         if (ndr_flags & NDR_SCALARS) {
 668                 NDR_CHECK(ndr_push_align(ndr, 4));
 669                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_char_buf));
 670         }
 671         if (ndr_flags & NDR_BUFFERS) {
 672         }
 673         return NDR_ERR_SUCCESS;
 674 }
 675
 676 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1023(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1023 *r)
 677 {
 678         if (ndr_flags & NDR_SCALARS) {
 679                 NDR_CHECK(ndr_pull_align(ndr, 4));
 680                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_char_buf));
 681         }
 682         if (ndr_flags & NDR_BUFFERS) {
 683         }
 684         return NDR_ERR_SUCCESS;
 685 }
 686
 687 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1023(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1023 *r)
 688 {
 689         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1023");
 690         ndr->depth++;
 691         ndr_print_uint32(ndr, "size_char_buf", r->size_char_buf);
 692         ndr->depth--;
 693 }
 694
 695 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1027(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1027 *r)
 696 {
 697         if (ndr_flags & NDR_SCALARS) {
 698                 NDR_CHECK(ndr_push_align(ndr, 4));
 699                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->errorlog_sz));
 700         }
 701         if (ndr_flags & NDR_BUFFERS) {
 702         }
 703         return NDR_ERR_SUCCESS;
 704 }
 705
 706 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1027(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1027 *r)
 707 {
 708         if (ndr_flags & NDR_SCALARS) {
 709                 NDR_CHECK(ndr_pull_align(ndr, 4));
 710                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->errorlog_sz));
 711         }
 712         if (ndr_flags & NDR_BUFFERS) {
 713         }
 714         return NDR_ERR_SUCCESS;
 715 }
 716
 717 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1027(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1027 *r)
 718 {
 719         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1027");
 720         ndr->depth++;
 721         ndr_print_uint32(ndr, "errorlog_sz", r->errorlog_sz);
 722         ndr->depth--;
 723 }
 724
 725 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1028(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1028 *r)
 726 {
 727         if (ndr_flags & NDR_SCALARS) {
 728                 NDR_CHECK(ndr_push_align(ndr, 4));
 729                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->print_buf_time));
 730         }
 731         if (ndr_flags & NDR_BUFFERS) {
 732         }
 733         return NDR_ERR_SUCCESS;
 734 }
 735
 736 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1028(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1028 *r)
 737 {
 738         if (ndr_flags & NDR_SCALARS) {
 739                 NDR_CHECK(ndr_pull_align(ndr, 4));
 740                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->print_buf_time));
 741         }
 742         if (ndr_flags & NDR_BUFFERS) {
 743         }
 744         return NDR_ERR_SUCCESS;
 745 }
 746
 747 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1028(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1028 *r)
 748 {
 749         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1028");
 750         ndr->depth++;
 751         ndr_print_uint32(ndr, "print_buf_time", r->print_buf_time);
 752         ndr->depth--;
 753 }
 754
 755 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1032(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1032 *r)
 756 {
 757         if (ndr_flags & NDR_SCALARS) {
 758                 NDR_CHECK(ndr_push_align(ndr, 4));
 759                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->wrk_heuristics));
 760         }
 761         if (ndr_flags & NDR_BUFFERS) {
 762         }
 763         return NDR_ERR_SUCCESS;
 764 }
 765
 766 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1032(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1032 *r)
 767 {
 768         if (ndr_flags & NDR_SCALARS) {
 769                 NDR_CHECK(ndr_pull_align(ndr, 4));
 770                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->wrk_heuristics));
 771         }
 772         if (ndr_flags & NDR_BUFFERS) {
 773         }
 774         return NDR_ERR_SUCCESS;
 775 }
 776
 777 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1032(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1032 *r)
 778 {
 779         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1032");
 780         ndr->depth++;
 781         ndr_print_uint32(ndr, "wrk_heuristics", r->wrk_heuristics);
 782         ndr->depth--;
 783 }
 784
 785 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1033(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1033 *r)
 786 {
 787         if (ndr_flags & NDR_SCALARS) {
 788                 NDR_CHECK(ndr_push_align(ndr, 4));
 789                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_threads));
 790         }
 791         if (ndr_flags & NDR_BUFFERS) {
 792         }
 793         return NDR_ERR_SUCCESS;
 794 }
 795
 796 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1033(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1033 *r)
 797 {
 798         if (ndr_flags & NDR_SCALARS) {
 799                 NDR_CHECK(ndr_pull_align(ndr, 4));
 800                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_threads));
 801         }
 802         if (ndr_flags & NDR_BUFFERS) {
 803         }
 804         return NDR_ERR_SUCCESS;
 805 }
 806
 807 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1033(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1033 *r)
 808 {
 809         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1033");
 810         ndr->depth++;
 811         ndr_print_uint32(ndr, "max_threads", r->max_threads);
 812         ndr->depth--;
 813 }
 814
 815 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1041(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1041 *r)
 816 {
 817         if (ndr_flags & NDR_SCALARS) {
 818                 NDR_CHECK(ndr_push_align(ndr, 4));
 819                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_quota));
 820         }
 821         if (ndr_flags & NDR_BUFFERS) {
 822         }
 823         return NDR_ERR_SUCCESS;
 824 }
 825
 826 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1041(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1041 *r)
 827 {
 828         if (ndr_flags & NDR_SCALARS) {
 829                 NDR_CHECK(ndr_pull_align(ndr, 4));
 830                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_quota));
 831         }
 832         if (ndr_flags & NDR_BUFFERS) {
 833         }
 834         return NDR_ERR_SUCCESS;
 835 }
 836
 837 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1041(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1041 *r)
 838 {
 839         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1041");
 840         ndr->depth++;
 841         ndr_print_uint32(ndr, "lock_quota", r->lock_quota);
 842         ndr->depth--;
 843 }
 844
 845 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1042(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1042 *r)
 846 {
 847         if (ndr_flags & NDR_SCALARS) {
 848                 NDR_CHECK(ndr_push_align(ndr, 4));
 849                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_increment));
 850         }
 851         if (ndr_flags & NDR_BUFFERS) {
 852         }
 853         return NDR_ERR_SUCCESS;
 854 }
 855
 856 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1042(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1042 *r)
 857 {
 858         if (ndr_flags & NDR_SCALARS) {
 859                 NDR_CHECK(ndr_pull_align(ndr, 4));
 860                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_increment));
 861         }
 862         if (ndr_flags & NDR_BUFFERS) {
 863         }
 864         return NDR_ERR_SUCCESS;
 865 }
 866
 867 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1042(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1042 *r)
 868 {
 869         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1042");
 870         ndr->depth++;
 871         ndr_print_uint32(ndr, "lock_increment", r->lock_increment);
 872         ndr->depth--;
 873 }
 874
 875 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1043(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1043 *r)
 876 {
 877         if (ndr_flags & NDR_SCALARS) {
 878                 NDR_CHECK(ndr_push_align(ndr, 4));
 879                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_maximum));
 880         }
 881         if (ndr_flags & NDR_BUFFERS) {
 882         }
 883         return NDR_ERR_SUCCESS;
 884 }
 885
 886 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1043(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1043 *r)
 887 {
 888         if (ndr_flags & NDR_SCALARS) {
 889                 NDR_CHECK(ndr_pull_align(ndr, 4));
 890                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_maximum));
 891         }
 892         if (ndr_flags & NDR_BUFFERS) {
 893         }
 894         return NDR_ERR_SUCCESS;
 895 }
 896
 897 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1043(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1043 *r)
 898 {
 899         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1043");
 900         ndr->depth++;
 901         ndr_print_uint32(ndr, "lock_maximum", r->lock_maximum);
 902         ndr->depth--;
 903 }
 904
 905 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1044(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1044 *r)
 906 {
 907         if (ndr_flags & NDR_SCALARS) {
 908                 NDR_CHECK(ndr_push_align(ndr, 4));
 909                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pipe_increment));
 910         }
 911         if (ndr_flags & NDR_BUFFERS) {
 912         }
 913         return NDR_ERR_SUCCESS;
 914 }
 915
 916 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1044(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1044 *r)
 917 {
 918         if (ndr_flags & NDR_SCALARS) {
 919                 NDR_CHECK(ndr_pull_align(ndr, 4));
 920                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pipe_increment));
 921         }
 922         if (ndr_flags & NDR_BUFFERS) {
 923         }
 924         return NDR_ERR_SUCCESS;
 925 }
 926
 927 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1044(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1044 *r)
 928 {
 929         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1044");
 930         ndr->depth++;
 931         ndr_print_uint32(ndr, "pipe_increment", r->pipe_increment);
 932         ndr->depth--;
 933 }
 934
 935 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1045(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1045 *r)
 936 {
 937         if (ndr_flags & NDR_SCALARS) {
 938                 NDR_CHECK(ndr_push_align(ndr, 4));
 939                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pipe_maximum));
 940         }
 941         if (ndr_flags & NDR_BUFFERS) {
 942         }
 943         return NDR_ERR_SUCCESS;
 944 }
 945
 946 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1045(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1045 *r)
 947 {
 948         if (ndr_flags & NDR_SCALARS) {
 949                 NDR_CHECK(ndr_pull_align(ndr, 4));
 950                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pipe_maximum));
 951         }
 952         if (ndr_flags & NDR_BUFFERS) {
 953         }
 954         return NDR_ERR_SUCCESS;
 955 }
 956
 957 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1045(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1045 *r)
 958 {
 959         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1045");
 960         ndr->depth++;
 961         ndr_print_uint32(ndr, "pipe_maximum", r->pipe_maximum);
 962         ndr->depth--;
 963 }
 964
 965 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1046(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1046 *r)
 966 {
 967         if (ndr_flags & NDR_SCALARS) {
 968                 NDR_CHECK(ndr_push_align(ndr, 4));
 969                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dormant_file_limit));
 970         }
 971         if (ndr_flags & NDR_BUFFERS) {
 972         }
 973         return NDR_ERR_SUCCESS;
 974 }
 975
 976 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1046(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1046 *r)
 977 {
 978         if (ndr_flags & NDR_SCALARS) {
 979                 NDR_CHECK(ndr_pull_align(ndr, 4));
 980                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dormant_file_limit));
 981         }
 982         if (ndr_flags & NDR_BUFFERS) {
 983         }
 984         return NDR_ERR_SUCCESS;
 985 }
 986
 987 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1046(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1046 *r)
 988 {
 989         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1046");
 990         ndr->depth++;
 991         ndr_print_uint32(ndr, "dormant_file_limit", r->dormant_file_limit);
 992         ndr->depth--;
 993 }
 994
 995 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1047(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1047 *r)
 996 {
 997         if (ndr_flags & NDR_SCALARS) {
 998                 NDR_CHECK(ndr_push_align(ndr, 4));
 999                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cache_file_timeout));
1000         }
1001         if (ndr_flags & NDR_BUFFERS) {
1002         }
1003         return NDR_ERR_SUCCESS;
1004 }
1005
1006 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1047(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1047 *r)
1007 {
1008         if (ndr_flags & NDR_SCALARS) {
1009                 NDR_CHECK(ndr_pull_align(ndr, 4));
1010                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cache_file_timeout));
1011         }
1012         if (ndr_flags & NDR_BUFFERS) {
1013         }
1014         return NDR_ERR_SUCCESS;
1015 }
1016
1017 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1047(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1047 *r)
1018 {
1019         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1047");
1020         ndr->depth++;
1021         ndr_print_uint32(ndr, "cache_file_timeout", r->cache_file_timeout);
1022         ndr->depth--;
1023 }
1024
1025 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1048(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1048 *r)
1026 {
1027         if (ndr_flags & NDR_SCALARS) {
1028                 NDR_CHECK(ndr_push_align(ndr, 4));
1029                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_opportunistic_locking));
1030         }
1031         if (ndr_flags & NDR_BUFFERS) {
1032         }
1033         return NDR_ERR_SUCCESS;
1034 }
1035
1036 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1048(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1048 *r)
1037 {
1038         if (ndr_flags & NDR_SCALARS) {
1039                 NDR_CHECK(ndr_pull_align(ndr, 4));
1040                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_opportunistic_locking));
1041         }
1042         if (ndr_flags & NDR_BUFFERS) {
1043         }
1044         return NDR_ERR_SUCCESS;
1045 }
1046
1047 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1048(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1048 *r)
1048 {
1049         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1048");
1050         ndr->depth++;
1051         ndr_print_uint32(ndr, "use_opportunistic_locking", r->use_opportunistic_locking);
1052         ndr->depth--;
1053 }
1054
1055 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1049(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1049 *r)
1056 {
1057         if (ndr_flags & NDR_SCALARS) {
1058                 NDR_CHECK(ndr_push_align(ndr, 4));
1059                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_unlock_behind));
1060         }
1061         if (ndr_flags & NDR_BUFFERS) {
1062         }
1063         return NDR_ERR_SUCCESS;
1064 }
1065
1066 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1049(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1049 *r)
1067 {
1068         if (ndr_flags & NDR_SCALARS) {
1069                 NDR_CHECK(ndr_pull_align(ndr, 4));
1070                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_unlock_behind));
1071         }
1072         if (ndr_flags & NDR_BUFFERS) {
1073         }
1074         return NDR_ERR_SUCCESS;
1075 }
1076
1077 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1049(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1049 *r)
1078 {
1079         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1049");
1080         ndr->depth++;
1081         ndr_print_uint32(ndr, "use_unlock_behind", r->use_unlock_behind);
1082         ndr->depth--;
1083 }
1084
1085 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1050(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1050 *r)
1086 {
1087         if (ndr_flags & NDR_SCALARS) {
1088                 NDR_CHECK(ndr_push_align(ndr, 4));
1089                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_close_behind));
1090         }
1091         if (ndr_flags & NDR_BUFFERS) {
1092         }
1093         return NDR_ERR_SUCCESS;
1094 }
1095
1096 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1050(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1050 *r)
1097 {
1098         if (ndr_flags & NDR_SCALARS) {
1099                 NDR_CHECK(ndr_pull_align(ndr, 4));
1100                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_close_behind));
1101         }
1102         if (ndr_flags & NDR_BUFFERS) {
1103         }
1104         return NDR_ERR_SUCCESS;
1105 }
1106
1107 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1050(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1050 *r)
1108 {
1109         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1050");
1110         ndr->depth++;
1111         ndr_print_uint32(ndr, "use_close_behind", r->use_close_behind);
1112         ndr->depth--;
1113 }
1114
1115 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1051(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1051 *r)
1116 {
1117         if (ndr_flags & NDR_SCALARS) {
1118                 NDR_CHECK(ndr_push_align(ndr, 4));
1119                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_named_pipes));
1120         }
1121         if (ndr_flags & NDR_BUFFERS) {
1122         }
1123         return NDR_ERR_SUCCESS;
1124 }
1125
1126 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1051(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1051 *r)
1127 {
1128         if (ndr_flags & NDR_SCALARS) {
1129                 NDR_CHECK(ndr_pull_align(ndr, 4));
1130                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_named_pipes));
1131         }
1132         if (ndr_flags & NDR_BUFFERS) {
1133         }
1134         return NDR_ERR_SUCCESS;
1135 }
1136
1137 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1051(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1051 *r)
1138 {
1139         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1051");
1140         ndr->depth++;
1141         ndr_print_uint32(ndr, "buf_named_pipes", r->buf_named_pipes);
1142         ndr->depth--;
1143 }
1144
1145 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1052(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1052 *r)
1146 {
1147         if (ndr_flags & NDR_SCALARS) {
1148                 NDR_CHECK(ndr_push_align(ndr, 4));
1149                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_lock_read_unlock));
1150         }
1151         if (ndr_flags & NDR_BUFFERS) {
1152         }
1153         return NDR_ERR_SUCCESS;
1154 }
1155
1156 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1052(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1052 *r)
1157 {
1158         if (ndr_flags & NDR_SCALARS) {
1159                 NDR_CHECK(ndr_pull_align(ndr, 4));
1160                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_lock_read_unlock));
1161         }
1162         if (ndr_flags & NDR_BUFFERS) {
1163         }
1164         return NDR_ERR_SUCCESS;
1165 }
1166
1167 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1052(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1052 *r)
1168 {
1169         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1052");
1170         ndr->depth++;
1171         ndr_print_uint32(ndr, "use_lock_read_unlock", r->use_lock_read_unlock);
1172         ndr->depth--;
1173 }
1174
1175 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1053(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1053 *r)
1176 {
1177         if (ndr_flags & NDR_SCALARS) {
1178                 NDR_CHECK(ndr_push_align(ndr, 4));
1179                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->utilize_nt_caching));
1180         }
1181         if (ndr_flags & NDR_BUFFERS) {
1182         }
1183         return NDR_ERR_SUCCESS;
1184 }
1185
1186 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1053(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1053 *r)
1187 {
1188         if (ndr_flags & NDR_SCALARS) {
1189                 NDR_CHECK(ndr_pull_align(ndr, 4));
1190                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->utilize_nt_caching));
1191         }
1192         if (ndr_flags & NDR_BUFFERS) {
1193         }
1194         return NDR_ERR_SUCCESS;
1195 }
1196
1197 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1053(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1053 *r)
1198 {
1199         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1053");
1200         ndr->depth++;
1201         ndr_print_uint32(ndr, "utilize_nt_caching", r->utilize_nt_caching);
1202         ndr->depth--;
1203 }
1204
1205 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1054(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1054 *r)
1206 {
1207         if (ndr_flags & NDR_SCALARS) {
1208                 NDR_CHECK(ndr_push_align(ndr, 4));
1209                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_raw_read));
1210         }
1211         if (ndr_flags & NDR_BUFFERS) {
1212         }
1213         return NDR_ERR_SUCCESS;
1214 }
1215
1216 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1054(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1054 *r)
1217 {
1218         if (ndr_flags & NDR_SCALARS) {
1219                 NDR_CHECK(ndr_pull_align(ndr, 4));
1220                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_raw_read));
1221         }
1222         if (ndr_flags & NDR_BUFFERS) {
1223         }
1224         return NDR_ERR_SUCCESS;
1225 }
1226
1227 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1054(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1054 *r)
1228 {
1229         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1054");
1230         ndr->depth++;
1231         ndr_print_uint32(ndr, "use_raw_read", r->use_raw_read);
1232         ndr->depth--;
1233 }
1234
1235 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1055(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1055 *r)
1236 {
1237         if (ndr_flags & NDR_SCALARS) {
1238                 NDR_CHECK(ndr_push_align(ndr, 4));
1239                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_raw_write));
1240         }
1241         if (ndr_flags & NDR_BUFFERS) {
1242         }
1243         return NDR_ERR_SUCCESS;
1244 }
1245
1246 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1055(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1055 *r)
1247 {
1248         if (ndr_flags & NDR_SCALARS) {
1249                 NDR_CHECK(ndr_pull_align(ndr, 4));
1250                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_raw_write));
1251         }
1252         if (ndr_flags & NDR_BUFFERS) {
1253         }
1254         return NDR_ERR_SUCCESS;
1255 }
1256
1257 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1055(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1055 *r)
1258 {
1259         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1055");
1260         ndr->depth++;
1261         ndr_print_uint32(ndr, "use_raw_write", r->use_raw_write);
1262         ndr->depth--;
1263 }
1264
1265 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1056(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1056 *r)
1266 {
1267         if (ndr_flags & NDR_SCALARS) {
1268                 NDR_CHECK(ndr_push_align(ndr, 4));
1269                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_write_raw_data));
1270         }
1271         if (ndr_flags & NDR_BUFFERS) {
1272         }
1273         return NDR_ERR_SUCCESS;
1274 }
1275
1276 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1056(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1056 *r)
1277 {
1278         if (ndr_flags & NDR_SCALARS) {
1279                 NDR_CHECK(ndr_pull_align(ndr, 4));
1280                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_write_raw_data));
1281         }
1282         if (ndr_flags & NDR_BUFFERS) {
1283         }
1284         return NDR_ERR_SUCCESS;
1285 }
1286
1287 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1056(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1056 *r)
1288 {
1289         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1056");
1290         ndr->depth++;
1291         ndr_print_uint32(ndr, "use_write_raw_data", r->use_write_raw_data);
1292         ndr->depth--;
1293 }
1294
1295 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1057(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1057 *r)
1296 {
1297         if (ndr_flags & NDR_SCALARS) {
1298                 NDR_CHECK(ndr_push_align(ndr, 4));
1299                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_encryption));
1300         }
1301         if (ndr_flags & NDR_BUFFERS) {
1302         }
1303         return NDR_ERR_SUCCESS;
1304 }
1305
1306 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1057(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1057 *r)
1307 {
1308         if (ndr_flags & NDR_SCALARS) {
1309                 NDR_CHECK(ndr_pull_align(ndr, 4));
1310                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_encryption));
1311         }
1312         if (ndr_flags & NDR_BUFFERS) {
1313         }
1314         return NDR_ERR_SUCCESS;
1315 }
1316
1317 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1057(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1057 *r)
1318 {
1319         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1057");
1320         ndr->depth++;
1321         ndr_print_uint32(ndr, "use_encryption", r->use_encryption);
1322         ndr->depth--;
1323 }
1324
1325 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1058(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1058 *r)
1326 {
1327         if (ndr_flags & NDR_SCALARS) {
1328                 NDR_CHECK(ndr_push_align(ndr, 4));
1329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_files_deny_write));
1330         }
1331         if (ndr_flags & NDR_BUFFERS) {
1332         }
1333         return NDR_ERR_SUCCESS;
1334 }
1335
1336 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1058(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1058 *r)
1337 {
1338         if (ndr_flags & NDR_SCALARS) {
1339                 NDR_CHECK(ndr_pull_align(ndr, 4));
1340                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_files_deny_write));
1341         }
1342         if (ndr_flags & NDR_BUFFERS) {
1343         }
1344         return NDR_ERR_SUCCESS;
1345 }
1346
1347 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1058(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1058 *r)
1348 {
1349         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1058");
1350         ndr->depth++;
1351         ndr_print_uint32(ndr, "buf_files_deny_write", r->buf_files_deny_write);
1352         ndr->depth--;
1353 }
1354
1355 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1059(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1059 *r)
1356 {
1357         if (ndr_flags & NDR_SCALARS) {
1358                 NDR_CHECK(ndr_push_align(ndr, 4));
1359                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_read_only_files));
1360         }
1361         if (ndr_flags & NDR_BUFFERS) {
1362         }
1363         return NDR_ERR_SUCCESS;
1364 }
1365
1366 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1059(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1059 *r)
1367 {
1368         if (ndr_flags & NDR_SCALARS) {
1369                 NDR_CHECK(ndr_pull_align(ndr, 4));
1370                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_read_only_files));
1371         }
1372         if (ndr_flags & NDR_BUFFERS) {
1373         }
1374         return NDR_ERR_SUCCESS;
1375 }
1376
1377 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1059(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1059 *r)
1378 {
1379         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1059");
1380         ndr->depth++;
1381         ndr_print_uint32(ndr, "buf_read_only_files", r->buf_read_only_files);
1382         ndr->depth--;
1383 }
1384
1385 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1060(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1060 *r)
1386 {
1387         if (ndr_flags & NDR_SCALARS) {
1388                 NDR_CHECK(ndr_push_align(ndr, 4));
1389                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->force_core_create_mode));
1390         }
1391         if (ndr_flags & NDR_BUFFERS) {
1392         }
1393         return NDR_ERR_SUCCESS;
1394 }
1395
1396 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1060(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1060 *r)
1397 {
1398         if (ndr_flags & NDR_SCALARS) {
1399                 NDR_CHECK(ndr_pull_align(ndr, 4));
1400                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->force_core_create_mode));
1401         }
1402         if (ndr_flags & NDR_BUFFERS) {
1403         }
1404         return NDR_ERR_SUCCESS;
1405 }
1406
1407 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1060(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1060 *r)
1408 {
1409         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1060");
1410         ndr->depth++;
1411         ndr_print_uint32(ndr, "force_core_create_mode", r->force_core_create_mode);
1412         ndr->depth--;
1413 }
1414
1415 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1061(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1061 *r)
1416 {
1417         if (ndr_flags & NDR_SCALARS) {
1418                 NDR_CHECK(ndr_push_align(ndr, 4));
1419                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_512_byte_max_transfer));
1420         }
1421         if (ndr_flags & NDR_BUFFERS) {
1422         }
1423         return NDR_ERR_SUCCESS;
1424 }
1425
1426 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1061(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1061 *r)
1427 {
1428         if (ndr_flags & NDR_SCALARS) {
1429                 NDR_CHECK(ndr_pull_align(ndr, 4));
1430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_512_byte_max_transfer));
1431         }
1432         if (ndr_flags & NDR_BUFFERS) {
1433         }
1434         return NDR_ERR_SUCCESS;
1435 }
1436
1437 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1061(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1061 *r)
1438 {
1439         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1061");
1440         ndr->depth++;
1441         ndr_print_uint32(ndr, "use_512_byte_max_transfer", r->use_512_byte_max_transfer);
1442         ndr->depth--;
1443 }
1444
1445 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1062(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1062 *r)
1446 {
1447         if (ndr_flags & NDR_SCALARS) {
1448                 NDR_CHECK(ndr_push_align(ndr, 4));
1449                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->read_ahead_throughput));
1450         }
1451         if (ndr_flags & NDR_BUFFERS) {
1452         }
1453         return NDR_ERR_SUCCESS;
1454 }
1455
1456 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1062(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1062 *r)
1457 {
1458         if (ndr_flags & NDR_SCALARS) {
1459                 NDR_CHECK(ndr_pull_align(ndr, 4));
1460                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->read_ahead_throughput));
1461         }
1462         if (ndr_flags & NDR_BUFFERS) {
1463         }
1464         return NDR_ERR_SUCCESS;
1465 }
1466
1467 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1062(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1062 *r)
1468 {
1469         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1062");
1470         ndr->depth++;
1471         ndr_print_uint32(ndr, "read_ahead_throughput", r->read_ahead_throughput);
1472         ndr->depth--;
1473 }
1474
1475 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetWkstaInfo *r)
1476 {
1477         if (ndr_flags & NDR_SCALARS) {
1478                 int level = ndr_push_get_switch_value(ndr, r);
1479                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
1480                 switch (level) {
1481                         case 100:
1482                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info100));
1483                         break;
1484
1485                         case 101:
1486                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info101));
1487                         break;
1488
1489                         case 102:
1490                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info102));
1491                         break;
1492
1493                         case 502:
1494                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info502));
1495                         break;
1496
1497                         case 1010:
1498                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1010));
1499                         break;
1500
1501                         case 1011:
1502                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1011));
1503                         break;
1504
1505                         case 1012:
1506                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1012));
1507                         break;
1508
1509                         case 1013:
1510                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1013));
1511                         break;
1512
1513                         case 1018:
1514                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1018));
1515                         break;
1516
1517                         case 1023:
1518                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1023));
1519                         break;
1520
1521                         case 1027:
1522                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1027));
1523                         break;
1524
1525                         case 1028:
1526                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1028));
1527                         break;
1528
1529                         case 1032:
1530                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1032));
1531                         break;
1532
1533                         case 1033:
1534                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1033));
1535                         break;
1536
1537                         case 1041:
1538                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1041));
1539                         break;
1540
1541                         case 1042:
1542                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1042));
1543                         break;
1544
1545                         case 1043:
1546                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1043));
1547                         break;
1548
1549                         case 1044:
1550                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1044));
1551                         break;
1552
1553                         case 1045:
1554                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1045));
1555                         break;
1556
1557                         case 1046:
1558                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1046));
1559                         break;
1560
1561                         case 1047:
1562                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1047));
1563                         break;
1564
1565                         case 1048:
1566                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1048));
1567                         break;
1568
1569                         case 1049:
1570                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1049));
1571                         break;
1572
1573                         case 1050:
1574                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1050));
1575                         break;
1576
1577                         case 1051:
1578                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1051));
1579                         break;
1580
1581                         case 1052:
1582                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1052));
1583                         break;
1584
1585                         case 1053:
1586                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1053));
1587                         break;
1588
1589                         case 1054:
1590                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1054));
1591                         break;
1592
1593                         case 1055:
1594                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1055));
1595                         break;
1596
1597                         case 1056:
1598                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1056));
1599                         break;
1600
1601                         case 1057:
1602                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1057));
1603                         break;
1604
1605                         case 1058:
1606                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1058));
1607                         break;
1608
1609                         case 1059:
1610                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1059));
1611                         break;
1612
1613                         case 1060:
1614                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1060));
1615                         break;
1616
1617                         case 1061:
1618                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1061));
1619                         break;
1620
1621                         case 1062:
1622                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1062));
1623                         break;
1624
1625                         default:
1626                         break;
1627
1628                 }
1629         }
1630         if (ndr_flags & NDR_BUFFERS) {
1631                 int level = ndr_push_get_switch_value(ndr, r);
1632                 switch (level) {
1633                         case 100:
1634                                 if (r->info100) {
1635                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo100(ndr, NDR_SCALARS|NDR_BUFFERS, r->info100));
1636                                 }
1637                         break;
1638
1639                         case 101:
1640                                 if (r->info101) {
1641                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info101));
1642                                 }
1643                         break;
1644
1645                         case 102:
1646                                 if (r->info102) {
1647                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo102(ndr, NDR_SCALARS|NDR_BUFFERS, r->info102));
1648                                 }
1649                         break;
1650
1651                         case 502:
1652                                 if (r->info502) {
1653                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo502(ndr, NDR_SCALARS, r->info502));
1654                                 }
1655                         break;
1656
1657                         case 1010:
1658                                 if (r->info1010) {
1659                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1010(ndr, NDR_SCALARS, r->info1010));
1660                                 }
1661                         break;
1662
1663                         case 1011:
1664                                 if (r->info1011) {
1665                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1011(ndr, NDR_SCALARS, r->info1011));
1666                                 }
1667                         break;
1668
1669                         case 1012:
1670                                 if (r->info1012) {
1671                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1012(ndr, NDR_SCALARS, r->info1012));
1672                                 }
1673                         break;
1674
1675                         case 1013:
1676                                 if (r->info1013) {
1677                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1013(ndr, NDR_SCALARS, r->info1013));
1678                                 }
1679                         break;
1680
1681                         case 1018:
1682                                 if (r->info1018) {
1683                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1018(ndr, NDR_SCALARS, r->info1018));
1684                                 }
1685                         break;
1686
1687                         case 1023:
1688                                 if (r->info1023) {
1689                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1023(ndr, NDR_SCALARS, r->info1023));
1690                                 }
1691                         break;
1692
1693                         case 1027:
1694                                 if (r->info1027) {
1695                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1027(ndr, NDR_SCALARS, r->info1027));
1696                                 }
1697                         break;
1698
1699                         case 1028:
1700                                 if (r->info1028) {
1701                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1028(ndr, NDR_SCALARS, r->info1028));
1702                                 }
1703                         break;
1704
1705                         case 1032:
1706                                 if (r->info1032) {
1707                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1032(ndr, NDR_SCALARS, r->info1032));
1708                                 }
1709                         break;
1710
1711                         case 1033:
1712                                 if (r->info1033) {
1713                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1033(ndr, NDR_SCALARS, r->info1033));
1714                                 }
1715                         break;
1716
1717                         case 1041:
1718                                 if (r->info1041) {
1719                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1041(ndr, NDR_SCALARS, r->info1041));
1720                                 }
1721                         break;
1722
1723                         case 1042:
1724                                 if (r->info1042) {
1725                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1042(ndr, NDR_SCALARS, r->info1042));
1726                                 }
1727                         break;
1728
1729                         case 1043:
1730                                 if (r->info1043) {
1731                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1043(ndr, NDR_SCALARS, r->info1043));
1732                                 }
1733                         break;
1734
1735                         case 1044:
1736                                 if (r->info1044) {
1737                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1044(ndr, NDR_SCALARS, r->info1044));
1738                                 }
1739                         break;
1740
1741                         case 1045:
1742                                 if (r->info1045) {
1743                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1045(ndr, NDR_SCALARS, r->info1045));
1744                                 }
1745                         break;
1746
1747                         case 1046:
1748                                 if (r->info1046) {
1749                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1046(ndr, NDR_SCALARS, r->info1046));
1750                                 }
1751                         break;
1752
1753                         case 1047:
1754                                 if (r->info1047) {
1755                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1047(ndr, NDR_SCALARS, r->info1047));
1756                                 }
1757                         break;
1758
1759                         case 1048:
1760                                 if (r->info1048) {
1761                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1048(ndr, NDR_SCALARS, r->info1048));
1762                                 }
1763                         break;
1764
1765                         case 1049:
1766                                 if (r->info1049) {
1767                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1049(ndr, NDR_SCALARS, r->info1049));
1768                                 }
1769                         break;
1770
1771                         case 1050:
1772                                 if (r->info1050) {
1773                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1050(ndr, NDR_SCALARS, r->info1050));
1774                                 }
1775                         break;
1776
1777                         case 1051:
1778                                 if (r->info1051) {
1779                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1051(ndr, NDR_SCALARS, r->info1051));
1780                                 }
1781                         break;
1782
1783                         case 1052:
1784                                 if (r->info1052) {
1785                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1052(ndr, NDR_SCALARS, r->info1052));
1786                                 }
1787                         break;
1788
1789                         case 1053:
1790                                 if (r->info1053) {
1791                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1053(ndr, NDR_SCALARS, r->info1053));
1792                                 }
1793                         break;
1794
1795                         case 1054:
1796                                 if (r->info1054) {
1797                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1054(ndr, NDR_SCALARS, r->info1054));
1798                                 }
1799                         break;
1800
1801                         case 1055:
1802                                 if (r->info1055) {
1803                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1055(ndr, NDR_SCALARS, r->info1055));
1804                                 }
1805                         break;
1806
1807                         case 1056:
1808                                 if (r->info1056) {
1809                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1056(ndr, NDR_SCALARS, r->info1056));
1810                                 }
1811                         break;
1812
1813                         case 1057:
1814                                 if (r->info1057) {
1815                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1057(ndr, NDR_SCALARS, r->info1057));
1816                                 }
1817                         break;
1818
1819                         case 1058:
1820                                 if (r->info1058) {
1821                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1058(ndr, NDR_SCALARS, r->info1058));
1822                                 }
1823                         break;
1824
1825                         case 1059:
1826                                 if (r->info1059) {
1827                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1059(ndr, NDR_SCALARS, r->info1059));
1828                                 }
1829                         break;
1830
1831                         case 1060:
1832                                 if (r->info1060) {
1833                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1060(ndr, NDR_SCALARS, r->info1060));
1834                                 }
1835                         break;
1836
1837                         case 1061:
1838                                 if (r->info1061) {
1839                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1061(ndr, NDR_SCALARS, r->info1061));
1840                                 }
1841                         break;
1842
1843                         case 1062:
1844                                 if (r->info1062) {
1845                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1062(ndr, NDR_SCALARS, r->info1062));
1846                                 }
1847                         break;
1848
1849                         default:
1850                         break;
1851
1852                 }
1853         }
1854         return NDR_ERR_SUCCESS;
1855 }
1856
1857 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetWkstaInfo *r)
1858 {
1859         int level;
1860         uint32_t _level;
1861         TALLOC_CTX *_mem_save_info100_0;
1862         TALLOC_CTX *_mem_save_info101_0;
1863         TALLOC_CTX *_mem_save_info102_0;
1864         TALLOC_CTX *_mem_save_info502_0;
1865         TALLOC_CTX *_mem_save_info1010_0;
1866         TALLOC_CTX *_mem_save_info1011_0;
1867         TALLOC_CTX *_mem_save_info1012_0;
1868         TALLOC_CTX *_mem_save_info1013_0;
1869         TALLOC_CTX *_mem_save_info1018_0;
1870         TALLOC_CTX *_mem_save_info1023_0;
1871         TALLOC_CTX *_mem_save_info1027_0;
1872         TALLOC_CTX *_mem_save_info1028_0;
1873         TALLOC_CTX *_mem_save_info1032_0;
1874         TALLOC_CTX *_mem_save_info1033_0;
1875         TALLOC_CTX *_mem_save_info1041_0;
1876         TALLOC_CTX *_mem_save_info1042_0;
1877         TALLOC_CTX *_mem_save_info1043_0;
1878         TALLOC_CTX *_mem_save_info1044_0;
1879         TALLOC_CTX *_mem_save_info1045_0;
1880         TALLOC_CTX *_mem_save_info1046_0;
1881         TALLOC_CTX *_mem_save_info1047_0;
1882         TALLOC_CTX *_mem_save_info1048_0;
1883         TALLOC_CTX *_mem_save_info1049_0;
1884         TALLOC_CTX *_mem_save_info1050_0;
1885         TALLOC_CTX *_mem_save_info1051_0;
1886         TALLOC_CTX *_mem_save_info1052_0;
1887         TALLOC_CTX *_mem_save_info1053_0;
1888         TALLOC_CTX *_mem_save_info1054_0;
1889         TALLOC_CTX *_mem_save_info1055_0;
1890         TALLOC_CTX *_mem_save_info1056_0;
1891         TALLOC_CTX *_mem_save_info1057_0;
1892         TALLOC_CTX *_mem_save_info1058_0;
1893         TALLOC_CTX *_mem_save_info1059_0;
1894         TALLOC_CTX *_mem_save_info1060_0;
1895         TALLOC_CTX *_mem_save_info1061_0;
1896         TALLOC_CTX *_mem_save_info1062_0;
1897         level = ndr_pull_get_switch_value(ndr, r);
1898         if (ndr_flags & NDR_SCALARS) {
1899                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
1900                 if (_level != level) {
1901                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1902                 }
1903                 switch (level) {
1904                         case 100: {
1905                                 uint32_t _ptr_info100;
1906                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info100));
1907                                 if (_ptr_info100) {
1908                                         NDR_PULL_ALLOC(ndr, r->info100);
1909                                 } else {
1910                                         r->info100 = NULL;
1911                                 }
1912                         break; }
1913
1914                         case 101: {
1915                                 uint32_t _ptr_info101;
1916                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info101));
1917                                 if (_ptr_info101) {
1918                                         NDR_PULL_ALLOC(ndr, r->info101);
1919                                 } else {
1920                                         r->info101 = NULL;
1921                                 }
1922                         break; }
1923
1924                         case 102: {
1925                                 uint32_t _ptr_info102;
1926                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info102));
1927                                 if (_ptr_info102) {
1928                                         NDR_PULL_ALLOC(ndr, r->info102);
1929                                 } else {
1930                                         r->info102 = NULL;
1931                                 }
1932                         break; }
1933
1934                         case 502: {
1935                                 uint32_t _ptr_info502;
1936                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info502));
1937                                 if (_ptr_info502) {
1938                                         NDR_PULL_ALLOC(ndr, r->info502);
1939                                 } else {
1940                                         r->info502 = NULL;
1941                                 }
1942                         break; }
1943
1944                         case 1010: {
1945                                 uint32_t _ptr_info1010;
1946                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1010));
1947                                 if (_ptr_info1010) {
1948                                         NDR_PULL_ALLOC(ndr, r->info1010);
1949                                 } else {
1950                                         r->info1010 = NULL;
1951                                 }
1952                         break; }
1953
1954                         case 1011: {
1955                                 uint32_t _ptr_info1011;
1956                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1011));
1957                                 if (_ptr_info1011) {
1958                                         NDR_PULL_ALLOC(ndr, r->info1011);
1959                                 } else {
1960                                         r->info1011 = NULL;
1961                                 }
1962                         break; }
1963
1964                         case 1012: {
1965                                 uint32_t _ptr_info1012;
1966                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1012));
1967                                 if (_ptr_info1012) {
1968                                         NDR_PULL_ALLOC(ndr, r->info1012);
1969                                 } else {
1970                                         r->info1012 = NULL;
1971                                 }
1972                         break; }
1973
1974                         case 1013: {
1975                                 uint32_t _ptr_info1013;
1976                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1013));
1977                                 if (_ptr_info1013) {
1978                                         NDR_PULL_ALLOC(ndr, r->info1013);
1979                                 } else {
1980                                         r->info1013 = NULL;
1981                                 }
1982                         break; }
1983
1984                         case 1018: {
1985                                 uint32_t _ptr_info1018;
1986                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1018));
1987                                 if (_ptr_info1018) {
1988                                         NDR_PULL_ALLOC(ndr, r->info1018);
1989                                 } else {
1990                                         r->info1018 = NULL;
1991                                 }
1992                         break; }
1993
1994                         case 1023: {
1995                                 uint32_t _ptr_info1023;
1996                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1023));
1997                                 if (_ptr_info1023) {
1998                                         NDR_PULL_ALLOC(ndr, r->info1023);
1999                                 } else {
2000                                         r->info1023 = NULL;
2001                                 }
2002                         break; }
2003
2004                         case 1027: {
2005                                 uint32_t _ptr_info1027;
2006                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1027));
2007                                 if (_ptr_info1027) {
2008                                         NDR_PULL_ALLOC(ndr, r->info1027);
2009                                 } else {
2010                                         r->info1027 = NULL;
2011                                 }
2012                         break; }
2013
2014                         case 1028: {
2015                                 uint32_t _ptr_info1028;
2016                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1028));
2017                                 if (_ptr_info1028) {
2018                                         NDR_PULL_ALLOC(ndr, r->info1028);
2019                                 } else {
2020                                         r->info1028 = NULL;
2021                                 }
2022                         break; }
2023
2024                         case 1032: {
2025                                 uint32_t _ptr_info1032;
2026                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1032));
2027                                 if (_ptr_info1032) {
2028                                         NDR_PULL_ALLOC(ndr, r->info1032);
2029                                 } else {
2030                                         r->info1032 = NULL;
2031                                 }
2032                         break; }
2033
2034                         case 1033: {
2035                                 uint32_t _ptr_info1033;
2036                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1033));
2037                                 if (_ptr_info1033) {
2038                                         NDR_PULL_ALLOC(ndr, r->info1033);
2039                                 } else {
2040                                         r->info1033 = NULL;
2041                                 }
2042                         break; }
2043
2044                         case 1041: {
2045                                 uint32_t _ptr_info1041;
2046                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1041));
2047                                 if (_ptr_info1041) {
2048                                         NDR_PULL_ALLOC(ndr, r->info1041);
2049                                 } else {
2050                                         r->info1041 = NULL;
2051                                 }
2052                         break; }
2053
2054                         case 1042: {
2055                                 uint32_t _ptr_info1042;
2056                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1042));
2057                                 if (_ptr_info1042) {
2058                                         NDR_PULL_ALLOC(ndr, r->info1042);
2059                                 } else {
2060                                         r->info1042 = NULL;
2061                                 }
2062                         break; }
2063
2064                         case 1043: {
2065                                 uint32_t _ptr_info1043;
2066                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1043));
2067                                 if (_ptr_info1043) {
2068                                         NDR_PULL_ALLOC(ndr, r->info1043);
2069                                 } else {
2070                                         r->info1043 = NULL;
2071                                 }
2072                         break; }
2073
2074                         case 1044: {
2075                                 uint32_t _ptr_info1044;
2076                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1044));
2077                                 if (_ptr_info1044) {
2078                                         NDR_PULL_ALLOC(ndr, r->info1044);
2079                                 } else {
2080                                         r->info1044 = NULL;
2081                                 }
2082                         break; }
2083
2084                         case 1045: {
2085                                 uint32_t _ptr_info1045;
2086                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1045));
2087                                 if (_ptr_info1045) {
2088                                         NDR_PULL_ALLOC(ndr, r->info1045);
2089                                 } else {
2090                                         r->info1045 = NULL;
2091                                 }
2092                         break; }
2093
2094                         case 1046: {
2095                                 uint32_t _ptr_info1046;
2096                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1046));
2097                                 if (_ptr_info1046) {
2098                                         NDR_PULL_ALLOC(ndr, r->info1046);
2099                                 } else {
2100                                         r->info1046 = NULL;
2101                                 }
2102                         break; }
2103
2104                         case 1047: {
2105                                 uint32_t _ptr_info1047;
2106                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1047));
2107                                 if (_ptr_info1047) {
2108                                         NDR_PULL_ALLOC(ndr, r->info1047);
2109                                 } else {
2110                                         r->info1047 = NULL;
2111                                 }
2112                         break; }
2113
2114                         case 1048: {
2115                                 uint32_t _ptr_info1048;
2116                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1048));
2117                                 if (_ptr_info1048) {
2118                                         NDR_PULL_ALLOC(ndr, r->info1048);
2119                                 } else {
2120                                         r->info1048 = NULL;
2121                                 }
2122                         break; }
2123
2124                         case 1049: {
2125                                 uint32_t _ptr_info1049;
2126                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1049));
2127                                 if (_ptr_info1049) {
2128                                         NDR_PULL_ALLOC(ndr, r->info1049);
2129                                 } else {
2130                                         r->info1049 = NULL;
2131                                 }
2132                         break; }
2133
2134                         case 1050: {
2135                                 uint32_t _ptr_info1050;
2136                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1050));
2137                                 if (_ptr_info1050) {
2138                                         NDR_PULL_ALLOC(ndr, r->info1050);
2139                                 } else {
2140                                         r->info1050 = NULL;
2141                                 }
2142                         break; }
2143
2144                         case 1051: {
2145                                 uint32_t _ptr_info1051;
2146                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1051));
2147                                 if (_ptr_info1051) {
2148                                         NDR_PULL_ALLOC(ndr, r->info1051);
2149                                 } else {
2150                                         r->info1051 = NULL;
2151                                 }
2152                         break; }
2153
2154                         case 1052: {
2155                                 uint32_t _ptr_info1052;
2156                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1052));
2157                                 if (_ptr_info1052) {
2158                                         NDR_PULL_ALLOC(ndr, r->info1052);
2159                                 } else {
2160                                         r->info1052 = NULL;
2161                                 }
2162                         break; }
2163
2164                         case 1053: {
2165                                 uint32_t _ptr_info1053;
2166                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1053));
2167                                 if (_ptr_info1053) {
2168                                         NDR_PULL_ALLOC(ndr, r->info1053);
2169                                 } else {
2170                                         r->info1053 = NULL;
2171                                 }
2172                         break; }
2173
2174                         case 1054: {
2175                                 uint32_t _ptr_info1054;
2176                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1054));
2177                                 if (_ptr_info1054) {
2178                                         NDR_PULL_ALLOC(ndr, r->info1054);
2179                                 } else {
2180                                         r->info1054 = NULL;
2181                                 }
2182                         break; }
2183
2184                         case 1055: {
2185                                 uint32_t _ptr_info1055;
2186                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1055));
2187                                 if (_ptr_info1055) {
2188                                         NDR_PULL_ALLOC(ndr, r->info1055);
2189                                 } else {
2190                                         r->info1055 = NULL;
2191                                 }
2192                         break; }
2193
2194                         case 1056: {
2195                                 uint32_t _ptr_info1056;
2196                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1056));
2197                                 if (_ptr_info1056) {
2198                                         NDR_PULL_ALLOC(ndr, r->info1056);
2199                                 } else {
2200                                         r->info1056 = NULL;
2201                                 }
2202                         break; }
2203
2204                         case 1057: {
2205                                 uint32_t _ptr_info1057;
2206                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1057));
2207                                 if (_ptr_info1057) {
2208                                         NDR_PULL_ALLOC(ndr, r->info1057);
2209                                 } else {
2210                                         r->info1057 = NULL;
2211                                 }
2212                         break; }
2213
2214                         case 1058: {
2215                                 uint32_t _ptr_info1058;
2216                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1058));
2217                                 if (_ptr_info1058) {
2218                                         NDR_PULL_ALLOC(ndr, r->info1058);
2219                                 } else {
2220                                         r->info1058 = NULL;
2221                                 }
2222                         break; }
2223
2224                         case 1059: {
2225                                 uint32_t _ptr_info1059;
2226                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1059));
2227                                 if (_ptr_info1059) {
2228                                         NDR_PULL_ALLOC(ndr, r->info1059);
2229                                 } else {
2230                                         r->info1059 = NULL;
2231                                 }
2232                         break; }
2233
2234                         case 1060: {
2235                                 uint32_t _ptr_info1060;
2236                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1060));
2237                                 if (_ptr_info1060) {
2238                                         NDR_PULL_ALLOC(ndr, r->info1060);
2239                                 } else {
2240                                         r->info1060 = NULL;
2241                                 }
2242                         break; }
2243
2244                         case 1061: {
2245                                 uint32_t _ptr_info1061;
2246                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1061));
2247                                 if (_ptr_info1061) {
2248                                         NDR_PULL_ALLOC(ndr, r->info1061);
2249                                 } else {
2250                                         r->info1061 = NULL;
2251                                 }
2252                         break; }
2253
2254                         case 1062: {
2255                                 uint32_t _ptr_info1062;
2256                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1062));
2257                                 if (_ptr_info1062) {
2258                                         NDR_PULL_ALLOC(ndr, r->info1062);
2259                                 } else {
2260                                         r->info1062 = NULL;
2261                                 }
2262                         break; }
2263
2264                         default: {
2265                         break; }
2266
2267                 }
2268         }
2269         if (ndr_flags & NDR_BUFFERS) {
2270                 switch (level) {
2271                         case 100:
2272                                 if (r->info100) {
2273                                         _mem_save_info100_0 = NDR_PULL_GET_MEM_CTX(ndr);
2274                                         NDR_PULL_SET_MEM_CTX(ndr, r->info100, 0);
2275                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo100(ndr, NDR_SCALARS|NDR_BUFFERS, r->info100));
2276                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info100_0, 0);
2277                                 }
2278                         break;
2279
2280                         case 101:
2281                                 if (r->info101) {
2282                                         _mem_save_info101_0 = NDR_PULL_GET_MEM_CTX(ndr);
2283                                         NDR_PULL_SET_MEM_CTX(ndr, r->info101, 0);
2284                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info101));
2285                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info101_0, 0);
2286                                 }
2287                         break;
2288
2289                         case 102:
2290                                 if (r->info102) {
2291                                         _mem_save_info102_0 = NDR_PULL_GET_MEM_CTX(ndr);
2292                                         NDR_PULL_SET_MEM_CTX(ndr, r->info102, 0);
2293                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo102(ndr, NDR_SCALARS|NDR_BUFFERS, r->info102));
2294                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info102_0, 0);
2295                                 }
2296                         break;
2297
2298                         case 502:
2299                                 if (r->info502) {
2300                                         _mem_save_info502_0 = NDR_PULL_GET_MEM_CTX(ndr);
2301                                         NDR_PULL_SET_MEM_CTX(ndr, r->info502, 0);
2302                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo502(ndr, NDR_SCALARS, r->info502));
2303                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info502_0, 0);
2304                                 }
2305                         break;
2306
2307                         case 1010:
2308                                 if (r->info1010) {
2309                                         _mem_save_info1010_0 = NDR_PULL_GET_MEM_CTX(ndr);
2310                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1010, 0);
2311                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1010(ndr, NDR_SCALARS, r->info1010));
2312                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1010_0, 0);
2313                                 }
2314                         break;
2315
2316                         case 1011:
2317                                 if (r->info1011) {
2318                                         _mem_save_info1011_0 = NDR_PULL_GET_MEM_CTX(ndr);
2319                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1011, 0);
2320                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1011(ndr, NDR_SCALARS, r->info1011));
2321                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1011_0, 0);
2322                                 }
2323                         break;
2324
2325                         case 1012:
2326                                 if (r->info1012) {
2327                                         _mem_save_info1012_0 = NDR_PULL_GET_MEM_CTX(ndr);
2328                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1012, 0);
2329                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1012(ndr, NDR_SCALARS, r->info1012));
2330                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1012_0, 0);
2331                                 }
2332                         break;
2333
2334                         case 1013:
2335                                 if (r->info1013) {
2336                                         _mem_save_info1013_0 = NDR_PULL_GET_MEM_CTX(ndr);
2337                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1013, 0);
2338                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1013(ndr, NDR_SCALARS, r->info1013));
2339                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1013_0, 0);
2340                                 }
2341                         break;
2342
2343                         case 1018:
2344                                 if (r->info1018) {
2345                                         _mem_save_info1018_0 = NDR_PULL_GET_MEM_CTX(ndr);
2346                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1018, 0);
2347                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1018(ndr, NDR_SCALARS, r->info1018));
2348                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1018_0, 0);
2349                                 }
2350                         break;
2351
2352                         case 1023:
2353                                 if (r->info1023) {
2354                                         _mem_save_info1023_0 = NDR_PULL_GET_MEM_CTX(ndr);
2355                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1023, 0);
2356                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1023(ndr, NDR_SCALARS, r->info1023));
2357                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1023_0, 0);
2358                                 }
2359                         break;
2360
2361                         case 1027:
2362                                 if (r->info1027) {
2363                                         _mem_save_info1027_0 = NDR_PULL_GET_MEM_CTX(ndr);
2364                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1027, 0);
2365                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1027(ndr, NDR_SCALARS, r->info1027));
2366                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1027_0, 0);
2367                                 }
2368                         break;
2369
2370                         case 1028:
2371                                 if (r->info1028) {
2372                                         _mem_save_info1028_0 = NDR_PULL_GET_MEM_CTX(ndr);
2373                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1028, 0);
2374                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1028(ndr, NDR_SCALARS, r->info1028));
2375                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1028_0, 0);
2376                                 }
2377                         break;
2378
2379                         case 1032:
2380                                 if (r->info1032) {
2381                                         _mem_save_info1032_0 = NDR_PULL_GET_MEM_CTX(ndr);
2382                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1032, 0);
2383                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1032(ndr, NDR_SCALARS, r->info1032));
2384                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1032_0, 0);
2385                                 }
2386                         break;
2387
2388                         case 1033:
2389                                 if (r->info1033) {
2390                                         _mem_save_info1033_0 = NDR_PULL_GET_MEM_CTX(ndr);
2391                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1033, 0);
2392                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1033(ndr, NDR_SCALARS, r->info1033));
2393                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1033_0, 0);
2394                                 }
2395                         break;
2396
2397                         case 1041:
2398                                 if (r->info1041) {
2399                                         _mem_save_info1041_0 = NDR_PULL_GET_MEM_CTX(ndr);
2400                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1041, 0);
2401                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1041(ndr, NDR_SCALARS, r->info1041));
2402                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1041_0, 0);
2403                                 }
2404                         break;
2405
2406                         case 1042:
2407                                 if (r->info1042) {
2408                                         _mem_save_info1042_0 = NDR_PULL_GET_MEM_CTX(ndr);
2409                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1042, 0);
2410                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1042(ndr, NDR_SCALARS, r->info1042));
2411                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1042_0, 0);
2412                                 }
2413                         break;
2414
2415                         case 1043:
2416                                 if (r->info1043) {
2417                                         _mem_save_info1043_0 = NDR_PULL_GET_MEM_CTX(ndr);
2418                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1043, 0);
2419                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1043(ndr, NDR_SCALARS, r->info1043));
2420                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1043_0, 0);
2421                                 }
2422                         break;
2423
2424                         case 1044:
2425                                 if (r->info1044) {
2426                                         _mem_save_info1044_0 = NDR_PULL_GET_MEM_CTX(ndr);
2427                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1044, 0);
2428                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1044(ndr, NDR_SCALARS, r->info1044));
2429                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1044_0, 0);
2430                                 }
2431                         break;
2432
2433                         case 1045:
2434                                 if (r->info1045) {
2435                                         _mem_save_info1045_0 = NDR_PULL_GET_MEM_CTX(ndr);
2436                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1045, 0);
2437                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1045(ndr, NDR_SCALARS, r->info1045));
2438                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1045_0, 0);
2439                                 }
2440                         break;
2441
2442                         case 1046:
2443                                 if (r->info1046) {
2444                                         _mem_save_info1046_0 = NDR_PULL_GET_MEM_CTX(ndr);
2445                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1046, 0);
2446                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1046(ndr, NDR_SCALARS, r->info1046));
2447                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1046_0, 0);
2448                                 }
2449                         break;
2450
2451                         case 1047:
2452                                 if (r->info1047) {
2453                                         _mem_save_info1047_0 = NDR_PULL_GET_MEM_CTX(ndr);
2454                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1047, 0);
2455                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1047(ndr, NDR_SCALARS, r->info1047));
2456                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1047_0, 0);
2457                                 }
2458                         break;
2459
2460                         case 1048:
2461                                 if (r->info1048) {
2462                                         _mem_save_info1048_0 = NDR_PULL_GET_MEM_CTX(ndr);
2463                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1048, 0);
2464                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1048(ndr, NDR_SCALARS, r->info1048));
2465                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1048_0, 0);
2466                                 }
2467                         break;
2468
2469                         case 1049:
2470                                 if (r->info1049) {
2471                                         _mem_save_info1049_0 = NDR_PULL_GET_MEM_CTX(ndr);
2472                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1049, 0);
2473                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1049(ndr, NDR_SCALARS, r->info1049));
2474                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1049_0, 0);
2475                                 }
2476                         break;
2477
2478                         case 1050:
2479                                 if (r->info1050) {
2480                                         _mem_save_info1050_0 = NDR_PULL_GET_MEM_CTX(ndr);
2481                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1050, 0);
2482                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1050(ndr, NDR_SCALARS, r->info1050));
2483                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1050_0, 0);
2484                                 }
2485                         break;
2486
2487                         case 1051:
2488                                 if (r->info1051) {
2489                                         _mem_save_info1051_0 = NDR_PULL_GET_MEM_CTX(ndr);
2490                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1051, 0);
2491                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1051(ndr, NDR_SCALARS, r->info1051));
2492                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1051_0, 0);
2493                                 }
2494                         break;
2495
2496                         case 1052:
2497                                 if (r->info1052) {
2498                                         _mem_save_info1052_0 = NDR_PULL_GET_MEM_CTX(ndr);
2499                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1052, 0);
2500                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1052(ndr, NDR_SCALARS, r->info1052));
2501                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1052_0, 0);
2502                                 }
2503                         break;
2504
2505                         case 1053:
2506                                 if (r->info1053) {
2507                                         _mem_save_info1053_0 = NDR_PULL_GET_MEM_CTX(ndr);
2508                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1053, 0);
2509                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1053(ndr, NDR_SCALARS, r->info1053));
2510                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1053_0, 0);
2511                                 }
2512                         break;
2513
2514                         case 1054:
2515                                 if (r->info1054) {
2516                                         _mem_save_info1054_0 = NDR_PULL_GET_MEM_CTX(ndr);
2517                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1054, 0);
2518                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1054(ndr, NDR_SCALARS, r->info1054));
2519                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1054_0, 0);
2520                                 }
2521                         break;
2522
2523                         case 1055:
2524                                 if (r->info1055) {
2525                                         _mem_save_info1055_0 = NDR_PULL_GET_MEM_CTX(ndr);
2526                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1055, 0);
2527                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1055(ndr, NDR_SCALARS, r->info1055));
2528                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1055_0, 0);
2529                                 }
2530                         break;
2531
2532                         case 1056:
2533                                 if (r->info1056) {
2534                                         _mem_save_info1056_0 = NDR_PULL_GET_MEM_CTX(ndr);
2535                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1056, 0);
2536                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1056(ndr, NDR_SCALARS, r->info1056));
2537                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1056_0, 0);
2538                                 }
2539                         break;
2540
2541                         case 1057:
2542                                 if (r->info1057) {
2543                                         _mem_save_info1057_0 = NDR_PULL_GET_MEM_CTX(ndr);
2544                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1057, 0);
2545                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1057(ndr, NDR_SCALARS, r->info1057));
2546                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1057_0, 0);
2547                                 }
2548                         break;
2549
2550                         case 1058:
2551                                 if (r->info1058) {
2552                                         _mem_save_info1058_0 = NDR_PULL_GET_MEM_CTX(ndr);
2553                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1058, 0);
2554                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1058(ndr, NDR_SCALARS, r->info1058));
2555                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1058_0, 0);
2556                                 }
2557                         break;
2558
2559                         case 1059:
2560                                 if (r->info1059) {
2561                                         _mem_save_info1059_0 = NDR_PULL_GET_MEM_CTX(ndr);
2562                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1059, 0);
2563                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1059(ndr, NDR_SCALARS, r->info1059));
2564                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1059_0, 0);
2565                                 }
2566                         break;
2567
2568                         case 1060:
2569                                 if (r->info1060) {
2570                                         _mem_save_info1060_0 = NDR_PULL_GET_MEM_CTX(ndr);
2571                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1060, 0);
2572                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1060(ndr, NDR_SCALARS, r->info1060));
2573                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1060_0, 0);
2574                                 }
2575                         break;
2576
2577                         case 1061:
2578                                 if (r->info1061) {
2579                                         _mem_save_info1061_0 = NDR_PULL_GET_MEM_CTX(ndr);
2580                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1061, 0);
2581                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1061(ndr, NDR_SCALARS, r->info1061));
2582                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1061_0, 0);
2583                                 }
2584                         break;
2585
2586                         case 1062:
2587                                 if (r->info1062) {
2588                                         _mem_save_info1062_0 = NDR_PULL_GET_MEM_CTX(ndr);
2589                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1062, 0);
2590                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1062(ndr, NDR_SCALARS, r->info1062));
2591                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1062_0, 0);
2592                                 }
2593                         break;
2594
2595                         default:
2596                         break;
2597
2598                 }
2599         }
2600         return NDR_ERR_SUCCESS;
2601 }
2602
2603 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo(struct ndr_print *ndr, const char *name, const union wkssvc_NetWkstaInfo *r)
2604 {
2605         int level;
2606         level = ndr_print_get_switch_value(ndr, r);
2607         ndr_print_union(ndr, name, level, "wkssvc_NetWkstaInfo");
2608         switch (level) {
2609                 case 100:
2610                         ndr_print_ptr(ndr, "info100", r->info100);
2611                         ndr->depth++;
2612                         if (r->info100) {
2613                                 ndr_print_wkssvc_NetWkstaInfo100(ndr, "info100", r->info100);
2614                         }
2615                         ndr->depth--;
2616                 break;
2617
2618                 case 101:
2619                         ndr_print_ptr(ndr, "info101", r->info101);
2620                         ndr->depth++;
2621                         if (r->info101) {
2622                                 ndr_print_wkssvc_NetWkstaInfo101(ndr, "info101", r->info101);
2623                         }
2624                         ndr->depth--;
2625                 break;
2626
2627                 case 102:
2628                         ndr_print_ptr(ndr, "info102", r->info102);
2629                         ndr->depth++;
2630                         if (r->info102) {
2631                                 ndr_print_wkssvc_NetWkstaInfo102(ndr, "info102", r->info102);
2632                         }
2633                         ndr->depth--;
2634                 break;
2635
2636                 case 502:
2637                         ndr_print_ptr(ndr, "info502", r->info502);
2638                         ndr->depth++;
2639                         if (r->info502) {
2640                                 ndr_print_wkssvc_NetWkstaInfo502(ndr, "info502", r->info502);
2641                         }
2642                         ndr->depth--;
2643                 break;
2644
2645                 case 1010:
2646                         ndr_print_ptr(ndr, "info1010", r->info1010);
2647                         ndr->depth++;
2648                         if (r->info1010) {
2649                                 ndr_print_wkssvc_NetWkstaInfo1010(ndr, "info1010", r->info1010);
2650                         }
2651                         ndr->depth--;
2652                 break;
2653
2654                 case 1011:
2655                         ndr_print_ptr(ndr, "info1011", r->info1011);
2656                         ndr->depth++;
2657                         if (r->info1011) {
2658                                 ndr_print_wkssvc_NetWkstaInfo1011(ndr, "info1011", r->info1011);
2659                         }
2660                         ndr->depth--;
2661                 break;
2662
2663                 case 1012:
2664                         ndr_print_ptr(ndr, "info1012", r->info1012);
2665                         ndr->depth++;
2666                         if (r->info1012) {
2667                                 ndr_print_wkssvc_NetWkstaInfo1012(ndr, "info1012", r->info1012);
2668                         }
2669                         ndr->depth--;
2670                 break;
2671
2672                 case 1013:
2673                         ndr_print_ptr(ndr, "info1013", r->info1013);
2674                         ndr->depth++;
2675                         if (r->info1013) {
2676                                 ndr_print_wkssvc_NetWkstaInfo1013(ndr, "info1013", r->info1013);
2677                         }
2678                         ndr->depth--;
2679                 break;
2680
2681                 case 1018:
2682                         ndr_print_ptr(ndr, "info1018", r->info1018);
2683                         ndr->depth++;
2684                         if (r->info1018) {
2685                                 ndr_print_wkssvc_NetWkstaInfo1018(ndr, "info1018", r->info1018);
2686                         }
2687                         ndr->depth--;
2688                 break;
2689
2690                 case 1023:
2691                         ndr_print_ptr(ndr, "info1023", r->info1023);
2692                         ndr->depth++;
2693                         if (r->info1023) {
2694                                 ndr_print_wkssvc_NetWkstaInfo1023(ndr, "info1023", r->info1023);
2695                         }
2696                         ndr->depth--;
2697                 break;
2698
2699                 case 1027:
2700                         ndr_print_ptr(ndr, "info1027", r->info1027);
2701                         ndr->depth++;
2702                         if (r->info1027) {
2703                                 ndr_print_wkssvc_NetWkstaInfo1027(ndr, "info1027", r->info1027);
2704                         }
2705                         ndr->depth--;
2706                 break;
2707
2708                 case 1028:
2709                         ndr_print_ptr(ndr, "info1028", r->info1028);
2710                         ndr->depth++;
2711                         if (r->info1028) {
2712                                 ndr_print_wkssvc_NetWkstaInfo1028(ndr, "info1028", r->info1028);
2713                         }
2714                         ndr->depth--;
2715                 break;
2716
2717                 case 1032:
2718                         ndr_print_ptr(ndr, "info1032", r->info1032);
2719                         ndr->depth++;
2720                         if (r->info1032) {
2721                                 ndr_print_wkssvc_NetWkstaInfo1032(ndr, "info1032", r->info1032);
2722                         }
2723                         ndr->depth--;
2724                 break;
2725
2726                 case 1033:
2727                         ndr_print_ptr(ndr, "info1033", r->info1033);
2728                         ndr->depth++;
2729                         if (r->info1033) {
2730                                 ndr_print_wkssvc_NetWkstaInfo1033(ndr, "info1033", r->info1033);
2731                         }
2732                         ndr->depth--;
2733                 break;
2734
2735                 case 1041:
2736                         ndr_print_ptr(ndr, "info1041", r->info1041);
2737                         ndr->depth++;
2738                         if (r->info1041) {
2739                                 ndr_print_wkssvc_NetWkstaInfo1041(ndr, "info1041", r->info1041);
2740                         }
2741                         ndr->depth--;
2742                 break;
2743
2744                 case 1042:
2745                         ndr_print_ptr(ndr, "info1042", r->info1042);
2746                         ndr->depth++;
2747                         if (r->info1042) {
2748                                 ndr_print_wkssvc_NetWkstaInfo1042(ndr, "info1042", r->info1042);
2749                         }
2750                         ndr->depth--;
2751                 break;
2752
2753                 case 1043:
2754                         ndr_print_ptr(ndr, "info1043", r->info1043);
2755                         ndr->depth++;
2756                         if (r->info1043) {
2757                                 ndr_print_wkssvc_NetWkstaInfo1043(ndr, "info1043", r->info1043);
2758                         }
2759                         ndr->depth--;
2760                 break;
2761
2762                 case 1044:
2763                         ndr_print_ptr(ndr, "info1044", r->info1044);
2764                         ndr->depth++;
2765                         if (r->info1044) {
2766                                 ndr_print_wkssvc_NetWkstaInfo1044(ndr, "info1044", r->info1044);
2767                         }
2768                         ndr->depth--;
2769                 break;
2770
2771                 case 1045:
2772                         ndr_print_ptr(ndr, "info1045", r->info1045);
2773                         ndr->depth++;
2774                         if (r->info1045) {
2775                                 ndr_print_wkssvc_NetWkstaInfo1045(ndr, "info1045", r->info1045);
2776                         }
2777                         ndr->depth--;
2778                 break;
2779
2780                 case 1046:
2781                         ndr_print_ptr(ndr, "info1046", r->info1046);
2782                         ndr->depth++;
2783                         if (r->info1046) {
2784                                 ndr_print_wkssvc_NetWkstaInfo1046(ndr, "info1046", r->info1046);
2785                         }
2786                         ndr->depth--;
2787                 break;
2788
2789                 case 1047:
2790                         ndr_print_ptr(ndr, "info1047", r->info1047);
2791                         ndr->depth++;
2792                         if (r->info1047) {
2793                                 ndr_print_wkssvc_NetWkstaInfo1047(ndr, "info1047", r->info1047);
2794                         }
2795                         ndr->depth--;
2796                 break;
2797
2798                 case 1048:
2799                         ndr_print_ptr(ndr, "info1048", r->info1048);
2800                         ndr->depth++;
2801                         if (r->info1048) {
2802                                 ndr_print_wkssvc_NetWkstaInfo1048(ndr, "info1048", r->info1048);
2803                         }
2804                         ndr->depth--;
2805                 break;
2806
2807                 case 1049:
2808                         ndr_print_ptr(ndr, "info1049", r->info1049);
2809                         ndr->depth++;
2810                         if (r->info1049) {
2811                                 ndr_print_wkssvc_NetWkstaInfo1049(ndr, "info1049", r->info1049);
2812                         }
2813                         ndr->depth--;
2814                 break;
2815
2816                 case 1050:
2817                         ndr_print_ptr(ndr, "info1050", r->info1050);
2818                         ndr->depth++;
2819                         if (r->info1050) {
2820                                 ndr_print_wkssvc_NetWkstaInfo1050(ndr, "info1050", r->info1050);
2821                         }
2822                         ndr->depth--;
2823                 break;
2824
2825                 case 1051:
2826                         ndr_print_ptr(ndr, "info1051", r->info1051);
2827                         ndr->depth++;
2828                         if (r->info1051) {
2829                                 ndr_print_wkssvc_NetWkstaInfo1051(ndr, "info1051", r->info1051);
2830                         }
2831                         ndr->depth--;
2832                 break;
2833
2834                 case 1052:
2835                         ndr_print_ptr(ndr, "info1052", r->info1052);
2836                         ndr->depth++;
2837                         if (r->info1052) {
2838                                 ndr_print_wkssvc_NetWkstaInfo1052(ndr, "info1052", r->info1052);
2839                         }
2840                         ndr->depth--;
2841                 break;
2842
2843                 case 1053:
2844                         ndr_print_ptr(ndr, "info1053", r->info1053);
2845                         ndr->depth++;
2846                         if (r->info1053) {
2847                                 ndr_print_wkssvc_NetWkstaInfo1053(ndr, "info1053", r->info1053);
2848                         }
2849                         ndr->depth--;
2850                 break;
2851
2852                 case 1054:
2853                         ndr_print_ptr(ndr, "info1054", r->info1054);
2854                         ndr->depth++;
2855                         if (r->info1054) {
2856                                 ndr_print_wkssvc_NetWkstaInfo1054(ndr, "info1054", r->info1054);
2857                         }
2858                         ndr->depth--;
2859                 break;
2860
2861                 case 1055:
2862                         ndr_print_ptr(ndr, "info1055", r->info1055);
2863                         ndr->depth++;
2864                         if (r->info1055) {
2865                                 ndr_print_wkssvc_NetWkstaInfo1055(ndr, "info1055", r->info1055);
2866                         }
2867                         ndr->depth--;
2868                 break;
2869
2870                 case 1056:
2871                         ndr_print_ptr(ndr, "info1056", r->info1056);
2872                         ndr->depth++;
2873                         if (r->info1056) {
2874                                 ndr_print_wkssvc_NetWkstaInfo1056(ndr, "info1056", r->info1056);
2875                         }
2876                         ndr->depth--;
2877                 break;
2878
2879                 case 1057:
2880                         ndr_print_ptr(ndr, "info1057", r->info1057);
2881                         ndr->depth++;
2882                         if (r->info1057) {
2883                                 ndr_print_wkssvc_NetWkstaInfo1057(ndr, "info1057", r->info1057);
2884                         }
2885                         ndr->depth--;
2886                 break;
2887
2888                 case 1058:
2889                         ndr_print_ptr(ndr, "info1058", r->info1058);
2890                         ndr->depth++;
2891                         if (r->info1058) {
2892                                 ndr_print_wkssvc_NetWkstaInfo1058(ndr, "info1058", r->info1058);
2893                         }
2894                         ndr->depth--;
2895                 break;
2896
2897                 case 1059:
2898                         ndr_print_ptr(ndr, "info1059", r->info1059);
2899                         ndr->depth++;
2900                         if (r->info1059) {
2901                                 ndr_print_wkssvc_NetWkstaInfo1059(ndr, "info1059", r->info1059);
2902                         }
2903                         ndr->depth--;
2904                 break;
2905
2906                 case 1060:
2907                         ndr_print_ptr(ndr, "info1060", r->info1060);
2908                         ndr->depth++;
2909                         if (r->info1060) {
2910                                 ndr_print_wkssvc_NetWkstaInfo1060(ndr, "info1060", r->info1060);
2911                         }
2912                         ndr->depth--;
2913                 break;
2914
2915                 case 1061:
2916                         ndr_print_ptr(ndr, "info1061", r->info1061);
2917                         ndr->depth++;
2918                         if (r->info1061) {
2919                                 ndr_print_wkssvc_NetWkstaInfo1061(ndr, "info1061", r->info1061);
2920                         }
2921                         ndr->depth--;
2922                 break;
2923
2924                 case 1062:
2925                         ndr_print_ptr(ndr, "info1062", r->info1062);
2926                         ndr->depth++;
2927                         if (r->info1062) {
2928                                 ndr_print_wkssvc_NetWkstaInfo1062(ndr, "info1062", r->info1062);
2929                         }
2930                         ndr->depth--;
2931                 break;
2932
2933                 default:
2934                 break;
2935
2936         }
2937 }
2938
2939 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserInfo0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrWkstaUserInfo0 *r)
2940 {
2941         if (ndr_flags & NDR_SCALARS) {
2942                 NDR_CHECK(ndr_push_align(ndr, 4));
2943                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
2944         }
2945         if (ndr_flags & NDR_BUFFERS) {
2946                 if (r->user_name) {
2947                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
2948                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2949                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
2950                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2951                 }
2952         }
2953         return NDR_ERR_SUCCESS;
2954 }
2955
2956 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserInfo0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrWkstaUserInfo0 *r)
2957 {
2958         uint32_t _ptr_user_name;
2959         TALLOC_CTX *_mem_save_user_name_0;
2960         if (ndr_flags & NDR_SCALARS) {
2961                 NDR_CHECK(ndr_pull_align(ndr, 4));
2962                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
2963                 if (_ptr_user_name) {
2964                         NDR_PULL_ALLOC(ndr, r->user_name);
2965                 } else {
2966                         r->user_name = NULL;
2967                 }
2968         }
2969         if (ndr_flags & NDR_BUFFERS) {
2970                 if (r->user_name) {
2971                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2972                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
2973                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
2974                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
2975                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
2976                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
2977                         }
2978                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
2979                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
2980                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
2981                 }
2982         }
2983         return NDR_ERR_SUCCESS;
2984 }
2985
2986 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserInfo0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrWkstaUserInfo0 *r)
2987 {
2988         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaUserInfo0");
2989         ndr->depth++;
2990         ndr_print_ptr(ndr, "user_name", r->user_name);
2991         ndr->depth++;
2992         if (r->user_name) {
2993                 ndr_print_string(ndr, "user_name", r->user_name);
2994         }
2995         ndr->depth--;
2996         ndr->depth--;
2997 }
2998
2999 static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsersCtr0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaEnumUsersCtr0 *r)
3000 {
3001         uint32_t cntr_user0_1;
3002         if (ndr_flags & NDR_SCALARS) {
3003                 NDR_CHECK(ndr_push_align(ndr, 4));
3004                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->entries_read));
3005                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user0));
3006         }
3007         if (ndr_flags & NDR_BUFFERS) {
3008                 if (r->user0) {
3009                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->entries_read));
3010                         for (cntr_user0_1 = 0; cntr_user0_1 < r->entries_read; cntr_user0_1++) {
3011                                 NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo0(ndr, NDR_SCALARS, &r->user0[cntr_user0_1]));
3012                         }
3013                         for (cntr_user0_1 = 0; cntr_user0_1 < r->entries_read; cntr_user0_1++) {
3014                                 NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo0(ndr, NDR_BUFFERS, &r->user0[cntr_user0_1]));
3015                         }
3016                 }
3017         }
3018         return NDR_ERR_SUCCESS;
3019 }
3020
3021 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsersCtr0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaEnumUsersCtr0 *r)
3022 {
3023         uint32_t _ptr_user0;
3024         uint32_t cntr_user0_1;
3025         TALLOC_CTX *_mem_save_user0_0;
3026         TALLOC_CTX *_mem_save_user0_1;
3027         if (ndr_flags & NDR_SCALARS) {
3028                 NDR_CHECK(ndr_pull_align(ndr, 4));
3029                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->entries_read));
3030                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user0));
3031                 if (_ptr_user0) {
3032                         NDR_PULL_ALLOC(ndr, r->user0);
3033                 } else {
3034                         r->user0 = NULL;
3035                 }
3036         }
3037         if (ndr_flags & NDR_BUFFERS) {
3038                 if (r->user0) {
3039                         _mem_save_user0_0 = NDR_PULL_GET_MEM_CTX(ndr);
3040                         NDR_PULL_SET_MEM_CTX(ndr, r->user0, 0);
3041                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user0));
3042                         NDR_PULL_ALLOC_N(ndr, r->user0, ndr_get_array_size(ndr, &r->user0));
3043                         _mem_save_user0_1 = NDR_PULL_GET_MEM_CTX(ndr);
3044                         NDR_PULL_SET_MEM_CTX(ndr, r->user0, 0);
3045                         for (cntr_user0_1 = 0; cntr_user0_1 < r->entries_read; cntr_user0_1++) {
3046                                 NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo0(ndr, NDR_SCALARS, &r->user0[cntr_user0_1]));
3047                         }
3048                         for (cntr_user0_1 = 0; cntr_user0_1 < r->entries_read; cntr_user0_1++) {
3049                                 NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo0(ndr, NDR_BUFFERS, &r->user0[cntr_user0_1]));
3050                         }
3051                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user0_1, 0);
3052                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user0_0, 0);
3053                 }
3054                 if (r->user0) {
3055                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->user0, r->entries_read));
3056                 }
3057         }
3058         return NDR_ERR_SUCCESS;
3059 }
3060
3061 _PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsersCtr0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaEnumUsersCtr0 *r)
3062 {
3063         uint32_t cntr_user0_1;
3064         ndr_print_struct(ndr, name, "wkssvc_NetWkstaEnumUsersCtr0");
3065         ndr->depth++;
3066         ndr_print_uint32(ndr, "entries_read", r->entries_read);
3067         ndr_print_ptr(ndr, "user0", r->user0);
3068         ndr->depth++;
3069         if (r->user0) {
3070                 ndr->print(ndr, "%s: ARRAY(%d)", "user0", r->entries_read);
3071                 ndr->depth++;
3072                 for (cntr_user0_1=0;cntr_user0_1<r->entries_read;cntr_user0_1++) {
3073                         char *idx_1=NULL;
3074                         asprintf(&idx_1, "[%d]", cntr_user0_1);
3075                         if (idx_1) {
3076                                 ndr_print_wkssvc_NetrWkstaUserInfo0(ndr, "user0", &r->user0[cntr_user0_1]);
3077                                 free(idx_1);
3078                         }
3079                 }
3080                 ndr->depth--;
3081         }
3082         ndr->depth--;
3083         ndr->depth--;
3084 }
3085
3086 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserInfo1(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrWkstaUserInfo1 *r)
3087 {
3088         if (ndr_flags & NDR_SCALARS) {
3089                 NDR_CHECK(ndr_push_align(ndr, 4));
3090                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
3091                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->logon_domain));
3092                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->other_domains));
3093                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->logon_server));
3094         }
3095         if (ndr_flags & NDR_BUFFERS) {
3096                 if (r->user_name) {
3097                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
3098                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3099                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
3100                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3101                 }
3102                 if (r->logon_domain) {
3103                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->logon_domain, CH_UTF16)));
3104                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3105                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->logon_domain, CH_UTF16)));
3106                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->logon_domain, ndr_charset_length(r->logon_domain, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3107                 }
3108                 if (r->other_domains) {
3109                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->other_domains, CH_UTF16)));
3110                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3111                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->other_domains, CH_UTF16)));
3112                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->other_domains, ndr_charset_length(r->other_domains, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3113                 }
3114                 if (r->logon_server) {
3115                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->logon_server, CH_UTF16)));
3116                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3117                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->logon_server, CH_UTF16)));
3118                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->logon_server, ndr_charset_length(r->logon_server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3119                 }
3120         }
3121         return NDR_ERR_SUCCESS;
3122 }
3123
3124 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserInfo1(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrWkstaUserInfo1 *r)
3125 {
3126         uint32_t _ptr_user_name;
3127         TALLOC_CTX *_mem_save_user_name_0;
3128         uint32_t _ptr_logon_domain;
3129         TALLOC_CTX *_mem_save_logon_domain_0;
3130         uint32_t _ptr_other_domains;
3131         TALLOC_CTX *_mem_save_other_domains_0;
3132         uint32_t _ptr_logon_server;
3133         TALLOC_CTX *_mem_save_logon_server_0;
3134         if (ndr_flags & NDR_SCALARS) {
3135                 NDR_CHECK(ndr_pull_align(ndr, 4));
3136                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3137                 if (_ptr_user_name) {
3138                         NDR_PULL_ALLOC(ndr, r->user_name);
3139                 } else {
3140                         r->user_name = NULL;
3141                 }
3142                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_logon_domain));
3143                 if (_ptr_logon_domain) {
3144                         NDR_PULL_ALLOC(ndr, r->logon_domain);
3145                 } else {
3146                         r->logon_domain = NULL;
3147                 }
3148                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_other_domains));
3149                 if (_ptr_other_domains) {
3150                         NDR_PULL_ALLOC(ndr, r->other_domains);
3151                 } else {
3152                         r->other_domains = NULL;
3153                 }
3154                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_logon_server));
3155                 if (_ptr_logon_server) {
3156                         NDR_PULL_ALLOC(ndr, r->logon_server);
3157                 } else {
3158                         r->logon_server = NULL;
3159                 }
3160         }
3161         if (ndr_flags & NDR_BUFFERS) {
3162                 if (r->user_name) {
3163                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3164                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3165                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
3166                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
3167                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
3168                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
3169                         }
3170                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
3171                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
3172                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3173                 }
3174                 if (r->logon_domain) {
3175                         _mem_save_logon_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
3176                         NDR_PULL_SET_MEM_CTX(ndr, r->logon_domain, 0);
3177                         NDR_CHECK(ndr_pull_array_size(ndr, &r->logon_domain));
3178                         NDR_CHECK(ndr_pull_array_length(ndr, &r->logon_domain));
3179                         if (ndr_get_array_length(ndr, &r->logon_domain) > ndr_get_array_size(ndr, &r->logon_domain)) {
3180                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->logon_domain), ndr_get_array_length(ndr, &r->logon_domain));
3181                         }
3182                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->logon_domain), sizeof(uint16_t)));
3183                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->logon_domain, ndr_get_array_length(ndr, &r->logon_domain), sizeof(uint16_t), CH_UTF16));
3184                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_logon_domain_0, 0);
3185                 }
3186                 if (r->other_domains) {
3187                         _mem_save_other_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
3188                         NDR_PULL_SET_MEM_CTX(ndr, r->other_domains, 0);
3189                         NDR_CHECK(ndr_pull_array_size(ndr, &r->other_domains));
3190                         NDR_CHECK(ndr_pull_array_length(ndr, &r->other_domains));
3191                         if (ndr_get_array_length(ndr, &r->other_domains) > ndr_get_array_size(ndr, &r->other_domains)) {
3192                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->other_domains), ndr_get_array_length(ndr, &r->other_domains));
3193                         }
3194                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->other_domains), sizeof(uint16_t)));
3195                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->other_domains, ndr_get_array_length(ndr, &r->other_domains), sizeof(uint16_t), CH_UTF16));
3196                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_other_domains_0, 0);
3197                 }
3198                 if (r->logon_server) {
3199                         _mem_save_logon_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
3200                         NDR_PULL_SET_MEM_CTX(ndr, r->logon_server, 0);
3201                         NDR_CHECK(ndr_pull_array_size(ndr, &r->logon_server));
3202                         NDR_CHECK(ndr_pull_array_length(ndr, &r->logon_server));
3203                         if (ndr_get_array_length(ndr, &r->logon_server) > ndr_get_array_size(ndr, &r->logon_server)) {
3204                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->logon_server), ndr_get_array_length(ndr, &r->logon_server));
3205                         }
3206                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->logon_server), sizeof(uint16_t)));
3207                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->logon_server, ndr_get_array_length(ndr, &r->logon_server), sizeof(uint16_t), CH_UTF16));
3208                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_logon_server_0, 0);
3209                 }
3210         }
3211         return NDR_ERR_SUCCESS;
3212 }
3213
3214 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserInfo1(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrWkstaUserInfo1 *r)
3215 {
3216         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaUserInfo1");
3217         ndr->depth++;
3218         ndr_print_ptr(ndr, "user_name", r->user_name);
3219         ndr->depth++;
3220         if (r->user_name) {
3221                 ndr_print_string(ndr, "user_name", r->user_name);
3222         }
3223         ndr->depth--;
3224         ndr_print_ptr(ndr, "logon_domain", r->logon_domain);
3225         ndr->depth++;
3226         if (r->logon_domain) {
3227                 ndr_print_string(ndr, "logon_domain", r->logon_domain);
3228         }
3229         ndr->depth--;
3230         ndr_print_ptr(ndr, "other_domains", r->other_domains);
3231         ndr->depth++;
3232         if (r->other_domains) {
3233                 ndr_print_string(ndr, "other_domains", r->other_domains);
3234         }
3235         ndr->depth--;
3236         ndr_print_ptr(ndr, "logon_server", r->logon_server);
3237         ndr->depth++;
3238         if (r->logon_server) {
3239                 ndr_print_string(ndr, "logon_server", r->logon_server);
3240         }
3241         ndr->depth--;
3242         ndr->depth--;
3243 }
3244
3245 static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsersCtr1(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaEnumUsersCtr1 *r)
3246 {
3247         uint32_t cntr_user1_1;
3248         if (ndr_flags & NDR_SCALARS) {
3249                 NDR_CHECK(ndr_push_align(ndr, 4));
3250                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->entries_read));
3251                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user1));
3252         }
3253         if (ndr_flags & NDR_BUFFERS) {
3254                 if (r->user1) {
3255                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->entries_read));
3256                         for (cntr_user1_1 = 0; cntr_user1_1 < r->entries_read; cntr_user1_1++) {
3257                                 NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo1(ndr, NDR_SCALARS, &r->user1[cntr_user1_1]));
3258                         }
3259                         for (cntr_user1_1 = 0; cntr_user1_1 < r->entries_read; cntr_user1_1++) {
3260                                 NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo1(ndr, NDR_BUFFERS, &r->user1[cntr_user1_1]));
3261                         }
3262                 }
3263         }
3264         return NDR_ERR_SUCCESS;
3265 }
3266
3267 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsersCtr1(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaEnumUsersCtr1 *r)
3268 {
3269         uint32_t _ptr_user1;
3270         uint32_t cntr_user1_1;
3271         TALLOC_CTX *_mem_save_user1_0;
3272         TALLOC_CTX *_mem_save_user1_1;
3273         if (ndr_flags & NDR_SCALARS) {
3274                 NDR_CHECK(ndr_pull_align(ndr, 4));
3275                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->entries_read));
3276                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user1));
3277                 if (_ptr_user1) {
3278                         NDR_PULL_ALLOC(ndr, r->user1);
3279                 } else {
3280                         r->user1 = NULL;
3281                 }
3282         }
3283         if (ndr_flags & NDR_BUFFERS) {
3284                 if (r->user1) {
3285                         _mem_save_user1_0 = NDR_PULL_GET_MEM_CTX(ndr);
3286                         NDR_PULL_SET_MEM_CTX(ndr, r->user1, 0);
3287                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user1));
3288                         NDR_PULL_ALLOC_N(ndr, r->user1, ndr_get_array_size(ndr, &r->user1));
3289                         _mem_save_user1_1 = NDR_PULL_GET_MEM_CTX(ndr);
3290                         NDR_PULL_SET_MEM_CTX(ndr, r->user1, 0);
3291                         for (cntr_user1_1 = 0; cntr_user1_1 < r->entries_read; cntr_user1_1++) {
3292                                 NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo1(ndr, NDR_SCALARS, &r->user1[cntr_user1_1]));
3293                         }
3294                         for (cntr_user1_1 = 0; cntr_user1_1 < r->entries_read; cntr_user1_1++) {
3295                                 NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo1(ndr, NDR_BUFFERS, &r->user1[cntr_user1_1]));
3296                         }
3297                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user1_1, 0);
3298                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user1_0, 0);
3299                 }
3300                 if (r->user1) {
3301                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->user1, r->entries_read));
3302                 }
3303         }
3304         return NDR_ERR_SUCCESS;
3305 }
3306
3307 _PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsersCtr1(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaEnumUsersCtr1 *r)
3308 {
3309         uint32_t cntr_user1_1;
3310         ndr_print_struct(ndr, name, "wkssvc_NetWkstaEnumUsersCtr1");
3311         ndr->depth++;
3312         ndr_print_uint32(ndr, "entries_read", r->entries_read);
3313         ndr_print_ptr(ndr, "user1", r->user1);
3314         ndr->depth++;
3315         if (r->user1) {
3316                 ndr->print(ndr, "%s: ARRAY(%d)", "user1", r->entries_read);
3317                 ndr->depth++;
3318                 for (cntr_user1_1=0;cntr_user1_1<r->entries_read;cntr_user1_1++) {
3319                         char *idx_1=NULL;
3320                         asprintf(&idx_1, "[%d]", cntr_user1_1);
3321                         if (idx_1) {
3322                                 ndr_print_wkssvc_NetrWkstaUserInfo1(ndr, "user1", &r->user1[cntr_user1_1]);
3323                                 free(idx_1);
3324                         }
3325                 }
3326                 ndr->depth--;
3327         }
3328         ndr->depth--;
3329         ndr->depth--;
3330 }
3331
3332 static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsersCtr(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetWkstaEnumUsersCtr *r)
3333 {
3334         if (ndr_flags & NDR_SCALARS) {
3335                 int level = ndr_push_get_switch_value(ndr, r);
3336                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
3337                 switch (level) {
3338                         case 0:
3339                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user0));
3340                         break;
3341
3342                         case 1:
3343                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user1));
3344                         break;
3345
3346                         default:
3347                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3348                 }
3349         }
3350         if (ndr_flags & NDR_BUFFERS) {
3351                 int level = ndr_push_get_switch_value(ndr, r);
3352                 switch (level) {
3353                         case 0:
3354                                 if (r->user0) {
3355                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->user0));
3356                                 }
3357                         break;
3358
3359                         case 1:
3360                                 if (r->user1) {
3361                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->user1));
3362                                 }
3363                         break;
3364
3365                         default:
3366                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3367                 }
3368         }
3369         return NDR_ERR_SUCCESS;
3370 }
3371
3372 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsersCtr(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetWkstaEnumUsersCtr *r)
3373 {
3374         int level;
3375         uint32_t _level;
3376         TALLOC_CTX *_mem_save_user0_0;
3377         TALLOC_CTX *_mem_save_user1_0;
3378         level = ndr_pull_get_switch_value(ndr, r);
3379         if (ndr_flags & NDR_SCALARS) {
3380                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
3381                 if (_level != level) {
3382                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
3383                 }
3384                 switch (level) {
3385                         case 0: {
3386                                 uint32_t _ptr_user0;
3387                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user0));
3388                                 if (_ptr_user0) {
3389                                         NDR_PULL_ALLOC(ndr, r->user0);
3390                                 } else {
3391                                         r->user0 = NULL;
3392                                 }
3393                         break; }
3394
3395                         case 1: {
3396                                 uint32_t _ptr_user1;
3397                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user1));
3398                                 if (_ptr_user1) {
3399                                         NDR_PULL_ALLOC(ndr, r->user1);
3400                                 } else {
3401                                         r->user1 = NULL;
3402                                 }
3403                         break; }
3404
3405                         default:
3406                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3407                 }
3408         }
3409         if (ndr_flags & NDR_BUFFERS) {
3410                 switch (level) {
3411                         case 0:
3412                                 if (r->user0) {
3413                                         _mem_save_user0_0 = NDR_PULL_GET_MEM_CTX(ndr);
3414                                         NDR_PULL_SET_MEM_CTX(ndr, r->user0, 0);
3415                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->user0));
3416                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user0_0, 0);
3417                                 }
3418                         break;
3419
3420                         case 1:
3421                                 if (r->user1) {
3422                                         _mem_save_user1_0 = NDR_PULL_GET_MEM_CTX(ndr);
3423                                         NDR_PULL_SET_MEM_CTX(ndr, r->user1, 0);
3424                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->user1));
3425                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user1_0, 0);
3426                                 }
3427                         break;
3428
3429                         default:
3430                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3431                 }
3432         }
3433         return NDR_ERR_SUCCESS;
3434 }
3435
3436 _PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsersCtr(struct ndr_print *ndr, const char *name, const union wkssvc_NetWkstaEnumUsersCtr *r)
3437 {
3438         int level;
3439         level = ndr_print_get_switch_value(ndr, r);
3440         ndr_print_union(ndr, name, level, "wkssvc_NetWkstaEnumUsersCtr");
3441         switch (level) {
3442                 case 0:
3443                         ndr_print_ptr(ndr, "user0", r->user0);
3444                         ndr->depth++;
3445                         if (r->user0) {
3446                                 ndr_print_wkssvc_NetWkstaEnumUsersCtr0(ndr, "user0", r->user0);
3447                         }
3448                         ndr->depth--;
3449                 break;
3450
3451                 case 1:
3452                         ndr_print_ptr(ndr, "user1", r->user1);
3453                         ndr->depth++;
3454                         if (r->user1) {
3455                                 ndr_print_wkssvc_NetWkstaEnumUsersCtr1(ndr, "user1", r->user1);
3456                         }
3457                         ndr->depth--;
3458                 break;
3459
3460                 default:
3461                         ndr_print_bad_level(ndr, name, level);
3462         }
3463 }
3464
3465 static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsersInfo(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaEnumUsersInfo *r)
3466 {
3467         if (ndr_flags & NDR_SCALARS) {
3468                 NDR_CHECK(ndr_push_align(ndr, 4));
3469                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
3470                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
3471                 NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersCtr(ndr, NDR_SCALARS, &r->ctr));
3472         }
3473         if (ndr_flags & NDR_BUFFERS) {
3474                 NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersCtr(ndr, NDR_BUFFERS, &r->ctr));
3475         }
3476         return NDR_ERR_SUCCESS;
3477 }
3478
3479 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsersInfo(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaEnumUsersInfo *r)
3480 {
3481         if (ndr_flags & NDR_SCALARS) {
3482                 NDR_CHECK(ndr_pull_align(ndr, 4));
3483                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
3484                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
3485                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersCtr(ndr, NDR_SCALARS, &r->ctr));
3486         }
3487         if (ndr_flags & NDR_BUFFERS) {
3488                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersCtr(ndr, NDR_BUFFERS, &r->ctr));
3489         }
3490         return NDR_ERR_SUCCESS;
3491 }
3492
3493 _PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsersInfo(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaEnumUsersInfo *r)
3494 {
3495         ndr_print_struct(ndr, name, "wkssvc_NetWkstaEnumUsersInfo");
3496         ndr->depth++;
3497         ndr_print_uint32(ndr, "level", r->level);
3498         ndr_print_set_switch_value(ndr, &r->ctr, r->level);
3499         ndr_print_wkssvc_NetWkstaEnumUsersCtr(ndr, "ctr", &r->ctr);
3500         ndr->depth--;
3501 }
3502
3503 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserInfo1101(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrWkstaUserInfo1101 *r)
3504 {
3505         if (ndr_flags & NDR_SCALARS) {
3506                 NDR_CHECK(ndr_push_align(ndr, 4));
3507                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->other_domains));
3508         }
3509         if (ndr_flags & NDR_BUFFERS) {
3510                 if (r->other_domains) {
3511                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->other_domains, CH_UTF16)));
3512                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3513                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->other_domains, CH_UTF16)));
3514                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->other_domains, ndr_charset_length(r->other_domains, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3515                 }
3516         }
3517         return NDR_ERR_SUCCESS;
3518 }
3519
3520 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserInfo1101(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrWkstaUserInfo1101 *r)
3521 {
3522         uint32_t _ptr_other_domains;
3523         TALLOC_CTX *_mem_save_other_domains_0;
3524         if (ndr_flags & NDR_SCALARS) {
3525                 NDR_CHECK(ndr_pull_align(ndr, 4));
3526                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_other_domains));
3527                 if (_ptr_other_domains) {
3528                         NDR_PULL_ALLOC(ndr, r->other_domains);
3529                 } else {
3530                         r->other_domains = NULL;
3531                 }
3532         }
3533         if (ndr_flags & NDR_BUFFERS) {
3534                 if (r->other_domains) {
3535                         _mem_save_other_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
3536                         NDR_PULL_SET_MEM_CTX(ndr, r->other_domains, 0);
3537                         NDR_CHECK(ndr_pull_array_size(ndr, &r->other_domains));
3538                         NDR_CHECK(ndr_pull_array_length(ndr, &r->other_domains));
3539                         if (ndr_get_array_length(ndr, &r->other_domains) > ndr_get_array_size(ndr, &r->other_domains)) {
3540                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->other_domains), ndr_get_array_length(ndr, &r->other_domains));
3541                         }
3542                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->other_domains), sizeof(uint16_t)));
3543                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->other_domains, ndr_get_array_length(ndr, &r->other_domains), sizeof(uint16_t), CH_UTF16));
3544                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_other_domains_0, 0);
3545                 }
3546         }
3547         return NDR_ERR_SUCCESS;
3548 }
3549
3550 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserInfo1101(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrWkstaUserInfo1101 *r)
3551 {
3552         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaUserInfo1101");
3553         ndr->depth++;
3554         ndr_print_ptr(ndr, "other_domains", r->other_domains);
3555         ndr->depth++;
3556         if (r->other_domains) {
3557                 ndr_print_string(ndr, "other_domains", r->other_domains);
3558         }
3559         ndr->depth--;
3560         ndr->depth--;
3561 }
3562
3563 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserInfo(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetrWkstaUserInfo *r)
3564 {
3565         if (ndr_flags & NDR_SCALARS) {
3566                 int level = ndr_push_get_switch_value(ndr, r);
3567                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
3568                 switch (level) {
3569                         case 0:
3570                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
3571                         break;
3572
3573                         case 1:
3574                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
3575                         break;
3576
3577                         case 1101:
3578                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1101));
3579                         break;
3580
3581                         default:
3582                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3583                 }
3584         }
3585         if (ndr_flags & NDR_BUFFERS) {
3586                 int level = ndr_push_get_switch_value(ndr, r);
3587                 switch (level) {
3588                         case 0:
3589                                 if (r->info0) {
3590                                         NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
3591                                 }
3592                         break;
3593
3594                         case 1:
3595                                 if (r->info1) {
3596                                         NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
3597                                 }
3598                         break;
3599
3600                         case 1101:
3601                                 if (r->info1101) {
3602                                         NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo1101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1101));
3603                                 }
3604                         break;
3605
3606                         default:
3607                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3608                 }
3609         }
3610         return NDR_ERR_SUCCESS;
3611 }
3612
3613 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserInfo(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetrWkstaUserInfo *r)
3614 {
3615         int level;
3616         uint32_t _level;
3617         TALLOC_CTX *_mem_save_info0_0;
3618         TALLOC_CTX *_mem_save_info1_0;
3619         TALLOC_CTX *_mem_save_info1101_0;
3620         level = ndr_pull_get_switch_value(ndr, r);
3621         if (ndr_flags & NDR_SCALARS) {
3622                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
3623                 if (_level != level) {
3624                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
3625                 }
3626                 switch (level) {
3627                         case 0: {
3628                                 uint32_t _ptr_info0;
3629                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
3630                                 if (_ptr_info0) {
3631                                         NDR_PULL_ALLOC(ndr, r->info0);
3632                                 } else {
3633                                         r->info0 = NULL;
3634                                 }
3635                         break; }
3636
3637                         case 1: {
3638                                 uint32_t _ptr_info1;
3639                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
3640                                 if (_ptr_info1) {
3641                                         NDR_PULL_ALLOC(ndr, r->info1);
3642                                 } else {
3643                                         r->info1 = NULL;
3644                                 }
3645                         break; }
3646
3647                         case 1101: {
3648                                 uint32_t _ptr_info1101;
3649                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1101));
3650                                 if (_ptr_info1101) {
3651                                         NDR_PULL_ALLOC(ndr, r->info1101);
3652                                 } else {
3653                                         r->info1101 = NULL;
3654                                 }
3655                         break; }
3656
3657                         default:
3658                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3659                 }
3660         }
3661         if (ndr_flags & NDR_BUFFERS) {
3662                 switch (level) {
3663                         case 0:
3664                                 if (r->info0) {
3665                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
3666                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
3667                                         NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
3668                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
3669                                 }
3670                         break;
3671
3672                         case 1:
3673                                 if (r->info1) {
3674                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
3675                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
3676                                         NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
3677                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
3678                                 }
3679                         break;
3680
3681                         case 1101:
3682                                 if (r->info1101) {
3683                                         _mem_save_info1101_0 = NDR_PULL_GET_MEM_CTX(ndr);
3684                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1101, 0);
3685                                         NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo1101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1101));
3686                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1101_0, 0);
3687                                 }
3688                         break;
3689
3690                         default:
3691                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3692                 }
3693         }
3694         return NDR_ERR_SUCCESS;
3695 }
3696
3697 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserInfo(struct ndr_print *ndr, const char *name, const union wkssvc_NetrWkstaUserInfo *r)
3698 {
3699         int level;
3700         level = ndr_print_get_switch_value(ndr, r);
3701         ndr_print_union(ndr, name, level, "wkssvc_NetrWkstaUserInfo");
3702         switch (level) {
3703                 case 0:
3704                         ndr_print_ptr(ndr, "info0", r->info0);
3705                         ndr->depth++;
3706                         if (r->info0) {
3707                                 ndr_print_wkssvc_NetrWkstaUserInfo0(ndr, "info0", r->info0);
3708                         }
3709                         ndr->depth--;
3710                 break;
3711
3712                 case 1:
3713                         ndr_print_ptr(ndr, "info1", r->info1);
3714                         ndr->depth++;
3715                         if (r->info1) {
3716                                 ndr_print_wkssvc_NetrWkstaUserInfo1(ndr, "info1", r->info1);
3717                         }
3718                         ndr->depth--;
3719                 break;
3720
3721                 case 1101:
3722                         ndr_print_ptr(ndr, "info1101", r->info1101);
3723                         ndr->depth++;
3724                         if (r->info1101) {
3725                                 ndr_print_wkssvc_NetrWkstaUserInfo1101(ndr, "info1101", r->info1101);
3726                         }
3727                         ndr->depth--;
3728                 break;
3729
3730                 default:
3731                         ndr_print_bad_level(ndr, name, level);
3732         }
3733 }
3734
3735 static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportInfo0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaTransportInfo0 *r)
3736 {
3737         if (ndr_flags & NDR_SCALARS) {
3738                 NDR_CHECK(ndr_push_align(ndr, 4));
3739                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->quality_of_service));
3740                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->vc_count));
3741                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
3742                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->address));
3743                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->wan_link));
3744         }
3745         if (ndr_flags & NDR_BUFFERS) {
3746                 if (r->name) {
3747                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
3748                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3749                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
3750                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3751                 }
3752                 if (r->address) {
3753                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->address, CH_UTF16)));
3754                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3755                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->address, CH_UTF16)));
3756                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->address, ndr_charset_length(r->address, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3757                 }
3758         }
3759         return NDR_ERR_SUCCESS;
3760 }
3761
3762 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportInfo0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaTransportInfo0 *r)
3763 {
3764         uint32_t _ptr_name;
3765         TALLOC_CTX *_mem_save_name_0;
3766         uint32_t _ptr_address;
3767         TALLOC_CTX *_mem_save_address_0;
3768         if (ndr_flags & NDR_SCALARS) {
3769                 NDR_CHECK(ndr_pull_align(ndr, 4));
3770                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->quality_of_service));
3771                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->vc_count));
3772                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
3773                 if (_ptr_name) {
3774                         NDR_PULL_ALLOC(ndr, r->name);
3775                 } else {
3776                         r->name = NULL;
3777                 }
3778                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_address));
3779                 if (_ptr_address) {
3780                         NDR_PULL_ALLOC(ndr, r->address);
3781                 } else {
3782                         r->address = NULL;
3783                 }
3784                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->wan_link));
3785         }
3786         if (ndr_flags & NDR_BUFFERS) {
3787                 if (r->name) {
3788                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3789                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
3790                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
3791                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
3792                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
3793                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));
3794                         }
3795                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
3796                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
3797                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
3798                 }
3799                 if (r->address) {
3800                         _mem_save_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
3801                         NDR_PULL_SET_MEM_CTX(ndr, r->address, 0);
3802                         NDR_CHECK(ndr_pull_array_size(ndr, &r->address));
3803                         NDR_CHECK(ndr_pull_array_length(ndr, &r->address));
3804                         if (ndr_get_array_length(ndr, &r->address) > ndr_get_array_size(ndr, &r->address)) {
3805                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->address), ndr_get_array_length(ndr, &r->address));
3806                         }
3807                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->address), sizeof(uint16_t)));
3808                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->address, ndr_get_array_length(ndr, &r->address), sizeof(uint16_t), CH_UTF16));
3809                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_address_0, 0);
3810                 }
3811         }
3812         return NDR_ERR_SUCCESS;
3813 }
3814
3815 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportInfo0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaTransportInfo0 *r)
3816 {
3817         ndr_print_struct(ndr, name, "wkssvc_NetWkstaTransportInfo0");
3818         ndr->depth++;
3819         ndr_print_uint32(ndr, "quality_of_service", r->quality_of_service);
3820         ndr_print_uint32(ndr, "vc_count", r->vc_count);
3821         ndr_print_ptr(ndr, "name", r->name);
3822         ndr->depth++;
3823         if (r->name) {
3824                 ndr_print_string(ndr, "name", r->name);
3825         }
3826         ndr->depth--;
3827         ndr_print_ptr(ndr, "address", r->address);
3828         ndr->depth++;
3829         if (r->address) {
3830                 ndr_print_string(ndr, "address", r->address);
3831         }
3832         ndr->depth--;
3833         ndr_print_uint32(ndr, "wan_link", r->wan_link);
3834         ndr->depth--;
3835 }
3836
3837 static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportCtr0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaTransportCtr0 *r)
3838 {
3839         uint32_t cntr_array_1;
3840         if (ndr_flags & NDR_SCALARS) {
3841                 NDR_CHECK(ndr_push_align(ndr, 4));
3842                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3843                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
3844         }
3845         if (ndr_flags & NDR_BUFFERS) {
3846                 if (r->array) {
3847                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3848                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3849                                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
3850                         }
3851                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3852                                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
3853                         }
3854                 }
3855         }
3856         return NDR_ERR_SUCCESS;
3857 }
3858
3859 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportCtr0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaTransportCtr0 *r)
3860 {
3861         uint32_t _ptr_array;
3862         uint32_t cntr_array_1;
3863         TALLOC_CTX *_mem_save_array_0;
3864         TALLOC_CTX *_mem_save_array_1;
3865         if (ndr_flags & NDR_SCALARS) {
3866                 NDR_CHECK(ndr_pull_align(ndr, 4));
3867                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3868                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
3869                 if (_ptr_array) {
3870                         NDR_PULL_ALLOC(ndr, r->array);
3871                 } else {
3872                         r->array = NULL;
3873                 }
3874         }
3875         if (ndr_flags & NDR_BUFFERS) {
3876                 if (r->array) {
3877                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
3878                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
3879                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
3880                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
3881                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
3882                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
3883                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3884                                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
3885                         }
3886                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3887                                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
3888                         }
3889                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
3890                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
3891                 }
3892                 if (r->array) {
3893                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
3894                 }
3895         }
3896         return NDR_ERR_SUCCESS;
3897 }
3898
3899 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportCtr0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaTransportCtr0 *r)
3900 {
3901         uint32_t cntr_array_1;
3902         ndr_print_struct(ndr, name, "wkssvc_NetWkstaTransportCtr0");
3903         ndr->depth++;
3904         ndr_print_uint32(ndr, "count", r->count);
3905         ndr_print_ptr(ndr, "array", r->array);
3906         ndr->depth++;
3907         if (r->array) {
3908                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
3909                 ndr->depth++;
3910                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
3911                         char *idx_1=NULL;
3912                         asprintf(&idx_1, "[%d]", cntr_array_1);
3913                         if (idx_1) {
3914                                 ndr_print_wkssvc_NetWkstaTransportInfo0(ndr, "array", &r->array[cntr_array_1]);
3915                                 free(idx_1);
3916                         }
3917                 }
3918                 ndr->depth--;
3919         }
3920         ndr->depth--;
3921         ndr->depth--;
3922 }
3923
3924 static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportCtr(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetWkstaTransportCtr *r)
3925 {
3926         if (ndr_flags & NDR_SCALARS) {
3927                 int level = ndr_push_get_switch_value(ndr, r);
3928                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
3929                 switch (level) {
3930                         case 0:
3931                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
3932                         break;
3933
3934                         default:
3935                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3936                 }
3937         }
3938         if (ndr_flags & NDR_BUFFERS) {
3939                 int level = ndr_push_get_switch_value(ndr, r);
3940                 switch (level) {
3941                         case 0:
3942                                 if (r->ctr0) {
3943                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
3944                                 }
3945                         break;
3946
3947                         default:
3948                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3949                 }
3950         }
3951         return NDR_ERR_SUCCESS;
3952 }
3953
3954 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportCtr(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetWkstaTransportCtr *r)
3955 {
3956         int level;
3957         uint32_t _level;
3958         TALLOC_CTX *_mem_save_ctr0_0;
3959         level = ndr_pull_get_switch_value(ndr, r);
3960         if (ndr_flags & NDR_SCALARS) {
3961                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
3962                 if (_level != level) {
3963                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
3964                 }
3965                 switch (level) {
3966                         case 0: {
3967                                 uint32_t _ptr_ctr0;
3968                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));
3969                                 if (_ptr_ctr0) {
3970                                         NDR_PULL_ALLOC(ndr, r->ctr0);
3971                                 } else {
3972                                         r->ctr0 = NULL;
3973                                 }
3974                         break; }
3975
3976                         default:
3977                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3978                 }
3979         }
3980         if (ndr_flags & NDR_BUFFERS) {
3981                 switch (level) {
3982                         case 0:
3983                                 if (r->ctr0) {
3984                                         _mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);
3985                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr0, 0);
3986                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
3987                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);
3988                                 }
3989                         break;
3990
3991                         default:
3992                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3993                 }
3994         }
3995         return NDR_ERR_SUCCESS;
3996 }
3997
3998 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportCtr(struct ndr_print *ndr, const char *name, const union wkssvc_NetWkstaTransportCtr *r)
3999 {
4000         int level;
4001         level = ndr_print_get_switch_value(ndr, r);
4002         ndr_print_union(ndr, name, level, "wkssvc_NetWkstaTransportCtr");
4003         switch (level) {
4004                 case 0:
4005                         ndr_print_ptr(ndr, "ctr0", r->ctr0);
4006                         ndr->depth++;
4007                         if (r->ctr0) {
4008                                 ndr_print_wkssvc_NetWkstaTransportCtr0(ndr, "ctr0", r->ctr0);
4009                         }
4010                         ndr->depth--;
4011                 break;
4012
4013                 default:
4014                         ndr_print_bad_level(ndr, name, level);
4015         }
4016 }
4017
4018 static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportInfo(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaTransportInfo *r)
4019 {
4020         if (ndr_flags & NDR_SCALARS) {
4021                 NDR_CHECK(ndr_push_align(ndr, 4));
4022                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
4023                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
4024                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportCtr(ndr, NDR_SCALARS, &r->ctr));
4025         }
4026         if (ndr_flags & NDR_BUFFERS) {
4027                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportCtr(ndr, NDR_BUFFERS, &r->ctr));
4028         }
4029         return NDR_ERR_SUCCESS;
4030 }
4031
4032 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportInfo(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaTransportInfo *r)
4033 {
4034         if (ndr_flags & NDR_SCALARS) {
4035                 NDR_CHECK(ndr_pull_align(ndr, 4));
4036                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
4037                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
4038                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportCtr(ndr, NDR_SCALARS, &r->ctr));
4039         }
4040         if (ndr_flags & NDR_BUFFERS) {
4041                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportCtr(ndr, NDR_BUFFERS, &r->ctr));
4042         }
4043         return NDR_ERR_SUCCESS;
4044 }
4045
4046 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportInfo(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaTransportInfo *r)
4047 {
4048         ndr_print_struct(ndr, name, "wkssvc_NetWkstaTransportInfo");
4049         ndr->depth++;
4050         ndr_print_uint32(ndr, "level", r->level);
4051         ndr_print_set_switch_value(ndr, &r->ctr, r->level);
4052         ndr_print_wkssvc_NetWkstaTransportCtr(ndr, "ctr", &r->ctr);
4053         ndr->depth--;
4054 }
4055
4056 static enum ndr_err_code ndr_push_wkssvc_NetrUseInfo3(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseInfo3 *r)
4057 {
4058         if (ndr_flags & NDR_SCALARS) {
4059                 NDR_CHECK(ndr_push_align(ndr, 4));
4060                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->unknown1));
4061                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->unknown2));
4062         }
4063         if (ndr_flags & NDR_BUFFERS) {
4064                 if (r->unknown1) {
4065                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->unknown1, CH_UTF16)));
4066                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4067                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->unknown1, CH_UTF16)));
4068                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->unknown1, ndr_charset_length(r->unknown1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4069                 }
4070                 if (r->unknown2) {
4071                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->unknown2, CH_UTF16)));
4072                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4073                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->unknown2, CH_UTF16)));
4074                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->unknown2, ndr_charset_length(r->unknown2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4075                 }
4076         }
4077         return NDR_ERR_SUCCESS;
4078 }
4079
4080 static enum ndr_err_code ndr_pull_wkssvc_NetrUseInfo3(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseInfo3 *r)
4081 {
4082         uint32_t _ptr_unknown1;
4083         TALLOC_CTX *_mem_save_unknown1_0;
4084         uint32_t _ptr_unknown2;
4085         TALLOC_CTX *_mem_save_unknown2_0;
4086         if (ndr_flags & NDR_SCALARS) {
4087                 NDR_CHECK(ndr_pull_align(ndr, 4));
4088                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown1));
4089                 if (_ptr_unknown1) {
4090                         NDR_PULL_ALLOC(ndr, r->unknown1);
4091                 } else {
4092                         r->unknown1 = NULL;
4093                 }
4094                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown2));
4095                 if (_ptr_unknown2) {
4096                         NDR_PULL_ALLOC(ndr, r->unknown2);
4097                 } else {
4098                         r->unknown2 = NULL;
4099                 }
4100         }
4101         if (ndr_flags & NDR_BUFFERS) {
4102                 if (r->unknown1) {
4103                         _mem_save_unknown1_0 = NDR_PULL_GET_MEM_CTX(ndr);
4104                         NDR_PULL_SET_MEM_CTX(ndr, r->unknown1, 0);
4105                         NDR_CHECK(ndr_pull_array_size(ndr, &r->unknown1));
4106                         NDR_CHECK(ndr_pull_array_length(ndr, &r->unknown1));
4107                         if (ndr_get_array_length(ndr, &r->unknown1) > ndr_get_array_size(ndr, &r->unknown1)) {
4108                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->unknown1), ndr_get_array_length(ndr, &r->unknown1));
4109                         }
4110                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->unknown1), sizeof(uint16_t)));
4111                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->unknown1, ndr_get_array_length(ndr, &r->unknown1), sizeof(uint16_t), CH_UTF16));
4112                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown1_0, 0);
4113                 }
4114                 if (r->unknown2) {
4115                         _mem_save_unknown2_0 = NDR_PULL_GET_MEM_CTX(ndr);
4116                         NDR_PULL_SET_MEM_CTX(ndr, r->unknown2, 0);
4117                         NDR_CHECK(ndr_pull_array_size(ndr, &r->unknown2));
4118                         NDR_CHECK(ndr_pull_array_length(ndr, &r->unknown2));
4119                         if (ndr_get_array_length(ndr, &r->unknown2) > ndr_get_array_size(ndr, &r->unknown2)) {
4120                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->unknown2), ndr_get_array_length(ndr, &r->unknown2));
4121                         }
4122                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->unknown2), sizeof(uint16_t)));
4123                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->unknown2, ndr_get_array_length(ndr, &r->unknown2), sizeof(uint16_t), CH_UTF16));
4124                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown2_0, 0);
4125                 }
4126         }
4127         return NDR_ERR_SUCCESS;
4128 }
4129
4130 _PUBLIC_ void ndr_print_wkssvc_NetrUseInfo3(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseInfo3 *r)
4131 {
4132         ndr_print_struct(ndr, name, "wkssvc_NetrUseInfo3");
4133         ndr->depth++;
4134         ndr_print_ptr(ndr, "unknown1", r->unknown1);
4135         ndr->depth++;
4136         if (r->unknown1) {
4137                 ndr_print_string(ndr, "unknown1", r->unknown1);
4138         }
4139         ndr->depth--;
4140         ndr_print_ptr(ndr, "unknown2", r->unknown2);
4141         ndr->depth++;
4142         if (r->unknown2) {
4143                 ndr_print_string(ndr, "unknown2", r->unknown2);
4144         }
4145         ndr->depth--;
4146         ndr->depth--;
4147 }
4148
4149 static enum ndr_err_code ndr_push_wkssvc_NetrUseInfo2(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseInfo2 *r)
4150 {
4151         if (ndr_flags & NDR_SCALARS) {
4152                 NDR_CHECK(ndr_push_align(ndr, 4));
4153                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->local));
4154                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote));
4155                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->password));
4156                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
4157                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->asg_type));
4158                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_count));
4159                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_count));
4160                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
4161                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
4162         }
4163         if (ndr_flags & NDR_BUFFERS) {
4164                 if (r->local) {
4165                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->local, CH_UTF16)));
4166                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4167                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->local, CH_UTF16)));
4168                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->local, ndr_charset_length(r->local, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4169                 }
4170                 if (r->remote) {
4171                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote, CH_UTF16)));
4172                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4173                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote, CH_UTF16)));
4174                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->remote, ndr_charset_length(r->remote, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4175                 }
4176                 if (r->password) {
4177                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));
4178                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4179                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));
4180                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->password, ndr_charset_length(r->password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4181                 }
4182                 if (r->user_name) {
4183                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4184                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4185                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4186                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4187                 }
4188                 if (r->domain_name) {
4189                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
4190                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4191                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
4192                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4193                 }
4194         }
4195         return NDR_ERR_SUCCESS;
4196 }
4197
4198 static enum ndr_err_code ndr_pull_wkssvc_NetrUseInfo2(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseInfo2 *r)
4199 {
4200         uint32_t _ptr_local;
4201         TALLOC_CTX *_mem_save_local_0;
4202         uint32_t _ptr_remote;
4203         TALLOC_CTX *_mem_save_remote_0;
4204         uint32_t _ptr_password;
4205         TALLOC_CTX *_mem_save_password_0;
4206         uint32_t _ptr_user_name;
4207         TALLOC_CTX *_mem_save_user_name_0;
4208         uint32_t _ptr_domain_name;
4209         TALLOC_CTX *_mem_save_domain_name_0;
4210         if (ndr_flags & NDR_SCALARS) {
4211                 NDR_CHECK(ndr_pull_align(ndr, 4));
4212                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local));
4213                 if (_ptr_local) {
4214                         NDR_PULL_ALLOC(ndr, r->local);
4215                 } else {
4216                         r->local = NULL;
4217                 }
4218                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote));
4219                 if (_ptr_remote) {
4220                         NDR_PULL_ALLOC(ndr, r->remote);
4221                 } else {
4222                         r->remote = NULL;
4223                 }
4224                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
4225                 if (_ptr_password) {
4226                         NDR_PULL_ALLOC(ndr, r->password);
4227                 } else {
4228                         r->password = NULL;
4229                 }
4230                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
4231                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->asg_type));
4232                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_count));
4233                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_count));
4234                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4235                 if (_ptr_user_name) {
4236                         NDR_PULL_ALLOC(ndr, r->user_name);
4237                 } else {
4238                         r->user_name = NULL;
4239                 }
4240                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
4241                 if (_ptr_domain_name) {
4242                         NDR_PULL_ALLOC(ndr, r->domain_name);
4243                 } else {
4244                         r->domain_name = NULL;
4245                 }
4246         }
4247         if (ndr_flags & NDR_BUFFERS) {
4248                 if (r->local) {
4249                         _mem_save_local_0 = NDR_PULL_GET_MEM_CTX(ndr);
4250                         NDR_PULL_SET_MEM_CTX(ndr, r->local, 0);
4251                         NDR_CHECK(ndr_pull_array_size(ndr, &r->local));
4252                         NDR_CHECK(ndr_pull_array_length(ndr, &r->local));
4253                         if (ndr_get_array_length(ndr, &r->local) > ndr_get_array_size(ndr, &r->local)) {
4254                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->local), ndr_get_array_length(ndr, &r->local));
4255                         }
4256                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->local), sizeof(uint16_t)));
4257                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->local, ndr_get_array_length(ndr, &r->local), sizeof(uint16_t), CH_UTF16));
4258                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_0, 0);
4259                 }
4260                 if (r->remote) {
4261                         _mem_save_remote_0 = NDR_PULL_GET_MEM_CTX(ndr);
4262                         NDR_PULL_SET_MEM_CTX(ndr, r->remote, 0);
4263                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote));
4264                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote));
4265                         if (ndr_get_array_length(ndr, &r->remote) > ndr_get_array_size(ndr, &r->remote)) {
4266                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->remote), ndr_get_array_length(ndr, &r->remote));
4267                         }
4268                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t)));
4269                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->remote, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t), CH_UTF16));
4270                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_0, 0);
4271                 }
4272                 if (r->password) {
4273                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
4274                         NDR_PULL_SET_MEM_CTX(ndr, r->password, 0);
4275                         NDR_CHECK(ndr_pull_array_size(ndr, &r->password));
4276                         NDR_CHECK(ndr_pull_array_length(ndr, &r->password));
4277                         if (ndr_get_array_length(ndr, &r->password) > ndr_get_array_size(ndr, &r->password)) {
4278                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->password), ndr_get_array_length(ndr, &r->password));
4279                         }
4280                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t)));
4281                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->password, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t), CH_UTF16));
4282                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
4283                 }
4284                 if (r->user_name) {
4285                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4286                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4287                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
4288                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
4289                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
4290                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
4291                         }
4292                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
4293                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
4294                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4295                 }
4296                 if (r->domain_name) {
4297                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4298                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
4299                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
4300                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
4301                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
4302                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->domain_name), ndr_get_array_length(ndr, &r->domain_name));
4303                         }
4304                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
4305                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
4306                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
4307                 }
4308         }
4309         return NDR_ERR_SUCCESS;
4310 }
4311
4312 _PUBLIC_ void ndr_print_wkssvc_NetrUseInfo2(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseInfo2 *r)
4313 {
4314         ndr_print_struct(ndr, name, "wkssvc_NetrUseInfo2");
4315         ndr->depth++;
4316         ndr_print_ptr(ndr, "local", r->local);
4317         ndr->depth++;
4318         if (r->local) {
4319                 ndr_print_string(ndr, "local", r->local);
4320         }
4321         ndr->depth--;
4322         ndr_print_ptr(ndr, "remote", r->remote);
4323         ndr->depth++;
4324         if (r->remote) {
4325                 ndr_print_string(ndr, "remote", r->remote);
4326         }
4327         ndr->depth--;
4328         ndr_print_ptr(ndr, "password", r->password);
4329         ndr->depth++;
4330         if (r->password) {
4331                 ndr_print_string(ndr, "password", r->password);
4332         }
4333         ndr->depth--;
4334         ndr_print_uint32(ndr, "status", r->status);
4335         ndr_print_uint32(ndr, "asg_type", r->asg_type);
4336         ndr_print_uint32(ndr, "ref_count", r->ref_count);
4337         ndr_print_uint32(ndr, "use_count", r->use_count);
4338         ndr_print_ptr(ndr, "user_name", r->user_name);
4339         ndr->depth++;
4340         if (r->user_name) {
4341                 ndr_print_string(ndr, "user_name", r->user_name);
4342         }
4343         ndr->depth--;
4344         ndr_print_ptr(ndr, "domain_name", r->domain_name);
4345         ndr->depth++;
4346         if (r->domain_name) {
4347                 ndr_print_string(ndr, "domain_name", r->domain_name);
4348         }
4349         ndr->depth--;
4350         ndr->depth--;
4351 }
4352
4353 static enum ndr_err_code ndr_push_wkssvc_NetrUseInfo1(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseInfo1 *r)
4354 {
4355         if (ndr_flags & NDR_SCALARS) {
4356                 NDR_CHECK(ndr_push_align(ndr, 4));
4357                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->local));
4358                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote));
4359                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->password));
4360                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
4361                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->asg_type));
4362                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_count));
4363                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_count));
4364         }
4365         if (ndr_flags & NDR_BUFFERS) {
4366                 if (r->local) {
4367                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->local, CH_UTF16)));
4368                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4369                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->local, CH_UTF16)));
4370                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->local, ndr_charset_length(r->local, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4371                 }
4372                 if (r->remote) {
4373                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote, CH_UTF16)));
4374                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4375                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote, CH_UTF16)));
4376                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->remote, ndr_charset_length(r->remote, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4377                 }
4378                 if (r->password) {
4379                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));
4380                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4381                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));
4382                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->password, ndr_charset_length(r->password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4383                 }
4384         }
4385         return NDR_ERR_SUCCESS;
4386 }
4387
4388 static enum ndr_err_code ndr_pull_wkssvc_NetrUseInfo1(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseInfo1 *r)
4389 {
4390         uint32_t _ptr_local;
4391         TALLOC_CTX *_mem_save_local_0;
4392         uint32_t _ptr_remote;
4393         TALLOC_CTX *_mem_save_remote_0;
4394         uint32_t _ptr_password;
4395         TALLOC_CTX *_mem_save_password_0;
4396         if (ndr_flags & NDR_SCALARS) {
4397                 NDR_CHECK(ndr_pull_align(ndr, 4));
4398                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local));
4399                 if (_ptr_local) {
4400                         NDR_PULL_ALLOC(ndr, r->local);
4401                 } else {
4402                         r->local = NULL;
4403                 }
4404                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote));
4405                 if (_ptr_remote) {
4406                         NDR_PULL_ALLOC(ndr, r->remote);
4407                 } else {
4408                         r->remote = NULL;
4409                 }
4410                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
4411                 if (_ptr_password) {
4412                         NDR_PULL_ALLOC(ndr, r->password);
4413                 } else {
4414                         r->password = NULL;
4415                 }
4416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
4417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->asg_type));
4418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_count));
4419                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_count));
4420         }
4421         if (ndr_flags & NDR_BUFFERS) {
4422                 if (r->local) {
4423                         _mem_save_local_0 = NDR_PULL_GET_MEM_CTX(ndr);
4424                         NDR_PULL_SET_MEM_CTX(ndr, r->local, 0);
4425                         NDR_CHECK(ndr_pull_array_size(ndr, &r->local));
4426                         NDR_CHECK(ndr_pull_array_length(ndr, &r->local));
4427                         if (ndr_get_array_length(ndr, &r->local) > ndr_get_array_size(ndr, &r->local)) {
4428                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->local), ndr_get_array_length(ndr, &r->local));
4429                         }
4430                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->local), sizeof(uint16_t)));
4431                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->local, ndr_get_array_length(ndr, &r->local), sizeof(uint16_t), CH_UTF16));
4432                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_0, 0);
4433                 }
4434                 if (r->remote) {
4435                         _mem_save_remote_0 = NDR_PULL_GET_MEM_CTX(ndr);
4436                         NDR_PULL_SET_MEM_CTX(ndr, r->remote, 0);
4437                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote));
4438                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote));
4439                         if (ndr_get_array_length(ndr, &r->remote) > ndr_get_array_size(ndr, &r->remote)) {
4440                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->remote), ndr_get_array_length(ndr, &r->remote));
4441                         }
4442                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t)));
4443                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->remote, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t), CH_UTF16));
4444                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_0, 0);
4445                 }
4446                 if (r->password) {
4447                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
4448                         NDR_PULL_SET_MEM_CTX(ndr, r->password, 0);
4449                         NDR_CHECK(ndr_pull_array_size(ndr, &r->password));
4450                         NDR_CHECK(ndr_pull_array_length(ndr, &r->password));
4451                         if (ndr_get_array_length(ndr, &r->password) > ndr_get_array_size(ndr, &r->password)) {
4452                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->password), ndr_get_array_length(ndr, &r->password));
4453                         }
4454                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t)));
4455                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->password, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t), CH_UTF16));
4456                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
4457                 }
4458         }
4459         return NDR_ERR_SUCCESS;
4460 }
4461
4462 _PUBLIC_ void ndr_print_wkssvc_NetrUseInfo1(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseInfo1 *r)
4463 {
4464         ndr_print_struct(ndr, name, "wkssvc_NetrUseInfo1");
4465         ndr->depth++;
4466         ndr_print_ptr(ndr, "local", r->local);
4467         ndr->depth++;
4468         if (r->local) {
4469                 ndr_print_string(ndr, "local", r->local);
4470         }
4471         ndr->depth--;
4472         ndr_print_ptr(ndr, "remote", r->remote);
4473         ndr->depth++;
4474         if (r->remote) {
4475                 ndr_print_string(ndr, "remote", r->remote);
4476         }
4477         ndr->depth--;
4478         ndr_print_ptr(ndr, "password", r->password);
4479         ndr->depth++;
4480         if (r->password) {
4481                 ndr_print_string(ndr, "password", r->password);
4482         }
4483         ndr->depth--;
4484         ndr_print_uint32(ndr, "status", r->status);
4485         ndr_print_uint32(ndr, "asg_type", r->asg_type);
4486         ndr_print_uint32(ndr, "ref_count", r->ref_count);
4487         ndr_print_uint32(ndr, "use_count", r->use_count);
4488         ndr->depth--;
4489 }
4490
4491 static enum ndr_err_code ndr_push_wkssvc_NetrUseInfo0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseInfo0 *r)
4492 {
4493         if (ndr_flags & NDR_SCALARS) {
4494                 NDR_CHECK(ndr_push_align(ndr, 4));
4495                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->local));
4496                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote));
4497         }
4498         if (ndr_flags & NDR_BUFFERS) {
4499                 if (r->local) {
4500                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->local, CH_UTF16)));
4501                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4502                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->local, CH_UTF16)));
4503                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->local, ndr_charset_length(r->local, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4504                 }
4505                 if (r->remote) {
4506                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote, CH_UTF16)));
4507                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4508                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote, CH_UTF16)));
4509                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->remote, ndr_charset_length(r->remote, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4510                 }
4511         }
4512         return NDR_ERR_SUCCESS;
4513 }
4514
4515 static enum ndr_err_code ndr_pull_wkssvc_NetrUseInfo0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseInfo0 *r)
4516 {
4517         uint32_t _ptr_local;
4518         TALLOC_CTX *_mem_save_local_0;
4519         uint32_t _ptr_remote;
4520         TALLOC_CTX *_mem_save_remote_0;
4521         if (ndr_flags & NDR_SCALARS) {
4522                 NDR_CHECK(ndr_pull_align(ndr, 4));
4523                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local));
4524                 if (_ptr_local) {
4525                         NDR_PULL_ALLOC(ndr, r->local);
4526                 } else {
4527                         r->local = NULL;
4528                 }
4529                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote));
4530                 if (_ptr_remote) {
4531                         NDR_PULL_ALLOC(ndr, r->remote);
4532                 } else {
4533                         r->remote = NULL;
4534                 }
4535         }
4536         if (ndr_flags & NDR_BUFFERS) {
4537                 if (r->local) {
4538                         _mem_save_local_0 = NDR_PULL_GET_MEM_CTX(ndr);
4539                         NDR_PULL_SET_MEM_CTX(ndr, r->local, 0);
4540                         NDR_CHECK(ndr_pull_array_size(ndr, &r->local));
4541                         NDR_CHECK(ndr_pull_array_length(ndr, &r->local));
4542                         if (ndr_get_array_length(ndr, &r->local) > ndr_get_array_size(ndr, &r->local)) {
4543                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->local), ndr_get_array_length(ndr, &r->local));
4544                         }
4545                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->local), sizeof(uint16_t)));
4546                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->local, ndr_get_array_length(ndr, &r->local), sizeof(uint16_t), CH_UTF16));
4547                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_0, 0);
4548                 }
4549                 if (r->remote) {
4550                         _mem_save_remote_0 = NDR_PULL_GET_MEM_CTX(ndr);
4551                         NDR_PULL_SET_MEM_CTX(ndr, r->remote, 0);
4552                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote));
4553                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote));
4554                         if (ndr_get_array_length(ndr, &r->remote) > ndr_get_array_size(ndr, &r->remote)) {
4555                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->remote), ndr_get_array_length(ndr, &r->remote));
4556                         }
4557                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t)));
4558                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->remote, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t), CH_UTF16));
4559                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_0, 0);
4560                 }
4561         }
4562         return NDR_ERR_SUCCESS;
4563 }
4564
4565 _PUBLIC_ void ndr_print_wkssvc_NetrUseInfo0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseInfo0 *r)
4566 {
4567         ndr_print_struct(ndr, name, "wkssvc_NetrUseInfo0");
4568         ndr->depth++;
4569         ndr_print_ptr(ndr, "local", r->local);
4570         ndr->depth++;
4571         if (r->local) {
4572                 ndr_print_string(ndr, "local", r->local);
4573         }
4574         ndr->depth--;
4575         ndr_print_ptr(ndr, "remote", r->remote);
4576         ndr->depth++;
4577         if (r->remote) {
4578                 ndr_print_string(ndr, "remote", r->remote);
4579         }
4580         ndr->depth--;
4581         ndr->depth--;
4582 }
4583
4584 static enum ndr_err_code ndr_push_wkssvc_NetrUseGetInfoCtr(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetrUseGetInfoCtr *r)
4585 {
4586         if (ndr_flags & NDR_SCALARS) {
4587                 int level = ndr_push_get_switch_value(ndr, r);
4588                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
4589                 switch (level) {
4590                         case 0:
4591                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
4592                         break;
4593
4594                         case 1:
4595                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
4596                         break;
4597
4598                         case 2:
4599                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
4600                         break;
4601
4602                         case 3:
4603                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
4604                         break;
4605
4606                         default:
4607                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4608                 }
4609         }
4610         if (ndr_flags & NDR_BUFFERS) {
4611                 int level = ndr_push_get_switch_value(ndr, r);
4612                 switch (level) {
4613                         case 0:
4614                                 if (r->info0) {
4615                                         NDR_CHECK(ndr_push_wkssvc_NetrUseInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
4616                                 }
4617                         break;
4618
4619                         case 1:
4620                                 if (r->info1) {
4621                                         NDR_CHECK(ndr_push_wkssvc_NetrUseInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
4622                                 }
4623                         break;
4624
4625                         case 2:
4626                                 if (r->info2) {
4627                                         NDR_CHECK(ndr_push_wkssvc_NetrUseInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
4628                                 }
4629                         break;
4630
4631                         case 3:
4632                                 if (r->info3) {
4633                                         NDR_CHECK(ndr_push_wkssvc_NetrUseInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
4634                                 }
4635                         break;
4636
4637                         default:
4638                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4639                 }
4640         }
4641         return NDR_ERR_SUCCESS;
4642 }
4643
4644 static enum ndr_err_code ndr_pull_wkssvc_NetrUseGetInfoCtr(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetrUseGetInfoCtr *r)
4645 {
4646         int level;
4647         uint32_t _level;
4648         TALLOC_CTX *_mem_save_info0_0;
4649         TALLOC_CTX *_mem_save_info1_0;
4650         TALLOC_CTX *_mem_save_info2_0;
4651         TALLOC_CTX *_mem_save_info3_0;
4652         level = ndr_pull_get_switch_value(ndr, r);
4653         if (ndr_flags & NDR_SCALARS) {
4654                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
4655                 if (_level != level) {
4656                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
4657                 }
4658                 switch (level) {
4659                         case 0: {
4660                                 uint32_t _ptr_info0;
4661                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
4662                                 if (_ptr_info0) {
4663                                         NDR_PULL_ALLOC(ndr, r->info0);
4664                                 } else {
4665                                         r->info0 = NULL;
4666                                 }
4667                         break; }
4668
4669                         case 1: {
4670                                 uint32_t _ptr_info1;
4671                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
4672                                 if (_ptr_info1) {
4673                                         NDR_PULL_ALLOC(ndr, r->info1);
4674                                 } else {
4675                                         r->info1 = NULL;
4676                                 }
4677                         break; }
4678
4679                         case 2: {
4680                                 uint32_t _ptr_info2;
4681                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
4682                                 if (_ptr_info2) {
4683                                         NDR_PULL_ALLOC(ndr, r->info2);
4684                                 } else {
4685                                         r->info2 = NULL;
4686                                 }
4687                         break; }
4688
4689                         case 3: {
4690                                 uint32_t _ptr_info3;
4691                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
4692                                 if (_ptr_info3) {
4693                                         NDR_PULL_ALLOC(ndr, r->info3);
4694                                 } else {
4695                                         r->info3 = NULL;
4696                                 }
4697                         break; }
4698
4699                         default:
4700                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4701                 }
4702         }
4703         if (ndr_flags & NDR_BUFFERS) {
4704                 switch (level) {
4705                         case 0:
4706                                 if (r->info0) {
4707                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
4708                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
4709                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
4710                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
4711                                 }
4712                         break;
4713
4714                         case 1:
4715                                 if (r->info1) {
4716                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
4717                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
4718                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
4719                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
4720                                 }
4721                         break;
4722
4723                         case 2:
4724                                 if (r->info2) {
4725                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
4726                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
4727                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
4728                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
4729                                 }
4730                         break;
4731
4732                         case 3:
4733                                 if (r->info3) {
4734                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
4735                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
4736                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
4737                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
4738                                 }
4739                         break;
4740
4741                         default:
4742                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4743                 }
4744         }
4745         return NDR_ERR_SUCCESS;
4746 }
4747
4748 _PUBLIC_ void ndr_print_wkssvc_NetrUseGetInfoCtr(struct ndr_print *ndr, const char *name, const union wkssvc_NetrUseGetInfoCtr *r)
4749 {
4750         int level;
4751         level = ndr_print_get_switch_value(ndr, r);
4752         ndr_print_union(ndr, name, level, "wkssvc_NetrUseGetInfoCtr");
4753         switch (level) {
4754                 case 0:
4755                         ndr_print_ptr(ndr, "info0", r->info0);
4756                         ndr->depth++;
4757                         if (r->info0) {
4758                                 ndr_print_wkssvc_NetrUseInfo0(ndr, "info0", r->info0);
4759                         }
4760                         ndr->depth--;
4761                 break;
4762
4763                 case 1:
4764                         ndr_print_ptr(ndr, "info1", r->info1);
4765                         ndr->depth++;
4766                         if (r->info1) {
4767                                 ndr_print_wkssvc_NetrUseInfo1(ndr, "info1", r->info1);
4768                         }
4769                         ndr->depth--;
4770                 break;
4771
4772                 case 2:
4773                         ndr_print_ptr(ndr, "info2", r->info2);
4774                         ndr->depth++;
4775                         if (r->info2) {
4776                                 ndr_print_wkssvc_NetrUseInfo2(ndr, "info2", r->info2);
4777                         }
4778                         ndr->depth--;
4779                 break;
4780
4781                 case 3:
4782                         ndr_print_ptr(ndr, "info3", r->info3);
4783                         ndr->depth++;
4784                         if (r->info3) {
4785                                 ndr_print_wkssvc_NetrUseInfo3(ndr, "info3", r->info3);
4786                         }
4787                         ndr->depth--;
4788                 break;
4789
4790                 default:
4791                         ndr_print_bad_level(ndr, name, level);
4792         }
4793 }
4794
4795 static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumCtr2(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseEnumCtr2 *r)
4796 {
4797         uint32_t cntr_array_1;
4798         if (ndr_flags & NDR_SCALARS) {
4799                 NDR_CHECK(ndr_push_align(ndr, 4));
4800                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4801                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
4802         }
4803         if (ndr_flags & NDR_BUFFERS) {
4804                 if (r->array) {
4805                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4806                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4807                                 NDR_CHECK(ndr_push_wkssvc_NetrUseInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4808                         }
4809                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4810                                 NDR_CHECK(ndr_push_wkssvc_NetrUseInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4811                         }
4812                 }
4813         }
4814         return NDR_ERR_SUCCESS;
4815 }
4816
4817 static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumCtr2(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseEnumCtr2 *r)
4818 {
4819         uint32_t _ptr_array;
4820         uint32_t cntr_array_1;
4821         TALLOC_CTX *_mem_save_array_0;
4822         TALLOC_CTX *_mem_save_array_1;
4823         if (ndr_flags & NDR_SCALARS) {
4824                 NDR_CHECK(ndr_pull_align(ndr, 4));
4825                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4826                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
4827                 if (_ptr_array) {
4828                         NDR_PULL_ALLOC(ndr, r->array);
4829                 } else {
4830                         r->array = NULL;
4831                 }
4832         }
4833         if (ndr_flags & NDR_BUFFERS) {
4834                 if (r->array) {
4835                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4836                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4837                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
4838                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
4839                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4840                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4841                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4842                                 NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4843                         }
4844                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4845                                 NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4846                         }
4847                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
4848                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
4849                 }
4850                 if (r->array) {
4851                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
4852                 }
4853         }
4854         return NDR_ERR_SUCCESS;
4855 }
4856
4857 _PUBLIC_ void ndr_print_wkssvc_NetrUseEnumCtr2(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseEnumCtr2 *r)
4858 {
4859         uint32_t cntr_array_1;
4860         ndr_print_struct(ndr, name, "wkssvc_NetrUseEnumCtr2");
4861         ndr->depth++;
4862         ndr_print_uint32(ndr, "count", r->count);
4863         ndr_print_ptr(ndr, "array", r->array);
4864         ndr->depth++;
4865         if (r->array) {
4866                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
4867                 ndr->depth++;
4868                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
4869                         char *idx_1=NULL;
4870                         asprintf(&idx_1, "[%d]", cntr_array_1);
4871                         if (idx_1) {
4872                                 ndr_print_wkssvc_NetrUseInfo2(ndr, "array", &r->array[cntr_array_1]);
4873                                 free(idx_1);
4874                         }
4875                 }
4876                 ndr->depth--;
4877         }
4878         ndr->depth--;
4879         ndr->depth--;
4880 }
4881
4882 static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumCtr1(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseEnumCtr1 *r)
4883 {
4884         uint32_t cntr_array_1;
4885         if (ndr_flags & NDR_SCALARS) {
4886                 NDR_CHECK(ndr_push_align(ndr, 4));
4887                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4888                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
4889         }
4890         if (ndr_flags & NDR_BUFFERS) {
4891                 if (r->array) {
4892                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4893                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4894                                 NDR_CHECK(ndr_push_wkssvc_NetrUseInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4895                         }
4896                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4897                                 NDR_CHECK(ndr_push_wkssvc_NetrUseInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4898                         }
4899                 }
4900         }
4901         return NDR_ERR_SUCCESS;
4902 }
4903
4904 static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumCtr1(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseEnumCtr1 *r)
4905 {
4906         uint32_t _ptr_array;
4907         uint32_t cntr_array_1;
4908         TALLOC_CTX *_mem_save_array_0;
4909         TALLOC_CTX *_mem_save_array_1;
4910         if (ndr_flags & NDR_SCALARS) {
4911                 NDR_CHECK(ndr_pull_align(ndr, 4));
4912                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4913                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
4914                 if (_ptr_array) {
4915                         NDR_PULL_ALLOC(ndr, r->array);
4916                 } else {
4917                         r->array = NULL;
4918                 }
4919         }
4920         if (ndr_flags & NDR_BUFFERS) {
4921                 if (r->array) {
4922                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4923                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4924                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
4925                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
4926                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4927                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4928                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4929                                 NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4930                         }
4931                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4932                                 NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4933                         }
4934                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
4935                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
4936                 }
4937                 if (r->array) {
4938                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
4939                 }
4940         }
4941         return NDR_ERR_SUCCESS;
4942 }
4943
4944 _PUBLIC_ void ndr_print_wkssvc_NetrUseEnumCtr1(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseEnumCtr1 *r)
4945 {
4946         uint32_t cntr_array_1;
4947         ndr_print_struct(ndr, name, "wkssvc_NetrUseEnumCtr1");
4948         ndr->depth++;
4949         ndr_print_uint32(ndr, "count", r->count);
4950         ndr_print_ptr(ndr, "array", r->array);
4951         ndr->depth++;
4952         if (r->array) {
4953                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
4954                 ndr->depth++;
4955                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
4956                         char *idx_1=NULL;
4957                         asprintf(&idx_1, "[%d]", cntr_array_1);
4958                         if (idx_1) {
4959                                 ndr_print_wkssvc_NetrUseInfo1(ndr, "array", &r->array[cntr_array_1]);
4960                                 free(idx_1);
4961                         }
4962                 }
4963                 ndr->depth--;
4964         }
4965         ndr->depth--;
4966         ndr->depth--;
4967 }
4968
4969 static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumCtr0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseEnumCtr0 *r)
4970 {
4971         uint32_t cntr_array_1;
4972         if (ndr_flags & NDR_SCALARS) {
4973                 NDR_CHECK(ndr_push_align(ndr, 4));
4974                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4975                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
4976         }
4977         if (ndr_flags & NDR_BUFFERS) {
4978                 if (r->array) {
4979                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4980                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4981                                 NDR_CHECK(ndr_push_wkssvc_NetrUseInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4982                         }
4983                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4984                                 NDR_CHECK(ndr_push_wkssvc_NetrUseInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4985                         }
4986                 }
4987         }
4988         return NDR_ERR_SUCCESS;
4989 }
4990
4991 static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumCtr0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseEnumCtr0 *r)
4992 {
4993         uint32_t _ptr_array;
4994         uint32_t cntr_array_1;
4995         TALLOC_CTX *_mem_save_array_0;
4996         TALLOC_CTX *_mem_save_array_1;
4997         if (ndr_flags & NDR_SCALARS) {
4998                 NDR_CHECK(ndr_pull_align(ndr, 4));
4999                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5000                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
5001                 if (_ptr_array) {
5002                         NDR_PULL_ALLOC(ndr, r->array);
5003                 } else {
5004                         r->array = NULL;
5005                 }
5006         }
5007         if (ndr_flags & NDR_BUFFERS) {
5008                 if (r->array) {
5009                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5010                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5011                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
5012                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
5013                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5014                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5015                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5016                                 NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5017                         }
5018                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5019                                 NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5020                         }
5021                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
5022                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
5023                 }
5024                 if (r->array) {
5025                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
5026                 }
5027         }
5028         return NDR_ERR_SUCCESS;
5029 }
5030
5031 _PUBLIC_ void ndr_print_wkssvc_NetrUseEnumCtr0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseEnumCtr0 *r)
5032 {
5033         uint32_t cntr_array_1;
5034         ndr_print_struct(ndr, name, "wkssvc_NetrUseEnumCtr0");
5035         ndr->depth++;
5036         ndr_print_uint32(ndr, "count", r->count);
5037         ndr_print_ptr(ndr, "array", r->array);
5038         ndr->depth++;
5039         if (r->array) {
5040                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
5041                 ndr->depth++;
5042                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
5043                         char *idx_1=NULL;
5044                         asprintf(&idx_1, "[%d]", cntr_array_1);
5045                         if (idx_1) {
5046                                 ndr_print_wkssvc_NetrUseInfo0(ndr, "array", &r->array[cntr_array_1]);
5047                                 free(idx_1);
5048                         }
5049                 }
5050                 ndr->depth--;
5051         }
5052         ndr->depth--;
5053         ndr->depth--;
5054 }
5055
5056 static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumCtr(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetrUseEnumCtr *r)
5057 {
5058         if (ndr_flags & NDR_SCALARS) {
5059                 int level = ndr_push_get_switch_value(ndr, r);
5060                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5061                 switch (level) {
5062                         case 0:
5063                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
5064                         break;
5065
5066                         case 1:
5067                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
5068                         break;
5069
5070                         case 2:
5071                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr2));
5072                         break;
5073
5074                         default:
5075                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5076                 }
5077         }
5078         if (ndr_flags & NDR_BUFFERS) {
5079                 int level = ndr_push_get_switch_value(ndr, r);
5080                 switch (level) {
5081                         case 0:
5082                                 if (r->ctr0) {
5083                                         NDR_CHECK(ndr_push_wkssvc_NetrUseEnumCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
5084                                 }
5085                         break;
5086
5087                         case 1:
5088                                 if (r->ctr1) {
5089                                         NDR_CHECK(ndr_push_wkssvc_NetrUseEnumCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
5090                                 }
5091                         break;
5092
5093                         case 2:
5094                                 if (r->ctr2) {
5095                                         NDR_CHECK(ndr_push_wkssvc_NetrUseEnumCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
5096                                 }
5097                         break;
5098
5099                         default:
5100                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5101                 }
5102         }
5103         return NDR_ERR_SUCCESS;
5104 }
5105
5106 static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumCtr(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetrUseEnumCtr *r)
5107 {
5108         int level;
5109         uint32_t _level;
5110         TALLOC_CTX *_mem_save_ctr0_0;
5111         TALLOC_CTX *_mem_save_ctr1_0;
5112         TALLOC_CTX *_mem_save_ctr2_0;
5113         level = ndr_pull_get_switch_value(ndr, r);
5114         if (ndr_flags & NDR_SCALARS) {
5115                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5116                 if (_level != level) {
5117                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5118                 }
5119                 switch (level) {
5120                         case 0: {
5121                                 uint32_t _ptr_ctr0;
5122                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));
5123                                 if (_ptr_ctr0) {
5124                                         NDR_PULL_ALLOC(ndr, r->ctr0);
5125                                 } else {
5126                                         r->ctr0 = NULL;
5127                                 }
5128                         break; }
5129
5130                         case 1: {
5131                                 uint32_t _ptr_ctr1;
5132                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
5133                                 if (_ptr_ctr1) {
5134                                         NDR_PULL_ALLOC(ndr, r->ctr1);
5135                                 } else {
5136                                         r->ctr1 = NULL;
5137                                 }
5138                         break; }
5139
5140                         case 2: {
5141                                 uint32_t _ptr_ctr2;
5142                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr2));
5143                                 if (_ptr_ctr2) {
5144                                         NDR_PULL_ALLOC(ndr, r->ctr2);
5145                                 } else {
5146                                         r->ctr2 = NULL;
5147                                 }
5148                         break; }
5149
5150                         default:
5151                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5152                 }
5153         }
5154         if (ndr_flags & NDR_BUFFERS) {
5155                 switch (level) {
5156                         case 0:
5157                                 if (r->ctr0) {
5158                                         _mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);
5159                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr0, 0);
5160                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
5161                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);
5162                                 }
5163                         break;
5164
5165                         case 1:
5166                                 if (r->ctr1) {
5167                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5168                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
5169                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
5170                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
5171                                 }
5172                         break;
5173
5174                         case 2:
5175                                 if (r->ctr2) {
5176                                         _mem_save_ctr2_0 = NDR_PULL_GET_MEM_CTX(ndr);
5177                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr2, 0);
5178                                         NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
5179                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr2_0, 0);
5180                                 }
5181                         break;
5182
5183                         default:
5184                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5185                 }
5186         }
5187         return NDR_ERR_SUCCESS;
5188 }
5189
5190 _PUBLIC_ void ndr_print_wkssvc_NetrUseEnumCtr(struct ndr_print *ndr, const char *name, const union wkssvc_NetrUseEnumCtr *r)
5191 {
5192         int level;
5193         level = ndr_print_get_switch_value(ndr, r);
5194         ndr_print_union(ndr, name, level, "wkssvc_NetrUseEnumCtr");
5195         switch (level) {
5196                 case 0:
5197                         ndr_print_ptr(ndr, "ctr0", r->ctr0);
5198                         ndr->depth++;
5199                         if (r->ctr0) {
5200                                 ndr_print_wkssvc_NetrUseEnumCtr0(ndr, "ctr0", r->ctr0);
5201                         }
5202                         ndr->depth--;
5203                 break;
5204
5205                 case 1:
5206                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
5207                         ndr->depth++;
5208                         if (r->ctr1) {
5209                                 ndr_print_wkssvc_NetrUseEnumCtr1(ndr, "ctr1", r->ctr1);
5210                         }
5211                         ndr->depth--;
5212                 break;
5213
5214                 case 2:
5215                         ndr_print_ptr(ndr, "ctr2", r->ctr2);
5216                         ndr->depth++;
5217                         if (r->ctr2) {
5218                                 ndr_print_wkssvc_NetrUseEnumCtr2(ndr, "ctr2", r->ctr2);
5219                         }
5220                         ndr->depth--;
5221                 break;
5222
5223                 default:
5224                         ndr_print_bad_level(ndr, name, level);
5225         }
5226 }
5227
5228 static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumInfo(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseEnumInfo *r)
5229 {
5230         if (ndr_flags & NDR_SCALARS) {
5231                 NDR_CHECK(ndr_push_align(ndr, 4));
5232                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
5233                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
5234                 NDR_CHECK(ndr_push_wkssvc_NetrUseEnumCtr(ndr, NDR_SCALARS, &r->ctr));
5235         }
5236         if (ndr_flags & NDR_BUFFERS) {
5237                 NDR_CHECK(ndr_push_wkssvc_NetrUseEnumCtr(ndr, NDR_BUFFERS, &r->ctr));
5238         }
5239         return NDR_ERR_SUCCESS;
5240 }
5241
5242 static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumInfo(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseEnumInfo *r)
5243 {
5244         if (ndr_flags & NDR_SCALARS) {
5245                 NDR_CHECK(ndr_pull_align(ndr, 4));
5246                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
5247                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
5248                 NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumCtr(ndr, NDR_SCALARS, &r->ctr));
5249         }
5250         if (ndr_flags & NDR_BUFFERS) {
5251                 NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumCtr(ndr, NDR_BUFFERS, &r->ctr));
5252         }
5253         return NDR_ERR_SUCCESS;
5254 }
5255
5256 _PUBLIC_ void ndr_print_wkssvc_NetrUseEnumInfo(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseEnumInfo *r)
5257 {
5258         ndr_print_struct(ndr, name, "wkssvc_NetrUseEnumInfo");
5259         ndr->depth++;
5260         ndr_print_uint32(ndr, "level", r->level);
5261         ndr_print_set_switch_value(ndr, &r->ctr, r->level);
5262         ndr_print_wkssvc_NetrUseEnumCtr(ndr, "ctr", &r->ctr);
5263         ndr->depth--;
5264 }
5265
5266 static enum ndr_err_code ndr_push_wkssvc_NetrWorkstationStatistics(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrWorkstationStatistics *r)
5267 {
5268         if (ndr_flags & NDR_SCALARS) {
5269                 NDR_CHECK(ndr_push_align(ndr, 8));
5270                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown1));
5271                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown2));
5272                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown3));
5273                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown4));
5274                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown5));
5275                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown6));
5276                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown7));
5277                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown8));
5278                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown9));
5279                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown10));
5280                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown11));
5281                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown12));
5282                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown13));
5283                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown14));
5284                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown15));
5285                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown16));
5286                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown17));
5287                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown18));
5288                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown19));
5289                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown20));
5290                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown21));
5291                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown22));
5292                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown23));
5293                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown24));
5294                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown25));
5295                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown26));
5296                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown27));
5297                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown28));
5298                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown29));
5299                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown30));
5300                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown31));
5301                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown32));
5302                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown33));
5303                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown34));
5304                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown35));
5305                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown36));
5306                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown37));
5307                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown38));
5308                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown39));
5309                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown40));
5310         }
5311         if (ndr_flags & NDR_BUFFERS) {
5312         }
5313         return NDR_ERR_SUCCESS;
5314 }
5315
5316 static enum ndr_err_code ndr_pull_wkssvc_NetrWorkstationStatistics(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrWorkstationStatistics *r)
5317 {
5318         if (ndr_flags & NDR_SCALARS) {
5319                 NDR_CHECK(ndr_pull_align(ndr, 8));
5320                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown1));
5321                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown2));
5322                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown3));
5323                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown4));
5324                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown5));
5325                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown6));
5326                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown7));
5327                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown8));
5328                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown9));
5329                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown10));
5330                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown11));
5331                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown12));
5332                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown13));
5333                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown14));
5334                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown15));
5335                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown16));
5336                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown17));
5337                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown18));
5338                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown19));
5339                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown20));
5340                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown21));
5341                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown22));
5342                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown23));
5343                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown24));
5344                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown25));
5345                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown26));
5346                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown27));
5347                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown28));
5348                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown29));
5349                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown30));
5350                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown31));
5351                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown32));
5352                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown33));
5353                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown34));
5354                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown35));
5355                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown36));
5356                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown37));
5357                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown38));
5358                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown39));
5359                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown40));
5360         }
5361         if (ndr_flags & NDR_BUFFERS) {
5362         }
5363         return NDR_ERR_SUCCESS;
5364 }
5365
5366 _PUBLIC_ void ndr_print_wkssvc_NetrWorkstationStatistics(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrWorkstationStatistics *r)
5367 {
5368         ndr_print_struct(ndr, name, "wkssvc_NetrWorkstationStatistics");
5369         ndr->depth++;
5370         ndr_print_hyper(ndr, "unknown1", r->unknown1);
5371         ndr_print_hyper(ndr, "unknown2", r->unknown2);
5372         ndr_print_hyper(ndr, "unknown3", r->unknown3);
5373         ndr_print_hyper(ndr, "unknown4", r->unknown4);
5374         ndr_print_hyper(ndr, "unknown5", r->unknown5);
5375         ndr_print_hyper(ndr, "unknown6", r->unknown6);
5376         ndr_print_hyper(ndr, "unknown7", r->unknown7);
5377         ndr_print_hyper(ndr, "unknown8", r->unknown8);
5378         ndr_print_hyper(ndr, "unknown9", r->unknown9);
5379         ndr_print_hyper(ndr, "unknown10", r->unknown10);
5380         ndr_print_hyper(ndr, "unknown11", r->unknown11);
5381         ndr_print_hyper(ndr, "unknown12", r->unknown12);
5382         ndr_print_hyper(ndr, "unknown13", r->unknown13);
5383         ndr_print_uint32(ndr, "unknown14", r->unknown14);
5384         ndr_print_uint32(ndr, "unknown15", r->unknown15);
5385         ndr_print_uint32(ndr, "unknown16", r->unknown16);
5386         ndr_print_uint32(ndr, "unknown17", r->unknown17);
5387         ndr_print_uint32(ndr, "unknown18", r->unknown18);
5388         ndr_print_uint32(ndr, "unknown19", r->unknown19);
5389         ndr_print_uint32(ndr, "unknown20", r->unknown20);
5390         ndr_print_uint32(ndr, "unknown21", r->unknown21);
5391         ndr_print_uint32(ndr, "unknown22", r->unknown22);
5392         ndr_print_uint32(ndr, "unknown23", r->unknown23);
5393         ndr_print_uint32(ndr, "unknown24", r->unknown24);
5394         ndr_print_uint32(ndr, "unknown25", r->unknown25);
5395         ndr_print_uint32(ndr, "unknown26", r->unknown26);
5396         ndr_print_uint32(ndr, "unknown27", r->unknown27);
5397         ndr_print_uint32(ndr, "unknown28", r->unknown28);
5398         ndr_print_uint32(ndr, "unknown29", r->unknown29);
5399         ndr_print_uint32(ndr, "unknown30", r->unknown30);
5400         ndr_print_uint32(ndr, "unknown31", r->unknown31);
5401         ndr_print_uint32(ndr, "unknown32", r->unknown32);
5402         ndr_print_uint32(ndr, "unknown33", r->unknown33);
5403         ndr_print_uint32(ndr, "unknown34", r->unknown34);
5404         ndr_print_uint32(ndr, "unknown35", r->unknown35);
5405         ndr_print_uint32(ndr, "unknown36", r->unknown36);
5406         ndr_print_uint32(ndr, "unknown37", r->unknown37);
5407         ndr_print_uint32(ndr, "unknown38", r->unknown38);
5408         ndr_print_uint32(ndr, "unknown39", r->unknown39);
5409         ndr_print_uint32(ndr, "unknown40", r->unknown40);
5410         ndr->depth--;
5411 }
5412
5413 static enum ndr_err_code ndr_push_wkssvc_renameflags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
5414 {
5415         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5416         return NDR_ERR_SUCCESS;
5417 }
5418
5419 static enum ndr_err_code ndr_pull_wkssvc_renameflags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
5420 {
5421         uint32_t v;
5422         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5423         *r = v;
5424         return NDR_ERR_SUCCESS;
5425 }
5426
5427 _PUBLIC_ void ndr_print_wkssvc_renameflags(struct ndr_print *ndr, const char *name, uint32_t r)
5428 {
5429         ndr_print_uint32(ndr, name, r);
5430         ndr->depth++;
5431         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE", WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE, r);
5432         ndr->depth--;
5433 }
5434
5435 static enum ndr_err_code ndr_push_wkssvc_NetValidateNameType(struct ndr_push *ndr, int ndr_flags, enum wkssvc_NetValidateNameType r)
5436 {
5437         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
5438         return NDR_ERR_SUCCESS;
5439 }
5440
5441 static enum ndr_err_code ndr_pull_wkssvc_NetValidateNameType(struct ndr_pull *ndr, int ndr_flags, enum wkssvc_NetValidateNameType *r)
5442 {
5443         uint16_t v;
5444         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
5445         *r = v;
5446         return NDR_ERR_SUCCESS;
5447 }
5448
5449 _PUBLIC_ void ndr_print_wkssvc_NetValidateNameType(struct ndr_print *ndr, const char *name, enum wkssvc_NetValidateNameType r)
5450 {
5451         const char *val = NULL;
5452
5453         switch (r) {
5454                 case NetSetupUnknown: val = "NetSetupUnknown"; break;
5455                 case NetSetupMachine: val = "NetSetupMachine"; break;
5456                 case NetSetupWorkgroup: val = "NetSetupWorkgroup"; break;
5457                 case NetSetupDomain: val = "NetSetupDomain"; break;
5458                 case NetSetupNonExistentDomain: val = "NetSetupNonExistentDomain"; break;
5459                 case NetSetupDnsMachine: val = "NetSetupDnsMachine"; break;
5460         }
5461         ndr_print_enum(ndr, name, "ENUM", val, r);
5462 }
5463
5464 static enum ndr_err_code ndr_push_wkssvc_NetJoinStatus(struct ndr_push *ndr, int ndr_flags, enum wkssvc_NetJoinStatus r)
5465 {
5466         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
5467         return NDR_ERR_SUCCESS;
5468 }
5469
5470 static enum ndr_err_code ndr_pull_wkssvc_NetJoinStatus(struct ndr_pull *ndr, int ndr_flags, enum wkssvc_NetJoinStatus *r)
5471 {
5472         uint16_t v;
5473         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
5474         *r = v;
5475         return NDR_ERR_SUCCESS;
5476 }
5477
5478 _PUBLIC_ void ndr_print_wkssvc_NetJoinStatus(struct ndr_print *ndr, const char *name, enum wkssvc_NetJoinStatus r)
5479 {
5480         const char *val = NULL;
5481
5482         switch (r) {
5483                 case NetSetupUnknownStatus: val = "NetSetupUnknownStatus"; break;
5484                 case NetSetupUnjoined: val = "NetSetupUnjoined"; break;
5485                 case NetSetupWorkgroupName: val = "NetSetupWorkgroupName"; break;
5486                 case NetSetupDomainName: val = "NetSetupDomainName"; break;
5487         }
5488         ndr_print_enum(ndr, name, "ENUM", val, r);
5489 }
5490
5491 static enum ndr_err_code ndr_push_wkssvc_PasswordBuffer(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_PasswordBuffer *r)
5492 {
5493         {
5494                 uint32_t _flags_save_STRUCT = ndr->flags;
5495                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
5496                 if (ndr_flags & NDR_SCALARS) {
5497                         NDR_CHECK(ndr_push_align(ndr, 1));
5498                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, 524));
5499                 }
5500                 if (ndr_flags & NDR_BUFFERS) {
5501                 }
5502                 ndr->flags = _flags_save_STRUCT;
5503         }
5504         return NDR_ERR_SUCCESS;
5505 }
5506
5507 static enum ndr_err_code ndr_pull_wkssvc_PasswordBuffer(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_PasswordBuffer *r)
5508 {
5509         {
5510                 uint32_t _flags_save_STRUCT = ndr->flags;
5511                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
5512                 if (ndr_flags & NDR_SCALARS) {
5513                         NDR_CHECK(ndr_pull_align(ndr, 1));
5514                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, 524));
5515                 }
5516                 if (ndr_flags & NDR_BUFFERS) {
5517                 }
5518                 ndr->flags = _flags_save_STRUCT;
5519         }
5520         return NDR_ERR_SUCCESS;
5521 }
5522
5523 _PUBLIC_ void ndr_print_wkssvc_PasswordBuffer(struct ndr_print *ndr, const char *name, const struct wkssvc_PasswordBuffer *r)
5524 {
5525         ndr_print_struct(ndr, name, "wkssvc_PasswordBuffer");
5526         {
5527                 uint32_t _flags_save_STRUCT = ndr->flags;
5528                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
5529                 ndr->depth++;
5530                 ndr_print_array_uint8(ndr, "data", r->data, 524);
5531                 ndr->depth--;
5532                 ndr->flags = _flags_save_STRUCT;
5533         }
5534 }
5535
5536 static enum ndr_err_code ndr_push_wkssvc_joinflags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
5537 {
5538         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5539         return NDR_ERR_SUCCESS;
5540 }
5541
5542 static enum ndr_err_code ndr_pull_wkssvc_joinflags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
5543 {
5544         uint32_t v;
5545         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5546         *r = v;
5547         return NDR_ERR_SUCCESS;
5548 }
5549
5550 _PUBLIC_ void ndr_print_wkssvc_joinflags(struct ndr_print *ndr, const char *name, uint32_t r)
5551 {
5552         ndr_print_uint32(ndr, name, r);
5553         ndr->depth++;
5554         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_JOIN_WITH_NEW_NAME", WKSSVC_JOIN_FLAGS_JOIN_WITH_NEW_NAME, r);
5555         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_JOIN_DC_ACCOUNT", WKSSVC_JOIN_FLAGS_JOIN_DC_ACCOUNT, r);
5556         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_DEFER_SPN", WKSSVC_JOIN_FLAGS_DEFER_SPN, r);
5557         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_MACHINE_PWD_PASSED", WKSSVC_JOIN_FLAGS_MACHINE_PWD_PASSED, r);
5558         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_JOIN_UNSECURE", WKSSVC_JOIN_FLAGS_JOIN_UNSECURE, r);
5559         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_DOMAIN_JOIN_IF_JOINED", WKSSVC_JOIN_FLAGS_DOMAIN_JOIN_IF_JOINED, r);
5560         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_WIN9X_UPGRADE", WKSSVC_JOIN_FLAGS_WIN9X_UPGRADE, r);
5561         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_ACCOUNT_DELETE", WKSSVC_JOIN_FLAGS_ACCOUNT_DELETE, r);
5562         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE", WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE, r);
5563         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_JOIN_TYPE", WKSSVC_JOIN_FLAGS_JOIN_TYPE, r);
5564         ndr->depth--;
5565 }
5566
5567 static enum ndr_err_code ndr_push_wkssvc_ComputerNameType(struct ndr_push *ndr, int ndr_flags, enum wkssvc_ComputerNameType r)
5568 {
5569         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
5570         return NDR_ERR_SUCCESS;
5571 }
5572
5573 static enum ndr_err_code ndr_pull_wkssvc_ComputerNameType(struct ndr_pull *ndr, int ndr_flags, enum wkssvc_ComputerNameType *r)
5574 {
5575         uint16_t v;
5576         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
5577         *r = v;
5578         return NDR_ERR_SUCCESS;
5579 }
5580
5581 _PUBLIC_ void ndr_print_wkssvc_ComputerNameType(struct ndr_print *ndr, const char *name, enum wkssvc_ComputerNameType r)
5582 {
5583         const char *val = NULL;
5584
5585         switch (r) {
5586                 case NetPrimaryComputerName: val = "NetPrimaryComputerName"; break;
5587                 case NetAlternateComputerNames: val = "NetAlternateComputerNames"; break;
5588                 case NetAllComputerNames: val = "NetAllComputerNames"; break;
5589                 case NetComputerNameTypeMax: val = "NetComputerNameTypeMax"; break;
5590         }
5591         ndr_print_enum(ndr, name, "ENUM", val, r);
5592 }
5593
5594 static enum ndr_err_code ndr_push_wkssvc_ComputerNamesCtr(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_ComputerNamesCtr *r)
5595 {
5596         uint32_t cntr_computer_name_1;
5597         if (ndr_flags & NDR_SCALARS) {
5598                 NDR_CHECK(ndr_push_align(ndr, 4));
5599                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5600                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_name));
5601         }
5602         if (ndr_flags & NDR_BUFFERS) {
5603                 if (r->computer_name) {
5604                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5605                         for (cntr_computer_name_1 = 0; cntr_computer_name_1 < r->count; cntr_computer_name_1++) {
5606                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->computer_name[cntr_computer_name_1]));
5607                         }
5608                         for (cntr_computer_name_1 = 0; cntr_computer_name_1 < r->count; cntr_computer_name_1++) {
5609                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->computer_name[cntr_computer_name_1]));
5610                         }
5611                 }
5612         }
5613         return NDR_ERR_SUCCESS;
5614 }
5615
5616 static enum ndr_err_code ndr_pull_wkssvc_ComputerNamesCtr(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_ComputerNamesCtr *r)
5617 {
5618         uint32_t _ptr_computer_name;
5619         uint32_t cntr_computer_name_1;
5620         TALLOC_CTX *_mem_save_computer_name_0;
5621         TALLOC_CTX *_mem_save_computer_name_1;
5622         if (ndr_flags & NDR_SCALARS) {
5623                 NDR_CHECK(ndr_pull_align(ndr, 4));
5624                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5625                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_name));
5626                 if (_ptr_computer_name) {
5627                         NDR_PULL_ALLOC(ndr, r->computer_name);
5628                 } else {
5629                         r->computer_name = NULL;
5630                 }
5631         }
5632         if (ndr_flags & NDR_BUFFERS) {
5633                 if (r->computer_name) {
5634                         _mem_save_computer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5635                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_name, 0);
5636                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_name));
5637                         NDR_PULL_ALLOC_N(ndr, r->computer_name, ndr_get_array_size(ndr, &r->computer_name));
5638                         _mem_save_computer_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
5639                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_name, 0);
5640                         for (cntr_computer_name_1 = 0; cntr_computer_name_1 < r->count; cntr_computer_name_1++) {
5641                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->computer_name[cntr_computer_name_1]));
5642                         }
5643                         for (cntr_computer_name_1 = 0; cntr_computer_name_1 < r->count; cntr_computer_name_1++) {
5644                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->computer_name[cntr_computer_name_1]));
5645                         }
5646                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_name_1, 0);
5647                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_name_0, 0);
5648                 }
5649                 if (r->computer_name) {
5650                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->computer_name, r->count));
5651                 }
5652         }
5653         return NDR_ERR_SUCCESS;
5654 }
5655
5656 _PUBLIC_ void ndr_print_wkssvc_ComputerNamesCtr(struct ndr_print *ndr, const char *name, const struct wkssvc_ComputerNamesCtr *r)
5657 {
5658         uint32_t cntr_computer_name_1;
5659         ndr_print_struct(ndr, name, "wkssvc_ComputerNamesCtr");
5660         ndr->depth++;
5661         ndr_print_uint32(ndr, "count", r->count);
5662         ndr_print_ptr(ndr, "computer_name", r->computer_name);
5663         ndr->depth++;
5664         if (r->computer_name) {
5665                 ndr->print(ndr, "%s: ARRAY(%d)", "computer_name", r->count);
5666                 ndr->depth++;
5667                 for (cntr_computer_name_1=0;cntr_computer_name_1<r->count;cntr_computer_name_1++) {
5668                         char *idx_1=NULL;
5669                         asprintf(&idx_1, "[%d]", cntr_computer_name_1);
5670                         if (idx_1) {
5671                                 ndr_print_lsa_String(ndr, "computer_name", &r->computer_name[cntr_computer_name_1]);
5672                                 free(idx_1);
5673                         }
5674                 }
5675                 ndr->depth--;
5676         }
5677         ndr->depth--;
5678         ndr->depth--;
5679 }
5680
5681 static enum ndr_err_code ndr_push_wkssvc_NetWkstaGetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaGetInfo *r)
5682 {
5683         if (flags & NDR_IN) {
5684                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
5685                 if (r->in.server_name) {
5686                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
5687                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5688                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
5689                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5690                 }
5691                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
5692         }
5693         if (flags & NDR_OUT) {
5694                 if (r->out.info == NULL) {
5695                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5696                 }
5697                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
5698                 NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
5699                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5700         }
5701         return NDR_ERR_SUCCESS;
5702 }
5703
5704 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaGetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaGetInfo *r)
5705 {
5706         uint32_t _ptr_server_name;
5707         TALLOC_CTX *_mem_save_server_name_0;
5708         TALLOC_CTX *_mem_save_info_0;
5709         if (flags & NDR_IN) {
5710                 ZERO_STRUCT(r->out);
5711
5712                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5713                 if (_ptr_server_name) {
5714                         NDR_PULL_ALLOC(ndr, r->in.server_name);
5715                 } else {
5716                         r->in.server_name = NULL;
5717                 }
5718                 if (r->in.server_name) {
5719                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5720                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
5721                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
5722                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
5723                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
5724                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server_name), ndr_get_array_length(ndr, &r->in.server_name));
5725                         }
5726                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
5727                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
5728                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5729                 }
5730                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
5731                 NDR_PULL_ALLOC(ndr, r->out.info);
5732                 ZERO_STRUCTP(r->out.info);
5733         }
5734         if (flags & NDR_OUT) {
5735                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5736                         NDR_PULL_ALLOC(ndr, r->out.info);
5737                 }
5738                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
5739                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
5740                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
5741                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
5742                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
5743                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5744         }
5745         return NDR_ERR_SUCCESS;
5746 }
5747
5748 _PUBLIC_ void ndr_print_wkssvc_NetWkstaGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaGetInfo *r)
5749 {
5750         ndr_print_struct(ndr, name, "wkssvc_NetWkstaGetInfo");
5751         ndr->depth++;
5752         if (flags & NDR_SET_VALUES) {
5753                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5754         }
5755         if (flags & NDR_IN) {
5756                 ndr_print_struct(ndr, "in", "wkssvc_NetWkstaGetInfo");
5757                 ndr->depth++;
5758                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
5759                 ndr->depth++;
5760                 if (r->in.server_name) {
5761                         ndr_print_string(ndr, "server_name", r->in.server_name);
5762                 }
5763                 ndr->depth--;
5764                 ndr_print_uint32(ndr, "level", r->in.level);
5765                 ndr->depth--;
5766         }
5767         if (flags & NDR_OUT) {
5768                 ndr_print_struct(ndr, "out", "wkssvc_NetWkstaGetInfo");
5769                 ndr->depth++;
5770                 ndr_print_ptr(ndr, "info", r->out.info);
5771                 ndr->depth++;
5772                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
5773                 ndr_print_wkssvc_NetWkstaInfo(ndr, "info", r->out.info);
5774                 ndr->depth--;
5775                 ndr_print_WERROR(ndr, "result", r->out.result);
5776                 ndr->depth--;
5777         }
5778         ndr->depth--;
5779 }
5780
5781 static enum ndr_err_code ndr_push_wkssvc_NetWkstaSetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaSetInfo *r)
5782 {
5783         if (flags & NDR_IN) {
5784                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
5785                 if (r->in.server_name) {
5786                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
5787                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5788                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
5789                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5790                 }
5791                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
5792                 if (r->in.info == NULL) {
5793                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5794                 }
5795                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
5796                 NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
5797                 if (r->in.parm_error == NULL) {
5798                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5799                 }
5800                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_error));
5801         }
5802         if (flags & NDR_OUT) {
5803                 if (r->out.parm_error == NULL) {
5804                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5805                 }
5806                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_error));
5807                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5808         }
5809         return NDR_ERR_SUCCESS;
5810 }
5811
5812 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaSetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaSetInfo *r)
5813 {
5814         uint32_t _ptr_server_name;
5815         TALLOC_CTX *_mem_save_server_name_0;
5816         TALLOC_CTX *_mem_save_info_0;
5817         TALLOC_CTX *_mem_save_parm_error_0;
5818         if (flags & NDR_IN) {
5819                 ZERO_STRUCT(r->out);
5820
5821                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5822                 if (_ptr_server_name) {
5823                         NDR_PULL_ALLOC(ndr, r->in.server_name);
5824                 } else {
5825                         r->in.server_name = NULL;
5826                 }
5827                 if (r->in.server_name) {
5828                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5829                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
5830                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
5831                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
5832                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
5833                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server_name), ndr_get_array_length(ndr, &r->in.server_name));
5834                         }
5835                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
5836                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
5837                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5838                 }
5839                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
5840                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5841                         NDR_PULL_ALLOC(ndr, r->in.info);
5842                 }
5843                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
5844                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
5845                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
5846                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
5847                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
5848                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5849                         NDR_PULL_ALLOC(ndr, r->in.parm_error);
5850                 }
5851                 _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
5852                 NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_error, LIBNDR_FLAG_REF_ALLOC);
5853                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_error));
5854                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, LIBNDR_FLAG_REF_ALLOC);
5855                 NDR_PULL_ALLOC(ndr, r->out.parm_error);
5856                 *r->out.parm_error = *r->in.parm_error;
5857         }
5858         if (flags & NDR_OUT) {
5859                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5860                         NDR_PULL_ALLOC(ndr, r->out.parm_error);
5861                 }
5862                 _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
5863                 NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_error, LIBNDR_FLAG_REF_ALLOC);
5864                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_error));
5865                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, LIBNDR_FLAG_REF_ALLOC);
5866                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5867         }
5868         return NDR_ERR_SUCCESS;
5869 }
5870
5871 _PUBLIC_ void ndr_print_wkssvc_NetWkstaSetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaSetInfo *r)
5872 {
5873         ndr_print_struct(ndr, name, "wkssvc_NetWkstaSetInfo");
5874         ndr->depth++;
5875         if (flags & NDR_SET_VALUES) {
5876                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5877         }
5878         if (flags & NDR_IN) {
5879                 ndr_print_struct(ndr, "in", "wkssvc_NetWkstaSetInfo");
5880                 ndr->depth++;
5881                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
5882                 ndr->depth++;
5883                 if (r->in.server_name) {
5884                         ndr_print_string(ndr, "server_name", r->in.server_name);
5885                 }
5886                 ndr->depth--;
5887                 ndr_print_uint32(ndr, "level", r->in.level);
5888                 ndr_print_ptr(ndr, "info", r->in.info);
5889                 ndr->depth++;
5890                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
5891                 ndr_print_wkssvc_NetWkstaInfo(ndr, "info", r->in.info);
5892                 ndr->depth--;
5893                 ndr_print_ptr(ndr, "parm_error", r->in.parm_error);
5894                 ndr->depth++;
5895                 ndr_print_uint32(ndr, "parm_error", *r->in.parm_error);
5896                 ndr->depth--;
5897                 ndr->depth--;
5898         }
5899         if (flags & NDR_OUT) {
5900                 ndr_print_struct(ndr, "out", "wkssvc_NetWkstaSetInfo");
5901                 ndr->depth++;
5902                 ndr_print_ptr(ndr, "parm_error", r->out.parm_error);
5903                 ndr->depth++;
5904                 ndr_print_uint32(ndr, "parm_error", *r->out.parm_error);
5905                 ndr->depth--;
5906                 ndr_print_WERROR(ndr, "result", r->out.result);
5907                 ndr->depth--;
5908         }
5909         ndr->depth--;
5910 }
5911
5912 static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsers(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaEnumUsers *r)
5913 {
5914         if (flags & NDR_IN) {
5915                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
5916                 if (r->in.server_name) {
5917                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
5918                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5919                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
5920                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5921                 }
5922                 if (r->in.info == NULL) {
5923                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5924                 }
5925                 NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
5926                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.prefmaxlen));
5927                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
5928                 if (r->in.resume_handle) {
5929                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
5930                 }
5931         }
5932         if (flags & NDR_OUT) {
5933                 if (r->out.info == NULL) {
5934                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5935                 }
5936                 NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
5937                 if (r->out.entries_read == NULL) {
5938                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5939                 }
5940                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.entries_read));
5941                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
5942                 if (r->out.resume_handle) {
5943                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
5944                 }
5945                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5946         }
5947         return NDR_ERR_SUCCESS;
5948 }
5949
5950 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsers(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaEnumUsers *r)
5951 {
5952         uint32_t _ptr_server_name;
5953         uint32_t _ptr_resume_handle;
5954         TALLOC_CTX *_mem_save_server_name_0;
5955         TALLOC_CTX *_mem_save_info_0;
5956         TALLOC_CTX *_mem_save_entries_read_0;
5957         TALLOC_CTX *_mem_save_resume_handle_0;
5958         if (flags & NDR_IN) {
5959                 ZERO_STRUCT(r->out);
5960
5961                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5962                 if (_ptr_server_name) {
5963                         NDR_PULL_ALLOC(ndr, r->in.server_name);
5964                 } else {
5965                         r->in.server_name = NULL;
5966                 }
5967                 if (r->in.server_name) {
5968                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5969                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
5970                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
5971                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
5972                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
5973                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server_name), ndr_get_array_length(ndr, &r->in.server_name));
5974                         }
5975                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
5976                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
5977                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5978                 }
5979                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5980                         NDR_PULL_ALLOC(ndr, r->in.info);
5981                 }
5982                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
5983                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
5984                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
5985                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
5986                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.prefmaxlen));
5987                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
5988                 if (_ptr_resume_handle) {
5989                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
5990                 } else {
5991                         r->in.resume_handle = NULL;
5992                 }
5993                 if (r->in.resume_handle) {
5994                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5995                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
5996                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
5997                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
5998                 }
5999                 NDR_PULL_ALLOC(ndr, r->out.info);
6000                 *r->out.info = *r->in.info;
6001                 NDR_PULL_ALLOC(ndr, r->out.entries_read);
6002                 ZERO_STRUCTP(r->out.entries_read);
6003         }
6004         if (flags & NDR_OUT) {
6005                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6006                         NDR_PULL_ALLOC(ndr, r->out.info);
6007                 }
6008                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6009                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
6010                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
6011                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6012                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6013                         NDR_PULL_ALLOC(ndr, r->out.entries_read);
6014                 }
6015                 _mem_save_entries_read_0 = NDR_PULL_GET_MEM_CTX(ndr);
6016                 NDR_PULL_SET_MEM_CTX(ndr, r->out.entries_read, LIBNDR_FLAG_REF_ALLOC);
6017                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.entries_read));
6018                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_read_0, LIBNDR_FLAG_REF_ALLOC);
6019                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
6020                 if (_ptr_resume_handle) {
6021                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6022                 } else {
6023                         r->out.resume_handle = NULL;
6024                 }
6025                 if (r->out.resume_handle) {
6026                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6027                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
6028                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
6029                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
6030                 }
6031                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6032         }
6033         return NDR_ERR_SUCCESS;
6034 }
6035
6036 _PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsers(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaEnumUsers *r)
6037 {
6038         ndr_print_struct(ndr, name, "wkssvc_NetWkstaEnumUsers");
6039         ndr->depth++;
6040         if (flags & NDR_SET_VALUES) {
6041                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6042         }
6043         if (flags & NDR_IN) {
6044                 ndr_print_struct(ndr, "in", "wkssvc_NetWkstaEnumUsers");
6045                 ndr->depth++;
6046                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
6047                 ndr->depth++;
6048                 if (r->in.server_name) {
6049                         ndr_print_string(ndr, "server_name", r->in.server_name);
6050                 }
6051                 ndr->depth--;
6052                 ndr_print_ptr(ndr, "info", r->in.info);
6053                 ndr->depth++;
6054                 ndr_print_wkssvc_NetWkstaEnumUsersInfo(ndr, "info", r->in.info);
6055                 ndr->depth--;
6056                 ndr_print_uint32(ndr, "prefmaxlen", r->in.prefmaxlen);
6057                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
6058                 ndr->depth++;
6059                 if (r->in.resume_handle) {
6060                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
6061                 }
6062                 ndr->depth--;
6063                 ndr->depth--;
6064         }
6065         if (flags & NDR_OUT) {
6066                 ndr_print_struct(ndr, "out", "wkssvc_NetWkstaEnumUsers");
6067                 ndr->depth++;
6068                 ndr_print_ptr(ndr, "info", r->out.info);
6069                 ndr->depth++;
6070                 ndr_print_wkssvc_NetWkstaEnumUsersInfo(ndr, "info", r->out.info);
6071                 ndr->depth--;
6072                 ndr_print_ptr(ndr, "entries_read", r->out.entries_read);
6073                 ndr->depth++;
6074                 ndr_print_uint32(ndr, "entries_read", *r->out.entries_read);
6075                 ndr->depth--;
6076                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
6077                 ndr->depth++;
6078                 if (r->out.resume_handle) {
6079                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
6080                 }
6081                 ndr->depth--;
6082                 ndr_print_WERROR(ndr, "result", r->out.result);
6083                 ndr->depth--;
6084         }
6085         ndr->depth--;
6086 }
6087
6088 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserGetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetrWkstaUserGetInfo *r)
6089 {
6090         if (flags & NDR_IN) {
6091                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown));
6092                 if (r->in.unknown) {
6093                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));
6094                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6095                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));
6096                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.unknown, ndr_charset_length(r->in.unknown, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6097                 }
6098                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
6099         }
6100         if (flags & NDR_OUT) {
6101                 if (r->out.info == NULL) {
6102                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6103                 }
6104                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
6105                 NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
6106                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6107         }
6108         return NDR_ERR_SUCCESS;
6109 }
6110
6111 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserGetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetrWkstaUserGetInfo *r)
6112 {
6113         uint32_t _ptr_unknown;
6114         TALLOC_CTX *_mem_save_unknown_0;
6115         TALLOC_CTX *_mem_save_info_0;
6116         if (flags & NDR_IN) {
6117                 ZERO_STRUCT(r->out);
6118
6119                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown));
6120                 if (_ptr_unknown) {
6121                         NDR_PULL_ALLOC(ndr, r->in.unknown);
6122                 } else {
6123                         r->in.unknown = NULL;
6124                 }
6125                 if (r->in.unknown) {
6126                         _mem_save_unknown_0 = NDR_PULL_GET_MEM_CTX(ndr);
6127                         NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown, 0);
6128                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.unknown));
6129                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.unknown));
6130                         if (ndr_get_array_length(ndr, &r->in.unknown) > ndr_get_array_size(ndr, &r->in.unknown)) {
6131                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.unknown), ndr_get_array_length(ndr, &r->in.unknown));
6132                         }
6133                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t)));
6134                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.unknown, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t), CH_UTF16));
6135                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown_0, 0);
6136                 }
6137                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
6138                 NDR_PULL_ALLOC(ndr, r->out.info);
6139                 ZERO_STRUCTP(r->out.info);
6140         }
6141         if (flags & NDR_OUT) {
6142                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6143                         NDR_PULL_ALLOC(ndr, r->out.info);
6144                 }
6145                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6146                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
6147                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
6148                 NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
6149                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6150                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6151         }
6152         return NDR_ERR_SUCCESS;
6153 }
6154
6155 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrWkstaUserGetInfo *r)
6156 {
6157         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaUserGetInfo");
6158         ndr->depth++;
6159         if (flags & NDR_SET_VALUES) {
6160                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6161         }
6162         if (flags & NDR_IN) {
6163                 ndr_print_struct(ndr, "in", "wkssvc_NetrWkstaUserGetInfo");
6164                 ndr->depth++;
6165                 ndr_print_ptr(ndr, "unknown", r->in.unknown);
6166                 ndr->depth++;
6167                 if (r->in.unknown) {
6168                         ndr_print_string(ndr, "unknown", r->in.unknown);
6169                 }
6170                 ndr->depth--;
6171                 ndr_print_uint32(ndr, "level", r->in.level);
6172                 ndr->depth--;
6173         }
6174         if (flags & NDR_OUT) {
6175                 ndr_print_struct(ndr, "out", "wkssvc_NetrWkstaUserGetInfo");
6176                 ndr->depth++;
6177                 ndr_print_ptr(ndr, "info", r->out.info);
6178                 ndr->depth++;
6179                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
6180                 ndr_print_wkssvc_NetrWkstaUserInfo(ndr, "info", r->out.info);
6181                 ndr->depth--;
6182                 ndr_print_WERROR(ndr, "result", r->out.result);
6183                 ndr->depth--;
6184         }
6185         ndr->depth--;
6186 }
6187
6188 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserSetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetrWkstaUserSetInfo *r)
6189 {
6190         if (flags & NDR_IN) {
6191                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown));
6192                 if (r->in.unknown) {
6193                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));
6194                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6195                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));
6196                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.unknown, ndr_charset_length(r->in.unknown, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6197                 }
6198                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
6199                 if (r->in.info == NULL) {
6200                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6201                 }
6202                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
6203                 NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6204                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_err));
6205                 if (r->in.parm_err) {
6206                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_err));
6207                 }
6208         }
6209         if (flags & NDR_OUT) {
6210                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_err));
6211                 if (r->out.parm_err) {
6212                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_err));
6213                 }
6214                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6215         }
6216         return NDR_ERR_SUCCESS;
6217 }
6218
6219 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserSetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetrWkstaUserSetInfo *r)
6220 {
6221         uint32_t _ptr_unknown;
6222         uint32_t _ptr_parm_err;
6223         TALLOC_CTX *_mem_save_unknown_0;
6224         TALLOC_CTX *_mem_save_info_0;
6225         TALLOC_CTX *_mem_save_parm_err_0;
6226         if (flags & NDR_IN) {
6227                 ZERO_STRUCT(r->out);
6228
6229                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown));
6230                 if (_ptr_unknown) {
6231                         NDR_PULL_ALLOC(ndr, r->in.unknown);
6232                 } else {
6233                         r->in.unknown = NULL;
6234                 }
6235                 if (r->in.unknown) {
6236                         _mem_save_unknown_0 = NDR_PULL_GET_MEM_CTX(ndr);
6237                         NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown, 0);
6238                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.unknown));
6239                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.unknown));
6240                         if (ndr_get_array_length(ndr, &r->in.unknown) > ndr_get_array_size(ndr, &r->in.unknown)) {
6241                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.unknown), ndr_get_array_length(ndr, &r->in.unknown));
6242                         }
6243                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t)));
6244                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.unknown, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t), CH_UTF16));
6245                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown_0, 0);
6246                 }
6247                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
6248                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6249                         NDR_PULL_ALLOC(ndr, r->in.info);
6250                 }
6251                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6252                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
6253                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
6254                 NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6255                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6256                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));
6257                 if (_ptr_parm_err) {
6258                         NDR_PULL_ALLOC(ndr, r->in.parm_err);
6259                 } else {
6260                         r->in.parm_err = NULL;
6261                 }
6262                 if (r->in.parm_err) {
6263                         _mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);
6264                         NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_err, 0);
6265                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_err));
6266                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);
6267                 }
6268         }
6269         if (flags & NDR_OUT) {
6270                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));
6271                 if (_ptr_parm_err) {
6272                         NDR_PULL_ALLOC(ndr, r->out.parm_err);
6273                 } else {
6274                         r->out.parm_err = NULL;
6275                 }
6276                 if (r->out.parm_err) {
6277                         _mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);
6278                         NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_err, 0);
6279                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_err));
6280                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);
6281                 }
6282                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6283         }
6284         return NDR_ERR_SUCCESS;
6285 }
6286
6287 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserSetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrWkstaUserSetInfo *r)
6288 {
6289         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaUserSetInfo");
6290         ndr->depth++;
6291         if (flags & NDR_SET_VALUES) {
6292                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6293         }
6294         if (flags & NDR_IN) {
6295                 ndr_print_struct(ndr, "in", "wkssvc_NetrWkstaUserSetInfo");
6296                 ndr->depth++;
6297                 ndr_print_ptr(ndr, "unknown", r->in.unknown);
6298                 ndr->depth++;
6299                 if (r->in.unknown) {
6300                         ndr_print_string(ndr, "unknown", r->in.unknown);
6301                 }
6302                 ndr->depth--;
6303                 ndr_print_uint32(ndr, "level", r->in.level);
6304                 ndr_print_ptr(ndr, "info", r->in.info);
6305                 ndr->depth++;
6306                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
6307                 ndr_print_wkssvc_NetrWkstaUserInfo(ndr, "info", r->in.info);
6308                 ndr->depth--;
6309                 ndr_print_ptr(ndr, "parm_err", r->in.parm_err);
6310                 ndr->depth++;
6311                 if (r->in.parm_err) {
6312                         ndr_print_uint32(ndr, "parm_err", *r->in.parm_err);
6313                 }
6314                 ndr->depth--;
6315                 ndr->depth--;
6316         }
6317         if (flags & NDR_OUT) {
6318                 ndr_print_struct(ndr, "out", "wkssvc_NetrWkstaUserSetInfo");
6319                 ndr->depth++;
6320                 ndr_print_ptr(ndr, "parm_err", r->out.parm_err);
6321                 ndr->depth++;
6322                 if (r->out.parm_err) {
6323                         ndr_print_uint32(ndr, "parm_err", *r->out.parm_err);
6324                 }
6325                 ndr->depth--;
6326                 ndr_print_WERROR(ndr, "result", r->out.result);
6327                 ndr->depth--;
6328         }
6329         ndr->depth--;
6330 }
6331
6332 static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportEnum(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaTransportEnum *r)
6333 {
6334         if (flags & NDR_IN) {
6335                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
6336                 if (r->in.server_name) {
6337                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6338                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6339                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6340                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6341                 }
6342                 if (r->in.info == NULL) {
6343                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6344                 }
6345                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6346                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));
6347                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
6348                 if (r->in.resume_handle) {
6349                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
6350                 }
6351         }
6352         if (flags & NDR_OUT) {
6353                 if (r->out.info == NULL) {
6354                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6355                 }
6356                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
6357                 if (r->out.total_entries == NULL) {
6358                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6359                 }
6360                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_entries));
6361                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
6362                 if (r->out.resume_handle) {
6363                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
6364                 }
6365                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6366         }
6367         return NDR_ERR_SUCCESS;
6368 }
6369
6370 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportEnum(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaTransportEnum *r)
6371 {
6372         uint32_t _ptr_server_name;
6373         uint32_t _ptr_resume_handle;
6374         TALLOC_CTX *_mem_save_server_name_0;
6375         TALLOC_CTX *_mem_save_info_0;
6376         TALLOC_CTX *_mem_save_total_entries_0;
6377         TALLOC_CTX *_mem_save_resume_handle_0;
6378         if (flags & NDR_IN) {
6379                 ZERO_STRUCT(r->out);
6380
6381                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6382                 if (_ptr_server_name) {
6383                         NDR_PULL_ALLOC(ndr, r->in.server_name);
6384                 } else {
6385                         r->in.server_name = NULL;
6386                 }
6387                 if (r->in.server_name) {
6388                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6389                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
6390                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
6391                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
6392                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
6393                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server_name), ndr_get_array_length(ndr, &r->in.server_name));
6394                         }
6395                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
6396                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
6397                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6398                 }
6399                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6400                         NDR_PULL_ALLOC(ndr, r->in.info);
6401                 }
6402                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6403                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
6404                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6405                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6406                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));
6407                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
6408                 if (_ptr_resume_handle) {
6409                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
6410                 } else {
6411                         r->in.resume_handle = NULL;
6412                 }
6413                 if (r->in.resume_handle) {
6414                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6415                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
6416                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
6417                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
6418                 }
6419                 NDR_PULL_ALLOC(ndr, r->out.info);
6420                 *r->out.info = *r->in.info;
6421                 NDR_PULL_ALLOC(ndr, r->out.total_entries);
6422                 ZERO_STRUCTP(r->out.total_entries);
6423         }
6424         if (flags & NDR_OUT) {
6425                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6426                         NDR_PULL_ALLOC(ndr, r->out.info);
6427                 }
6428                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6429                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
6430                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
6431                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6432                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6433                         NDR_PULL_ALLOC(ndr, r->out.total_entries);
6434                 }
6435                 _mem_save_total_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
6436                 NDR_PULL_SET_MEM_CTX(ndr, r->out.total_entries, LIBNDR_FLAG_REF_ALLOC);
6437                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_entries));
6438                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_entries_0, LIBNDR_FLAG_REF_ALLOC);
6439                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
6440                 if (_ptr_resume_handle) {
6441                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6442                 } else {
6443                         r->out.resume_handle = NULL;
6444                 }
6445                 if (r->out.resume_handle) {
6446                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6447                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
6448                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
6449                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
6450                 }
6451                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6452         }
6453         return NDR_ERR_SUCCESS;
6454 }
6455
6456 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportEnum(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaTransportEnum *r)
6457 {
6458         ndr_print_struct(ndr, name, "wkssvc_NetWkstaTransportEnum");
6459         ndr->depth++;
6460         if (flags & NDR_SET_VALUES) {
6461                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6462         }
6463         if (flags & NDR_IN) {
6464                 ndr_print_struct(ndr, "in", "wkssvc_NetWkstaTransportEnum");
6465                 ndr->depth++;
6466                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
6467                 ndr->depth++;
6468                 if (r->in.server_name) {
6469                         ndr_print_string(ndr, "server_name", r->in.server_name);
6470                 }
6471                 ndr->depth--;
6472                 ndr_print_ptr(ndr, "info", r->in.info);
6473                 ndr->depth++;
6474                 ndr_print_wkssvc_NetWkstaTransportInfo(ndr, "info", r->in.info);
6475                 ndr->depth--;
6476                 ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);
6477                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
6478                 ndr->depth++;
6479                 if (r->in.resume_handle) {
6480                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
6481                 }
6482                 ndr->depth--;
6483                 ndr->depth--;
6484         }
6485         if (flags & NDR_OUT) {
6486                 ndr_print_struct(ndr, "out", "wkssvc_NetWkstaTransportEnum");
6487                 ndr->depth++;
6488                 ndr_print_ptr(ndr, "info", r->out.info);
6489                 ndr->depth++;
6490                 ndr_print_wkssvc_NetWkstaTransportInfo(ndr, "info", r->out.info);
6491                 ndr->depth--;
6492                 ndr_print_ptr(ndr, "total_entries", r->out.total_entries);
6493                 ndr->depth++;
6494                 ndr_print_uint32(ndr, "total_entries", *r->out.total_entries);
6495                 ndr->depth--;
6496                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
6497                 ndr->depth++;
6498                 if (r->out.resume_handle) {
6499                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
6500                 }
6501                 ndr->depth--;
6502                 ndr_print_WERROR(ndr, "result", r->out.result);
6503                 ndr->depth--;
6504         }
6505         ndr->depth--;
6506 }
6507
6508 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaTransportAdd(struct ndr_push *ndr, int flags, const struct wkssvc_NetrWkstaTransportAdd *r)
6509 {
6510         if (flags & NDR_IN) {
6511                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
6512                 if (r->in.server_name) {
6513                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6514                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6515                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6516                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6517                 }
6518                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
6519                 if (r->in.info0 == NULL) {
6520                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6521                 }
6522                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info0));
6523                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_err));
6524                 if (r->in.parm_err) {
6525                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_err));
6526                 }
6527         }
6528         if (flags & NDR_OUT) {
6529                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_err));
6530                 if (r->out.parm_err) {
6531                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_err));
6532                 }
6533                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6534         }
6535         return NDR_ERR_SUCCESS;
6536 }
6537
6538 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaTransportAdd(struct ndr_pull *ndr, int flags, struct wkssvc_NetrWkstaTransportAdd *r)
6539 {
6540         uint32_t _ptr_server_name;
6541         uint32_t _ptr_parm_err;
6542         TALLOC_CTX *_mem_save_server_name_0;
6543         TALLOC_CTX *_mem_save_info0_0;
6544         TALLOC_CTX *_mem_save_parm_err_0;
6545         if (flags & NDR_IN) {
6546                 ZERO_STRUCT(r->out);
6547
6548                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6549                 if (_ptr_server_name) {
6550                         NDR_PULL_ALLOC(ndr, r->in.server_name);
6551                 } else {
6552                         r->in.server_name = NULL;
6553                 }
6554                 if (r->in.server_name) {
6555                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6556                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
6557                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
6558                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
6559                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
6560                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server_name), ndr_get_array_length(ndr, &r->in.server_name));
6561                         }
6562                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
6563                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
6564                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6565                 }
6566                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
6567                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6568                         NDR_PULL_ALLOC(ndr, r->in.info0);
6569                 }
6570                 _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
6571                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info0, LIBNDR_FLAG_REF_ALLOC);
6572                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info0));
6573                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, LIBNDR_FLAG_REF_ALLOC);
6574                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));
6575                 if (_ptr_parm_err) {
6576                         NDR_PULL_ALLOC(ndr, r->in.parm_err);
6577                 } else {
6578                         r->in.parm_err = NULL;
6579                 }
6580                 if (r->in.parm_err) {
6581                         _mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);
6582                         NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_err, 0);
6583                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_err));
6584                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);
6585                 }
6586         }
6587         if (flags & NDR_OUT) {
6588                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));
6589                 if (_ptr_parm_err) {
6590                         NDR_PULL_ALLOC(ndr, r->out.parm_err);
6591                 } else {
6592                         r->out.parm_err = NULL;
6593                 }
6594                 if (r->out.parm_err) {
6595                         _mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);
6596                         NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_err, 0);
6597                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_err));
6598                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);
6599                 }
6600                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6601         }
6602         return NDR_ERR_SUCCESS;
6603 }
6604
6605 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaTransportAdd(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrWkstaTransportAdd *r)
6606 {
6607         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaTransportAdd");
6608         ndr->depth++;
6609         if (flags & NDR_SET_VALUES) {
6610                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6611         }
6612         if (flags & NDR_IN) {
6613                 ndr_print_struct(ndr, "in", "wkssvc_NetrWkstaTransportAdd");
6614                 ndr->depth++;
6615                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
6616                 ndr->depth++;
6617                 if (r->in.server_name) {
6618                         ndr_print_string(ndr, "server_name", r->in.server_name);
6619                 }
6620                 ndr->depth--;
6621                 ndr_print_uint32(ndr, "level", r->in.level);
6622                 ndr_print_ptr(ndr, "info0", r->in.info0);
6623                 ndr->depth++;
6624                 ndr_print_wkssvc_NetWkstaTransportInfo0(ndr, "info0", r->in.info0);
6625                 ndr->depth--;
6626                 ndr_print_ptr(ndr, "parm_err", r->in.parm_err);
6627                 ndr->depth++;
6628                 if (r->in.parm_err) {
6629                         ndr_print_uint32(ndr, "parm_err", *r->in.parm_err);
6630                 }
6631                 ndr->depth--;
6632                 ndr->depth--;
6633         }
6634         if (flags & NDR_OUT) {
6635                 ndr_print_struct(ndr, "out", "wkssvc_NetrWkstaTransportAdd");
6636                 ndr->depth++;
6637                 ndr_print_ptr(ndr, "parm_err", r->out.parm_err);
6638                 ndr->depth++;
6639                 if (r->out.parm_err) {
6640                         ndr_print_uint32(ndr, "parm_err", *r->out.parm_err);
6641                 }
6642                 ndr->depth--;
6643                 ndr_print_WERROR(ndr, "result", r->out.result);
6644                 ndr->depth--;
6645         }
6646         ndr->depth--;
6647 }
6648
6649 static enum ndr_err_code ndr_push_wkssvc_NetrWkstaTransportDel(struct ndr_push *ndr, int flags, const struct wkssvc_NetrWkstaTransportDel *r)
6650 {
6651         if (flags & NDR_IN) {
6652                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
6653                 if (r->in.server_name) {
6654                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6655                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6656                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6657                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6658                 }
6659                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.transport_name));
6660                 if (r->in.transport_name) {
6661                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.transport_name, CH_UTF16)));
6662                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6663                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.transport_name, CH_UTF16)));
6664                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.transport_name, ndr_charset_length(r->in.transport_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6665                 }
6666                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown3));
6667         }
6668         if (flags & NDR_OUT) {
6669                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6670         }
6671         return NDR_ERR_SUCCESS;
6672 }
6673
6674 static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaTransportDel(struct ndr_pull *ndr, int flags, struct wkssvc_NetrWkstaTransportDel *r)
6675 {
6676         uint32_t _ptr_server_name;
6677         uint32_t _ptr_transport_name;
6678         TALLOC_CTX *_mem_save_server_name_0;
6679         TALLOC_CTX *_mem_save_transport_name_0;
6680         if (flags & NDR_IN) {
6681                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6682                 if (_ptr_server_name) {
6683                         NDR_PULL_ALLOC(ndr, r->in.server_name);
6684                 } else {
6685                         r->in.server_name = NULL;
6686                 }
6687                 if (r->in.server_name) {
6688                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6689                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
6690                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
6691                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
6692                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
6693                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server_name), ndr_get_array_length(ndr, &r->in.server_name));
6694                         }
6695                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
6696                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
6697                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6698                 }
6699                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_name));
6700                 if (_ptr_transport_name) {
6701                         NDR_PULL_ALLOC(ndr, r->in.transport_name);
6702                 } else {
6703                         r->in.transport_name = NULL;
6704                 }
6705                 if (r->in.transport_name) {
6706                         _mem_save_transport_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6707                         NDR_PULL_SET_MEM_CTX(ndr, r->in.transport_name, 0);
6708                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.transport_name));
6709                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.transport_name));
6710                         if (ndr_get_array_length(ndr, &r->in.transport_name) > ndr_get_array_size(ndr, &r->in.transport_name)) {
6711                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.transport_name), ndr_get_array_length(ndr, &r->in.transport_name));
6712                         }
6713                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.transport_name), sizeof(uint16_t)));
6714                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.transport_name, ndr_get_array_length(ndr, &r->in.transport_name), sizeof(uint16_t), CH_UTF16));
6715                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_name_0, 0);
6716                 }
6717                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown3));
6718         }
6719         if (flags & NDR_OUT) {
6720                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6721         }
6722         return NDR_ERR_SUCCESS;
6723 }
6724
6725 _PUBLIC_ void ndr_print_wkssvc_NetrWkstaTransportDel(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrWkstaTransportDel *r)
6726 {
6727         ndr_print_struct(ndr, name, "wkssvc_NetrWkstaTransportDel");
6728         ndr->depth++;
6729         if (flags & NDR_SET_VALUES) {
6730                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6731         }
6732         if (flags & NDR_IN) {
6733                 ndr_print_struct(ndr, "in", "wkssvc_NetrWkstaTransportDel");
6734                 ndr->depth++;
6735                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
6736                 ndr->depth++;
6737                 if (r->in.server_name) {
6738                         ndr_print_string(ndr, "server_name", r->in.server_name);
6739                 }
6740                 ndr->depth--;
6741                 ndr_print_ptr(ndr, "transport_name", r->in.transport_name);
6742                 ndr->depth++;
6743                 if (r->in.transport_name) {
6744                         ndr_print_string(ndr, "transport_name", r->in.transport_name);
6745                 }
6746                 ndr->depth--;
6747                 ndr_print_uint32(ndr, "unknown3", r->in.unknown3);
6748                 ndr->depth--;
6749         }
6750         if (flags & NDR_OUT) {
6751                 ndr_print_struct(ndr, "out", "wkssvc_NetrWkstaTransportDel");
6752                 ndr->depth++;
6753                 ndr_print_WERROR(ndr, "result", r->out.result);
6754                 ndr->depth--;
6755         }
6756         ndr->depth--;
6757 }
6758
6759 static enum ndr_err_code ndr_push_wkssvc_NetrUseAdd(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUseAdd *r)
6760 {
6761         if (flags & NDR_IN) {
6762                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
6763                 if (r->in.server_name) {
6764                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6765                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6766                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6767                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6768                 }
6769                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
6770                 if (r->in.ctr == NULL) {
6771                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6772                 }
6773                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.ctr, r->in.level));
6774                 NDR_CHECK(ndr_push_wkssvc_NetrUseGetInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
6775                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_err));
6776                 if (r->in.parm_err) {
6777                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_err));
6778                 }
6779         }
6780         if (flags & NDR_OUT) {
6781                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_err));
6782                 if (r->out.parm_err) {
6783                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_err));
6784                 }
6785                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6786         }
6787         return NDR_ERR_SUCCESS;
6788 }
6789
6790 static enum ndr_err_code ndr_pull_wkssvc_NetrUseAdd(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUseAdd *r)
6791 {
6792         uint32_t _ptr_server_name;
6793         uint32_t _ptr_parm_err;
6794         TALLOC_CTX *_mem_save_server_name_0;
6795         TALLOC_CTX *_mem_save_ctr_0;
6796         TALLOC_CTX *_mem_save_parm_err_0;
6797         if (flags & NDR_IN) {
6798                 ZERO_STRUCT(r->out);
6799
6800                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6801                 if (_ptr_server_name) {
6802                         NDR_PULL_ALLOC(ndr, r->in.server_name);
6803                 } else {
6804                         r->in.server_name = NULL;
6805                 }
6806                 if (r->in.server_name) {
6807                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6808                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
6809                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
6810                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
6811                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
6812                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server_name), ndr_get_array_length(ndr, &r->in.server_name));
6813                         }
6814                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
6815                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
6816                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6817                 }
6818                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
6819                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6820                         NDR_PULL_ALLOC(ndr, r->in.ctr);
6821                 }
6822                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
6823                 NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, LIBNDR_FLAG_REF_ALLOC);
6824                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.ctr, r->in.level));
6825                 NDR_CHECK(ndr_pull_wkssvc_NetrUseGetInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
6826                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
6827                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));
6828                 if (_ptr_parm_err) {
6829                         NDR_PULL_ALLOC(ndr, r->in.parm_err);
6830                 } else {
6831                         r->in.parm_err = NULL;
6832                 }
6833                 if (r->in.parm_err) {
6834                         _mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);
6835                         NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_err, 0);
6836                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_err));
6837                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);
6838                 }
6839         }
6840         if (flags & NDR_OUT) {
6841                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));
6842                 if (_ptr_parm_err) {
6843                         NDR_PULL_ALLOC(ndr, r->out.parm_err);
6844                 } else {
6845                         r->out.parm_err = NULL;
6846                 }
6847                 if (r->out.parm_err) {
6848                         _mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);
6849                         NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_err, 0);
6850                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_err));
6851                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);
6852                 }
6853                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6854         }
6855         return NDR_ERR_SUCCESS;
6856 }
6857
6858 _PUBLIC_ void ndr_print_wkssvc_NetrUseAdd(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUseAdd *r)
6859 {
6860         ndr_print_struct(ndr, name, "wkssvc_NetrUseAdd");
6861         ndr->depth++;
6862         if (flags & NDR_SET_VALUES) {
6863                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6864         }
6865         if (flags & NDR_IN) {
6866                 ndr_print_struct(ndr, "in", "wkssvc_NetrUseAdd");
6867                 ndr->depth++;
6868                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
6869                 ndr->depth++;
6870                 if (r->in.server_name) {
6871                         ndr_print_string(ndr, "server_name", r->in.server_name);
6872                 }
6873                 ndr->depth--;
6874                 ndr_print_uint32(ndr, "level", r->in.level);
6875                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
6876                 ndr->depth++;
6877                 ndr_print_set_switch_value(ndr, r->in.ctr, r->in.level);
6878                 ndr_print_wkssvc_NetrUseGetInfoCtr(ndr, "ctr", r->in.ctr);
6879                 ndr->depth--;
6880                 ndr_print_ptr(ndr, "parm_err", r->in.parm_err);
6881                 ndr->depth++;
6882                 if (r->in.parm_err) {
6883                         ndr_print_uint32(ndr, "parm_err", *r->in.parm_err);
6884                 }
6885                 ndr->depth--;
6886                 ndr->depth--;
6887         }
6888         if (flags & NDR_OUT) {
6889                 ndr_print_struct(ndr, "out", "wkssvc_NetrUseAdd");
6890                 ndr->depth++;
6891                 ndr_print_ptr(ndr, "parm_err", r->out.parm_err);
6892                 ndr->depth++;
6893                 if (r->out.parm_err) {
6894                         ndr_print_uint32(ndr, "parm_err", *r->out.parm_err);
6895                 }
6896                 ndr->depth--;
6897                 ndr_print_WERROR(ndr, "result", r->out.result);
6898                 ndr->depth--;
6899         }
6900         ndr->depth--;
6901 }
6902
6903 static enum ndr_err_code ndr_push_wkssvc_NetrUseGetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUseGetInfo *r)
6904 {
6905         if (flags & NDR_IN) {
6906                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
6907                 if (r->in.server_name) {
6908                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6909                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6910                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
6911                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6912                 }
6913                 if (r->in.use_name == NULL) {
6914                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6915                 }
6916                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.use_name, CH_UTF16)));
6917                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6918                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.use_name, CH_UTF16)));
6919                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.use_name, ndr_charset_length(r->in.use_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6920                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
6921         }
6922         if (flags & NDR_OUT) {
6923                 if (r->out.ctr == NULL) {
6924                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6925                 }
6926                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, r->in.level));
6927                 NDR_CHECK(ndr_push_wkssvc_NetrUseGetInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
6928                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6929         }
6930         return NDR_ERR_SUCCESS;
6931 }
6932
6933 static enum ndr_err_code ndr_pull_wkssvc_NetrUseGetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUseGetInfo *r)
6934 {
6935         uint32_t _ptr_server_name;
6936         TALLOC_CTX *_mem_save_server_name_0;
6937         TALLOC_CTX *_mem_save_ctr_0;
6938         if (flags & NDR_IN) {
6939                 ZERO_STRUCT(r->out);
6940
6941                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6942                 if (_ptr_server_name) {
6943                         NDR_PULL_ALLOC(ndr, r->in.server_name);
6944                 } else {
6945                         r->in.server_name = NULL;
6946                 }
6947                 if (r->in.server_name) {
6948                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6949                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
6950                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
6951                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
6952                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
6953                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server_name), ndr_get_array_length(ndr, &r->in.server_name));
6954                         }
6955                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
6956                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
6957                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6958                 }
6959                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.use_name));
6960                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.use_name));
6961                 if (ndr_get_array_length(ndr, &r->in.use_name) > ndr_get_array_size(ndr, &r->in.use_name)) {
6962                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.use_name), ndr_get_array_length(ndr, &r->in.use_name));
6963                 }
6964                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.use_name), sizeof(uint16_t)));
6965                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.use_name, ndr_get_array_length(ndr, &r->in.use_name), sizeof(uint16_t), CH_UTF16));
6966                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
6967                 NDR_PULL_ALLOC(ndr, r->out.ctr);
6968                 ZERO_STRUCTP(r->out.ctr);
6969         }
6970         if (flags & NDR_OUT) {
6971                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6972                         NDR_PULL_ALLOC(ndr, r->out.ctr);
6973                 }
6974                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
6975                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
6976                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, r->in.level));
6977                 NDR_CHECK(ndr_pull_wkssvc_NetrUseGetInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
6978                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
6979                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6980         }
6981         return NDR_ERR_SUCCESS;
6982 }
6983
6984 _PUBLIC_ void ndr_print_wkssvc_NetrUseGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUseGetInfo *r)
6985 {
6986         ndr_print_struct(ndr, name, "wkssvc_NetrUseGetInfo");
6987         ndr->depth++;
6988         if (flags & NDR_SET_VALUES) {
6989                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6990         }
6991         if (flags & NDR_IN) {
6992                 ndr_print_struct(ndr, "in", "wkssvc_NetrUseGetInfo");
6993                 ndr->depth++;
6994                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
6995                 ndr->depth++;
6996                 if (r->in.server_name) {
6997                         ndr_print_string(ndr, "server_name", r->in.server_name);
6998                 }
6999                 ndr->depth--;
7000                 ndr_print_ptr(ndr, "use_name", r->in.use_name);
7001                 ndr->depth++;
7002                 ndr_print_string(ndr, "use_name", r->in.use_name);
7003                 ndr->depth--;
7004                 ndr_print_uint32(ndr, "level", r->in.level);
7005                 ndr->depth--;
7006         }
7007         if (flags & NDR_OUT) {
7008                 ndr_print_struct(ndr, "out", "wkssvc_NetrUseGetInfo");
7009                 ndr->depth++;
7010                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
7011                 ndr->depth++;
7012                 ndr_print_set_switch_value(ndr, r->out.ctr, r->in.level);
7013                 ndr_print_wkssvc_NetrUseGetInfoCtr(ndr, "ctr", r->out.ctr);
7014                 ndr->depth--;
7015                 ndr_print_WERROR(ndr, "result", r->out.result);
7016                 ndr->depth--;
7017         }
7018         ndr->depth--;
7019 }
7020
7021 static enum ndr_err_code ndr_push_wkssvc_NetrUseDel(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUseDel *r)
7022 {
7023         if (flags & NDR_IN) {
7024                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
7025                 if (r->in.server_name) {
7026                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7027                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7028                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7029                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7030                 }
7031                 if (r->in.use_name == NULL) {
7032                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7033                 }
7034                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.use_name, CH_UTF16)));
7035                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7036                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.use_name, CH_UTF16)));
7037                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.use_name, ndr_charset_length(r->in.use_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7038                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.force_cond));
7039         }
7040         if (flags & NDR_OUT) {
7041                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7042         }
7043         return NDR_ERR_SUCCESS;
7044 }
7045
7046 static enum ndr_err_code ndr_pull_wkssvc_NetrUseDel(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUseDel *r)
7047 {
7048         uint32_t _ptr_server_name;
7049         TALLOC_CTX *_mem_save_server_name_0;
7050         if (flags & NDR_IN) {
7051                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
7052                 if (_ptr_server_name) {
7053                         NDR_PULL_ALLOC(ndr, r->in.server_name);
7054                 } else {
7055                         r->in.server_name = NULL;
7056                 }
7057                 if (r->in.server_name) {
7058                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7059                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
7060                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
7061                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
7062                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
7063                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server_name), ndr_get_array_length(ndr, &r->in.server_name));
7064                         }
7065                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
7066                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
7067                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
7068                 }
7069                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.use_name));
7070                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.use_name));
7071                 if (ndr_get_array_length(ndr, &r->in.use_name) > ndr_get_array_size(ndr, &r->in.use_name)) {
7072                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.use_name), ndr_get_array_length(ndr, &r->in.use_name));
7073                 }
7074                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.use_name), sizeof(uint16_t)));
7075                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.use_name, ndr_get_array_length(ndr, &r->in.use_name), sizeof(uint16_t), CH_UTF16));
7076                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.force_cond));
7077         }
7078         if (flags & NDR_OUT) {
7079                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7080         }
7081         return NDR_ERR_SUCCESS;
7082 }
7083
7084 _PUBLIC_ void ndr_print_wkssvc_NetrUseDel(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUseDel *r)
7085 {
7086         ndr_print_struct(ndr, name, "wkssvc_NetrUseDel");
7087         ndr->depth++;
7088         if (flags & NDR_SET_VALUES) {
7089                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7090         }
7091         if (flags & NDR_IN) {
7092                 ndr_print_struct(ndr, "in", "wkssvc_NetrUseDel");
7093                 ndr->depth++;
7094                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
7095                 ndr->depth++;
7096                 if (r->in.server_name) {
7097                         ndr_print_string(ndr, "server_name", r->in.server_name);
7098                 }
7099                 ndr->depth--;
7100                 ndr_print_ptr(ndr, "use_name", r->in.use_name);
7101                 ndr->depth++;
7102                 ndr_print_string(ndr, "use_name", r->in.use_name);
7103                 ndr->depth--;
7104                 ndr_print_uint32(ndr, "force_cond", r->in.force_cond);
7105                 ndr->depth--;
7106         }
7107         if (flags & NDR_OUT) {
7108                 ndr_print_struct(ndr, "out", "wkssvc_NetrUseDel");
7109                 ndr->depth++;
7110                 ndr_print_WERROR(ndr, "result", r->out.result);
7111                 ndr->depth--;
7112         }
7113         ndr->depth--;
7114 }
7115
7116 static enum ndr_err_code ndr_push_wkssvc_NetrUseEnum(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUseEnum *r)
7117 {
7118         if (flags & NDR_IN) {
7119                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
7120                 if (r->in.server_name) {
7121                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7122                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7123                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7124                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7125                 }
7126                 if (r->in.info == NULL) {
7127                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7128                 }
7129                 NDR_CHECK(ndr_push_wkssvc_NetrUseEnumInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
7130                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.prefmaxlen));
7131                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
7132                 if (r->in.resume_handle) {
7133                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
7134                 }
7135         }
7136         if (flags & NDR_OUT) {
7137                 if (r->out.info == NULL) {
7138                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7139                 }
7140                 NDR_CHECK(ndr_push_wkssvc_NetrUseEnumInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
7141                 if (r->out.entries_read == NULL) {
7142                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7143                 }
7144                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.entries_read));
7145                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
7146                 if (r->out.resume_handle) {
7147                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
7148                 }
7149                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7150         }
7151         return NDR_ERR_SUCCESS;
7152 }
7153
7154 static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnum(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUseEnum *r)
7155 {
7156         uint32_t _ptr_server_name;
7157         uint32_t _ptr_resume_handle;
7158         TALLOC_CTX *_mem_save_server_name_0;
7159         TALLOC_CTX *_mem_save_info_0;
7160         TALLOC_CTX *_mem_save_entries_read_0;
7161         TALLOC_CTX *_mem_save_resume_handle_0;
7162         if (flags & NDR_IN) {
7163                 ZERO_STRUCT(r->out);
7164
7165                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
7166                 if (_ptr_server_name) {
7167                         NDR_PULL_ALLOC(ndr, r->in.server_name);
7168                 } else {
7169                         r->in.server_name = NULL;
7170                 }
7171                 if (r->in.server_name) {
7172                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7173                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
7174                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
7175                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
7176                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
7177                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server_name), ndr_get_array_length(ndr, &r->in.server_name));
7178                         }
7179                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
7180                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
7181                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
7182                 }
7183                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7184                         NDR_PULL_ALLOC(ndr, r->in.info);
7185                 }
7186                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
7187                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
7188                 NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
7189                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
7190                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.prefmaxlen));
7191                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
7192                 if (_ptr_resume_handle) {
7193                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
7194                 } else {
7195                         r->in.resume_handle = NULL;
7196                 }
7197                 if (r->in.resume_handle) {
7198                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7199                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
7200                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
7201                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
7202                 }
7203                 NDR_PULL_ALLOC(ndr, r->out.info);
7204                 *r->out.info = *r->in.info;
7205                 NDR_PULL_ALLOC(ndr, r->out.entries_read);
7206                 ZERO_STRUCTP(r->out.entries_read);
7207         }
7208         if (flags & NDR_OUT) {
7209                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7210                         NDR_PULL_ALLOC(ndr, r->out.info);
7211                 }
7212                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
7213                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
7214                 NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
7215                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
7216                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7217                         NDR_PULL_ALLOC(ndr, r->out.entries_read);
7218                 }
7219                 _mem_save_entries_read_0 = NDR_PULL_GET_MEM_CTX(ndr);
7220                 NDR_PULL_SET_MEM_CTX(ndr, r->out.entries_read, LIBNDR_FLAG_REF_ALLOC);
7221                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.entries_read));
7222                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_read_0, LIBNDR_FLAG_REF_ALLOC);
7223                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
7224                 if (_ptr_resume_handle) {
7225                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
7226                 } else {
7227                         r->out.resume_handle = NULL;
7228                 }
7229                 if (r->out.resume_handle) {
7230                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7231                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
7232                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
7233                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
7234                 }
7235                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7236         }
7237         return NDR_ERR_SUCCESS;
7238 }
7239
7240 _PUBLIC_ void ndr_print_wkssvc_NetrUseEnum(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUseEnum *r)
7241 {
7242         ndr_print_struct(ndr, name, "wkssvc_NetrUseEnum");
7243         ndr->depth++;
7244         if (flags & NDR_SET_VALUES) {
7245                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7246         }
7247         if (flags & NDR_IN) {
7248                 ndr_print_struct(ndr, "in", "wkssvc_NetrUseEnum");
7249                 ndr->depth++;
7250                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
7251                 ndr->depth++;
7252                 if (r->in.server_name) {
7253                         ndr_print_string(ndr, "server_name", r->in.server_name);
7254                 }
7255                 ndr->depth--;
7256                 ndr_print_ptr(ndr, "info", r->in.info);
7257                 ndr->depth++;
7258                 ndr_print_wkssvc_NetrUseEnumInfo(ndr, "info", r->in.info);
7259                 ndr->depth--;
7260                 ndr_print_uint32(ndr, "prefmaxlen", r->in.prefmaxlen);
7261                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
7262                 ndr->depth++;
7263                 if (r->in.resume_handle) {
7264                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
7265                 }
7266                 ndr->depth--;
7267                 ndr->depth--;
7268         }
7269         if (flags & NDR_OUT) {
7270                 ndr_print_struct(ndr, "out", "wkssvc_NetrUseEnum");
7271                 ndr->depth++;
7272                 ndr_print_ptr(ndr, "info", r->out.info);
7273                 ndr->depth++;
7274                 ndr_print_wkssvc_NetrUseEnumInfo(ndr, "info", r->out.info);
7275                 ndr->depth--;
7276                 ndr_print_ptr(ndr, "entries_read", r->out.entries_read);
7277                 ndr->depth++;
7278                 ndr_print_uint32(ndr, "entries_read", *r->out.entries_read);
7279                 ndr->depth--;
7280                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
7281                 ndr->depth++;
7282                 if (r->out.resume_handle) {
7283                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
7284                 }
7285                 ndr->depth--;
7286                 ndr_print_WERROR(ndr, "result", r->out.result);
7287                 ndr->depth--;
7288         }
7289         ndr->depth--;
7290 }
7291
7292 static enum ndr_err_code ndr_push_wkssvc_NetrMessageBufferSend(struct ndr_push *ndr, int flags, const struct wkssvc_NetrMessageBufferSend *r)
7293 {
7294         if (flags & NDR_IN) {
7295                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
7296                 if (r->in.server_name) {
7297                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7298                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7299                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7300                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7301                 }
7302                 if (r->in.message_name == NULL) {
7303                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7304                 }
7305                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.message_name, CH_UTF16)));
7306                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7307                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.message_name, CH_UTF16)));
7308                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.message_name, ndr_charset_length(r->in.message_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7309                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.message_sender_name));
7310                 if (r->in.message_sender_name) {
7311                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.message_sender_name, CH_UTF16)));
7312                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7313                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.message_sender_name, CH_UTF16)));
7314                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.message_sender_name, ndr_charset_length(r->in.message_sender_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7315                 }
7316                 if (r->in.message_buffer == NULL) {
7317                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7318                 }
7319                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.message_size));
7320                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.message_buffer, r->in.message_size));
7321                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.message_size));
7322         }
7323         if (flags & NDR_OUT) {
7324                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7325         }
7326         return NDR_ERR_SUCCESS;
7327 }
7328
7329 static enum ndr_err_code ndr_pull_wkssvc_NetrMessageBufferSend(struct ndr_pull *ndr, int flags, struct wkssvc_NetrMessageBufferSend *r)
7330 {
7331         uint32_t _ptr_server_name;
7332         uint32_t _ptr_message_sender_name;
7333         TALLOC_CTX *_mem_save_server_name_0;
7334         TALLOC_CTX *_mem_save_message_sender_name_0;
7335         if (flags & NDR_IN) {
7336                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
7337                 if (_ptr_server_name) {
7338                         NDR_PULL_ALLOC(ndr, r->in.server_name);
7339                 } else {
7340                         r->in.server_name = NULL;
7341                 }
7342                 if (r->in.server_name) {
7343                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7344                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
7345                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
7346                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
7347                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
7348                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server_name), ndr_get_array_length(ndr, &r->in.server_name));
7349                         }
7350                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
7351                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
7352                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
7353                 }
7354                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.message_name));
7355                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.message_name));
7356                 if (ndr_get_array_length(ndr, &r->in.message_name) > ndr_get_array_size(ndr, &r->in.message_name)) {
7357                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.message_name), ndr_get_array_length(ndr, &r->in.message_name));
7358                 }
7359                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.message_name), sizeof(uint16_t)));
7360                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.message_name, ndr_get_array_length(ndr, &r->in.message_name), sizeof(uint16_t), CH_UTF16));
7361                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_message_sender_name));
7362                 if (_ptr_message_sender_name) {
7363                         NDR_PULL_ALLOC(ndr, r->in.message_sender_name);
7364                 } else {
7365                         r->in.message_sender_name = NULL;
7366                 }
7367                 if (r->in.message_sender_name) {
7368                         _mem_save_message_sender_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7369                         NDR_PULL_SET_MEM_CTX(ndr, r->in.message_sender_name, 0);
7370                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.message_sender_name));
7371                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.message_sender_name));
7372                         if (ndr_get_array_length(ndr, &r->in.message_sender_name) > ndr_get_array_size(ndr, &r->in.message_sender_name)) {
7373                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.message_sender_name), ndr_get_array_length(ndr, &r->in.message_sender_name));
7374                         }
7375                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.message_sender_name), sizeof(uint16_t)));
7376                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.message_sender_name, ndr_get_array_length(ndr, &r->in.message_sender_name), sizeof(uint16_t), CH_UTF16));
7377                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_message_sender_name_0, 0);
7378                 }
7379                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.message_buffer));
7380                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7381                         NDR_PULL_ALLOC_N(ndr, r->in.message_buffer, ndr_get_array_size(ndr, &r->in.message_buffer));
7382                 }
7383                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.message_buffer, ndr_get_array_size(ndr, &r->in.message_buffer)));
7384                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.message_size));
7385                 if (r->in.message_buffer) {
7386                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.message_buffer, r->in.message_size));
7387                 }
7388         }
7389         if (flags & NDR_OUT) {
7390                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7391         }
7392         return NDR_ERR_SUCCESS;
7393 }
7394
7395 _PUBLIC_ void ndr_print_wkssvc_NetrMessageBufferSend(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrMessageBufferSend *r)
7396 {
7397         ndr_print_struct(ndr, name, "wkssvc_NetrMessageBufferSend");
7398         ndr->depth++;
7399         if (flags & NDR_SET_VALUES) {
7400                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7401         }
7402         if (flags & NDR_IN) {
7403                 ndr_print_struct(ndr, "in", "wkssvc_NetrMessageBufferSend");
7404                 ndr->depth++;
7405                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
7406                 ndr->depth++;
7407                 if (r->in.server_name) {
7408                         ndr_print_string(ndr, "server_name", r->in.server_name);
7409                 }
7410                 ndr->depth--;
7411                 ndr_print_ptr(ndr, "message_name", r->in.message_name);
7412                 ndr->depth++;
7413                 ndr_print_string(ndr, "message_name", r->in.message_name);
7414                 ndr->depth--;
7415                 ndr_print_ptr(ndr, "message_sender_name", r->in.message_sender_name);
7416                 ndr->depth++;
7417                 if (r->in.message_sender_name) {
7418                         ndr_print_string(ndr, "message_sender_name", r->in.message_sender_name);
7419                 }
7420                 ndr->depth--;
7421                 ndr_print_ptr(ndr, "message_buffer", r->in.message_buffer);
7422                 ndr->depth++;
7423                 ndr_print_array_uint8(ndr, "message_buffer", r->in.message_buffer, r->in.message_size);
7424                 ndr->depth--;
7425                 ndr_print_uint32(ndr, "message_size", r->in.message_size);
7426                 ndr->depth--;
7427         }
7428         if (flags & NDR_OUT) {
7429                 ndr_print_struct(ndr, "out", "wkssvc_NetrMessageBufferSend");
7430                 ndr->depth++;
7431                 ndr_print_WERROR(ndr, "result", r->out.result);
7432                 ndr->depth--;
7433         }
7434         ndr->depth--;
7435 }
7436
7437 static enum ndr_err_code ndr_push_wkssvc_NetrWorkstationStatisticsGet(struct ndr_push *ndr, int flags, const struct wkssvc_NetrWorkstationStatisticsGet *r)
7438 {
7439         if (flags & NDR_IN) {
7440                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
7441                 if (r->in.server_name) {
7442                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7443                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7444                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7445                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7446                 }
7447                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown2));
7448                 if (r->in.unknown2) {
7449                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown2, CH_UTF16)));
7450                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7451                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown2, CH_UTF16)));
7452                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.unknown2, ndr_charset_length(r->in.unknown2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7453                 }
7454                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown3));
7455                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown4));
7456         }
7457         if (flags & NDR_OUT) {
7458                 if (r->out.info == NULL) {
7459                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7460                 }
7461                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
7462                 if (*r->out.info) {
7463                         NDR_CHECK(ndr_push_wkssvc_NetrWorkstationStatistics(ndr, NDR_SCALARS, *r->out.info));
7464                 }
7465                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7466         }
7467         return NDR_ERR_SUCCESS;
7468 }
7469
7470 static enum ndr_err_code ndr_pull_wkssvc_NetrWorkstationStatisticsGet(struct ndr_pull *ndr, int flags, struct wkssvc_NetrWorkstationStatisticsGet *r)
7471 {
7472         uint32_t _ptr_server_name;
7473         uint32_t _ptr_unknown2;
7474         uint32_t _ptr_info;
7475         TALLOC_CTX *_mem_save_server_name_0;
7476         TALLOC_CTX *_mem_save_unknown2_0;
7477         TALLOC_CTX *_mem_save_info_0;
7478         TALLOC_CTX *_mem_save_info_1;
7479         if (flags & NDR_IN) {
7480                 ZERO_STRUCT(r->out);
7481
7482                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
7483                 if (_ptr_server_name) {
7484                         NDR_PULL_ALLOC(ndr, r->in.server_name);
7485                 } else {
7486                         r->in.server_name = NULL;
7487                 }
7488                 if (r->in.server_name) {
7489                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7490                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
7491                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
7492                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
7493                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
7494                                 return 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));
7495                         }
7496                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
7497                         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));
7498                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
7499                 }
7500                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown2));
7501                 if (_ptr_unknown2) {
7502                         NDR_PULL_ALLOC(ndr, r->in.unknown2);
7503                 } else {
7504                         r->in.unknown2 = NULL;
7505                 }
7506                 if (r->in.unknown2) {
7507                         _mem_save_unknown2_0 = NDR_PULL_GET_MEM_CTX(ndr);
7508                         NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown2, 0);
7509                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.unknown2));
7510                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.unknown2));
7511                         if (ndr_get_array_length(ndr, &r->in.unknown2) > ndr_get_array_size(ndr, &r->in.unknown2)) {
7512                                 return 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));
7513                         }
7514                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.unknown2), sizeof(uint16_t)));
7515                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.unknown2, ndr_get_array_length(ndr, &r->in.unknown2), sizeof(uint16_t), CH_UTF16));
7516                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown2_0, 0);
7517                 }
7518                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown3));
7519                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown4));
7520                 NDR_PULL_ALLOC(ndr, r->out.info);
7521                 ZERO_STRUCTP(r->out.info);
7522         }
7523         if (flags & NDR_OUT) {
7524                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7525                         NDR_PULL_ALLOC(ndr, r->out.info);
7526                 }
7527                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
7528                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
7529                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
7530                 if (_ptr_info) {
7531                         NDR_PULL_ALLOC(ndr, *r->out.info);
7532                 } else {
7533                         *r->out.info = NULL;
7534                 }
7535                 if (*r->out.info) {
7536                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
7537                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
7538                         NDR_CHECK(ndr_pull_wkssvc_NetrWorkstationStatistics(ndr, NDR_SCALARS, *r->out.info));
7539                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
7540                 }
7541                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
7542                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7543         }
7544         return NDR_ERR_SUCCESS;
7545 }
7546
7547 _PUBLIC_ void ndr_print_wkssvc_NetrWorkstationStatisticsGet(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrWorkstationStatisticsGet *r)
7548 {
7549         ndr_print_struct(ndr, name, "wkssvc_NetrWorkstationStatisticsGet");
7550         ndr->depth++;
7551         if (flags & NDR_SET_VALUES) {
7552                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7553         }
7554         if (flags & NDR_IN) {
7555                 ndr_print_struct(ndr, "in", "wkssvc_NetrWorkstationStatisticsGet");
7556                 ndr->depth++;
7557                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
7558                 ndr->depth++;
7559                 if (r->in.server_name) {
7560                         ndr_print_string(ndr, "server_name", r->in.server_name);
7561                 }
7562                 ndr->depth--;
7563                 ndr_print_ptr(ndr, "unknown2", r->in.unknown2);
7564                 ndr->depth++;
7565                 if (r->in.unknown2) {
7566                         ndr_print_string(ndr, "unknown2", r->in.unknown2);
7567                 }
7568                 ndr->depth--;
7569                 ndr_print_uint32(ndr, "unknown3", r->in.unknown3);
7570                 ndr_print_uint32(ndr, "unknown4", r->in.unknown4);
7571                 ndr->depth--;
7572         }
7573         if (flags & NDR_OUT) {
7574                 ndr_print_struct(ndr, "out", "wkssvc_NetrWorkstationStatisticsGet");
7575                 ndr->depth++;
7576                 ndr_print_ptr(ndr, "info", r->out.info);
7577                 ndr->depth++;
7578                 ndr_print_ptr(ndr, "info", *r->out.info);
7579                 ndr->depth++;
7580                 if (*r->out.info) {
7581                         ndr_print_wkssvc_NetrWorkstationStatistics(ndr, "info", *r->out.info);
7582                 }
7583                 ndr->depth--;
7584                 ndr->depth--;
7585                 ndr_print_WERROR(ndr, "result", r->out.result);
7586                 ndr->depth--;
7587         }
7588         ndr->depth--;
7589 }
7590
7591 static enum ndr_err_code ndr_push_wkssvc_NetrLogonDomainNameAdd(struct ndr_push *ndr, int flags, const struct wkssvc_NetrLogonDomainNameAdd *r)
7592 {
7593         if (flags & NDR_IN) {
7594                 if (r->in.domain_name == NULL) {
7595                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7596                 }
7597                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
7598                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7599                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
7600                 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));
7601         }
7602         if (flags & NDR_OUT) {
7603                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7604         }
7605         return NDR_ERR_SUCCESS;
7606 }
7607
7608 static enum ndr_err_code ndr_pull_wkssvc_NetrLogonDomainNameAdd(struct ndr_pull *ndr, int flags, struct wkssvc_NetrLogonDomainNameAdd *r)
7609 {
7610         if (flags & NDR_IN) {
7611                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
7612                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
7613                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
7614                         return 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));
7615                 }
7616                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
7617                 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));
7618         }
7619         if (flags & NDR_OUT) {
7620                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7621         }
7622         return NDR_ERR_SUCCESS;
7623 }
7624
7625 _PUBLIC_ void ndr_print_wkssvc_NetrLogonDomainNameAdd(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrLogonDomainNameAdd *r)
7626 {
7627         ndr_print_struct(ndr, name, "wkssvc_NetrLogonDomainNameAdd");
7628         ndr->depth++;
7629         if (flags & NDR_SET_VALUES) {
7630                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7631         }
7632         if (flags & NDR_IN) {
7633                 ndr_print_struct(ndr, "in", "wkssvc_NetrLogonDomainNameAdd");
7634                 ndr->depth++;
7635                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
7636                 ndr->depth++;
7637                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
7638                 ndr->depth--;
7639                 ndr->depth--;
7640         }
7641         if (flags & NDR_OUT) {
7642                 ndr_print_struct(ndr, "out", "wkssvc_NetrLogonDomainNameAdd");
7643                 ndr->depth++;
7644                 ndr_print_WERROR(ndr, "result", r->out.result);
7645                 ndr->depth--;
7646         }
7647         ndr->depth--;
7648 }
7649
7650 static enum ndr_err_code ndr_push_wkssvc_NetrLogonDomainNameDel(struct ndr_push *ndr, int flags, const struct wkssvc_NetrLogonDomainNameDel *r)
7651 {
7652         if (flags & NDR_IN) {
7653                 if (r->in.domain_name == NULL) {
7654                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7655                 }
7656                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
7657                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7658                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
7659                 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));
7660         }
7661         if (flags & NDR_OUT) {
7662                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7663         }
7664         return NDR_ERR_SUCCESS;
7665 }
7666
7667 static enum ndr_err_code ndr_pull_wkssvc_NetrLogonDomainNameDel(struct ndr_pull *ndr, int flags, struct wkssvc_NetrLogonDomainNameDel *r)
7668 {
7669         if (flags & NDR_IN) {
7670                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
7671                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
7672                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
7673                         return 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));
7674                 }
7675                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
7676                 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));
7677         }
7678         if (flags & NDR_OUT) {
7679                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7680         }
7681         return NDR_ERR_SUCCESS;
7682 }
7683
7684 _PUBLIC_ void ndr_print_wkssvc_NetrLogonDomainNameDel(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrLogonDomainNameDel *r)
7685 {
7686         ndr_print_struct(ndr, name, "wkssvc_NetrLogonDomainNameDel");
7687         ndr->depth++;
7688         if (flags & NDR_SET_VALUES) {
7689                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7690         }
7691         if (flags & NDR_IN) {
7692                 ndr_print_struct(ndr, "in", "wkssvc_NetrLogonDomainNameDel");
7693                 ndr->depth++;
7694                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
7695                 ndr->depth++;
7696                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
7697                 ndr->depth--;
7698                 ndr->depth--;
7699         }
7700         if (flags & NDR_OUT) {
7701                 ndr_print_struct(ndr, "out", "wkssvc_NetrLogonDomainNameDel");
7702                 ndr->depth++;
7703                 ndr_print_WERROR(ndr, "result", r->out.result);
7704                 ndr->depth--;
7705         }
7706         ndr->depth--;
7707 }
7708
7709 static enum ndr_err_code ndr_push_wkssvc_NetrJoinDomain(struct ndr_push *ndr, int flags, const struct wkssvc_NetrJoinDomain *r)
7710 {
7711         if (flags & NDR_IN) {
7712                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
7713                 if (r->in.server_name) {
7714                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7715                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7716                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7717                         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));
7718                 }
7719                 if (r->in.domain_name == NULL) {
7720                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7721                 }
7722                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
7723                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7724                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
7725                 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));
7726                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.account_ou));
7727                 if (r->in.account_ou) {
7728                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account_ou, CH_UTF16)));
7729                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7730                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account_ou, CH_UTF16)));
7731                         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));
7732                 }
7733                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
7734                 if (r->in.Account) {
7735                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
7736                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7737                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
7738                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7739                 }
7740                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
7741                 if (r->in.password) {
7742                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
7743                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7744                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
7745                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7746                 }
7747                 NDR_CHECK(ndr_push_wkssvc_joinflags(ndr, NDR_SCALARS, r->in.join_flags));
7748         }
7749         if (flags & NDR_OUT) {
7750                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7751         }
7752         return NDR_ERR_SUCCESS;
7753 }
7754
7755 static enum ndr_err_code ndr_pull_wkssvc_NetrJoinDomain(struct ndr_pull *ndr, int flags, struct wkssvc_NetrJoinDomain *r)
7756 {
7757         uint32_t _ptr_server_name;
7758         uint32_t _ptr_account_ou;
7759         uint32_t _ptr_Account;
7760         uint32_t _ptr_password;
7761         TALLOC_CTX *_mem_save_server_name_0;
7762         TALLOC_CTX *_mem_save_account_ou_0;
7763         TALLOC_CTX *_mem_save_Account_0;
7764         TALLOC_CTX *_mem_save_password_0;
7765         if (flags & NDR_IN) {
7766                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
7767                 if (_ptr_server_name) {
7768                         NDR_PULL_ALLOC(ndr, r->in.server_name);
7769                 } else {
7770                         r->in.server_name = NULL;
7771                 }
7772                 if (r->in.server_name) {
7773                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7774                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
7775                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
7776                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
7777                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
7778                                 return 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));
7779                         }
7780                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
7781                         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));
7782                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
7783                 }
7784                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
7785                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
7786                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
7787                         return 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));
7788                 }
7789                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
7790                 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));
7791                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account_ou));
7792                 if (_ptr_account_ou) {
7793                         NDR_PULL_ALLOC(ndr, r->in.account_ou);
7794                 } else {
7795                         r->in.account_ou = NULL;
7796                 }
7797                 if (r->in.account_ou) {
7798                         _mem_save_account_ou_0 = NDR_PULL_GET_MEM_CTX(ndr);
7799                         NDR_PULL_SET_MEM_CTX(ndr, r->in.account_ou, 0);
7800                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.account_ou));
7801                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.account_ou));
7802                         if (ndr_get_array_length(ndr, &r->in.account_ou) > ndr_get_array_size(ndr, &r->in.account_ou)) {
7803                                 return 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));
7804                         }
7805                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.account_ou), sizeof(uint16_t)));
7806                         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));
7807                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_ou_0, 0);
7808                 }
7809                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
7810                 if (_ptr_Account) {
7811                         NDR_PULL_ALLOC(ndr, r->in.Account);
7812                 } else {
7813                         r->in.Account = NULL;
7814                 }
7815                 if (r->in.Account) {
7816                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
7817                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
7818                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
7819                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
7820                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
7821                                 return 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));
7822                         }
7823                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
7824                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
7825                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
7826                 }
7827                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
7828                 if (_ptr_password) {
7829                         NDR_PULL_ALLOC(ndr, r->in.password);
7830                 } else {
7831                         r->in.password = NULL;
7832                 }
7833                 if (r->in.password) {
7834                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
7835                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
7836                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.password));
7837                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.password));
7838                         if (ndr_get_array_length(ndr, &r->in.password) > ndr_get_array_size(ndr, &r->in.password)) {
7839                                 return 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));
7840                         }
7841                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t)));
7842                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.password, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t), CH_UTF16));
7843                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
7844                 }
7845                 NDR_CHECK(ndr_pull_wkssvc_joinflags(ndr, NDR_SCALARS, &r->in.join_flags));
7846         }
7847         if (flags & NDR_OUT) {
7848                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7849         }
7850         return NDR_ERR_SUCCESS;
7851 }
7852
7853 _PUBLIC_ void ndr_print_wkssvc_NetrJoinDomain(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrJoinDomain *r)
7854 {
7855         ndr_print_struct(ndr, name, "wkssvc_NetrJoinDomain");
7856         ndr->depth++;
7857         if (flags & NDR_SET_VALUES) {
7858                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7859         }
7860         if (flags & NDR_IN) {
7861                 ndr_print_struct(ndr, "in", "wkssvc_NetrJoinDomain");
7862                 ndr->depth++;
7863                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
7864                 ndr->depth++;
7865                 if (r->in.server_name) {
7866                         ndr_print_string(ndr, "server_name", r->in.server_name);
7867                 }
7868                 ndr->depth--;
7869                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
7870                 ndr->depth++;
7871                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
7872                 ndr->depth--;
7873                 ndr_print_ptr(ndr, "account_ou", r->in.account_ou);
7874                 ndr->depth++;
7875                 if (r->in.account_ou) {
7876                         ndr_print_string(ndr, "account_ou", r->in.account_ou);
7877                 }
7878                 ndr->depth--;
7879                 ndr_print_ptr(ndr, "Account", r->in.Account);
7880                 ndr->depth++;
7881                 if (r->in.Account) {
7882                         ndr_print_string(ndr, "Account", r->in.Account);
7883                 }
7884                 ndr->depth--;
7885                 ndr_print_ptr(ndr, "password", r->in.password);
7886                 ndr->depth++;
7887                 if (r->in.password) {
7888                         ndr_print_string(ndr, "password", r->in.password);
7889                 }
7890                 ndr->depth--;
7891                 ndr_print_wkssvc_joinflags(ndr, "join_flags", r->in.join_flags);
7892                 ndr->depth--;
7893         }
7894         if (flags & NDR_OUT) {
7895                 ndr_print_struct(ndr, "out", "wkssvc_NetrJoinDomain");
7896                 ndr->depth++;
7897                 ndr_print_WERROR(ndr, "result", r->out.result);
7898                 ndr->depth--;
7899         }
7900         ndr->depth--;
7901 }
7902
7903 static enum ndr_err_code ndr_push_wkssvc_NetrUnjoinDomain(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUnjoinDomain *r)
7904 {
7905         if (flags & NDR_IN) {
7906                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
7907                 if (r->in.server_name) {
7908                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7909                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7910                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
7911                         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));
7912                 }
7913                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
7914                 if (r->in.Account) {
7915                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
7916                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7917                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
7918                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7919                 }
7920                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
7921                 if (r->in.password) {
7922                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
7923                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7924                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
7925                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7926                 }
7927                 NDR_CHECK(ndr_push_wkssvc_joinflags(ndr, NDR_SCALARS, r->in.unjoin_flags));
7928         }
7929         if (flags & NDR_OUT) {
7930                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7931         }
7932         return NDR_ERR_SUCCESS;
7933 }
7934
7935 static enum ndr_err_code ndr_pull_wkssvc_NetrUnjoinDomain(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUnjoinDomain *r)
7936 {
7937         uint32_t _ptr_server_name;
7938         uint32_t _ptr_Account;
7939         uint32_t _ptr_password;
7940         TALLOC_CTX *_mem_save_server_name_0;
7941         TALLOC_CTX *_mem_save_Account_0;
7942         TALLOC_CTX *_mem_save_password_0;
7943         if (flags & NDR_IN) {
7944                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
7945                 if (_ptr_server_name) {
7946                         NDR_PULL_ALLOC(ndr, r->in.server_name);
7947                 } else {
7948                         r->in.server_name = NULL;
7949                 }
7950                 if (r->in.server_name) {
7951                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7952                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
7953                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
7954                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
7955                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
7956                                 return 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));
7957                         }
7958                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
7959                         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));
7960                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
7961                 }
7962                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
7963                 if (_ptr_Account) {
7964                         NDR_PULL_ALLOC(ndr, r->in.Account);
7965                 } else {
7966                         r->in.Account = NULL;
7967                 }
7968                 if (r->in.Account) {
7969                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
7970                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
7971                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
7972                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
7973                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
7974                                 return 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));
7975                         }
7976                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
7977                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
7978                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
7979                 }
7980                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
7981                 if (_ptr_password) {
7982                         NDR_PULL_ALLOC(ndr, r->in.password);
7983                 } else {
7984                         r->in.password = NULL;
7985                 }
7986                 if (r->in.password) {
7987                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
7988                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
7989                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.password));
7990                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.password));
7991                         if (ndr_get_array_length(ndr, &r->in.password) > ndr_get_array_size(ndr, &r->in.password)) {
7992                                 return 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));
7993                         }
7994                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t)));
7995                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.password, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t), CH_UTF16));
7996                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
7997                 }
7998                 NDR_CHECK(ndr_pull_wkssvc_joinflags(ndr, NDR_SCALARS, &r->in.unjoin_flags));
7999         }
8000         if (flags & NDR_OUT) {
8001                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
8002         }
8003         return NDR_ERR_SUCCESS;
8004 }
8005
8006 _PUBLIC_ void ndr_print_wkssvc_NetrUnjoinDomain(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUnjoinDomain *r)
8007 {
8008         ndr_print_struct(ndr, name, "wkssvc_NetrUnjoinDomain");
8009         ndr->depth++;
8010         if (flags & NDR_SET_VALUES) {
8011                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8012         }
8013         if (flags & NDR_IN) {
8014                 ndr_print_struct(ndr, "in", "wkssvc_NetrUnjoinDomain");
8015                 ndr->depth++;
8016                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
8017                 ndr->depth++;
8018                 if (r->in.server_name) {
8019                         ndr_print_string(ndr, "server_name", r->in.server_name);
8020                 }
8021                 ndr->depth--;
8022                 ndr_print_ptr(ndr, "Account", r->in.Account);
8023                 ndr->depth++;
8024                 if (r->in.Account) {
8025                         ndr_print_string(ndr, "Account", r->in.Account);
8026                 }
8027                 ndr->depth--;
8028                 ndr_print_ptr(ndr, "password", r->in.password);
8029                 ndr->depth++;
8030                 if (r->in.password) {
8031                         ndr_print_string(ndr, "password", r->in.password);
8032                 }
8033                 ndr->depth--;
8034                 ndr_print_wkssvc_joinflags(ndr, "unjoin_flags", r->in.unjoin_flags);
8035                 ndr->depth--;
8036         }
8037         if (flags & NDR_OUT) {
8038                 ndr_print_struct(ndr, "out", "wkssvc_NetrUnjoinDomain");
8039                 ndr->depth++;
8040                 ndr_print_WERROR(ndr, "result", r->out.result);
8041                 ndr->depth--;
8042         }
8043         ndr->depth--;
8044 }
8045
8046 static enum ndr_err_code ndr_push_wkssvc_NetrRenameMachineInDomain(struct ndr_push *ndr, int flags, const struct wkssvc_NetrRenameMachineInDomain *r)
8047 {
8048         if (flags & NDR_IN) {
8049                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
8050                 if (r->in.server_name) {
8051                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8052                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8053                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8054                         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));
8055                 }
8056                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.NewMachineName));
8057                 if (r->in.NewMachineName) {
8058                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewMachineName, CH_UTF16)));
8059                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8060                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewMachineName, CH_UTF16)));
8061                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.NewMachineName, ndr_charset_length(r->in.NewMachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8062                 }
8063                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
8064                 if (r->in.Account) {
8065                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
8066                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8067                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
8068                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8069                 }
8070                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
8071                 if (r->in.password) {
8072                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
8073                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8074                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
8075                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8076                 }
8077                 NDR_CHECK(ndr_push_wkssvc_renameflags(ndr, NDR_SCALARS, r->in.RenameOptions));
8078         }
8079         if (flags & NDR_OUT) {
8080                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
8081         }
8082         return NDR_ERR_SUCCESS;
8083 }
8084
8085 static enum ndr_err_code ndr_pull_wkssvc_NetrRenameMachineInDomain(struct ndr_pull *ndr, int flags, struct wkssvc_NetrRenameMachineInDomain *r)
8086 {
8087         uint32_t _ptr_server_name;
8088         uint32_t _ptr_NewMachineName;
8089         uint32_t _ptr_Account;
8090         uint32_t _ptr_password;
8091         TALLOC_CTX *_mem_save_server_name_0;
8092         TALLOC_CTX *_mem_save_NewMachineName_0;
8093         TALLOC_CTX *_mem_save_Account_0;
8094         TALLOC_CTX *_mem_save_password_0;
8095         if (flags & NDR_IN) {
8096                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
8097                 if (_ptr_server_name) {
8098                         NDR_PULL_ALLOC(ndr, r->in.server_name);
8099                 } else {
8100                         r->in.server_name = NULL;
8101                 }
8102                 if (r->in.server_name) {
8103                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8104                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
8105                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
8106                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
8107                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
8108                                 return 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));
8109                         }
8110                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
8111                         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));
8112                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
8113                 }
8114                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_NewMachineName));
8115                 if (_ptr_NewMachineName) {
8116                         NDR_PULL_ALLOC(ndr, r->in.NewMachineName);
8117                 } else {
8118                         r->in.NewMachineName = NULL;
8119                 }
8120                 if (r->in.NewMachineName) {
8121                         _mem_save_NewMachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);
8122                         NDR_PULL_SET_MEM_CTX(ndr, r->in.NewMachineName, 0);
8123                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.NewMachineName));
8124                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.NewMachineName));
8125                         if (ndr_get_array_length(ndr, &r->in.NewMachineName) > ndr_get_array_size(ndr, &r->in.NewMachineName)) {
8126                                 return 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));
8127                         }
8128                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.NewMachineName), sizeof(uint16_t)));
8129                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.NewMachineName, ndr_get_array_length(ndr, &r->in.NewMachineName), sizeof(uint16_t), CH_UTF16));
8130                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_NewMachineName_0, 0);
8131                 }
8132                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
8133                 if (_ptr_Account) {
8134                         NDR_PULL_ALLOC(ndr, r->in.Account);
8135                 } else {
8136                         r->in.Account = NULL;
8137                 }
8138                 if (r->in.Account) {
8139                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
8140                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
8141                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
8142                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
8143                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
8144                                 return 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));
8145                         }
8146                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
8147                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
8148                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
8149                 }
8150                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
8151                 if (_ptr_password) {
8152                         NDR_PULL_ALLOC(ndr, r->in.password);
8153                 } else {
8154                         r->in.password = NULL;
8155                 }
8156                 if (r->in.password) {
8157                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
8158                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
8159                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.password));
8160                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.password));
8161                         if (ndr_get_array_length(ndr, &r->in.password) > ndr_get_array_size(ndr, &r->in.password)) {
8162                                 return 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));
8163                         }
8164                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t)));
8165                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.password, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t), CH_UTF16));
8166                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
8167                 }
8168                 NDR_CHECK(ndr_pull_wkssvc_renameflags(ndr, NDR_SCALARS, &r->in.RenameOptions));
8169         }
8170         if (flags & NDR_OUT) {
8171                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
8172         }
8173         return NDR_ERR_SUCCESS;
8174 }
8175
8176 _PUBLIC_ void ndr_print_wkssvc_NetrRenameMachineInDomain(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrRenameMachineInDomain *r)
8177 {
8178         ndr_print_struct(ndr, name, "wkssvc_NetrRenameMachineInDomain");
8179         ndr->depth++;
8180         if (flags & NDR_SET_VALUES) {
8181                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8182         }
8183         if (flags & NDR_IN) {
8184                 ndr_print_struct(ndr, "in", "wkssvc_NetrRenameMachineInDomain");
8185                 ndr->depth++;
8186                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
8187                 ndr->depth++;
8188                 if (r->in.server_name) {
8189                         ndr_print_string(ndr, "server_name", r->in.server_name);
8190                 }
8191                 ndr->depth--;
8192                 ndr_print_ptr(ndr, "NewMachineName", r->in.NewMachineName);
8193                 ndr->depth++;
8194                 if (r->in.NewMachineName) {
8195                         ndr_print_string(ndr, "NewMachineName", r->in.NewMachineName);
8196                 }
8197                 ndr->depth--;
8198                 ndr_print_ptr(ndr, "Account", r->in.Account);
8199                 ndr->depth++;
8200                 if (r->in.Account) {
8201                         ndr_print_string(ndr, "Account", r->in.Account);
8202                 }
8203                 ndr->depth--;
8204                 ndr_print_ptr(ndr, "password", r->in.password);
8205                 ndr->depth++;
8206                 if (r->in.password) {
8207                         ndr_print_string(ndr, "password", r->in.password);
8208                 }
8209                 ndr->depth--;
8210                 ndr_print_wkssvc_renameflags(ndr, "RenameOptions", r->in.RenameOptions);
8211                 ndr->depth--;
8212         }
8213         if (flags & NDR_OUT) {
8214                 ndr_print_struct(ndr, "out", "wkssvc_NetrRenameMachineInDomain");
8215                 ndr->depth++;
8216                 ndr_print_WERROR(ndr, "result", r->out.result);
8217                 ndr->depth--;
8218         }
8219         ndr->depth--;
8220 }
8221
8222 static enum ndr_err_code ndr_push_wkssvc_NetrValidateName(struct ndr_push *ndr, int flags, const struct wkssvc_NetrValidateName *r)
8223 {
8224         if (flags & NDR_IN) {
8225                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
8226                 if (r->in.server_name) {
8227                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8228                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8229                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8230                         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));
8231                 }
8232                 if (r->in.name == NULL) {
8233                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8234                 }
8235                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF16)));
8236                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8237                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF16)));
8238                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.name, ndr_charset_length(r->in.name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8239                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
8240                 if (r->in.Account) {
8241                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
8242                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8243                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
8244                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8245                 }
8246                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Password));
8247                 if (r->in.Password) {
8248                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Password, CH_UTF16)));
8249                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8250                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Password, CH_UTF16)));
8251                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Password, ndr_charset_length(r->in.Password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8252                 }
8253                 NDR_CHECK(ndr_push_wkssvc_NetValidateNameType(ndr, NDR_SCALARS, r->in.name_type));
8254         }
8255         if (flags & NDR_OUT) {
8256                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
8257         }
8258         return NDR_ERR_SUCCESS;
8259 }
8260
8261 static enum ndr_err_code ndr_pull_wkssvc_NetrValidateName(struct ndr_pull *ndr, int flags, struct wkssvc_NetrValidateName *r)
8262 {
8263         uint32_t _ptr_server_name;
8264         uint32_t _ptr_Account;
8265         uint32_t _ptr_Password;
8266         TALLOC_CTX *_mem_save_server_name_0;
8267         TALLOC_CTX *_mem_save_Account_0;
8268         TALLOC_CTX *_mem_save_Password_0;
8269         if (flags & NDR_IN) {
8270                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
8271                 if (_ptr_server_name) {
8272                         NDR_PULL_ALLOC(ndr, r->in.server_name);
8273                 } else {
8274                         r->in.server_name = NULL;
8275                 }
8276                 if (r->in.server_name) {
8277                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8278                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
8279                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
8280                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
8281                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
8282                                 return 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));
8283                         }
8284                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
8285                         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));
8286                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
8287                 }
8288                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.name));
8289                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.name));
8290                 if (ndr_get_array_length(ndr, &r->in.name) > ndr_get_array_size(ndr, &r->in.name)) {
8291                         return 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));
8292                 }
8293                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.name), sizeof(uint16_t)));
8294                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.name, ndr_get_array_length(ndr, &r->in.name), sizeof(uint16_t), CH_UTF16));
8295                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
8296                 if (_ptr_Account) {
8297                         NDR_PULL_ALLOC(ndr, r->in.Account);
8298                 } else {
8299                         r->in.Account = NULL;
8300                 }
8301                 if (r->in.Account) {
8302                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
8303                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
8304                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
8305                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
8306                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
8307                                 return 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));
8308                         }
8309                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
8310                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
8311                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
8312                 }
8313                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Password));
8314                 if (_ptr_Password) {
8315                         NDR_PULL_ALLOC(ndr, r->in.Password);
8316                 } else {
8317                         r->in.Password = NULL;
8318                 }
8319                 if (r->in.Password) {
8320                         _mem_save_Password_0 = NDR_PULL_GET_MEM_CTX(ndr);
8321                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Password, 0);
8322                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Password));
8323                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Password));
8324                         if (ndr_get_array_length(ndr, &r->in.Password) > ndr_get_array_size(ndr, &r->in.Password)) {
8325                                 return 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));
8326                         }
8327                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Password), sizeof(uint16_t)));
8328                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Password, ndr_get_array_length(ndr, &r->in.Password), sizeof(uint16_t), CH_UTF16));
8329                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Password_0, 0);
8330                 }
8331                 NDR_CHECK(ndr_pull_wkssvc_NetValidateNameType(ndr, NDR_SCALARS, &r->in.name_type));
8332         }
8333         if (flags & NDR_OUT) {
8334                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
8335         }
8336         return NDR_ERR_SUCCESS;
8337 }
8338
8339 _PUBLIC_ void ndr_print_wkssvc_NetrValidateName(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrValidateName *r)
8340 {
8341         ndr_print_struct(ndr, name, "wkssvc_NetrValidateName");
8342         ndr->depth++;
8343         if (flags & NDR_SET_VALUES) {
8344                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8345         }
8346         if (flags & NDR_IN) {
8347                 ndr_print_struct(ndr, "in", "wkssvc_NetrValidateName");
8348                 ndr->depth++;
8349                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
8350                 ndr->depth++;
8351                 if (r->in.server_name) {
8352                         ndr_print_string(ndr, "server_name", r->in.server_name);
8353                 }
8354                 ndr->depth--;
8355                 ndr_print_ptr(ndr, "name", r->in.name);
8356                 ndr->depth++;
8357                 ndr_print_string(ndr, "name", r->in.name);
8358                 ndr->depth--;
8359                 ndr_print_ptr(ndr, "Account", r->in.Account);
8360                 ndr->depth++;
8361                 if (r->in.Account) {
8362                         ndr_print_string(ndr, "Account", r->in.Account);
8363                 }
8364                 ndr->depth--;
8365                 ndr_print_ptr(ndr, "Password", r->in.Password);
8366                 ndr->depth++;
8367                 if (r->in.Password) {
8368                         ndr_print_string(ndr, "Password", r->in.Password);
8369                 }
8370                 ndr->depth--;
8371                 ndr_print_wkssvc_NetValidateNameType(ndr, "name_type", r->in.name_type);
8372                 ndr->depth--;
8373         }
8374         if (flags & NDR_OUT) {
8375                 ndr_print_struct(ndr, "out", "wkssvc_NetrValidateName");
8376                 ndr->depth++;
8377                 ndr_print_WERROR(ndr, "result", r->out.result);
8378                 ndr->depth--;
8379         }
8380         ndr->depth--;
8381 }
8382
8383 static enum ndr_err_code ndr_push_wkssvc_NetrGetJoinInformation(struct ndr_push *ndr, int flags, const struct wkssvc_NetrGetJoinInformation *r)
8384 {
8385         if (flags & NDR_IN) {
8386                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
8387                 if (r->in.server_name) {
8388                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8389                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8390                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8391                         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));
8392                 }
8393                 if (r->in.name_buffer == NULL) {
8394                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8395                 }
8396                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->in.name_buffer));
8397                 if (*r->in.name_buffer) {
8398                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->in.name_buffer, CH_UTF16)));
8399                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8400                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->in.name_buffer, CH_UTF16)));
8401                         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));
8402                 }
8403         }
8404         if (flags & NDR_OUT) {
8405                 if (r->out.name_buffer == NULL) {
8406                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8407                 }
8408                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.name_buffer));
8409                 if (*r->out.name_buffer) {
8410                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.name_buffer, CH_UTF16)));
8411                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8412                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.name_buffer, CH_UTF16)));
8413                         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));
8414                 }
8415                 if (r->out.name_type == NULL) {
8416                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8417                 }
8418                 NDR_CHECK(ndr_push_wkssvc_NetJoinStatus(ndr, NDR_SCALARS, *r->out.name_type));
8419                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
8420         }
8421         return NDR_ERR_SUCCESS;
8422 }
8423
8424 static enum ndr_err_code ndr_pull_wkssvc_NetrGetJoinInformation(struct ndr_pull *ndr, int flags, struct wkssvc_NetrGetJoinInformation *r)
8425 {
8426         uint32_t _ptr_server_name;
8427         uint32_t _ptr_name_buffer;
8428         TALLOC_CTX *_mem_save_server_name_0;
8429         TALLOC_CTX *_mem_save_name_buffer_0;
8430         TALLOC_CTX *_mem_save_name_buffer_1;
8431         TALLOC_CTX *_mem_save_name_type_0;
8432         if (flags & NDR_IN) {
8433                 ZERO_STRUCT(r->out);
8434
8435                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
8436                 if (_ptr_server_name) {
8437                         NDR_PULL_ALLOC(ndr, r->in.server_name);
8438                 } else {
8439                         r->in.server_name = NULL;
8440                 }
8441                 if (r->in.server_name) {
8442                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8443                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
8444                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
8445                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
8446                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
8447                                 return 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));
8448                         }
8449                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
8450                         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));
8451                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
8452                 }
8453                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8454                         NDR_PULL_ALLOC(ndr, r->in.name_buffer);
8455                 }
8456                 _mem_save_name_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
8457                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name_buffer, LIBNDR_FLAG_REF_ALLOC);
8458                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_buffer));
8459                 if (_ptr_name_buffer) {
8460                         NDR_PULL_ALLOC(ndr, *r->in.name_buffer);
8461                 } else {
8462                         *r->in.name_buffer = NULL;
8463                 }
8464                 if (*r->in.name_buffer) {
8465                         _mem_save_name_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
8466                         NDR_PULL_SET_MEM_CTX(ndr, *r->in.name_buffer, 0);
8467                         NDR_CHECK(ndr_pull_array_size(ndr, r->in.name_buffer));
8468                         NDR_CHECK(ndr_pull_array_length(ndr, r->in.name_buffer));
8469                         if (ndr_get_array_length(ndr, r->in.name_buffer) > ndr_get_array_size(ndr, r->in.name_buffer)) {
8470                                 return 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));
8471                         }
8472                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->in.name_buffer), sizeof(uint16_t)));
8473                         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));
8474                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_buffer_1, 0);
8475                 }
8476                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_buffer_0, LIBNDR_FLAG_REF_ALLOC);
8477                 NDR_PULL_ALLOC(ndr, r->out.name_buffer);
8478                 *r->out.name_buffer = *r->in.name_buffer;
8479                 NDR_PULL_ALLOC(ndr, r->out.name_type);
8480                 ZERO_STRUCTP(r->out.name_type);
8481         }
8482         if (flags & NDR_OUT) {
8483                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8484                         NDR_PULL_ALLOC(ndr, r->out.name_buffer);
8485                 }
8486                 _mem_save_name_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
8487                 NDR_PULL_SET_MEM_CTX(ndr, r->out.name_buffer, LIBNDR_FLAG_REF_ALLOC);
8488                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_buffer));
8489                 if (_ptr_name_buffer) {
8490                         NDR_PULL_ALLOC(ndr, *r->out.name_buffer);
8491                 } else {
8492                         *r->out.name_buffer = NULL;
8493                 }
8494                 if (*r->out.name_buffer) {
8495                         _mem_save_name_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
8496                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.name_buffer, 0);
8497                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.name_buffer));
8498                         NDR_CHECK(ndr_pull_array_length(ndr, r->out.name_buffer));
8499                         if (ndr_get_array_length(ndr, r->out.name_buffer) > ndr_get_array_size(ndr, r->out.name_buffer)) {
8500                                 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));
8501                         }
8502                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->out.name_buffer), sizeof(uint16_t)));
8503                         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));
8504                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_buffer_1, 0);
8505                 }
8506                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_buffer_0, LIBNDR_FLAG_REF_ALLOC);
8507                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8508                         NDR_PULL_ALLOC(ndr, r->out.name_type);
8509                 }
8510                 _mem_save_name_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
8511                 NDR_PULL_SET_MEM_CTX(ndr, r->out.name_type, LIBNDR_FLAG_REF_ALLOC);
8512                 NDR_CHECK(ndr_pull_wkssvc_NetJoinStatus(ndr, NDR_SCALARS, r->out.name_type));
8513                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_type_0, LIBNDR_FLAG_REF_ALLOC);
8514                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
8515         }
8516         return NDR_ERR_SUCCESS;
8517 }
8518
8519 _PUBLIC_ void ndr_print_wkssvc_NetrGetJoinInformation(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrGetJoinInformation *r)
8520 {
8521         ndr_print_struct(ndr, name, "wkssvc_NetrGetJoinInformation");
8522         ndr->depth++;
8523         if (flags & NDR_SET_VALUES) {
8524                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8525         }
8526         if (flags & NDR_IN) {
8527                 ndr_print_struct(ndr, "in", "wkssvc_NetrGetJoinInformation");
8528                 ndr->depth++;
8529                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
8530                 ndr->depth++;
8531                 if (r->in.server_name) {
8532                         ndr_print_string(ndr, "server_name", r->in.server_name);
8533                 }
8534                 ndr->depth--;
8535                 ndr_print_ptr(ndr, "name_buffer", r->in.name_buffer);
8536                 ndr->depth++;
8537                 ndr_print_ptr(ndr, "name_buffer", *r->in.name_buffer);
8538                 ndr->depth++;
8539                 if (*r->in.name_buffer) {
8540                         ndr_print_string(ndr, "name_buffer", *r->in.name_buffer);
8541                 }
8542                 ndr->depth--;
8543                 ndr->depth--;
8544                 ndr->depth--;
8545         }
8546         if (flags & NDR_OUT) {
8547                 ndr_print_struct(ndr, "out", "wkssvc_NetrGetJoinInformation");
8548                 ndr->depth++;
8549                 ndr_print_ptr(ndr, "name_buffer", r->out.name_buffer);
8550                 ndr->depth++;
8551                 ndr_print_ptr(ndr, "name_buffer", *r->out.name_buffer);
8552                 ndr->depth++;
8553                 if (*r->out.name_buffer) {
8554                         ndr_print_string(ndr, "name_buffer", *r->out.name_buffer);
8555                 }
8556                 ndr->depth--;
8557                 ndr->depth--;
8558                 ndr_print_ptr(ndr, "name_type", r->out.name_type);
8559                 ndr->depth++;
8560                 ndr_print_wkssvc_NetJoinStatus(ndr, "name_type", *r->out.name_type);
8561                 ndr->depth--;
8562                 ndr_print_WERROR(ndr, "result", r->out.result);
8563                 ndr->depth--;
8564         }
8565         ndr->depth--;
8566 }
8567
8568 static enum ndr_err_code ndr_push_wkssvc_NetrGetJoinableOus(struct ndr_push *ndr, int flags, const struct wkssvc_NetrGetJoinableOus *r)
8569 {
8570         uint32_t cntr_ous_2;
8571         if (flags & NDR_IN) {
8572                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
8573                 if (r->in.server_name) {
8574                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8575                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8576                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8577                         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));
8578                 }
8579                 if (r->in.domain_name == NULL) {
8580                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8581                 }
8582                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
8583                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8584                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
8585                 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));
8586                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
8587                 if (r->in.Account) {
8588                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
8589                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8590                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
8591                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8592                 }
8593                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown));
8594                 if (r->in.unknown) {
8595                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));
8596                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8597                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));
8598                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.unknown, ndr_charset_length(r->in.unknown, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8599                 }
8600                 if (r->in.num_ous == NULL) {
8601                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8602                 }
8603                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.num_ous));
8604         }
8605         if (flags & NDR_OUT) {
8606                 if (r->out.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->out.num_ous));
8610                 if (r->out.ous == NULL) {
8611                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8612                 }
8613                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.ous));
8614                 if (*r->out.ous) {
8615                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_ous));
8616                         for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {
8617                                 NDR_CHECK(ndr_push_unique_ptr(ndr, (*r->out.ous)[cntr_ous_2]));
8618                         }
8619                         for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {
8620                                 if ((*r->out.ous)[cntr_ous_2]) {
8621                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length((*r->out.ous)[cntr_ous_2], CH_UTF16)));
8622                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8623                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length((*r->out.ous)[cntr_ous_2], CH_UTF16)));
8624                                         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));
8625                                 }
8626                         }
8627                 }
8628                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
8629         }
8630         return NDR_ERR_SUCCESS;
8631 }
8632
8633 static enum ndr_err_code ndr_pull_wkssvc_NetrGetJoinableOus(struct ndr_pull *ndr, int flags, struct wkssvc_NetrGetJoinableOus *r)
8634 {
8635         uint32_t _ptr_server_name;
8636         uint32_t _ptr_Account;
8637         uint32_t _ptr_unknown;
8638         uint32_t _ptr_ous;
8639         uint32_t cntr_ous_2;
8640         TALLOC_CTX *_mem_save_server_name_0;
8641         TALLOC_CTX *_mem_save_Account_0;
8642         TALLOC_CTX *_mem_save_unknown_0;
8643         TALLOC_CTX *_mem_save_num_ous_0;
8644         TALLOC_CTX *_mem_save_ous_0;
8645         TALLOC_CTX *_mem_save_ous_1;
8646         TALLOC_CTX *_mem_save_ous_2;
8647         TALLOC_CTX *_mem_save_ous_3;
8648         if (flags & NDR_IN) {
8649                 ZERO_STRUCT(r->out);
8650
8651                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
8652                 if (_ptr_server_name) {
8653                         NDR_PULL_ALLOC(ndr, r->in.server_name);
8654                 } else {
8655                         r->in.server_name = NULL;
8656                 }
8657                 if (r->in.server_name) {
8658                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8659                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
8660                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
8661                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
8662                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
8663                                 return 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));
8664                         }
8665                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
8666                         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));
8667                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
8668                 }
8669                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
8670                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
8671                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
8672                         return 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));
8673                 }
8674                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
8675                 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));
8676                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
8677                 if (_ptr_Account) {
8678                         NDR_PULL_ALLOC(ndr, r->in.Account);
8679                 } else {
8680                         r->in.Account = NULL;
8681                 }
8682                 if (r->in.Account) {
8683                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
8684                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
8685                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
8686                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
8687                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
8688                                 return 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));
8689                         }
8690                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
8691                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
8692                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
8693                 }
8694                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown));
8695                 if (_ptr_unknown) {
8696                         NDR_PULL_ALLOC(ndr, r->in.unknown);
8697                 } else {
8698                         r->in.unknown = NULL;
8699                 }
8700                 if (r->in.unknown) {
8701                         _mem_save_unknown_0 = NDR_PULL_GET_MEM_CTX(ndr);
8702                         NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown, 0);
8703                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.unknown));
8704                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.unknown));
8705                         if (ndr_get_array_length(ndr, &r->in.unknown) > ndr_get_array_size(ndr, &r->in.unknown)) {
8706                                 return 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));
8707                         }
8708                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t)));
8709                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.unknown, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t), CH_UTF16));
8710                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown_0, 0);
8711                 }
8712                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8713                         NDR_PULL_ALLOC(ndr, r->in.num_ous);
8714                 }
8715                 _mem_save_num_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);
8716                 NDR_PULL_SET_MEM_CTX(ndr, r->in.num_ous, LIBNDR_FLAG_REF_ALLOC);
8717                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.num_ous));
8718                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_ous_0, LIBNDR_FLAG_REF_ALLOC);
8719                 NDR_PULL_ALLOC(ndr, r->out.num_ous);
8720                 *r->out.num_ous = *r->in.num_ous;
8721                 NDR_PULL_ALLOC(ndr, r->out.ous);
8722                 ZERO_STRUCTP(r->out.ous);
8723         }
8724         if (flags & NDR_OUT) {
8725                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8726                         NDR_PULL_ALLOC(ndr, r->out.num_ous);
8727                 }
8728                 _mem_save_num_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);
8729                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_ous, LIBNDR_FLAG_REF_ALLOC);
8730                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_ous));
8731                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_ous_0, LIBNDR_FLAG_REF_ALLOC);
8732                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8733                         NDR_PULL_ALLOC(ndr, r->out.ous);
8734                 }
8735                 _mem_save_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);
8736                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ous, LIBNDR_FLAG_REF_ALLOC);
8737                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ous));
8738                 if (_ptr_ous) {
8739                         NDR_PULL_ALLOC(ndr, *r->out.ous);
8740                 } else {
8741                         *r->out.ous = NULL;
8742                 }
8743                 if (*r->out.ous) {
8744                         _mem_save_ous_1 = NDR_PULL_GET_MEM_CTX(ndr);
8745                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.ous, 0);
8746                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.ous));
8747                         NDR_PULL_ALLOC_N(ndr, *r->out.ous, ndr_get_array_size(ndr, r->out.ous));
8748                         _mem_save_ous_2 = NDR_PULL_GET_MEM_CTX(ndr);
8749                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.ous, 0);
8750                         for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {
8751                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ous));
8752                                 if (_ptr_ous) {
8753                                         NDR_PULL_ALLOC(ndr, (*r->out.ous)[cntr_ous_2]);
8754                                 } else {
8755                                         (*r->out.ous)[cntr_ous_2] = NULL;
8756                                 }
8757                         }
8758                         for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {
8759                                 if ((*r->out.ous)[cntr_ous_2]) {
8760                                         _mem_save_ous_3 = NDR_PULL_GET_MEM_CTX(ndr);
8761                                         NDR_PULL_SET_MEM_CTX(ndr, (*r->out.ous)[cntr_ous_2], 0);
8762                                         NDR_CHECK(ndr_pull_array_size(ndr, &(*r->out.ous)[cntr_ous_2]));
8763                                         NDR_CHECK(ndr_pull_array_length(ndr, &(*r->out.ous)[cntr_ous_2]));
8764                                         if (ndr_get_array_length(ndr, &(*r->out.ous)[cntr_ous_2]) > ndr_get_array_size(ndr, &(*r->out.ous)[cntr_ous_2])) {
8765                                                 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]));
8766                                         }
8767                                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &(*r->out.ous)[cntr_ous_2]), sizeof(uint16_t)));
8768                                         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));
8769                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_3, 0);
8770                                 }
8771                         }
8772                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_2, 0);
8773                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_1, 0);
8774                 }
8775                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_0, LIBNDR_FLAG_REF_ALLOC);
8776                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
8777                 if (*r->out.ous) {
8778                         NDR_CHECK(ndr_check_array_size(ndr, (void*)r->out.ous, *r->out.num_ous));
8779                 }
8780         }
8781         return NDR_ERR_SUCCESS;
8782 }
8783
8784 _PUBLIC_ void ndr_print_wkssvc_NetrGetJoinableOus(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrGetJoinableOus *r)
8785 {
8786         uint32_t cntr_ous_2;
8787         ndr_print_struct(ndr, name, "wkssvc_NetrGetJoinableOus");
8788         ndr->depth++;
8789         if (flags & NDR_SET_VALUES) {
8790                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8791         }
8792         if (flags & NDR_IN) {
8793                 ndr_print_struct(ndr, "in", "wkssvc_NetrGetJoinableOus");
8794                 ndr->depth++;
8795                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
8796                 ndr->depth++;
8797                 if (r->in.server_name) {
8798                         ndr_print_string(ndr, "server_name", r->in.server_name);
8799                 }
8800                 ndr->depth--;
8801                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
8802                 ndr->depth++;
8803                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
8804                 ndr->depth--;
8805                 ndr_print_ptr(ndr, "Account", r->in.Account);
8806                 ndr->depth++;
8807                 if (r->in.Account) {
8808                         ndr_print_string(ndr, "Account", r->in.Account);
8809                 }
8810                 ndr->depth--;
8811                 ndr_print_ptr(ndr, "unknown", r->in.unknown);
8812                 ndr->depth++;
8813                 if (r->in.unknown) {
8814                         ndr_print_string(ndr, "unknown", r->in.unknown);
8815                 }
8816                 ndr->depth--;
8817                 ndr_print_ptr(ndr, "num_ous", r->in.num_ous);
8818                 ndr->depth++;
8819                 ndr_print_uint32(ndr, "num_ous", *r->in.num_ous);
8820                 ndr->depth--;
8821                 ndr->depth--;
8822         }
8823         if (flags & NDR_OUT) {
8824                 ndr_print_struct(ndr, "out", "wkssvc_NetrGetJoinableOus");
8825                 ndr->depth++;
8826                 ndr_print_ptr(ndr, "num_ous", r->out.num_ous);
8827                 ndr->depth++;
8828                 ndr_print_uint32(ndr, "num_ous", *r->out.num_ous);
8829                 ndr->depth--;
8830                 ndr_print_ptr(ndr, "ous", r->out.ous);
8831                 ndr->depth++;
8832                 ndr_print_ptr(ndr, "ous", *r->out.ous);
8833                 ndr->depth++;
8834                 if (*r->out.ous) {
8835                         ndr->print(ndr, "%s: ARRAY(%d)", "ous", *r->out.num_ous);
8836                         ndr->depth++;
8837                         for (cntr_ous_2=0;cntr_ous_2<*r->out.num_ous;cntr_ous_2++) {
8838                                 char *idx_2=NULL;
8839                                 asprintf(&idx_2, "[%d]", cntr_ous_2);
8840                                 if (idx_2) {
8841                                         ndr_print_ptr(ndr, "ous", (*r->out.ous)[cntr_ous_2]);
8842                                         ndr->depth++;
8843                                         if ((*r->out.ous)[cntr_ous_2]) {
8844                                                 ndr_print_string(ndr, "ous", (*r->out.ous)[cntr_ous_2]);
8845                                         }
8846                                         ndr->depth--;
8847                                         free(idx_2);
8848                                 }
8849                         }
8850                         ndr->depth--;
8851                 }
8852                 ndr->depth--;
8853                 ndr->depth--;
8854                 ndr_print_WERROR(ndr, "result", r->out.result);
8855                 ndr->depth--;
8856         }
8857         ndr->depth--;
8858 }
8859
8860 static enum ndr_err_code ndr_push_wkssvc_NetrJoinDomain2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrJoinDomain2 *r)
8861 {
8862         if (flags & NDR_IN) {
8863                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
8864                 if (r->in.server_name) {
8865                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8866                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8867                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
8868                         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));
8869                 }
8870                 if (r->in.domain_name == NULL) {
8871                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8872                 }
8873                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
8874                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8875                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
8876                 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));
8877                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.account_ou));
8878                 if (r->in.account_ou) {
8879                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account_ou, CH_UTF16)));
8880                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8881                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account_ou, CH_UTF16)));
8882                         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));
8883                 }
8884                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.admin_account));
8885                 if (r->in.admin_account) {
8886                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.admin_account, CH_UTF16)));
8887                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8888                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.admin_account, CH_UTF16)));
8889                         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));
8890                 }
8891                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.encrypted_password));
8892                 if (r->in.encrypted_password) {
8893                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));
8894                 }
8895                 NDR_CHECK(ndr_push_wkssvc_joinflags(ndr, NDR_SCALARS, r->in.join_flags));
8896         }
8897         if (flags & NDR_OUT) {
8898                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
8899         }
8900         return NDR_ERR_SUCCESS;
8901 }
8902
8903 static enum ndr_err_code ndr_pull_wkssvc_NetrJoinDomain2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrJoinDomain2 *r)
8904 {
8905         uint32_t _ptr_server_name;
8906         uint32_t _ptr_account_ou;
8907         uint32_t _ptr_admin_account;
8908         uint32_t _ptr_encrypted_password;
8909         TALLOC_CTX *_mem_save_server_name_0;
8910         TALLOC_CTX *_mem_save_account_ou_0;
8911         TALLOC_CTX *_mem_save_admin_account_0;
8912         TALLOC_CTX *_mem_save_encrypted_password_0;
8913         if (flags & NDR_IN) {
8914                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
8915                 if (_ptr_server_name) {
8916                         NDR_PULL_ALLOC(ndr, r->in.server_name);
8917                 } else {
8918                         r->in.server_name = NULL;
8919                 }
8920                 if (r->in.server_name) {
8921                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8922                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
8923                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
8924                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
8925                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
8926                                 return 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));
8927                         }
8928                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
8929                         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));
8930                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
8931                 }
8932                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
8933                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
8934                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
8935                         return 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));
8936                 }
8937                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
8938                 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));
8939                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account_ou));
8940                 if (_ptr_account_ou) {
8941                         NDR_PULL_ALLOC(ndr, r->in.account_ou);
8942                 } else {
8943                         r->in.account_ou = NULL;
8944                 }
8945                 if (r->in.account_ou) {
8946                         _mem_save_account_ou_0 = NDR_PULL_GET_MEM_CTX(ndr);
8947                         NDR_PULL_SET_MEM_CTX(ndr, r->in.account_ou, 0);
8948                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.account_ou));
8949                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.account_ou));
8950                         if (ndr_get_array_length(ndr, &r->in.account_ou) > ndr_get_array_size(ndr, &r->in.account_ou)) {
8951                                 return 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));
8952                         }
8953                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.account_ou), sizeof(uint16_t)));
8954                         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));
8955                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_ou_0, 0);
8956                 }
8957                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_admin_account));
8958                 if (_ptr_admin_account) {
8959                         NDR_PULL_ALLOC(ndr, r->in.admin_account);
8960                 } else {
8961                         r->in.admin_account = NULL;
8962                 }
8963                 if (r->in.admin_account) {
8964                         _mem_save_admin_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
8965                         NDR_PULL_SET_MEM_CTX(ndr, r->in.admin_account, 0);
8966                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.admin_account));
8967                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.admin_account));
8968                         if (ndr_get_array_length(ndr, &r->in.admin_account) > ndr_get_array_size(ndr, &r->in.admin_account)) {
8969                                 return 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));
8970                         }
8971                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.admin_account), sizeof(uint16_t)));
8972                         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));
8973                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_admin_account_0, 0);
8974                 }
8975                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_encrypted_password));
8976                 if (_ptr_encrypted_password) {
8977                         NDR_PULL_ALLOC(ndr, r->in.encrypted_password);
8978                 } else {
8979                         r->in.encrypted_password = NULL;
8980                 }
8981                 if (r->in.encrypted_password) {
8982                         _mem_save_encrypted_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
8983                         NDR_PULL_SET_MEM_CTX(ndr, r->in.encrypted_password, 0);
8984                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));
8985                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_encrypted_password_0, 0);
8986                 }
8987                 NDR_CHECK(ndr_pull_wkssvc_joinflags(ndr, NDR_SCALARS, &r->in.join_flags));
8988         }
8989         if (flags & NDR_OUT) {
8990                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
8991         }
8992         return NDR_ERR_SUCCESS;
8993 }
8994
8995 _PUBLIC_ void ndr_print_wkssvc_NetrJoinDomain2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrJoinDomain2 *r)
8996 {
8997         ndr_print_struct(ndr, name, "wkssvc_NetrJoinDomain2");
8998         ndr->depth++;
8999         if (flags & NDR_SET_VALUES) {
9000                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9001         }
9002         if (flags & NDR_IN) {
9003                 ndr_print_struct(ndr, "in", "wkssvc_NetrJoinDomain2");
9004                 ndr->depth++;
9005                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
9006                 ndr->depth++;
9007                 if (r->in.server_name) {
9008                         ndr_print_string(ndr, "server_name", r->in.server_name);
9009                 }
9010                 ndr->depth--;
9011                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
9012                 ndr->depth++;
9013                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
9014                 ndr->depth--;
9015                 ndr_print_ptr(ndr, "account_ou", r->in.account_ou);
9016                 ndr->depth++;
9017                 if (r->in.account_ou) {
9018                         ndr_print_string(ndr, "account_ou", r->in.account_ou);
9019                 }
9020                 ndr->depth--;
9021                 ndr_print_ptr(ndr, "admin_account", r->in.admin_account);
9022                 ndr->depth++;
9023                 if (r->in.admin_account) {
9024                         ndr_print_string(ndr, "admin_account", r->in.admin_account);
9025                 }
9026                 ndr->depth--;
9027                 ndr_print_ptr(ndr, "encrypted_password", r->in.encrypted_password);
9028                 ndr->depth++;
9029                 if (r->in.encrypted_password) {
9030                         ndr_print_wkssvc_PasswordBuffer(ndr, "encrypted_password", r->in.encrypted_password);
9031                 }
9032                 ndr->depth--;
9033                 ndr_print_wkssvc_joinflags(ndr, "join_flags", r->in.join_flags);
9034                 ndr->depth--;
9035         }
9036         if (flags & NDR_OUT) {
9037                 ndr_print_struct(ndr, "out", "wkssvc_NetrJoinDomain2");
9038                 ndr->depth++;
9039                 ndr_print_WERROR(ndr, "result", r->out.result);
9040                 ndr->depth--;
9041         }
9042         ndr->depth--;
9043 }
9044
9045 static enum ndr_err_code ndr_push_wkssvc_NetrUnjoinDomain2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUnjoinDomain2 *r)
9046 {
9047         if (flags & NDR_IN) {
9048                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
9049                 if (r->in.server_name) {
9050                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9051                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9052                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9053                         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));
9054                 }
9055                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.account));
9056                 if (r->in.account) {
9057                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account, CH_UTF16)));
9058                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9059                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account, CH_UTF16)));
9060                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.account, ndr_charset_length(r->in.account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9061                 }
9062                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.encrypted_password));
9063                 if (r->in.encrypted_password) {
9064                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));
9065                 }
9066                 NDR_CHECK(ndr_push_wkssvc_joinflags(ndr, NDR_SCALARS, r->in.unjoin_flags));
9067         }
9068         if (flags & NDR_OUT) {
9069                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9070         }
9071         return NDR_ERR_SUCCESS;
9072 }
9073
9074 static enum ndr_err_code ndr_pull_wkssvc_NetrUnjoinDomain2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUnjoinDomain2 *r)
9075 {
9076         uint32_t _ptr_server_name;
9077         uint32_t _ptr_account;
9078         uint32_t _ptr_encrypted_password;
9079         TALLOC_CTX *_mem_save_server_name_0;
9080         TALLOC_CTX *_mem_save_account_0;
9081         TALLOC_CTX *_mem_save_encrypted_password_0;
9082         if (flags & NDR_IN) {
9083                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
9084                 if (_ptr_server_name) {
9085                         NDR_PULL_ALLOC(ndr, r->in.server_name);
9086                 } else {
9087                         r->in.server_name = NULL;
9088                 }
9089                 if (r->in.server_name) {
9090                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9091                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
9092                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
9093                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
9094                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
9095                                 return 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));
9096                         }
9097                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
9098                         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));
9099                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
9100                 }
9101                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account));
9102                 if (_ptr_account) {
9103                         NDR_PULL_ALLOC(ndr, r->in.account);
9104                 } else {
9105                         r->in.account = NULL;
9106                 }
9107                 if (r->in.account) {
9108                         _mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
9109                         NDR_PULL_SET_MEM_CTX(ndr, r->in.account, 0);
9110                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.account));
9111                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.account));
9112                         if (ndr_get_array_length(ndr, &r->in.account) > ndr_get_array_size(ndr, &r->in.account)) {
9113                                 return 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));
9114                         }
9115                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.account), sizeof(uint16_t)));
9116                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.account, ndr_get_array_length(ndr, &r->in.account), sizeof(uint16_t), CH_UTF16));
9117                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, 0);
9118                 }
9119                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_encrypted_password));
9120                 if (_ptr_encrypted_password) {
9121                         NDR_PULL_ALLOC(ndr, r->in.encrypted_password);
9122                 } else {
9123                         r->in.encrypted_password = NULL;
9124                 }
9125                 if (r->in.encrypted_password) {
9126                         _mem_save_encrypted_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
9127                         NDR_PULL_SET_MEM_CTX(ndr, r->in.encrypted_password, 0);
9128                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));
9129                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_encrypted_password_0, 0);
9130                 }
9131                 NDR_CHECK(ndr_pull_wkssvc_joinflags(ndr, NDR_SCALARS, &r->in.unjoin_flags));
9132         }
9133         if (flags & NDR_OUT) {
9134                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9135         }
9136         return NDR_ERR_SUCCESS;
9137 }
9138
9139 _PUBLIC_ void ndr_print_wkssvc_NetrUnjoinDomain2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUnjoinDomain2 *r)
9140 {
9141         ndr_print_struct(ndr, name, "wkssvc_NetrUnjoinDomain2");
9142         ndr->depth++;
9143         if (flags & NDR_SET_VALUES) {
9144                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9145         }
9146         if (flags & NDR_IN) {
9147                 ndr_print_struct(ndr, "in", "wkssvc_NetrUnjoinDomain2");
9148                 ndr->depth++;
9149                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
9150                 ndr->depth++;
9151                 if (r->in.server_name) {
9152                         ndr_print_string(ndr, "server_name", r->in.server_name);
9153                 }
9154                 ndr->depth--;
9155                 ndr_print_ptr(ndr, "account", r->in.account);
9156                 ndr->depth++;
9157                 if (r->in.account) {
9158                         ndr_print_string(ndr, "account", r->in.account);
9159                 }
9160                 ndr->depth--;
9161                 ndr_print_ptr(ndr, "encrypted_password", r->in.encrypted_password);
9162                 ndr->depth++;
9163                 if (r->in.encrypted_password) {
9164                         ndr_print_wkssvc_PasswordBuffer(ndr, "encrypted_password", r->in.encrypted_password);
9165                 }
9166                 ndr->depth--;
9167                 ndr_print_wkssvc_joinflags(ndr, "unjoin_flags", r->in.unjoin_flags);
9168                 ndr->depth--;
9169         }
9170         if (flags & NDR_OUT) {
9171                 ndr_print_struct(ndr, "out", "wkssvc_NetrUnjoinDomain2");
9172                 ndr->depth++;
9173                 ndr_print_WERROR(ndr, "result", r->out.result);
9174                 ndr->depth--;
9175         }
9176         ndr->depth--;
9177 }
9178
9179 static enum ndr_err_code ndr_push_wkssvc_NetrRenameMachineInDomain2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrRenameMachineInDomain2 *r)
9180 {
9181         if (flags & NDR_IN) {
9182                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
9183                 if (r->in.server_name) {
9184                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9185                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9186                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9187                         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));
9188                 }
9189                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.NewMachineName));
9190                 if (r->in.NewMachineName) {
9191                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewMachineName, CH_UTF16)));
9192                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9193                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewMachineName, CH_UTF16)));
9194                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.NewMachineName, ndr_charset_length(r->in.NewMachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9195                 }
9196                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
9197                 if (r->in.Account) {
9198                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9199                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9200                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9201                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9202                 }
9203                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
9204                 if (r->in.EncryptedPassword) {
9205                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9206                 }
9207                 NDR_CHECK(ndr_push_wkssvc_renameflags(ndr, NDR_SCALARS, r->in.RenameOptions));
9208         }
9209         if (flags & NDR_OUT) {
9210                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9211         }
9212         return NDR_ERR_SUCCESS;
9213 }
9214
9215 static enum ndr_err_code ndr_pull_wkssvc_NetrRenameMachineInDomain2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrRenameMachineInDomain2 *r)
9216 {
9217         uint32_t _ptr_server_name;
9218         uint32_t _ptr_NewMachineName;
9219         uint32_t _ptr_Account;
9220         uint32_t _ptr_EncryptedPassword;
9221         TALLOC_CTX *_mem_save_server_name_0;
9222         TALLOC_CTX *_mem_save_NewMachineName_0;
9223         TALLOC_CTX *_mem_save_Account_0;
9224         TALLOC_CTX *_mem_save_EncryptedPassword_0;
9225         if (flags & NDR_IN) {
9226                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
9227                 if (_ptr_server_name) {
9228                         NDR_PULL_ALLOC(ndr, r->in.server_name);
9229                 } else {
9230                         r->in.server_name = NULL;
9231                 }
9232                 if (r->in.server_name) {
9233                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9234                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
9235                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
9236                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
9237                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
9238                                 return 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));
9239                         }
9240                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
9241                         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));
9242                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
9243                 }
9244                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_NewMachineName));
9245                 if (_ptr_NewMachineName) {
9246                         NDR_PULL_ALLOC(ndr, r->in.NewMachineName);
9247                 } else {
9248                         r->in.NewMachineName = NULL;
9249                 }
9250                 if (r->in.NewMachineName) {
9251                         _mem_save_NewMachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);
9252                         NDR_PULL_SET_MEM_CTX(ndr, r->in.NewMachineName, 0);
9253                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.NewMachineName));
9254                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.NewMachineName));
9255                         if (ndr_get_array_length(ndr, &r->in.NewMachineName) > ndr_get_array_size(ndr, &r->in.NewMachineName)) {
9256                                 return 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));
9257                         }
9258                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.NewMachineName), sizeof(uint16_t)));
9259                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.NewMachineName, ndr_get_array_length(ndr, &r->in.NewMachineName), sizeof(uint16_t), CH_UTF16));
9260                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_NewMachineName_0, 0);
9261                 }
9262                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
9263                 if (_ptr_Account) {
9264                         NDR_PULL_ALLOC(ndr, r->in.Account);
9265                 } else {
9266                         r->in.Account = NULL;
9267                 }
9268                 if (r->in.Account) {
9269                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
9270                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
9271                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
9272                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
9273                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
9274                                 return 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));
9275                         }
9276                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
9277                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
9278                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
9279                 }
9280                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
9281                 if (_ptr_EncryptedPassword) {
9282                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
9283                 } else {
9284                         r->in.EncryptedPassword = NULL;
9285                 }
9286                 if (r->in.EncryptedPassword) {
9287                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
9288                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
9289                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9290                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
9291                 }
9292                 NDR_CHECK(ndr_pull_wkssvc_renameflags(ndr, NDR_SCALARS, &r->in.RenameOptions));
9293         }
9294         if (flags & NDR_OUT) {
9295                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9296         }
9297         return NDR_ERR_SUCCESS;
9298 }
9299
9300 _PUBLIC_ void ndr_print_wkssvc_NetrRenameMachineInDomain2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrRenameMachineInDomain2 *r)
9301 {
9302         ndr_print_struct(ndr, name, "wkssvc_NetrRenameMachineInDomain2");
9303         ndr->depth++;
9304         if (flags & NDR_SET_VALUES) {
9305                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9306         }
9307         if (flags & NDR_IN) {
9308                 ndr_print_struct(ndr, "in", "wkssvc_NetrRenameMachineInDomain2");
9309                 ndr->depth++;
9310                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
9311                 ndr->depth++;
9312                 if (r->in.server_name) {
9313                         ndr_print_string(ndr, "server_name", r->in.server_name);
9314                 }
9315                 ndr->depth--;
9316                 ndr_print_ptr(ndr, "NewMachineName", r->in.NewMachineName);
9317                 ndr->depth++;
9318                 if (r->in.NewMachineName) {
9319                         ndr_print_string(ndr, "NewMachineName", r->in.NewMachineName);
9320                 }
9321                 ndr->depth--;
9322                 ndr_print_ptr(ndr, "Account", r->in.Account);
9323                 ndr->depth++;
9324                 if (r->in.Account) {
9325                         ndr_print_string(ndr, "Account", r->in.Account);
9326                 }
9327                 ndr->depth--;
9328                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9329                 ndr->depth++;
9330                 if (r->in.EncryptedPassword) {
9331                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9332                 }
9333                 ndr->depth--;
9334                 ndr_print_wkssvc_renameflags(ndr, "RenameOptions", r->in.RenameOptions);
9335                 ndr->depth--;
9336         }
9337         if (flags & NDR_OUT) {
9338                 ndr_print_struct(ndr, "out", "wkssvc_NetrRenameMachineInDomain2");
9339                 ndr->depth++;
9340                 ndr_print_WERROR(ndr, "result", r->out.result);
9341                 ndr->depth--;
9342         }
9343         ndr->depth--;
9344 }
9345
9346 static enum ndr_err_code ndr_push_wkssvc_NetrValidateName2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrValidateName2 *r)
9347 {
9348         if (flags & NDR_IN) {
9349                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
9350                 if (r->in.server_name) {
9351                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9352                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9353                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9354                         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));
9355                 }
9356                 if (r->in.name == NULL) {
9357                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9358                 }
9359                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF16)));
9360                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9361                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF16)));
9362                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.name, ndr_charset_length(r->in.name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9363                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
9364                 if (r->in.Account) {
9365                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9366                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9367                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9368                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9369                 }
9370                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
9371                 if (r->in.EncryptedPassword) {
9372                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9373                 }
9374                 NDR_CHECK(ndr_push_wkssvc_NetValidateNameType(ndr, NDR_SCALARS, r->in.name_type));
9375         }
9376         if (flags & NDR_OUT) {
9377                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9378         }
9379         return NDR_ERR_SUCCESS;
9380 }
9381
9382 static enum ndr_err_code ndr_pull_wkssvc_NetrValidateName2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrValidateName2 *r)
9383 {
9384         uint32_t _ptr_server_name;
9385         uint32_t _ptr_Account;
9386         uint32_t _ptr_EncryptedPassword;
9387         TALLOC_CTX *_mem_save_server_name_0;
9388         TALLOC_CTX *_mem_save_Account_0;
9389         TALLOC_CTX *_mem_save_EncryptedPassword_0;
9390         if (flags & NDR_IN) {
9391                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
9392                 if (_ptr_server_name) {
9393                         NDR_PULL_ALLOC(ndr, r->in.server_name);
9394                 } else {
9395                         r->in.server_name = NULL;
9396                 }
9397                 if (r->in.server_name) {
9398                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9399                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
9400                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
9401                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
9402                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
9403                                 return 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));
9404                         }
9405                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
9406                         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));
9407                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
9408                 }
9409                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.name));
9410                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.name));
9411                 if (ndr_get_array_length(ndr, &r->in.name) > ndr_get_array_size(ndr, &r->in.name)) {
9412                         return 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));
9413                 }
9414                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.name), sizeof(uint16_t)));
9415                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.name, ndr_get_array_length(ndr, &r->in.name), sizeof(uint16_t), CH_UTF16));
9416                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
9417                 if (_ptr_Account) {
9418                         NDR_PULL_ALLOC(ndr, r->in.Account);
9419                 } else {
9420                         r->in.Account = NULL;
9421                 }
9422                 if (r->in.Account) {
9423                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
9424                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
9425                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
9426                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
9427                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
9428                                 return 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));
9429                         }
9430                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
9431                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
9432                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
9433                 }
9434                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
9435                 if (_ptr_EncryptedPassword) {
9436                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
9437                 } else {
9438                         r->in.EncryptedPassword = NULL;
9439                 }
9440                 if (r->in.EncryptedPassword) {
9441                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
9442                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
9443                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9444                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
9445                 }
9446                 NDR_CHECK(ndr_pull_wkssvc_NetValidateNameType(ndr, NDR_SCALARS, &r->in.name_type));
9447         }
9448         if (flags & NDR_OUT) {
9449                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9450         }
9451         return NDR_ERR_SUCCESS;
9452 }
9453
9454 _PUBLIC_ void ndr_print_wkssvc_NetrValidateName2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrValidateName2 *r)
9455 {
9456         ndr_print_struct(ndr, name, "wkssvc_NetrValidateName2");
9457         ndr->depth++;
9458         if (flags & NDR_SET_VALUES) {
9459                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9460         }
9461         if (flags & NDR_IN) {
9462                 ndr_print_struct(ndr, "in", "wkssvc_NetrValidateName2");
9463                 ndr->depth++;
9464                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
9465                 ndr->depth++;
9466                 if (r->in.server_name) {
9467                         ndr_print_string(ndr, "server_name", r->in.server_name);
9468                 }
9469                 ndr->depth--;
9470                 ndr_print_ptr(ndr, "name", r->in.name);
9471                 ndr->depth++;
9472                 ndr_print_string(ndr, "name", r->in.name);
9473                 ndr->depth--;
9474                 ndr_print_ptr(ndr, "Account", r->in.Account);
9475                 ndr->depth++;
9476                 if (r->in.Account) {
9477                         ndr_print_string(ndr, "Account", r->in.Account);
9478                 }
9479                 ndr->depth--;
9480                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9481                 ndr->depth++;
9482                 if (r->in.EncryptedPassword) {
9483                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9484                 }
9485                 ndr->depth--;
9486                 ndr_print_wkssvc_NetValidateNameType(ndr, "name_type", r->in.name_type);
9487                 ndr->depth--;
9488         }
9489         if (flags & NDR_OUT) {
9490                 ndr_print_struct(ndr, "out", "wkssvc_NetrValidateName2");
9491                 ndr->depth++;
9492                 ndr_print_WERROR(ndr, "result", r->out.result);
9493                 ndr->depth--;
9494         }
9495         ndr->depth--;
9496 }
9497
9498 static enum ndr_err_code ndr_push_wkssvc_NetrGetJoinableOus2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrGetJoinableOus2 *r)
9499 {
9500         uint32_t cntr_ous_2;
9501         if (flags & NDR_IN) {
9502                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
9503                 if (r->in.server_name) {
9504                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9505                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9506                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9507                         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));
9508                 }
9509                 if (r->in.domain_name == NULL) {
9510                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9511                 }
9512                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
9513                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9514                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
9515                 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));
9516                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
9517                 if (r->in.Account) {
9518                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9519                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9520                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9521                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9522                 }
9523                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
9524                 if (r->in.EncryptedPassword) {
9525                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9526                 }
9527                 if (r->in.num_ous == NULL) {
9528                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9529                 }
9530                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.num_ous));
9531         }
9532         if (flags & NDR_OUT) {
9533                 if (r->out.num_ous == NULL) {
9534                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9535                 }
9536                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_ous));
9537                 if (r->out.ous == NULL) {
9538                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9539                 }
9540                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.ous));
9541                 if (*r->out.ous) {
9542                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_ous));
9543                         for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {
9544                                 NDR_CHECK(ndr_push_unique_ptr(ndr, (*r->out.ous)[cntr_ous_2]));
9545                         }
9546                         for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {
9547                                 if ((*r->out.ous)[cntr_ous_2]) {
9548                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length((*r->out.ous)[cntr_ous_2], CH_UTF16)));
9549                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9550                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length((*r->out.ous)[cntr_ous_2], CH_UTF16)));
9551                                         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));
9552                                 }
9553                         }
9554                 }
9555                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9556         }
9557         return NDR_ERR_SUCCESS;
9558 }
9559
9560 static enum ndr_err_code ndr_pull_wkssvc_NetrGetJoinableOus2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrGetJoinableOus2 *r)
9561 {
9562         uint32_t _ptr_server_name;
9563         uint32_t _ptr_Account;
9564         uint32_t _ptr_EncryptedPassword;
9565         uint32_t _ptr_ous;
9566         uint32_t cntr_ous_2;
9567         TALLOC_CTX *_mem_save_server_name_0;
9568         TALLOC_CTX *_mem_save_Account_0;
9569         TALLOC_CTX *_mem_save_EncryptedPassword_0;
9570         TALLOC_CTX *_mem_save_num_ous_0;
9571         TALLOC_CTX *_mem_save_ous_0;
9572         TALLOC_CTX *_mem_save_ous_1;
9573         TALLOC_CTX *_mem_save_ous_2;
9574         TALLOC_CTX *_mem_save_ous_3;
9575         if (flags & NDR_IN) {
9576                 ZERO_STRUCT(r->out);
9577
9578                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
9579                 if (_ptr_server_name) {
9580                         NDR_PULL_ALLOC(ndr, r->in.server_name);
9581                 } else {
9582                         r->in.server_name = NULL;
9583                 }
9584                 if (r->in.server_name) {
9585                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9586                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
9587                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
9588                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
9589                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
9590                                 return 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));
9591                         }
9592                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
9593                         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));
9594                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
9595                 }
9596                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
9597                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
9598                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
9599                         return 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));
9600                 }
9601                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
9602                 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));
9603                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
9604                 if (_ptr_Account) {
9605                         NDR_PULL_ALLOC(ndr, r->in.Account);
9606                 } else {
9607                         r->in.Account = NULL;
9608                 }
9609                 if (r->in.Account) {
9610                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
9611                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
9612                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
9613                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
9614                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
9615                                 return 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));
9616                         }
9617                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
9618                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
9619                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
9620                 }
9621                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
9622                 if (_ptr_EncryptedPassword) {
9623                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
9624                 } else {
9625                         r->in.EncryptedPassword = NULL;
9626                 }
9627                 if (r->in.EncryptedPassword) {
9628                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
9629                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
9630                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9631                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
9632                 }
9633                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9634                         NDR_PULL_ALLOC(ndr, r->in.num_ous);
9635                 }
9636                 _mem_save_num_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);
9637                 NDR_PULL_SET_MEM_CTX(ndr, r->in.num_ous, LIBNDR_FLAG_REF_ALLOC);
9638                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.num_ous));
9639                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_ous_0, LIBNDR_FLAG_REF_ALLOC);
9640                 NDR_PULL_ALLOC(ndr, r->out.num_ous);
9641                 *r->out.num_ous = *r->in.num_ous;
9642                 NDR_PULL_ALLOC(ndr, r->out.ous);
9643                 ZERO_STRUCTP(r->out.ous);
9644         }
9645         if (flags & NDR_OUT) {
9646                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9647                         NDR_PULL_ALLOC(ndr, r->out.num_ous);
9648                 }
9649                 _mem_save_num_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);
9650                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_ous, LIBNDR_FLAG_REF_ALLOC);
9651                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_ous));
9652                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_ous_0, LIBNDR_FLAG_REF_ALLOC);
9653                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9654                         NDR_PULL_ALLOC(ndr, r->out.ous);
9655                 }
9656                 _mem_save_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);
9657                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ous, LIBNDR_FLAG_REF_ALLOC);
9658                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ous));
9659                 if (_ptr_ous) {
9660                         NDR_PULL_ALLOC(ndr, *r->out.ous);
9661                 } else {
9662                         *r->out.ous = NULL;
9663                 }
9664                 if (*r->out.ous) {
9665                         _mem_save_ous_1 = NDR_PULL_GET_MEM_CTX(ndr);
9666                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.ous, 0);
9667                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.ous));
9668                         NDR_PULL_ALLOC_N(ndr, *r->out.ous, ndr_get_array_size(ndr, r->out.ous));
9669                         _mem_save_ous_2 = NDR_PULL_GET_MEM_CTX(ndr);
9670                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.ous, 0);
9671                         for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {
9672                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ous));
9673                                 if (_ptr_ous) {
9674                                         NDR_PULL_ALLOC(ndr, (*r->out.ous)[cntr_ous_2]);
9675                                 } else {
9676                                         (*r->out.ous)[cntr_ous_2] = NULL;
9677                                 }
9678                         }
9679                         for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {
9680                                 if ((*r->out.ous)[cntr_ous_2]) {
9681                                         _mem_save_ous_3 = NDR_PULL_GET_MEM_CTX(ndr);
9682                                         NDR_PULL_SET_MEM_CTX(ndr, (*r->out.ous)[cntr_ous_2], 0);
9683                                         NDR_CHECK(ndr_pull_array_size(ndr, &(*r->out.ous)[cntr_ous_2]));
9684                                         NDR_CHECK(ndr_pull_array_length(ndr, &(*r->out.ous)[cntr_ous_2]));
9685                                         if (ndr_get_array_length(ndr, &(*r->out.ous)[cntr_ous_2]) > ndr_get_array_size(ndr, &(*r->out.ous)[cntr_ous_2])) {
9686                                                 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]));
9687                                         }
9688                                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &(*r->out.ous)[cntr_ous_2]), sizeof(uint16_t)));
9689                                         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));
9690                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_3, 0);
9691                                 }
9692                         }
9693                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_2, 0);
9694                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_1, 0);
9695                 }
9696                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_0, LIBNDR_FLAG_REF_ALLOC);
9697                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9698                 if (*r->out.ous) {
9699                         NDR_CHECK(ndr_check_array_size(ndr, (void*)r->out.ous, *r->out.num_ous));
9700                 }
9701         }
9702         return NDR_ERR_SUCCESS;
9703 }
9704
9705 _PUBLIC_ void ndr_print_wkssvc_NetrGetJoinableOus2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrGetJoinableOus2 *r)
9706 {
9707         uint32_t cntr_ous_2;
9708         ndr_print_struct(ndr, name, "wkssvc_NetrGetJoinableOus2");
9709         ndr->depth++;
9710         if (flags & NDR_SET_VALUES) {
9711                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9712         }
9713         if (flags & NDR_IN) {
9714                 ndr_print_struct(ndr, "in", "wkssvc_NetrGetJoinableOus2");
9715                 ndr->depth++;
9716                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
9717                 ndr->depth++;
9718                 if (r->in.server_name) {
9719                         ndr_print_string(ndr, "server_name", r->in.server_name);
9720                 }
9721                 ndr->depth--;
9722                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
9723                 ndr->depth++;
9724                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
9725                 ndr->depth--;
9726                 ndr_print_ptr(ndr, "Account", r->in.Account);
9727                 ndr->depth++;
9728                 if (r->in.Account) {
9729                         ndr_print_string(ndr, "Account", r->in.Account);
9730                 }
9731                 ndr->depth--;
9732                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9733                 ndr->depth++;
9734                 if (r->in.EncryptedPassword) {
9735                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9736                 }
9737                 ndr->depth--;
9738                 ndr_print_ptr(ndr, "num_ous", r->in.num_ous);
9739                 ndr->depth++;
9740                 ndr_print_uint32(ndr, "num_ous", *r->in.num_ous);
9741                 ndr->depth--;
9742                 ndr->depth--;
9743         }
9744         if (flags & NDR_OUT) {
9745                 ndr_print_struct(ndr, "out", "wkssvc_NetrGetJoinableOus2");
9746                 ndr->depth++;
9747                 ndr_print_ptr(ndr, "num_ous", r->out.num_ous);
9748                 ndr->depth++;
9749                 ndr_print_uint32(ndr, "num_ous", *r->out.num_ous);
9750                 ndr->depth--;
9751                 ndr_print_ptr(ndr, "ous", r->out.ous);
9752                 ndr->depth++;
9753                 ndr_print_ptr(ndr, "ous", *r->out.ous);
9754                 ndr->depth++;
9755                 if (*r->out.ous) {
9756                         ndr->print(ndr, "%s: ARRAY(%d)", "ous", *r->out.num_ous);
9757                         ndr->depth++;
9758                         for (cntr_ous_2=0;cntr_ous_2<*r->out.num_ous;cntr_ous_2++) {
9759                                 char *idx_2=NULL;
9760                                 asprintf(&idx_2, "[%d]", cntr_ous_2);
9761                                 if (idx_2) {
9762                                         ndr_print_ptr(ndr, "ous", (*r->out.ous)[cntr_ous_2]);
9763                                         ndr->depth++;
9764                                         if ((*r->out.ous)[cntr_ous_2]) {
9765                                                 ndr_print_string(ndr, "ous", (*r->out.ous)[cntr_ous_2]);
9766                                         }
9767                                         ndr->depth--;
9768                                         free(idx_2);
9769                                 }
9770                         }
9771                         ndr->depth--;
9772                 }
9773                 ndr->depth--;
9774                 ndr->depth--;
9775                 ndr_print_WERROR(ndr, "result", r->out.result);
9776                 ndr->depth--;
9777         }
9778         ndr->depth--;
9779 }
9780
9781 static enum ndr_err_code ndr_push_wkssvc_NetrAddAlternateComputerName(struct ndr_push *ndr, int flags, const struct wkssvc_NetrAddAlternateComputerName *r)
9782 {
9783         if (flags & NDR_IN) {
9784                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
9785                 if (r->in.server_name) {
9786                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9787                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9788                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9789                         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));
9790                 }
9791                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.NewAlternateMachineName));
9792                 if (r->in.NewAlternateMachineName) {
9793                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewAlternateMachineName, CH_UTF16)));
9794                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9795                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewAlternateMachineName, CH_UTF16)));
9796                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.NewAlternateMachineName, ndr_charset_length(r->in.NewAlternateMachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9797                 }
9798                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
9799                 if (r->in.Account) {
9800                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9801                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9802                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9803                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9804                 }
9805                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
9806                 if (r->in.EncryptedPassword) {
9807                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9808                 }
9809                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Reserved));
9810         }
9811         if (flags & NDR_OUT) {
9812                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9813         }
9814         return NDR_ERR_SUCCESS;
9815 }
9816
9817 static enum ndr_err_code ndr_pull_wkssvc_NetrAddAlternateComputerName(struct ndr_pull *ndr, int flags, struct wkssvc_NetrAddAlternateComputerName *r)
9818 {
9819         uint32_t _ptr_server_name;
9820         uint32_t _ptr_NewAlternateMachineName;
9821         uint32_t _ptr_Account;
9822         uint32_t _ptr_EncryptedPassword;
9823         TALLOC_CTX *_mem_save_server_name_0;
9824         TALLOC_CTX *_mem_save_NewAlternateMachineName_0;
9825         TALLOC_CTX *_mem_save_Account_0;
9826         TALLOC_CTX *_mem_save_EncryptedPassword_0;
9827         if (flags & NDR_IN) {
9828                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
9829                 if (_ptr_server_name) {
9830                         NDR_PULL_ALLOC(ndr, r->in.server_name);
9831                 } else {
9832                         r->in.server_name = NULL;
9833                 }
9834                 if (r->in.server_name) {
9835                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9836                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
9837                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
9838                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
9839                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
9840                                 return 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));
9841                         }
9842                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
9843                         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));
9844                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
9845                 }
9846                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_NewAlternateMachineName));
9847                 if (_ptr_NewAlternateMachineName) {
9848                         NDR_PULL_ALLOC(ndr, r->in.NewAlternateMachineName);
9849                 } else {
9850                         r->in.NewAlternateMachineName = NULL;
9851                 }
9852                 if (r->in.NewAlternateMachineName) {
9853                         _mem_save_NewAlternateMachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);
9854                         NDR_PULL_SET_MEM_CTX(ndr, r->in.NewAlternateMachineName, 0);
9855                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.NewAlternateMachineName));
9856                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.NewAlternateMachineName));
9857                         if (ndr_get_array_length(ndr, &r->in.NewAlternateMachineName) > ndr_get_array_size(ndr, &r->in.NewAlternateMachineName)) {
9858                                 return 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));
9859                         }
9860                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.NewAlternateMachineName), sizeof(uint16_t)));
9861                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.NewAlternateMachineName, ndr_get_array_length(ndr, &r->in.NewAlternateMachineName), sizeof(uint16_t), CH_UTF16));
9862                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_NewAlternateMachineName_0, 0);
9863                 }
9864                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
9865                 if (_ptr_Account) {
9866                         NDR_PULL_ALLOC(ndr, r->in.Account);
9867                 } else {
9868                         r->in.Account = NULL;
9869                 }
9870                 if (r->in.Account) {
9871                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
9872                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
9873                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
9874                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
9875                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
9876                                 return 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));
9877                         }
9878                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
9879                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
9880                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
9881                 }
9882                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
9883                 if (_ptr_EncryptedPassword) {
9884                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
9885                 } else {
9886                         r->in.EncryptedPassword = NULL;
9887                 }
9888                 if (r->in.EncryptedPassword) {
9889                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
9890                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
9891                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9892                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
9893                 }
9894                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Reserved));
9895         }
9896         if (flags & NDR_OUT) {
9897                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9898         }
9899         return NDR_ERR_SUCCESS;
9900 }
9901
9902 _PUBLIC_ void ndr_print_wkssvc_NetrAddAlternateComputerName(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrAddAlternateComputerName *r)
9903 {
9904         ndr_print_struct(ndr, name, "wkssvc_NetrAddAlternateComputerName");
9905         ndr->depth++;
9906         if (flags & NDR_SET_VALUES) {
9907                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9908         }
9909         if (flags & NDR_IN) {
9910                 ndr_print_struct(ndr, "in", "wkssvc_NetrAddAlternateComputerName");
9911                 ndr->depth++;
9912                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
9913                 ndr->depth++;
9914                 if (r->in.server_name) {
9915                         ndr_print_string(ndr, "server_name", r->in.server_name);
9916                 }
9917                 ndr->depth--;
9918                 ndr_print_ptr(ndr, "NewAlternateMachineName", r->in.NewAlternateMachineName);
9919                 ndr->depth++;
9920                 if (r->in.NewAlternateMachineName) {
9921                         ndr_print_string(ndr, "NewAlternateMachineName", r->in.NewAlternateMachineName);
9922                 }
9923                 ndr->depth--;
9924                 ndr_print_ptr(ndr, "Account", r->in.Account);
9925                 ndr->depth++;
9926                 if (r->in.Account) {
9927                         ndr_print_string(ndr, "Account", r->in.Account);
9928                 }
9929                 ndr->depth--;
9930                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9931                 ndr->depth++;
9932                 if (r->in.EncryptedPassword) {
9933                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
9934                 }
9935                 ndr->depth--;
9936                 ndr_print_uint32(ndr, "Reserved", r->in.Reserved);
9937                 ndr->depth--;
9938         }
9939         if (flags & NDR_OUT) {
9940                 ndr_print_struct(ndr, "out", "wkssvc_NetrAddAlternateComputerName");
9941                 ndr->depth++;
9942                 ndr_print_WERROR(ndr, "result", r->out.result);
9943                 ndr->depth--;
9944         }
9945         ndr->depth--;
9946 }
9947
9948 static enum ndr_err_code ndr_push_wkssvc_NetrRemoveAlternateComputerName(struct ndr_push *ndr, int flags, const struct wkssvc_NetrRemoveAlternateComputerName *r)
9949 {
9950         if (flags & NDR_IN) {
9951                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
9952                 if (r->in.server_name) {
9953                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9954                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9955                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
9956                         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));
9957                 }
9958                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.AlternateMachineNameToRemove));
9959                 if (r->in.AlternateMachineNameToRemove) {
9960                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.AlternateMachineNameToRemove, CH_UTF16)));
9961                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9962                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.AlternateMachineNameToRemove, CH_UTF16)));
9963                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.AlternateMachineNameToRemove, ndr_charset_length(r->in.AlternateMachineNameToRemove, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9964                 }
9965                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
9966                 if (r->in.Account) {
9967                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9968                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9969                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
9970                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9971                 }
9972                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
9973                 if (r->in.EncryptedPassword) {
9974                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
9975                 }
9976                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Reserved));
9977         }
9978         if (flags & NDR_OUT) {
9979                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9980         }
9981         return NDR_ERR_SUCCESS;
9982 }
9983
9984 static enum ndr_err_code ndr_pull_wkssvc_NetrRemoveAlternateComputerName(struct ndr_pull *ndr, int flags, struct wkssvc_NetrRemoveAlternateComputerName *r)
9985 {
9986         uint32_t _ptr_server_name;
9987         uint32_t _ptr_AlternateMachineNameToRemove;
9988         uint32_t _ptr_Account;
9989         uint32_t _ptr_EncryptedPassword;
9990         TALLOC_CTX *_mem_save_server_name_0;
9991         TALLOC_CTX *_mem_save_AlternateMachineNameToRemove_0;
9992         TALLOC_CTX *_mem_save_Account_0;
9993         TALLOC_CTX *_mem_save_EncryptedPassword_0;
9994         if (flags & NDR_IN) {
9995                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
9996                 if (_ptr_server_name) {
9997                         NDR_PULL_ALLOC(ndr, r->in.server_name);
9998                 } else {
9999                         r->in.server_name = NULL;
10000                 }
10001                 if (r->in.server_name) {
10002                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10003                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
10004                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
10005                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
10006                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
10007                                 return 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));
10008                         }
10009                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
10010                         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));
10011                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
10012                 }
10013                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_AlternateMachineNameToRemove));
10014                 if (_ptr_AlternateMachineNameToRemove) {
10015                         NDR_PULL_ALLOC(ndr, r->in.AlternateMachineNameToRemove);
10016                 } else {
10017                         r->in.AlternateMachineNameToRemove = NULL;
10018                 }
10019                 if (r->in.AlternateMachineNameToRemove) {
10020                         _mem_save_AlternateMachineNameToRemove_0 = NDR_PULL_GET_MEM_CTX(ndr);
10021                         NDR_PULL_SET_MEM_CTX(ndr, r->in.AlternateMachineNameToRemove, 0);
10022                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.AlternateMachineNameToRemove));
10023                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.AlternateMachineNameToRemove));
10024                         if (ndr_get_array_length(ndr, &r->in.AlternateMachineNameToRemove) > ndr_get_array_size(ndr, &r->in.AlternateMachineNameToRemove)) {
10025                                 return 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));
10026                         }
10027                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.AlternateMachineNameToRemove), sizeof(uint16_t)));
10028                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.AlternateMachineNameToRemove, ndr_get_array_length(ndr, &r->in.AlternateMachineNameToRemove), sizeof(uint16_t), CH_UTF16));
10029                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_AlternateMachineNameToRemove_0, 0);
10030                 }
10031                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
10032                 if (_ptr_Account) {
10033                         NDR_PULL_ALLOC(ndr, r->in.Account);
10034                 } else {
10035                         r->in.Account = NULL;
10036                 }
10037                 if (r->in.Account) {
10038                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
10039                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
10040                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
10041                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
10042                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
10043                                 return 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));
10044                         }
10045                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
10046                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
10047                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
10048                 }
10049                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
10050                 if (_ptr_EncryptedPassword) {
10051                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
10052                 } else {
10053                         r->in.EncryptedPassword = NULL;
10054                 }
10055                 if (r->in.EncryptedPassword) {
10056                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
10057                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
10058                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
10059                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
10060                 }
10061                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Reserved));
10062         }
10063         if (flags & NDR_OUT) {
10064                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
10065         }
10066         return NDR_ERR_SUCCESS;
10067 }
10068
10069 _PUBLIC_ void ndr_print_wkssvc_NetrRemoveAlternateComputerName(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrRemoveAlternateComputerName *r)
10070 {
10071         ndr_print_struct(ndr, name, "wkssvc_NetrRemoveAlternateComputerName");
10072         ndr->depth++;
10073         if (flags & NDR_SET_VALUES) {
10074                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10075         }
10076         if (flags & NDR_IN) {
10077                 ndr_print_struct(ndr, "in", "wkssvc_NetrRemoveAlternateComputerName");
10078                 ndr->depth++;
10079                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
10080                 ndr->depth++;
10081                 if (r->in.server_name) {
10082                         ndr_print_string(ndr, "server_name", r->in.server_name);
10083                 }
10084                 ndr->depth--;
10085                 ndr_print_ptr(ndr, "AlternateMachineNameToRemove", r->in.AlternateMachineNameToRemove);
10086                 ndr->depth++;
10087                 if (r->in.AlternateMachineNameToRemove) {
10088                         ndr_print_string(ndr, "AlternateMachineNameToRemove", r->in.AlternateMachineNameToRemove);
10089                 }
10090                 ndr->depth--;
10091                 ndr_print_ptr(ndr, "Account", r->in.Account);
10092                 ndr->depth++;
10093                 if (r->in.Account) {
10094                         ndr_print_string(ndr, "Account", r->in.Account);
10095                 }
10096                 ndr->depth--;
10097                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
10098                 ndr->depth++;
10099                 if (r->in.EncryptedPassword) {
10100                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
10101                 }
10102                 ndr->depth--;
10103                 ndr_print_uint32(ndr, "Reserved", r->in.Reserved);
10104                 ndr->depth--;
10105         }
10106         if (flags & NDR_OUT) {
10107                 ndr_print_struct(ndr, "out", "wkssvc_NetrRemoveAlternateComputerName");
10108                 ndr->depth++;
10109                 ndr_print_WERROR(ndr, "result", r->out.result);
10110                 ndr->depth--;
10111         }
10112         ndr->depth--;
10113 }
10114
10115 static enum ndr_err_code ndr_push_wkssvc_NetrSetPrimaryComputername(struct ndr_push *ndr, int flags, const struct wkssvc_NetrSetPrimaryComputername *r)
10116 {
10117         if (flags & NDR_IN) {
10118                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
10119                 if (r->in.server_name) {
10120                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
10121                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10122                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
10123                         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));
10124                 }
10125                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.primary_name));
10126                 if (r->in.primary_name) {
10127                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.primary_name, CH_UTF16)));
10128                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10129                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.primary_name, CH_UTF16)));
10130                         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));
10131                 }
10132                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
10133                 if (r->in.Account) {
10134                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
10135                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10136                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
10137                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10138                 }
10139                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
10140                 if (r->in.EncryptedPassword) {
10141                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
10142                 }
10143                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Reserved));
10144         }
10145         if (flags & NDR_OUT) {
10146                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
10147         }
10148         return NDR_ERR_SUCCESS;
10149 }
10150
10151 static enum ndr_err_code ndr_pull_wkssvc_NetrSetPrimaryComputername(struct ndr_pull *ndr, int flags, struct wkssvc_NetrSetPrimaryComputername *r)
10152 {
10153         uint32_t _ptr_server_name;
10154         uint32_t _ptr_primary_name;
10155         uint32_t _ptr_Account;
10156         uint32_t _ptr_EncryptedPassword;
10157         TALLOC_CTX *_mem_save_server_name_0;
10158         TALLOC_CTX *_mem_save_primary_name_0;
10159         TALLOC_CTX *_mem_save_Account_0;
10160         TALLOC_CTX *_mem_save_EncryptedPassword_0;
10161         if (flags & NDR_IN) {
10162                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
10163                 if (_ptr_server_name) {
10164                         NDR_PULL_ALLOC(ndr, r->in.server_name);
10165                 } else {
10166                         r->in.server_name = NULL;
10167                 }
10168                 if (r->in.server_name) {
10169                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10170                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
10171                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
10172                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
10173                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
10174                                 return 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));
10175                         }
10176                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
10177                         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));
10178                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
10179                 }
10180                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_primary_name));
10181                 if (_ptr_primary_name) {
10182                         NDR_PULL_ALLOC(ndr, r->in.primary_name);
10183                 } else {
10184                         r->in.primary_name = NULL;
10185                 }
10186                 if (r->in.primary_name) {
10187                         _mem_save_primary_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10188                         NDR_PULL_SET_MEM_CTX(ndr, r->in.primary_name, 0);
10189                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.primary_name));
10190                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.primary_name));
10191                         if (ndr_get_array_length(ndr, &r->in.primary_name) > ndr_get_array_size(ndr, &r->in.primary_name)) {
10192                                 return 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));
10193                         }
10194                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.primary_name), sizeof(uint16_t)));
10195                         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));
10196                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_primary_name_0, 0);
10197                 }
10198                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
10199                 if (_ptr_Account) {
10200                         NDR_PULL_ALLOC(ndr, r->in.Account);
10201                 } else {
10202                         r->in.Account = NULL;
10203                 }
10204                 if (r->in.Account) {
10205                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
10206                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
10207                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
10208                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
10209                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
10210                                 return 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));
10211                         }
10212                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
10213                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
10214                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
10215                 }
10216                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
10217                 if (_ptr_EncryptedPassword) {
10218                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
10219                 } else {
10220                         r->in.EncryptedPassword = NULL;
10221                 }
10222                 if (r->in.EncryptedPassword) {
10223                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
10224                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
10225                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
10226                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
10227                 }
10228                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Reserved));
10229         }
10230         if (flags & NDR_OUT) {
10231                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
10232         }
10233         return NDR_ERR_SUCCESS;
10234 }
10235
10236 _PUBLIC_ void ndr_print_wkssvc_NetrSetPrimaryComputername(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrSetPrimaryComputername *r)
10237 {
10238         ndr_print_struct(ndr, name, "wkssvc_NetrSetPrimaryComputername");
10239         ndr->depth++;
10240         if (flags & NDR_SET_VALUES) {
10241                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10242         }
10243         if (flags & NDR_IN) {
10244                 ndr_print_struct(ndr, "in", "wkssvc_NetrSetPrimaryComputername");
10245                 ndr->depth++;
10246                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
10247                 ndr->depth++;
10248                 if (r->in.server_name) {
10249                         ndr_print_string(ndr, "server_name", r->in.server_name);
10250                 }
10251                 ndr->depth--;
10252                 ndr_print_ptr(ndr, "primary_name", r->in.primary_name);
10253                 ndr->depth++;
10254                 if (r->in.primary_name) {
10255                         ndr_print_string(ndr, "primary_name", r->in.primary_name);
10256                 }
10257                 ndr->depth--;
10258                 ndr_print_ptr(ndr, "Account", r->in.Account);
10259                 ndr->depth++;
10260                 if (r->in.Account) {
10261                         ndr_print_string(ndr, "Account", r->in.Account);
10262                 }
10263                 ndr->depth--;
10264                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
10265                 ndr->depth++;
10266                 if (r->in.EncryptedPassword) {
10267                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
10268                 }
10269                 ndr->depth--;
10270                 ndr_print_uint32(ndr, "Reserved", r->in.Reserved);
10271                 ndr->depth--;
10272         }
10273         if (flags & NDR_OUT) {
10274                 ndr_print_struct(ndr, "out", "wkssvc_NetrSetPrimaryComputername");
10275                 ndr->depth++;
10276                 ndr_print_WERROR(ndr, "result", r->out.result);
10277                 ndr->depth--;
10278         }
10279         ndr->depth--;
10280 }
10281
10282 static enum ndr_err_code ndr_push_wkssvc_NetrEnumerateComputerNames(struct ndr_push *ndr, int flags, const struct wkssvc_NetrEnumerateComputerNames *r)
10283 {
10284         if (flags & NDR_IN) {
10285                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
10286                 if (r->in.server_name) {
10287                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
10288                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10289                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
10290                         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));
10291                 }
10292                 NDR_CHECK(ndr_push_wkssvc_ComputerNameType(ndr, NDR_SCALARS, r->in.name_type));
10293                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Reserved));
10294         }
10295         if (flags & NDR_OUT) {
10296                 if (r->out.ctr == NULL) {
10297                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10298                 }
10299                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.ctr));
10300                 if (*r->out.ctr) {
10301                         NDR_CHECK(ndr_push_wkssvc_ComputerNamesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.ctr));
10302                 }
10303                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
10304         }
10305         return NDR_ERR_SUCCESS;
10306 }
10307
10308 static enum ndr_err_code ndr_pull_wkssvc_NetrEnumerateComputerNames(struct ndr_pull *ndr, int flags, struct wkssvc_NetrEnumerateComputerNames *r)
10309 {
10310         uint32_t _ptr_server_name;
10311         uint32_t _ptr_ctr;
10312         TALLOC_CTX *_mem_save_server_name_0;
10313         TALLOC_CTX *_mem_save_ctr_0;
10314         TALLOC_CTX *_mem_save_ctr_1;
10315         if (flags & NDR_IN) {
10316                 ZERO_STRUCT(r->out);
10317
10318                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
10319                 if (_ptr_server_name) {
10320                         NDR_PULL_ALLOC(ndr, r->in.server_name);
10321                 } else {
10322                         r->in.server_name = NULL;
10323                 }
10324                 if (r->in.server_name) {
10325                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10326                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
10327                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
10328                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
10329                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
10330                                 return 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));
10331                         }
10332                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
10333                         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));
10334                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
10335                 }
10336                 NDR_CHECK(ndr_pull_wkssvc_ComputerNameType(ndr, NDR_SCALARS, &r->in.name_type));
10337                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Reserved));
10338                 NDR_PULL_ALLOC(ndr, r->out.ctr);
10339                 ZERO_STRUCTP(r->out.ctr);
10340         }
10341         if (flags & NDR_OUT) {
10342                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10343                         NDR_PULL_ALLOC(ndr, r->out.ctr);
10344                 }
10345                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
10346                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
10347                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
10348                 if (_ptr_ctr) {
10349                         NDR_PULL_ALLOC(ndr, *r->out.ctr);
10350                 } else {
10351                         *r->out.ctr = NULL;
10352                 }
10353                 if (*r->out.ctr) {
10354                         _mem_save_ctr_1 = NDR_PULL_GET_MEM_CTX(ndr);
10355                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.ctr, 0);
10356                         NDR_CHECK(ndr_pull_wkssvc_ComputerNamesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.ctr));
10357                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_1, 0);
10358                 }
10359                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
10360                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
10361         }
10362         return NDR_ERR_SUCCESS;
10363 }
10364
10365 _PUBLIC_ void ndr_print_wkssvc_NetrEnumerateComputerNames(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrEnumerateComputerNames *r)
10366 {
10367         ndr_print_struct(ndr, name, "wkssvc_NetrEnumerateComputerNames");
10368         ndr->depth++;
10369         if (flags & NDR_SET_VALUES) {
10370                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10371         }
10372         if (flags & NDR_IN) {
10373                 ndr_print_struct(ndr, "in", "wkssvc_NetrEnumerateComputerNames");
10374                 ndr->depth++;
10375                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
10376                 ndr->depth++;
10377                 if (r->in.server_name) {
10378                         ndr_print_string(ndr, "server_name", r->in.server_name);
10379                 }
10380                 ndr->depth--;
10381                 ndr_print_wkssvc_ComputerNameType(ndr, "name_type", r->in.name_type);
10382                 ndr_print_uint32(ndr, "Reserved", r->in.Reserved);
10383                 ndr->depth--;
10384         }
10385         if (flags & NDR_OUT) {
10386                 ndr_print_struct(ndr, "out", "wkssvc_NetrEnumerateComputerNames");
10387                 ndr->depth++;
10388                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
10389                 ndr->depth++;
10390                 ndr_print_ptr(ndr, "ctr", *r->out.ctr);
10391                 ndr->depth++;
10392                 if (*r->out.ctr) {
10393                         ndr_print_wkssvc_ComputerNamesCtr(ndr, "ctr", *r->out.ctr);
10394                 }
10395                 ndr->depth--;
10396                 ndr->depth--;
10397                 ndr_print_WERROR(ndr, "result", r->out.result);
10398                 ndr->depth--;
10399         }
10400         ndr->depth--;
10401 }
10402
10403 static const struct ndr_interface_call wkssvc_calls[] = {
10404         {
10405                 "wkssvc_NetWkstaGetInfo",
10406                 sizeof(struct wkssvc_NetWkstaGetInfo),
10407                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaGetInfo,
10408                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaGetInfo,
10409                 (ndr_print_function_t) ndr_print_wkssvc_NetWkstaGetInfo,
10410                 false,
10411         },
10412         {
10413                 "wkssvc_NetWkstaSetInfo",
10414                 sizeof(struct wkssvc_NetWkstaSetInfo),
10415                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaSetInfo,
10416                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaSetInfo,
10417                 (ndr_print_function_t) ndr_print_wkssvc_NetWkstaSetInfo,
10418                 false,
10419         },
10420         {
10421                 "wkssvc_NetWkstaEnumUsers",
10422                 sizeof(struct wkssvc_NetWkstaEnumUsers),
10423                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaEnumUsers,
10424                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaEnumUsers,
10425                 (ndr_print_function_t) ndr_print_wkssvc_NetWkstaEnumUsers,
10426                 false,
10427         },
10428         {
10429                 "wkssvc_NetrWkstaUserGetInfo",
10430                 sizeof(struct wkssvc_NetrWkstaUserGetInfo),
10431                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrWkstaUserGetInfo,
10432                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrWkstaUserGetInfo,
10433                 (ndr_print_function_t) ndr_print_wkssvc_NetrWkstaUserGetInfo,
10434                 false,
10435         },
10436         {
10437                 "wkssvc_NetrWkstaUserSetInfo",
10438                 sizeof(struct wkssvc_NetrWkstaUserSetInfo),
10439                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrWkstaUserSetInfo,
10440                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrWkstaUserSetInfo,
10441                 (ndr_print_function_t) ndr_print_wkssvc_NetrWkstaUserSetInfo,
10442                 false,
10443         },
10444         {
10445                 "wkssvc_NetWkstaTransportEnum",
10446                 sizeof(struct wkssvc_NetWkstaTransportEnum),
10447                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaTransportEnum,
10448                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaTransportEnum,
10449                 (ndr_print_function_t) ndr_print_wkssvc_NetWkstaTransportEnum,
10450                 false,
10451         },
10452         {
10453                 "wkssvc_NetrWkstaTransportAdd",
10454                 sizeof(struct wkssvc_NetrWkstaTransportAdd),
10455                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrWkstaTransportAdd,
10456                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrWkstaTransportAdd,
10457                 (ndr_print_function_t) ndr_print_wkssvc_NetrWkstaTransportAdd,
10458                 false,
10459         },
10460         {
10461                 "wkssvc_NetrWkstaTransportDel",
10462                 sizeof(struct wkssvc_NetrWkstaTransportDel),
10463                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrWkstaTransportDel,
10464                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrWkstaTransportDel,
10465                 (ndr_print_function_t) ndr_print_wkssvc_NetrWkstaTransportDel,
10466                 false,
10467         },
10468         {
10469                 "wkssvc_NetrUseAdd",
10470                 sizeof(struct wkssvc_NetrUseAdd),
10471                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUseAdd,
10472                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUseAdd,
10473                 (ndr_print_function_t) ndr_print_wkssvc_NetrUseAdd,
10474                 false,
10475         },
10476         {
10477                 "wkssvc_NetrUseGetInfo",
10478                 sizeof(struct wkssvc_NetrUseGetInfo),
10479                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUseGetInfo,
10480                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUseGetInfo,
10481                 (ndr_print_function_t) ndr_print_wkssvc_NetrUseGetInfo,
10482                 false,
10483         },
10484         {
10485                 "wkssvc_NetrUseDel",
10486                 sizeof(struct wkssvc_NetrUseDel),
10487                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUseDel,
10488                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUseDel,
10489                 (ndr_print_function_t) ndr_print_wkssvc_NetrUseDel,
10490                 false,
10491         },
10492         {
10493                 "wkssvc_NetrUseEnum",
10494                 sizeof(struct wkssvc_NetrUseEnum),
10495                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUseEnum,
10496                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUseEnum,
10497                 (ndr_print_function_t) ndr_print_wkssvc_NetrUseEnum,
10498                 false,
10499         },
10500         {
10501                 "wkssvc_NetrMessageBufferSend",
10502                 sizeof(struct wkssvc_NetrMessageBufferSend),
10503                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrMessageBufferSend,
10504                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrMessageBufferSend,
10505                 (ndr_print_function_t) ndr_print_wkssvc_NetrMessageBufferSend,
10506                 false,
10507         },
10508         {
10509                 "wkssvc_NetrWorkstationStatisticsGet",
10510                 sizeof(struct wkssvc_NetrWorkstationStatisticsGet),
10511                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrWorkstationStatisticsGet,
10512                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrWorkstationStatisticsGet,
10513                 (ndr_print_function_t) ndr_print_wkssvc_NetrWorkstationStatisticsGet,
10514                 false,
10515         },
10516         {
10517                 "wkssvc_NetrLogonDomainNameAdd",
10518                 sizeof(struct wkssvc_NetrLogonDomainNameAdd),
10519                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrLogonDomainNameAdd,
10520                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrLogonDomainNameAdd,
10521                 (ndr_print_function_t) ndr_print_wkssvc_NetrLogonDomainNameAdd,
10522                 false,
10523         },
10524         {
10525                 "wkssvc_NetrLogonDomainNameDel",
10526                 sizeof(struct wkssvc_NetrLogonDomainNameDel),
10527                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrLogonDomainNameDel,
10528                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrLogonDomainNameDel,
10529                 (ndr_print_function_t) ndr_print_wkssvc_NetrLogonDomainNameDel,
10530                 false,
10531         },
10532         {
10533                 "wkssvc_NetrJoinDomain",
10534                 sizeof(struct wkssvc_NetrJoinDomain),
10535                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrJoinDomain,
10536                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrJoinDomain,
10537                 (ndr_print_function_t) ndr_print_wkssvc_NetrJoinDomain,
10538                 false,
10539         },
10540         {
10541                 "wkssvc_NetrUnjoinDomain",
10542                 sizeof(struct wkssvc_NetrUnjoinDomain),
10543                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUnjoinDomain,
10544                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUnjoinDomain,
10545                 (ndr_print_function_t) ndr_print_wkssvc_NetrUnjoinDomain,
10546                 false,
10547         },
10548         {
10549                 "wkssvc_NetrRenameMachineInDomain",
10550                 sizeof(struct wkssvc_NetrRenameMachineInDomain),
10551                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrRenameMachineInDomain,
10552                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrRenameMachineInDomain,
10553                 (ndr_print_function_t) ndr_print_wkssvc_NetrRenameMachineInDomain,
10554                 false,
10555         },
10556         {
10557                 "wkssvc_NetrValidateName",
10558                 sizeof(struct wkssvc_NetrValidateName),
10559                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrValidateName,
10560                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrValidateName,
10561                 (ndr_print_function_t) ndr_print_wkssvc_NetrValidateName,
10562                 false,
10563         },
10564         {
10565                 "wkssvc_NetrGetJoinInformation",
10566                 sizeof(struct wkssvc_NetrGetJoinInformation),
10567                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrGetJoinInformation,
10568                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrGetJoinInformation,
10569                 (ndr_print_function_t) ndr_print_wkssvc_NetrGetJoinInformation,
10570                 false,
10571         },
10572         {
10573                 "wkssvc_NetrGetJoinableOus",
10574                 sizeof(struct wkssvc_NetrGetJoinableOus),
10575                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrGetJoinableOus,
10576                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrGetJoinableOus,
10577                 (ndr_print_function_t) ndr_print_wkssvc_NetrGetJoinableOus,
10578                 false,
10579         },
10580         {
10581                 "wkssvc_NetrJoinDomain2",
10582                 sizeof(struct wkssvc_NetrJoinDomain2),
10583                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrJoinDomain2,
10584                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrJoinDomain2,
10585                 (ndr_print_function_t) ndr_print_wkssvc_NetrJoinDomain2,
10586                 false,
10587         },
10588         {
10589                 "wkssvc_NetrUnjoinDomain2",
10590                 sizeof(struct wkssvc_NetrUnjoinDomain2),
10591                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUnjoinDomain2,
10592                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUnjoinDomain2,
10593                 (ndr_print_function_t) ndr_print_wkssvc_NetrUnjoinDomain2,
10594                 false,
10595         },
10596         {
10597                 "wkssvc_NetrRenameMachineInDomain2",
10598                 sizeof(struct wkssvc_NetrRenameMachineInDomain2),
10599                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrRenameMachineInDomain2,
10600                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrRenameMachineInDomain2,
10601                 (ndr_print_function_t) ndr_print_wkssvc_NetrRenameMachineInDomain2,
10602                 false,
10603         },
10604         {
10605                 "wkssvc_NetrValidateName2",
10606                 sizeof(struct wkssvc_NetrValidateName2),
10607                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrValidateName2,
10608                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrValidateName2,
10609                 (ndr_print_function_t) ndr_print_wkssvc_NetrValidateName2,
10610                 false,
10611         },
10612         {
10613                 "wkssvc_NetrGetJoinableOus2",
10614                 sizeof(struct wkssvc_NetrGetJoinableOus2),
10615                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrGetJoinableOus2,
10616                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrGetJoinableOus2,
10617                 (ndr_print_function_t) ndr_print_wkssvc_NetrGetJoinableOus2,
10618                 false,
10619         },
10620         {
10621                 "wkssvc_NetrAddAlternateComputerName",
10622                 sizeof(struct wkssvc_NetrAddAlternateComputerName),
10623                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrAddAlternateComputerName,
10624                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrAddAlternateComputerName,
10625                 (ndr_print_function_t) ndr_print_wkssvc_NetrAddAlternateComputerName,
10626                 false,
10627         },
10628         {
10629                 "wkssvc_NetrRemoveAlternateComputerName",
10630                 sizeof(struct wkssvc_NetrRemoveAlternateComputerName),
10631                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrRemoveAlternateComputerName,
10632                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrRemoveAlternateComputerName,
10633                 (ndr_print_function_t) ndr_print_wkssvc_NetrRemoveAlternateComputerName,
10634                 false,
10635         },
10636         {
10637                 "wkssvc_NetrSetPrimaryComputername",
10638                 sizeof(struct wkssvc_NetrSetPrimaryComputername),
10639                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrSetPrimaryComputername,
10640                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrSetPrimaryComputername,
10641                 (ndr_print_function_t) ndr_print_wkssvc_NetrSetPrimaryComputername,
10642                 false,
10643         },
10644         {
10645                 "wkssvc_NetrEnumerateComputerNames",
10646                 sizeof(struct wkssvc_NetrEnumerateComputerNames),
10647                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrEnumerateComputerNames,
10648                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrEnumerateComputerNames,
10649                 (ndr_print_function_t) ndr_print_wkssvc_NetrEnumerateComputerNames,
10650                 false,
10651         },
10652         { NULL, 0, NULL, NULL, NULL, false }
10653 };
10654
10655 static const char * const wkssvc_endpoint_strings[] = {
10656         "ncacn_np:[\\pipe\\wkssvc]",
10657         "ncacn_ip_tcp:",
10658         "ncalrpc:",
10659 };
10660
10661 static const struct ndr_interface_string_array wkssvc_endpoints = {
10662         .count  = 3,
10663         .names  = wkssvc_endpoint_strings
10664 };
10665
10666 static const char * const wkssvc_authservice_strings[] = {
10667         "host",
10668 };
10669
10670 static const struct ndr_interface_string_array wkssvc_authservices = {
10671         .count  = 3,
10672         .names  = wkssvc_authservice_strings
10673 };
10674
10675
10676 const struct ndr_interface_table ndr_table_wkssvc = {
10677         .name           = "wkssvc",
10678         .syntax_id      = {
10679                 {0x6bffd098,0xa112,0x3610,{0x98,0x33},{0x46,0xc3,0xf8,0x7e,0x34,0x5a}},
10680                 NDR_WKSSVC_VERSION
10681         },
10682         .helpstring     = NDR_WKSSVC_HELPSTRING,
10683         .num_calls      = 31,
10684         .calls          = wkssvc_calls,
10685         .endpoints      = &wkssvc_endpoints,
10686         .authservices   = &wkssvc_authservices
10687 };
10688