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