source3/librpc/gen_ndr/ndr_wkssvc.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "librpc/gen_ndr/ndr_wkssvc.h"
   5
   6 #include "librpc/gen_ndr/ndr_srvsvc.h"
   7 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo100(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo100 *r)
   8 {
   9         if (ndr_flags & NDR_SCALARS) {
  10                 NDR_CHECK(ndr_push_align(ndr, 4));
  11                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->platform_id));
  12                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
  13                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
  14                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_major));
  15                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_minor));
  16         }
  17         if (ndr_flags & NDR_BUFFERS) {
  18                 if (r->server_name) {
  19                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
  20                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  21                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
  22                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
  23                 }
  24                 if (r->domain_name) {
  25                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
  26                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  27                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
  28                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
  29                 }
  30         }
  31         return NDR_ERR_SUCCESS;
  32 }
  33
  34 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo100(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo100 *r)
  35 {
  36         uint32_t _ptr_server_name;
  37         TALLOC_CTX *_mem_save_server_name_0;
  38         uint32_t _ptr_domain_name;
  39         TALLOC_CTX *_mem_save_domain_name_0;
  40         if (ndr_flags & NDR_SCALARS) {
  41                 NDR_CHECK(ndr_pull_align(ndr, 4));
  42                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->platform_id));
  43                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
  44                 if (_ptr_server_name) {
  45                         NDR_PULL_ALLOC(ndr, r->server_name);
  46                 } else {
  47                         r->server_name = NULL;
  48                 }
  49                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
  50                 if (_ptr_domain_name) {
  51                         NDR_PULL_ALLOC(ndr, r->domain_name);
  52                 } else {
  53                         r->domain_name = NULL;
  54                 }
  55                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_major));
  56                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_minor));
  57         }
  58         if (ndr_flags & NDR_BUFFERS) {
  59                 if (r->server_name) {
  60                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
  61                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
  62                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
  63                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
  64                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
  65                                 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));
  66                         }
  67                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
  68                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
  69                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
  70                 }
  71                 if (r->domain_name) {
  72                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
  73                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
  74                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
  75                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
  76                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
  77                                 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));
  78                         }
  79                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
  80                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
  81                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
  82                 }
  83         }
  84         return NDR_ERR_SUCCESS;
  85 }
  86
  87 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo100(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo100 *r)
  88 {
  89         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo100");
  90         ndr->depth++;
  91         ndr_print_uint16(ndr, "platform_id", r->platform_id);
  92         ndr_print_ptr(ndr, "server_name", r->server_name);
  93         ndr->depth++;
  94         if (r->server_name) {
  95                 ndr_print_string(ndr, "server_name", r->server_name);
  96         }
  97         ndr->depth--;
  98         ndr_print_ptr(ndr, "domain_name", r->domain_name);
  99         ndr->depth++;
 100         if (r->domain_name) {
 101                 ndr_print_string(ndr, "domain_name", r->domain_name);
 102         }
 103         ndr->depth--;
 104         ndr_print_uint32(ndr, "version_major", r->version_major);
 105         ndr_print_uint32(ndr, "version_minor", r->version_minor);
 106         ndr->depth--;
 107 }
 108
 109 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo101(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo101 *r)
 110 {
 111         if (ndr_flags & NDR_SCALARS) {
 112                 NDR_CHECK(ndr_push_align(ndr, 4));
 113                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->platform_id));
 114                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
 115                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
 116                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_major));
 117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_minor));
 118                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->lan_root));
 119         }
 120         if (ndr_flags & NDR_BUFFERS) {
 121                 if (r->server_name) {
 122                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
 123                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 124                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
 125                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 126                 }
 127                 if (r->domain_name) {
 128                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
 129                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 130                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
 131                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 132                 }
 133                 if (r->lan_root) {
 134                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->lan_root, CH_UTF16)));
 135                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 136                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->lan_root, CH_UTF16)));
 137                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->lan_root, ndr_charset_length(r->lan_root, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 138                 }
 139         }
 140         return NDR_ERR_SUCCESS;
 141 }
 142
 143 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo101(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo101 *r)
 144 {
 145         uint32_t _ptr_server_name;
 146         TALLOC_CTX *_mem_save_server_name_0;
 147         uint32_t _ptr_domain_name;
 148         TALLOC_CTX *_mem_save_domain_name_0;
 149         uint32_t _ptr_lan_root;
 150         TALLOC_CTX *_mem_save_lan_root_0;
 151         if (ndr_flags & NDR_SCALARS) {
 152                 NDR_CHECK(ndr_pull_align(ndr, 4));
 153                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->platform_id));
 154                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
 155                 if (_ptr_server_name) {
 156                         NDR_PULL_ALLOC(ndr, r->server_name);
 157                 } else {
 158                         r->server_name = NULL;
 159                 }
 160                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
 161                 if (_ptr_domain_name) {
 162                         NDR_PULL_ALLOC(ndr, r->domain_name);
 163                 } else {
 164                         r->domain_name = NULL;
 165                 }
 166                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_major));
 167                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_minor));
 168                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lan_root));
 169                 if (_ptr_lan_root) {
 170                         NDR_PULL_ALLOC(ndr, r->lan_root);
 171                 } else {
 172                         r->lan_root = NULL;
 173                 }
 174         }
 175         if (ndr_flags & NDR_BUFFERS) {
 176                 if (r->server_name) {
 177                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 178                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
 179                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
 180                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
 181                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
 182                                 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));
 183                         }
 184                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
 185                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
 186                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
 187                 }
 188                 if (r->domain_name) {
 189                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 190                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
 191                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
 192                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
 193                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
 194                                 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));
 195                         }
 196                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
 197                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
 198                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
 199                 }
 200                 if (r->lan_root) {
 201                         _mem_save_lan_root_0 = NDR_PULL_GET_MEM_CTX(ndr);
 202                         NDR_PULL_SET_MEM_CTX(ndr, r->lan_root, 0);
 203                         NDR_CHECK(ndr_pull_array_size(ndr, &r->lan_root));
 204                         NDR_CHECK(ndr_pull_array_length(ndr, &r->lan_root));
 205                         if (ndr_get_array_length(ndr, &r->lan_root) > ndr_get_array_size(ndr, &r->lan_root)) {
 206                                 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));
 207                         }
 208                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->lan_root), sizeof(uint16_t)));
 209                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->lan_root, ndr_get_array_length(ndr, &r->lan_root), sizeof(uint16_t), CH_UTF16));
 210                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lan_root_0, 0);
 211                 }
 212         }
 213         return NDR_ERR_SUCCESS;
 214 }
 215
 216 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo101(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo101 *r)
 217 {
 218         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo101");
 219         ndr->depth++;
 220         ndr_print_uint16(ndr, "platform_id", r->platform_id);
 221         ndr_print_ptr(ndr, "server_name", r->server_name);
 222         ndr->depth++;
 223         if (r->server_name) {
 224                 ndr_print_string(ndr, "server_name", r->server_name);
 225         }
 226         ndr->depth--;
 227         ndr_print_ptr(ndr, "domain_name", r->domain_name);
 228         ndr->depth++;
 229         if (r->domain_name) {
 230                 ndr_print_string(ndr, "domain_name", r->domain_name);
 231         }
 232         ndr->depth--;
 233         ndr_print_uint32(ndr, "version_major", r->version_major);
 234         ndr_print_uint32(ndr, "version_minor", r->version_minor);
 235         ndr_print_ptr(ndr, "lan_root", r->lan_root);
 236         ndr->depth++;
 237         if (r->lan_root) {
 238                 ndr_print_string(ndr, "lan_root", r->lan_root);
 239         }
 240         ndr->depth--;
 241         ndr->depth--;
 242 }
 243
 244 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo102(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo102 *r)
 245 {
 246         if (ndr_flags & NDR_SCALARS) {
 247                 NDR_CHECK(ndr_push_align(ndr, 4));
 248                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->platform_id));
 249                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
 250                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
 251                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_major));
 252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_minor));
 253                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->lan_root));
 254                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->logged_on_users));
 255         }
 256         if (ndr_flags & NDR_BUFFERS) {
 257                 if (r->server_name) {
 258                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
 259                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 260                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
 261                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 262                 }
 263                 if (r->domain_name) {
 264                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
 265                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 266                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
 267                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 268                 }
 269                 if (r->lan_root) {
 270                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->lan_root, CH_UTF16)));
 271                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 272                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->lan_root, CH_UTF16)));
 273                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->lan_root, ndr_charset_length(r->lan_root, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 274                 }
 275         }
 276         return NDR_ERR_SUCCESS;
 277 }
 278
 279 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo102(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo102 *r)
 280 {
 281         uint32_t _ptr_server_name;
 282         TALLOC_CTX *_mem_save_server_name_0;
 283         uint32_t _ptr_domain_name;
 284         TALLOC_CTX *_mem_save_domain_name_0;
 285         uint32_t _ptr_lan_root;
 286         TALLOC_CTX *_mem_save_lan_root_0;
 287         if (ndr_flags & NDR_SCALARS) {
 288                 NDR_CHECK(ndr_pull_align(ndr, 4));
 289                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->platform_id));
 290                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
 291                 if (_ptr_server_name) {
 292                         NDR_PULL_ALLOC(ndr, r->server_name);
 293                 } else {
 294                         r->server_name = NULL;
 295                 }
 296                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
 297                 if (_ptr_domain_name) {
 298                         NDR_PULL_ALLOC(ndr, r->domain_name);
 299                 } else {
 300                         r->domain_name = NULL;
 301                 }
 302                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_major));
 303                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_minor));
 304                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lan_root));
 305                 if (_ptr_lan_root) {
 306                         NDR_PULL_ALLOC(ndr, r->lan_root);
 307                 } else {
 308                         r->lan_root = NULL;
 309                 }
 310                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->logged_on_users));
 311         }
 312         if (ndr_flags & NDR_BUFFERS) {
 313                 if (r->server_name) {
 314                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 315                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
 316                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
 317                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
 318                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
 319                                 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));
 320                         }
 321                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
 322                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
 323                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
 324                 }
 325                 if (r->domain_name) {
 326                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 327                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
 328                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
 329                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
 330                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
 331                                 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));
 332                         }
 333                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
 334                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
 335                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
 336                 }
 337                 if (r->lan_root) {
 338                         _mem_save_lan_root_0 = NDR_PULL_GET_MEM_CTX(ndr);
 339                         NDR_PULL_SET_MEM_CTX(ndr, r->lan_root, 0);
 340                         NDR_CHECK(ndr_pull_array_size(ndr, &r->lan_root));
 341                         NDR_CHECK(ndr_pull_array_length(ndr, &r->lan_root));
 342                         if (ndr_get_array_length(ndr, &r->lan_root) > ndr_get_array_size(ndr, &r->lan_root)) {
 343                                 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));
 344                         }
 345                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->lan_root), sizeof(uint16_t)));
 346                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->lan_root, ndr_get_array_length(ndr, &r->lan_root), sizeof(uint16_t), CH_UTF16));
 347                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lan_root_0, 0);
 348                 }
 349         }
 350         return NDR_ERR_SUCCESS;
 351 }
 352
 353 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo102(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo102 *r)
 354 {
 355         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo102");
 356         ndr->depth++;
 357         ndr_print_uint16(ndr, "platform_id", r->platform_id);
 358         ndr_print_ptr(ndr, "server_name", r->server_name);
 359         ndr->depth++;
 360         if (r->server_name) {
 361                 ndr_print_string(ndr, "server_name", r->server_name);
 362         }
 363         ndr->depth--;
 364         ndr_print_ptr(ndr, "domain_name", r->domain_name);
 365         ndr->depth++;
 366         if (r->domain_name) {
 367                 ndr_print_string(ndr, "domain_name", r->domain_name);
 368         }
 369         ndr->depth--;
 370         ndr_print_uint32(ndr, "version_major", r->version_major);
 371         ndr_print_uint32(ndr, "version_minor", r->version_minor);
 372         ndr_print_ptr(ndr, "lan_root", r->lan_root);
 373         ndr->depth++;
 374         if (r->lan_root) {
 375                 ndr_print_string(ndr, "lan_root", r->lan_root);
 376         }
 377         ndr->depth--;
 378         ndr_print_uint32(ndr, "logged_on_users", r->logged_on_users);
 379         ndr->depth--;
 380 }
 381
 382 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo502(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo502 *r)
 383 {
 384         if (ndr_flags & NDR_SCALARS) {
 385                 NDR_CHECK(ndr_push_align(ndr, 4));
 386                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->char_wait));
 387                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->collection_time));
 388                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maximum_collection_count));
 389                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->keep_connection));
 390                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_commands));
 391                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_timeout));
 392                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_char_buf));
 393                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_threads));
 394                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_quota));
 395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_increment));
 396                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_maximum));
 397                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pipe_increment));
 398                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pipe_maximum));
 399                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cache_file_timeout));
 400                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dormant_file_limit));
 401                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->read_ahead_throughput));
 402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_mailslot_buffers));
 403                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_srv_announce_buffers));
 404                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_illegal_dgram_events));
 405                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dgram_event_reset_freq));
 406                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->log_election_packets));
 407                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_opportunistic_locking));
 408                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_unlock_behind));
 409                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_close_behind));
 410                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_named_pipes));
 411                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_lock_read_unlock));
 412                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->utilize_nt_caching));
 413                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_raw_read));
 414                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_raw_write));
 415                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_write_raw_data));
 416                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_encryption));
 417                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_files_deny_write));
 418                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_read_only_files));
 419                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->force_core_create_mode));
 420                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_512_byte_max_transfer));
 421         }
 422         if (ndr_flags & NDR_BUFFERS) {
 423         }
 424         return NDR_ERR_SUCCESS;
 425 }
 426
 427 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo502(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo502 *r)
 428 {
 429         if (ndr_flags & NDR_SCALARS) {
 430                 NDR_CHECK(ndr_pull_align(ndr, 4));
 431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->char_wait));
 432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->collection_time));
 433                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maximum_collection_count));
 434                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->keep_connection));
 435                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_commands));
 436                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_timeout));
 437                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_char_buf));
 438                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_threads));
 439                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_quota));
 440                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_increment));
 441                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_maximum));
 442                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pipe_increment));
 443                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pipe_maximum));
 444                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cache_file_timeout));
 445                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dormant_file_limit));
 446                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->read_ahead_throughput));
 447                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_mailslot_buffers));
 448                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_srv_announce_buffers));
 449                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_illegal_dgram_events));
 450                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dgram_event_reset_freq));
 451                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->log_election_packets));
 452                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_opportunistic_locking));
 453                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_unlock_behind));
 454                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_close_behind));
 455                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_named_pipes));
 456                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_lock_read_unlock));
 457                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->utilize_nt_caching));
 458                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_raw_read));
 459                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_raw_write));
 460                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_write_raw_data));
 461                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_encryption));
 462                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_files_deny_write));
 463                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_read_only_files));
 464                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->force_core_create_mode));
 465                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_512_byte_max_transfer));
 466         }
 467         if (ndr_flags & NDR_BUFFERS) {
 468         }
 469         return NDR_ERR_SUCCESS;
 470 }
 471
 472 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo502(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo502 *r)
 473 {
 474         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo502");
 475         ndr->depth++;
 476         ndr_print_uint32(ndr, "char_wait", r->char_wait);
 477         ndr_print_uint32(ndr, "collection_time", r->collection_time);
 478         ndr_print_uint32(ndr, "maximum_collection_count", r->maximum_collection_count);
 479         ndr_print_uint32(ndr, "keep_connection", r->keep_connection);
 480         ndr_print_uint32(ndr, "max_commands", r->max_commands);
 481         ndr_print_uint32(ndr, "session_timeout", r->session_timeout);
 482         ndr_print_uint32(ndr, "size_char_buf", r->size_char_buf);
 483         ndr_print_uint32(ndr, "max_threads", r->max_threads);
 484         ndr_print_uint32(ndr, "lock_quota", r->lock_quota);
 485         ndr_print_uint32(ndr, "lock_increment", r->lock_increment);
 486         ndr_print_uint32(ndr, "lock_maximum", r->lock_maximum);
 487         ndr_print_uint32(ndr, "pipe_increment", r->pipe_increment);
 488         ndr_print_uint32(ndr, "pipe_maximum", r->pipe_maximum);
 489         ndr_print_uint32(ndr, "cache_file_timeout", r->cache_file_timeout);
 490         ndr_print_uint32(ndr, "dormant_file_limit", r->dormant_file_limit);
 491         ndr_print_uint32(ndr, "read_ahead_throughput", r->read_ahead_throughput);
 492         ndr_print_uint32(ndr, "num_mailslot_buffers", r->num_mailslot_buffers);
 493         ndr_print_uint32(ndr, "num_srv_announce_buffers", r->num_srv_announce_buffers);
 494         ndr_print_uint32(ndr, "max_illegal_dgram_events", r->max_illegal_dgram_events);
 495         ndr_print_uint32(ndr, "dgram_event_reset_freq", r->dgram_event_reset_freq);
 496         ndr_print_uint32(ndr, "log_election_packets", r->log_election_packets);
 497         ndr_print_uint32(ndr, "use_opportunistic_locking", r->use_opportunistic_locking);
 498         ndr_print_uint32(ndr, "use_unlock_behind", r->use_unlock_behind);
 499         ndr_print_uint32(ndr, "use_close_behind", r->use_close_behind);
 500         ndr_print_uint32(ndr, "buf_named_pipes", r->buf_named_pipes);
 501         ndr_print_uint32(ndr, "use_lock_read_unlock", r->use_lock_read_unlock);
 502         ndr_print_uint32(ndr, "utilize_nt_caching", r->utilize_nt_caching);
 503         ndr_print_uint32(ndr, "use_raw_read", r->use_raw_read);
 504         ndr_print_uint32(ndr, "use_raw_write", r->use_raw_write);
 505         ndr_print_uint32(ndr, "use_write_raw_data", r->use_write_raw_data);
 506         ndr_print_uint32(ndr, "use_encryption", r->use_encryption);
 507         ndr_print_uint32(ndr, "buf_files_deny_write", r->buf_files_deny_write);
 508         ndr_print_uint32(ndr, "buf_read_only_files", r->buf_read_only_files);
 509         ndr_print_uint32(ndr, "force_core_create_mode", r->force_core_create_mode);
 510         ndr_print_uint32(ndr, "use_512_byte_max_transfer", r->use_512_byte_max_transfer);
 511         ndr->depth--;
 512 }
 513
 514 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1010(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1010 *r)
 515 {
 516         if (ndr_flags & NDR_SCALARS) {
 517                 NDR_CHECK(ndr_push_align(ndr, 4));
 518                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->char_wait));
 519         }
 520         if (ndr_flags & NDR_BUFFERS) {
 521         }
 522         return NDR_ERR_SUCCESS;
 523 }
 524
 525 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1010(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1010 *r)
 526 {
 527         if (ndr_flags & NDR_SCALARS) {
 528                 NDR_CHECK(ndr_pull_align(ndr, 4));
 529                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->char_wait));
 530         }
 531         if (ndr_flags & NDR_BUFFERS) {
 532         }
 533         return NDR_ERR_SUCCESS;
 534 }
 535
 536 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1010(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1010 *r)
 537 {
 538         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1010");
 539         ndr->depth++;
 540         ndr_print_uint32(ndr, "char_wait", r->char_wait);
 541         ndr->depth--;
 542 }
 543
 544 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1011(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1011 *r)
 545 {
 546         if (ndr_flags & NDR_SCALARS) {
 547                 NDR_CHECK(ndr_push_align(ndr, 4));
 548                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->collection_time));
 549         }
 550         if (ndr_flags & NDR_BUFFERS) {
 551         }
 552         return NDR_ERR_SUCCESS;
 553 }
 554
 555 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1011(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1011 *r)
 556 {
 557         if (ndr_flags & NDR_SCALARS) {
 558                 NDR_CHECK(ndr_pull_align(ndr, 4));
 559                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->collection_time));
 560         }
 561         if (ndr_flags & NDR_BUFFERS) {
 562         }
 563         return NDR_ERR_SUCCESS;
 564 }
 565
 566 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1011(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1011 *r)
 567 {
 568         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1011");
 569         ndr->depth++;
 570         ndr_print_uint32(ndr, "collection_time", r->collection_time);
 571         ndr->depth--;
 572 }
 573
 574 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1012(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1012 *r)
 575 {
 576         if (ndr_flags & NDR_SCALARS) {
 577                 NDR_CHECK(ndr_push_align(ndr, 4));
 578                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maximum_collection_count));
 579         }
 580         if (ndr_flags & NDR_BUFFERS) {
 581         }
 582         return NDR_ERR_SUCCESS;
 583 }
 584
 585 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1012(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1012 *r)
 586 {
 587         if (ndr_flags & NDR_SCALARS) {
 588                 NDR_CHECK(ndr_pull_align(ndr, 4));
 589                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maximum_collection_count));
 590         }
 591         if (ndr_flags & NDR_BUFFERS) {
 592         }
 593         return NDR_ERR_SUCCESS;
 594 }
 595
 596 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1012(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1012 *r)
 597 {
 598         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1012");
 599         ndr->depth++;
 600         ndr_print_uint32(ndr, "maximum_collection_count", r->maximum_collection_count);
 601         ndr->depth--;
 602 }
 603
 604 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1013(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1013 *r)
 605 {
 606         if (ndr_flags & NDR_SCALARS) {
 607                 NDR_CHECK(ndr_push_align(ndr, 4));
 608                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->keep_connection));
 609         }
 610         if (ndr_flags & NDR_BUFFERS) {
 611         }
 612         return NDR_ERR_SUCCESS;
 613 }
 614
 615 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1013(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1013 *r)
 616 {
 617         if (ndr_flags & NDR_SCALARS) {
 618                 NDR_CHECK(ndr_pull_align(ndr, 4));
 619                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->keep_connection));
 620         }
 621         if (ndr_flags & NDR_BUFFERS) {
 622         }
 623         return NDR_ERR_SUCCESS;
 624 }
 625
 626 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1013(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1013 *r)
 627 {
 628         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1013");
 629         ndr->depth++;
 630         ndr_print_uint32(ndr, "keep_connection", r->keep_connection);
 631         ndr->depth--;
 632 }
 633
 634 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1018(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1018 *r)
 635 {
 636         if (ndr_flags & NDR_SCALARS) {
 637                 NDR_CHECK(ndr_push_align(ndr, 4));
 638                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_timeout));
 639         }
 640         if (ndr_flags & NDR_BUFFERS) {
 641         }
 642         return NDR_ERR_SUCCESS;
 643 }
 644
 645 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1018(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1018 *r)
 646 {
 647         if (ndr_flags & NDR_SCALARS) {
 648                 NDR_CHECK(ndr_pull_align(ndr, 4));
 649                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_timeout));
 650         }
 651         if (ndr_flags & NDR_BUFFERS) {
 652         }
 653         return NDR_ERR_SUCCESS;
 654 }
 655
 656 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1018(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1018 *r)
 657 {
 658         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1018");
 659         ndr->depth++;
 660         ndr_print_uint32(ndr, "session_timeout", r->session_timeout);
 661         ndr->depth--;
 662 }
 663
 664 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1023(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1023 *r)
 665 {
 666         if (ndr_flags & NDR_SCALARS) {
 667                 NDR_CHECK(ndr_push_align(ndr, 4));
 668                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_char_buf));
 669         }
 670         if (ndr_flags & NDR_BUFFERS) {
 671         }
 672         return NDR_ERR_SUCCESS;
 673 }
 674
 675 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1023(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1023 *r)
 676 {
 677         if (ndr_flags & NDR_SCALARS) {
 678                 NDR_CHECK(ndr_pull_align(ndr, 4));
 679                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_char_buf));
 680         }
 681         if (ndr_flags & NDR_BUFFERS) {
 682         }
 683         return NDR_ERR_SUCCESS;
 684 }
 685
 686 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1023(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1023 *r)
 687 {
 688         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1023");
 689         ndr->depth++;
 690         ndr_print_uint32(ndr, "size_char_buf", r->size_char_buf);
 691         ndr->depth--;
 692 }
 693
 694 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1027(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1027 *r)
 695 {
 696         if (ndr_flags & NDR_SCALARS) {
 697                 NDR_CHECK(ndr_push_align(ndr, 4));
 698                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->errorlog_sz));
 699         }
 700         if (ndr_flags & NDR_BUFFERS) {
 701         }
 702         return NDR_ERR_SUCCESS;
 703 }
 704
 705 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1027(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1027 *r)
 706 {
 707         if (ndr_flags & NDR_SCALARS) {
 708                 NDR_CHECK(ndr_pull_align(ndr, 4));
 709                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->errorlog_sz));
 710         }
 711         if (ndr_flags & NDR_BUFFERS) {
 712         }
 713         return NDR_ERR_SUCCESS;
 714 }
 715
 716 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1027(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1027 *r)
 717 {
 718         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1027");
 719         ndr->depth++;
 720         ndr_print_uint32(ndr, "errorlog_sz", r->errorlog_sz);
 721         ndr->depth--;
 722 }
 723
 724 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1033(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1033 *r)
 725 {
 726         if (ndr_flags & NDR_SCALARS) {
 727                 NDR_CHECK(ndr_push_align(ndr, 4));
 728                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_threads));
 729         }
 730         if (ndr_flags & NDR_BUFFERS) {
 731         }
 732         return NDR_ERR_SUCCESS;
 733 }
 734
 735 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1033(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1033 *r)
 736 {
 737         if (ndr_flags & NDR_SCALARS) {
 738                 NDR_CHECK(ndr_pull_align(ndr, 4));
 739                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_threads));
 740         }
 741         if (ndr_flags & NDR_BUFFERS) {
 742         }
 743         return NDR_ERR_SUCCESS;
 744 }
 745
 746 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1033(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1033 *r)
 747 {
 748         ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1033");
 749         ndr->depth++;
 750         ndr_print_uint32(ndr, "max_threads", r->max_threads);
 751         ndr->depth--;
 752 }
 753
 754 static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetWkstaInfo *r)
 755 {
 756         if (ndr_flags & NDR_SCALARS) {
 757                 int level = ndr_push_get_switch_value(ndr, r);
 758                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
 759                 switch (level) {
 760                         case 100:
 761                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info100));
 762                         break;
 763
 764                         case 101:
 765                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info101));
 766                         break;
 767
 768                         case 102:
 769                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info102));
 770                         break;
 771
 772                         case 502:
 773                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info502));
 774                         break;
 775
 776                         case 1010:
 777                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1010));
 778                         break;
 779
 780                         case 1011:
 781                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1011));
 782                         break;
 783
 784                         case 1012:
 785                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1012));
 786                         break;
 787
 788                         case 1013:
 789                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1013));
 790                         break;
 791
 792                         case 1018:
 793                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1018));
 794                         break;
 795
 796                         case 1023:
 797                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1023));
 798                         break;
 799
 800                         case 1027:
 801                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1027));
 802                         break;
 803
 804                         case 1033:
 805                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1033));
 806                         break;
 807
 808                         default:
 809                         break;
 810
 811                 }
 812         }
 813         if (ndr_flags & NDR_BUFFERS) {
 814                 int level = ndr_push_get_switch_value(ndr, r);
 815                 switch (level) {
 816                         case 100:
 817                                 if (r->info100) {
 818                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo100(ndr, NDR_SCALARS|NDR_BUFFERS, r->info100));
 819                                 }
 820                         break;
 821
 822                         case 101:
 823                                 if (r->info101) {
 824                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info101));
 825                                 }
 826                         break;
 827
 828                         case 102:
 829                                 if (r->info102) {
 830                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo102(ndr, NDR_SCALARS|NDR_BUFFERS, r->info102));
 831                                 }
 832                         break;
 833
 834                         case 502:
 835                                 if (r->info502) {
 836                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo502(ndr, NDR_SCALARS, r->info502));
 837                                 }
 838                         break;
 839
 840                         case 1010:
 841                                 if (r->info1010) {
 842                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1010(ndr, NDR_SCALARS, r->info1010));
 843                                 }
 844                         break;
 845
 846                         case 1011:
 847                                 if (r->info1011) {
 848                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1011(ndr, NDR_SCALARS, r->info1011));
 849                                 }
 850                         break;
 851
 852                         case 1012:
 853                                 if (r->info1012) {
 854                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1012(ndr, NDR_SCALARS, r->info1012));
 855                                 }
 856                         break;
 857
 858                         case 1013:
 859                                 if (r->info1013) {
 860                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1013(ndr, NDR_SCALARS, r->info1013));
 861                                 }
 862                         break;
 863
 864                         case 1018:
 865                                 if (r->info1018) {
 866                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1018(ndr, NDR_SCALARS, r->info1018));
 867                                 }
 868                         break;
 869
 870                         case 1023:
 871                                 if (r->info1023) {
 872                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1023(ndr, NDR_SCALARS, r->info1023));
 873                                 }
 874                         break;
 875
 876                         case 1027:
 877                                 if (r->info1027) {
 878                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1027(ndr, NDR_SCALARS, r->info1027));
 879                                 }
 880                         break;
 881
 882                         case 1033:
 883                                 if (r->info1033) {
 884                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1033(ndr, NDR_SCALARS, r->info1033));
 885                                 }
 886                         break;
 887
 888                         default:
 889                         break;
 890
 891                 }
 892         }
 893         return NDR_ERR_SUCCESS;
 894 }
 895
 896 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetWkstaInfo *r)
 897 {
 898         int level;
 899         uint32_t _level;
 900         TALLOC_CTX *_mem_save_info100_0;
 901         TALLOC_CTX *_mem_save_info101_0;
 902         TALLOC_CTX *_mem_save_info102_0;
 903         TALLOC_CTX *_mem_save_info502_0;
 904         TALLOC_CTX *_mem_save_info1010_0;
 905         TALLOC_CTX *_mem_save_info1011_0;
 906         TALLOC_CTX *_mem_save_info1012_0;
 907         TALLOC_CTX *_mem_save_info1013_0;
 908         TALLOC_CTX *_mem_save_info1018_0;
 909         TALLOC_CTX *_mem_save_info1023_0;
 910         TALLOC_CTX *_mem_save_info1027_0;
 911         TALLOC_CTX *_mem_save_info1033_0;
 912         level = ndr_pull_get_switch_value(ndr, r);
 913         if (ndr_flags & NDR_SCALARS) {
 914                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
 915                 if (_level != level) {
 916                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
 917                 }
 918                 switch (level) {
 919                         case 100: {
 920                                 uint32_t _ptr_info100;
 921                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info100));
 922                                 if (_ptr_info100) {
 923                                         NDR_PULL_ALLOC(ndr, r->info100);
 924                                 } else {
 925                                         r->info100 = NULL;
 926                                 }
 927                         break; }
 928
 929                         case 101: {
 930                                 uint32_t _ptr_info101;
 931                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info101));
 932                                 if (_ptr_info101) {
 933                                         NDR_PULL_ALLOC(ndr, r->info101);
 934                                 } else {
 935                                         r->info101 = NULL;
 936                                 }
 937                         break; }
 938
 939                         case 102: {
 940                                 uint32_t _ptr_info102;
 941                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info102));
 942                                 if (_ptr_info102) {
 943                                         NDR_PULL_ALLOC(ndr, r->info102);
 944                                 } else {
 945                                         r->info102 = NULL;
 946                                 }
 947                         break; }
 948
 949                         case 502: {
 950                                 uint32_t _ptr_info502;
 951                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info502));
 952                                 if (_ptr_info502) {
 953                                         NDR_PULL_ALLOC(ndr, r->info502);
 954                                 } else {
 955                                         r->info502 = NULL;
 956                                 }
 957                         break; }
 958
 959                         case 1010: {
 960                                 uint32_t _ptr_info1010;
 961                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1010));
 962                                 if (_ptr_info1010) {
 963                                         NDR_PULL_ALLOC(ndr, r->info1010);
 964                                 } else {
 965                                         r->info1010 = NULL;
 966                                 }
 967                         break; }
 968
 969                         case 1011: {
 970                                 uint32_t _ptr_info1011;
 971                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1011));
 972                                 if (_ptr_info1011) {
 973                                         NDR_PULL_ALLOC(ndr, r->info1011);
 974                                 } else {
 975                                         r->info1011 = NULL;
 976                                 }
 977                         break; }
 978
 979                         case 1012: {
 980                                 uint32_t _ptr_info1012;
 981                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1012));
 982                                 if (_ptr_info1012) {
 983                                         NDR_PULL_ALLOC(ndr, r->info1012);
 984                                 } else {
 985                                         r->info1012 = NULL;
 986                                 }
 987                         break; }
 988
 989                         case 1013: {
 990                                 uint32_t _ptr_info1013;
 991                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1013));
 992                                 if (_ptr_info1013) {
 993                                         NDR_PULL_ALLOC(ndr, r->info1013);
 994                                 } else {
 995                                         r->info1013 = NULL;
 996                                 }
 997                         break; }
 998
 999                         case 1018: {
1000                                 uint32_t _ptr_info1018;
1001                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1018));
1002                                 if (_ptr_info1018) {
1003                                         NDR_PULL_ALLOC(ndr, r->info1018);
1004                                 } else {
1005                                         r->info1018 = NULL;
1006                                 }
1007                         break; }
1008
1009                         case 1023: {
1010                                 uint32_t _ptr_info1023;
1011                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1023));
1012                                 if (_ptr_info1023) {
1013                                         NDR_PULL_ALLOC(ndr, r->info1023);
1014                                 } else {
1015                                         r->info1023 = NULL;
1016                                 }
1017                         break; }
1018
1019                         case 1027: {
1020                                 uint32_t _ptr_info1027;
1021                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1027));
1022                                 if (_ptr_info1027) {
1023                                         NDR_PULL_ALLOC(ndr, r->info1027);
1024                                 } else {
1025                                         r->info1027 = NULL;
1026                                 }
1027                         break; }
1028
1029                         case 1033: {
1030                                 uint32_t _ptr_info1033;
1031                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1033));
1032                                 if (_ptr_info1033) {
1033                                         NDR_PULL_ALLOC(ndr, r->info1033);
1034                                 } else {
1035                                         r->info1033 = NULL;
1036                                 }
1037                         break; }
1038
1039                         default: {
1040                         break; }
1041
1042                 }
1043         }
1044         if (ndr_flags & NDR_BUFFERS) {
1045                 switch (level) {
1046                         case 100:
1047                                 if (r->info100) {
1048                                         _mem_save_info100_0 = NDR_PULL_GET_MEM_CTX(ndr);
1049                                         NDR_PULL_SET_MEM_CTX(ndr, r->info100, 0);
1050                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo100(ndr, NDR_SCALARS|NDR_BUFFERS, r->info100));
1051                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info100_0, 0);
1052                                 }
1053                         break;
1054
1055                         case 101:
1056                                 if (r->info101) {
1057                                         _mem_save_info101_0 = NDR_PULL_GET_MEM_CTX(ndr);
1058                                         NDR_PULL_SET_MEM_CTX(ndr, r->info101, 0);
1059                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info101));
1060                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info101_0, 0);
1061                                 }
1062                         break;
1063
1064                         case 102:
1065                                 if (r->info102) {
1066                                         _mem_save_info102_0 = NDR_PULL_GET_MEM_CTX(ndr);
1067                                         NDR_PULL_SET_MEM_CTX(ndr, r->info102, 0);
1068                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo102(ndr, NDR_SCALARS|NDR_BUFFERS, r->info102));
1069                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info102_0, 0);
1070                                 }
1071                         break;
1072
1073                         case 502:
1074                                 if (r->info502) {
1075                                         _mem_save_info502_0 = NDR_PULL_GET_MEM_CTX(ndr);
1076                                         NDR_PULL_SET_MEM_CTX(ndr, r->info502, 0);
1077                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo502(ndr, NDR_SCALARS, r->info502));
1078                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info502_0, 0);
1079                                 }
1080                         break;
1081
1082                         case 1010:
1083                                 if (r->info1010) {
1084                                         _mem_save_info1010_0 = NDR_PULL_GET_MEM_CTX(ndr);
1085                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1010, 0);
1086                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1010(ndr, NDR_SCALARS, r->info1010));
1087                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1010_0, 0);
1088                                 }
1089                         break;
1090
1091                         case 1011:
1092                                 if (r->info1011) {
1093                                         _mem_save_info1011_0 = NDR_PULL_GET_MEM_CTX(ndr);
1094                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1011, 0);
1095                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1011(ndr, NDR_SCALARS, r->info1011));
1096                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1011_0, 0);
1097                                 }
1098                         break;
1099
1100                         case 1012:
1101                                 if (r->info1012) {
1102                                         _mem_save_info1012_0 = NDR_PULL_GET_MEM_CTX(ndr);
1103                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1012, 0);
1104                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1012(ndr, NDR_SCALARS, r->info1012));
1105                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1012_0, 0);
1106                                 }
1107                         break;
1108
1109                         case 1013:
1110                                 if (r->info1013) {
1111                                         _mem_save_info1013_0 = NDR_PULL_GET_MEM_CTX(ndr);
1112                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1013, 0);
1113                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1013(ndr, NDR_SCALARS, r->info1013));
1114                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1013_0, 0);
1115                                 }
1116                         break;
1117
1118                         case 1018:
1119                                 if (r->info1018) {
1120                                         _mem_save_info1018_0 = NDR_PULL_GET_MEM_CTX(ndr);
1121                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1018, 0);
1122                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1018(ndr, NDR_SCALARS, r->info1018));
1123                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1018_0, 0);
1124                                 }
1125                         break;
1126
1127                         case 1023:
1128                                 if (r->info1023) {
1129                                         _mem_save_info1023_0 = NDR_PULL_GET_MEM_CTX(ndr);
1130                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1023, 0);
1131                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1023(ndr, NDR_SCALARS, r->info1023));
1132                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1023_0, 0);
1133                                 }
1134                         break;
1135
1136                         case 1027:
1137                                 if (r->info1027) {
1138                                         _mem_save_info1027_0 = NDR_PULL_GET_MEM_CTX(ndr);
1139                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1027, 0);
1140                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1027(ndr, NDR_SCALARS, r->info1027));
1141                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1027_0, 0);
1142                                 }
1143                         break;
1144
1145                         case 1033:
1146                                 if (r->info1033) {
1147                                         _mem_save_info1033_0 = NDR_PULL_GET_MEM_CTX(ndr);
1148                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1033, 0);
1149                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1033(ndr, NDR_SCALARS, r->info1033));
1150                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1033_0, 0);
1151                                 }
1152                         break;
1153
1154                         default:
1155                         break;
1156
1157                 }
1158         }
1159         return NDR_ERR_SUCCESS;
1160 }
1161
1162 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo(struct ndr_print *ndr, const char *name, const union wkssvc_NetWkstaInfo *r)
1163 {
1164         int level;
1165         level = ndr_print_get_switch_value(ndr, r);
1166         ndr_print_union(ndr, name, level, "wkssvc_NetWkstaInfo");
1167         switch (level) {
1168                 case 100:
1169                         ndr_print_ptr(ndr, "info100", r->info100);
1170                         ndr->depth++;
1171                         if (r->info100) {
1172                                 ndr_print_wkssvc_NetWkstaInfo100(ndr, "info100", r->info100);
1173                         }
1174                         ndr->depth--;
1175                 break;
1176
1177                 case 101:
1178                         ndr_print_ptr(ndr, "info101", r->info101);
1179                         ndr->depth++;
1180                         if (r->info101) {
1181                                 ndr_print_wkssvc_NetWkstaInfo101(ndr, "info101", r->info101);
1182                         }
1183                         ndr->depth--;
1184                 break;
1185
1186                 case 102:
1187                         ndr_print_ptr(ndr, "info102", r->info102);
1188                         ndr->depth++;
1189                         if (r->info102) {
1190                                 ndr_print_wkssvc_NetWkstaInfo102(ndr, "info102", r->info102);
1191                         }
1192                         ndr->depth--;
1193                 break;
1194
1195                 case 502:
1196                         ndr_print_ptr(ndr, "info502", r->info502);
1197                         ndr->depth++;
1198                         if (r->info502) {
1199                                 ndr_print_wkssvc_NetWkstaInfo502(ndr, "info502", r->info502);
1200                         }
1201                         ndr->depth--;
1202                 break;
1203
1204                 case 1010:
1205                         ndr_print_ptr(ndr, "info1010", r->info1010);
1206                         ndr->depth++;
1207                         if (r->info1010) {
1208                                 ndr_print_wkssvc_NetWkstaInfo1010(ndr, "info1010", r->info1010);
1209                         }
1210                         ndr->depth--;
1211                 break;
1212
1213                 case 1011:
1214                         ndr_print_ptr(ndr, "info1011", r->info1011);
1215                         ndr->depth++;
1216                         if (r->info1011) {
1217                                 ndr_print_wkssvc_NetWkstaInfo1011(ndr, "info1011", r->info1011);
1218                         }
1219                         ndr->depth--;
1220                 break;
1221
1222                 case 1012:
1223                         ndr_print_ptr(ndr, "info1012", r->info1012);
1224                         ndr->depth++;
1225                         if (r->info1012) {
1226                                 ndr_print_wkssvc_NetWkstaInfo1012(ndr, "info1012", r->info1012);
1227                         }
1228                         ndr->depth--;
1229                 break;
1230
1231                 case 1013:
1232                         ndr_print_ptr(ndr, "info1013", r->info1013);
1233                         ndr->depth++;
1234                         if (r->info1013) {
1235                                 ndr_print_wkssvc_NetWkstaInfo1013(ndr, "info1013", r->info1013);
1236                         }
1237                         ndr->depth--;
1238                 break;
1239
1240                 case 1018:
1241                         ndr_print_ptr(ndr, "info1018", r->info1018);
1242                         ndr->depth++;
1243                         if (r->info1018) {
1244                                 ndr_print_wkssvc_NetWkstaInfo1018(ndr, "info1018", r->info1018);
1245                         }
1246                         ndr->depth--;
1247                 break;
1248
1249                 case 1023:
1250                         ndr_print_ptr(ndr, "info1023", r->info1023);
1251                         ndr->depth++;
1252                         if (r->info1023) {
1253                                 ndr_print_wkssvc_NetWkstaInfo1023(ndr, "info1023", r->info1023);
1254                         }
1255                         ndr->depth--;
1256                 break;
1257
1258                 case 1027:
1259                         ndr_print_ptr(ndr, "info1027", r->info1027);
1260                         ndr->depth++;
1261                         if (r->info1027) {
1262                                 ndr_print_wkssvc_NetWkstaInfo1027(ndr, "info1027", r->info1027);
1263                         }
1264                         ndr->depth--;
1265                 break;
1266
1267                 case 1033:
1268                         ndr_print_ptr(ndr, "info1033", r->info1033);
1269                         ndr->depth++;
1270                         if (r->info1033) {
1271                                 ndr_print_wkssvc_NetWkstaInfo1033(ndr, "info1033", r->info1033);
1272                         }
1273                         ndr->depth--;
1274                 break;
1275
1276                 default:
1277                 break;
1278
1279         }
1280 }
1281
1282 static enum ndr_err_code ndr_push_USER_INFO_0(struct ndr_push *ndr, int ndr_flags, const struct USER_INFO_0 *r)
1283 {
1284         if (ndr_flags & NDR_SCALARS) {
1285                 NDR_CHECK(ndr_push_align(ndr, 4));
1286                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
1287         }
1288         if (ndr_flags & NDR_BUFFERS) {
1289                 if (r->user) {
1290                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
1291                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1292                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
1293                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
1294                 }
1295         }
1296         return NDR_ERR_SUCCESS;
1297 }
1298
1299 static enum ndr_err_code ndr_pull_USER_INFO_0(struct ndr_pull *ndr, int ndr_flags, struct USER_INFO_0 *r)
1300 {
1301         uint32_t _ptr_user;
1302         TALLOC_CTX *_mem_save_user_0;
1303         if (ndr_flags & NDR_SCALARS) {
1304                 NDR_CHECK(ndr_pull_align(ndr, 4));
1305                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
1306                 if (_ptr_user) {
1307                         NDR_PULL_ALLOC(ndr, r->user);
1308                 } else {
1309                         r->user = NULL;
1310                 }
1311         }
1312         if (ndr_flags & NDR_BUFFERS) {
1313                 if (r->user) {
1314                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
1315                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
1316                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
1317                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
1318                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
1319                                 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), ndr_get_array_length(ndr, &r->user));
1320                         }
1321                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
1322                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
1323                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
1324                 }
1325         }
1326         return NDR_ERR_SUCCESS;
1327 }
1328
1329 _PUBLIC_ void ndr_print_USER_INFO_0(struct ndr_print *ndr, const char *name, const struct USER_INFO_0 *r)
1330 {
1331         ndr_print_struct(ndr, name, "USER_INFO_0");
1332         ndr->depth++;
1333         ndr_print_ptr(ndr, "user", r->user);
1334         ndr->depth++;
1335         if (r->user) {
1336                 ndr_print_string(ndr, "user", r->user);
1337         }
1338         ndr->depth--;
1339         ndr->depth--;
1340 }
1341
1342 static enum ndr_err_code ndr_push_USER_INFO_0_CONTAINER(struct ndr_push *ndr, int ndr_flags, const struct USER_INFO_0_CONTAINER *r)
1343 {
1344         uint32_t cntr_user0_1;
1345         if (ndr_flags & NDR_SCALARS) {
1346                 NDR_CHECK(ndr_push_align(ndr, 4));
1347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->entries_read));
1348                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user0));
1349         }
1350         if (ndr_flags & NDR_BUFFERS) {
1351                 if (r->user0) {
1352                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->entries_read));
1353                         for (cntr_user0_1 = 0; cntr_user0_1 < r->entries_read; cntr_user0_1++) {
1354                                 NDR_CHECK(ndr_push_USER_INFO_0(ndr, NDR_SCALARS, &r->user0[cntr_user0_1]));
1355                         }
1356                         for (cntr_user0_1 = 0; cntr_user0_1 < r->entries_read; cntr_user0_1++) {
1357                                 NDR_CHECK(ndr_push_USER_INFO_0(ndr, NDR_BUFFERS, &r->user0[cntr_user0_1]));
1358                         }
1359                 }
1360         }
1361         return NDR_ERR_SUCCESS;
1362 }
1363
1364 static enum ndr_err_code ndr_pull_USER_INFO_0_CONTAINER(struct ndr_pull *ndr, int ndr_flags, struct USER_INFO_0_CONTAINER *r)
1365 {
1366         uint32_t _ptr_user0;
1367         uint32_t cntr_user0_1;
1368         TALLOC_CTX *_mem_save_user0_0;
1369         TALLOC_CTX *_mem_save_user0_1;
1370         if (ndr_flags & NDR_SCALARS) {
1371                 NDR_CHECK(ndr_pull_align(ndr, 4));
1372                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->entries_read));
1373                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user0));
1374                 if (_ptr_user0) {
1375                         NDR_PULL_ALLOC(ndr, r->user0);
1376                 } else {
1377                         r->user0 = NULL;
1378                 }
1379         }
1380         if (ndr_flags & NDR_BUFFERS) {
1381                 if (r->user0) {
1382                         _mem_save_user0_0 = NDR_PULL_GET_MEM_CTX(ndr);
1383                         NDR_PULL_SET_MEM_CTX(ndr, r->user0, 0);
1384                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user0));
1385                         NDR_PULL_ALLOC_N(ndr, r->user0, ndr_get_array_size(ndr, &r->user0));
1386                         _mem_save_user0_1 = NDR_PULL_GET_MEM_CTX(ndr);
1387                         NDR_PULL_SET_MEM_CTX(ndr, r->user0, 0);
1388                         for (cntr_user0_1 = 0; cntr_user0_1 < r->entries_read; cntr_user0_1++) {
1389                                 NDR_CHECK(ndr_pull_USER_INFO_0(ndr, NDR_SCALARS, &r->user0[cntr_user0_1]));
1390                         }
1391                         for (cntr_user0_1 = 0; cntr_user0_1 < r->entries_read; cntr_user0_1++) {
1392                                 NDR_CHECK(ndr_pull_USER_INFO_0(ndr, NDR_BUFFERS, &r->user0[cntr_user0_1]));
1393                         }
1394                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user0_1, 0);
1395                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user0_0, 0);
1396                 }
1397                 if (r->user0) {
1398                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->user0, r->entries_read));
1399                 }
1400         }
1401         return NDR_ERR_SUCCESS;
1402 }
1403
1404 _PUBLIC_ void ndr_print_USER_INFO_0_CONTAINER(struct ndr_print *ndr, const char *name, const struct USER_INFO_0_CONTAINER *r)
1405 {
1406         uint32_t cntr_user0_1;
1407         ndr_print_struct(ndr, name, "USER_INFO_0_CONTAINER");
1408         ndr->depth++;
1409         ndr_print_uint32(ndr, "entries_read", r->entries_read);
1410         ndr_print_ptr(ndr, "user0", r->user0);
1411         ndr->depth++;
1412         if (r->user0) {
1413                 ndr->print(ndr, "%s: ARRAY(%d)", "user0", r->entries_read);
1414                 ndr->depth++;
1415                 for (cntr_user0_1=0;cntr_user0_1<r->entries_read;cntr_user0_1++) {
1416                         char *idx_1=NULL;
1417                         asprintf(&idx_1, "[%d]", cntr_user0_1);
1418                         if (idx_1) {
1419                                 ndr_print_USER_INFO_0(ndr, "user0", &r->user0[cntr_user0_1]);
1420                                 free(idx_1);
1421                         }
1422                 }
1423                 ndr->depth--;
1424         }
1425         ndr->depth--;
1426         ndr->depth--;
1427 }
1428
1429 static enum ndr_err_code ndr_push_USER_INFO_1(struct ndr_push *ndr, int ndr_flags, const struct USER_INFO_1 *r)
1430 {
1431         if (ndr_flags & NDR_SCALARS) {
1432                 NDR_CHECK(ndr_push_align(ndr, 4));
1433                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
1434                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->logon_domain));
1435                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->other_domains));
1436                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->logon_server));
1437         }
1438         if (ndr_flags & NDR_BUFFERS) {
1439                 if (r->user_name) {
1440                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
1441                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1442                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
1443                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
1444                 }
1445                 if (r->logon_domain) {
1446                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->logon_domain, CH_UTF16)));
1447                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1448                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->logon_domain, CH_UTF16)));
1449                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->logon_domain, ndr_charset_length(r->logon_domain, CH_UTF16), sizeof(uint16_t), CH_UTF16));
1450                 }
1451                 if (r->other_domains) {
1452                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->other_domains, CH_UTF16)));
1453                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1454                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->other_domains, CH_UTF16)));
1455                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->other_domains, ndr_charset_length(r->other_domains, CH_UTF16), sizeof(uint16_t), CH_UTF16));
1456                 }
1457                 if (r->logon_server) {
1458                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->logon_server, CH_UTF16)));
1459                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1460                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->logon_server, CH_UTF16)));
1461                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->logon_server, ndr_charset_length(r->logon_server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
1462                 }
1463         }
1464         return NDR_ERR_SUCCESS;
1465 }
1466
1467 static enum ndr_err_code ndr_pull_USER_INFO_1(struct ndr_pull *ndr, int ndr_flags, struct USER_INFO_1 *r)
1468 {
1469         uint32_t _ptr_user_name;
1470         TALLOC_CTX *_mem_save_user_name_0;
1471         uint32_t _ptr_logon_domain;
1472         TALLOC_CTX *_mem_save_logon_domain_0;
1473         uint32_t _ptr_other_domains;
1474         TALLOC_CTX *_mem_save_other_domains_0;
1475         uint32_t _ptr_logon_server;
1476         TALLOC_CTX *_mem_save_logon_server_0;
1477         if (ndr_flags & NDR_SCALARS) {
1478                 NDR_CHECK(ndr_pull_align(ndr, 4));
1479                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
1480                 if (_ptr_user_name) {
1481                         NDR_PULL_ALLOC(ndr, r->user_name);
1482                 } else {
1483                         r->user_name = NULL;
1484                 }
1485                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_logon_domain));
1486                 if (_ptr_logon_domain) {
1487                         NDR_PULL_ALLOC(ndr, r->logon_domain);
1488                 } else {
1489                         r->logon_domain = NULL;
1490                 }
1491                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_other_domains));
1492                 if (_ptr_other_domains) {
1493                         NDR_PULL_ALLOC(ndr, r->other_domains);
1494                 } else {
1495                         r->other_domains = NULL;
1496                 }
1497                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_logon_server));
1498                 if (_ptr_logon_server) {
1499                         NDR_PULL_ALLOC(ndr, r->logon_server);
1500                 } else {
1501                         r->logon_server = NULL;
1502                 }
1503         }
1504         if (ndr_flags & NDR_BUFFERS) {
1505                 if (r->user_name) {
1506                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1507                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
1508                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
1509                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
1510                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
1511                                 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));
1512                         }
1513                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
1514                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
1515                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
1516                 }
1517                 if (r->logon_domain) {
1518                         _mem_save_logon_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
1519                         NDR_PULL_SET_MEM_CTX(ndr, r->logon_domain, 0);
1520                         NDR_CHECK(ndr_pull_array_size(ndr, &r->logon_domain));
1521                         NDR_CHECK(ndr_pull_array_length(ndr, &r->logon_domain));
1522                         if (ndr_get_array_length(ndr, &r->logon_domain) > ndr_get_array_size(ndr, &r->logon_domain)) {
1523                                 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));
1524                         }
1525                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->logon_domain), sizeof(uint16_t)));
1526                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->logon_domain, ndr_get_array_length(ndr, &r->logon_domain), sizeof(uint16_t), CH_UTF16));
1527                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_logon_domain_0, 0);
1528                 }
1529                 if (r->other_domains) {
1530                         _mem_save_other_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
1531                         NDR_PULL_SET_MEM_CTX(ndr, r->other_domains, 0);
1532                         NDR_CHECK(ndr_pull_array_size(ndr, &r->other_domains));
1533                         NDR_CHECK(ndr_pull_array_length(ndr, &r->other_domains));
1534                         if (ndr_get_array_length(ndr, &r->other_domains) > ndr_get_array_size(ndr, &r->other_domains)) {
1535                                 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));
1536                         }
1537                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->other_domains), sizeof(uint16_t)));
1538                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->other_domains, ndr_get_array_length(ndr, &r->other_domains), sizeof(uint16_t), CH_UTF16));
1539                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_other_domains_0, 0);
1540                 }
1541                 if (r->logon_server) {
1542                         _mem_save_logon_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
1543                         NDR_PULL_SET_MEM_CTX(ndr, r->logon_server, 0);
1544                         NDR_CHECK(ndr_pull_array_size(ndr, &r->logon_server));
1545                         NDR_CHECK(ndr_pull_array_length(ndr, &r->logon_server));
1546                         if (ndr_get_array_length(ndr, &r->logon_server) > ndr_get_array_size(ndr, &r->logon_server)) {
1547                                 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));
1548                         }
1549                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->logon_server), sizeof(uint16_t)));
1550                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->logon_server, ndr_get_array_length(ndr, &r->logon_server), sizeof(uint16_t), CH_UTF16));
1551                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_logon_server_0, 0);
1552                 }
1553         }
1554         return NDR_ERR_SUCCESS;
1555 }
1556
1557 _PUBLIC_ void ndr_print_USER_INFO_1(struct ndr_print *ndr, const char *name, const struct USER_INFO_1 *r)
1558 {
1559         ndr_print_struct(ndr, name, "USER_INFO_1");
1560         ndr->depth++;
1561         ndr_print_ptr(ndr, "user_name", r->user_name);
1562         ndr->depth++;
1563         if (r->user_name) {
1564                 ndr_print_string(ndr, "user_name", r->user_name);
1565         }
1566         ndr->depth--;
1567         ndr_print_ptr(ndr, "logon_domain", r->logon_domain);
1568         ndr->depth++;
1569         if (r->logon_domain) {
1570                 ndr_print_string(ndr, "logon_domain", r->logon_domain);
1571         }
1572         ndr->depth--;
1573         ndr_print_ptr(ndr, "other_domains", r->other_domains);
1574         ndr->depth++;
1575         if (r->other_domains) {
1576                 ndr_print_string(ndr, "other_domains", r->other_domains);
1577         }
1578         ndr->depth--;
1579         ndr_print_ptr(ndr, "logon_server", r->logon_server);
1580         ndr->depth++;
1581         if (r->logon_server) {
1582                 ndr_print_string(ndr, "logon_server", r->logon_server);
1583         }
1584         ndr->depth--;
1585         ndr->depth--;
1586 }
1587
1588 static enum ndr_err_code ndr_push_USER_INFO_1_CONTAINER(struct ndr_push *ndr, int ndr_flags, const struct USER_INFO_1_CONTAINER *r)
1589 {
1590         uint32_t cntr_user1_1;
1591         if (ndr_flags & NDR_SCALARS) {
1592                 NDR_CHECK(ndr_push_align(ndr, 4));
1593                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->entries_read));
1594                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user1));
1595         }
1596         if (ndr_flags & NDR_BUFFERS) {
1597                 if (r->user1) {
1598                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->entries_read));
1599                         for (cntr_user1_1 = 0; cntr_user1_1 < r->entries_read; cntr_user1_1++) {
1600                                 NDR_CHECK(ndr_push_USER_INFO_1(ndr, NDR_SCALARS, &r->user1[cntr_user1_1]));
1601                         }
1602                         for (cntr_user1_1 = 0; cntr_user1_1 < r->entries_read; cntr_user1_1++) {
1603                                 NDR_CHECK(ndr_push_USER_INFO_1(ndr, NDR_BUFFERS, &r->user1[cntr_user1_1]));
1604                         }
1605                 }
1606         }
1607         return NDR_ERR_SUCCESS;
1608 }
1609
1610 static enum ndr_err_code ndr_pull_USER_INFO_1_CONTAINER(struct ndr_pull *ndr, int ndr_flags, struct USER_INFO_1_CONTAINER *r)
1611 {
1612         uint32_t _ptr_user1;
1613         uint32_t cntr_user1_1;
1614         TALLOC_CTX *_mem_save_user1_0;
1615         TALLOC_CTX *_mem_save_user1_1;
1616         if (ndr_flags & NDR_SCALARS) {
1617                 NDR_CHECK(ndr_pull_align(ndr, 4));
1618                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->entries_read));
1619                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user1));
1620                 if (_ptr_user1) {
1621                         NDR_PULL_ALLOC(ndr, r->user1);
1622                 } else {
1623                         r->user1 = NULL;
1624                 }
1625         }
1626         if (ndr_flags & NDR_BUFFERS) {
1627                 if (r->user1) {
1628                         _mem_save_user1_0 = NDR_PULL_GET_MEM_CTX(ndr);
1629                         NDR_PULL_SET_MEM_CTX(ndr, r->user1, 0);
1630                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user1));
1631                         NDR_PULL_ALLOC_N(ndr, r->user1, ndr_get_array_size(ndr, &r->user1));
1632                         _mem_save_user1_1 = NDR_PULL_GET_MEM_CTX(ndr);
1633                         NDR_PULL_SET_MEM_CTX(ndr, r->user1, 0);
1634                         for (cntr_user1_1 = 0; cntr_user1_1 < r->entries_read; cntr_user1_1++) {
1635                                 NDR_CHECK(ndr_pull_USER_INFO_1(ndr, NDR_SCALARS, &r->user1[cntr_user1_1]));
1636                         }
1637                         for (cntr_user1_1 = 0; cntr_user1_1 < r->entries_read; cntr_user1_1++) {
1638                                 NDR_CHECK(ndr_pull_USER_INFO_1(ndr, NDR_BUFFERS, &r->user1[cntr_user1_1]));
1639                         }
1640                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user1_1, 0);
1641                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user1_0, 0);
1642                 }
1643                 if (r->user1) {
1644                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->user1, r->entries_read));
1645                 }
1646         }
1647         return NDR_ERR_SUCCESS;
1648 }
1649
1650 _PUBLIC_ void ndr_print_USER_INFO_1_CONTAINER(struct ndr_print *ndr, const char *name, const struct USER_INFO_1_CONTAINER *r)
1651 {
1652         uint32_t cntr_user1_1;
1653         ndr_print_struct(ndr, name, "USER_INFO_1_CONTAINER");
1654         ndr->depth++;
1655         ndr_print_uint32(ndr, "entries_read", r->entries_read);
1656         ndr_print_ptr(ndr, "user1", r->user1);
1657         ndr->depth++;
1658         if (r->user1) {
1659                 ndr->print(ndr, "%s: ARRAY(%d)", "user1", r->entries_read);
1660                 ndr->depth++;
1661                 for (cntr_user1_1=0;cntr_user1_1<r->entries_read;cntr_user1_1++) {
1662                         char *idx_1=NULL;
1663                         asprintf(&idx_1, "[%d]", cntr_user1_1);
1664                         if (idx_1) {
1665                                 ndr_print_USER_INFO_1(ndr, "user1", &r->user1[cntr_user1_1]);
1666                                 free(idx_1);
1667                         }
1668                 }
1669                 ndr->depth--;
1670         }
1671         ndr->depth--;
1672         ndr->depth--;
1673 }
1674
1675 static enum ndr_err_code ndr_push_WKS_USER_ENUM_UNION(struct ndr_push *ndr, int ndr_flags, const union WKS_USER_ENUM_UNION *r)
1676 {
1677         if (ndr_flags & NDR_SCALARS) {
1678                 int level = ndr_push_get_switch_value(ndr, r);
1679                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
1680                 switch (level) {
1681                         case 0:
1682                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user0));
1683                         break;
1684
1685                         case 1:
1686                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user1));
1687                         break;
1688
1689                         default:
1690                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1691                 }
1692         }
1693         if (ndr_flags & NDR_BUFFERS) {
1694                 int level = ndr_push_get_switch_value(ndr, r);
1695                 switch (level) {
1696                         case 0:
1697                                 if (r->user0) {
1698                                         NDR_CHECK(ndr_push_USER_INFO_0_CONTAINER(ndr, NDR_SCALARS|NDR_BUFFERS, r->user0));
1699                                 }
1700                         break;
1701
1702                         case 1:
1703                                 if (r->user1) {
1704                                         NDR_CHECK(ndr_push_USER_INFO_1_CONTAINER(ndr, NDR_SCALARS|NDR_BUFFERS, r->user1));
1705                                 }
1706                         break;
1707
1708                         default:
1709                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1710                 }
1711         }
1712         return NDR_ERR_SUCCESS;
1713 }
1714
1715 static enum ndr_err_code ndr_pull_WKS_USER_ENUM_UNION(struct ndr_pull *ndr, int ndr_flags, union WKS_USER_ENUM_UNION *r)
1716 {
1717         int level;
1718         uint32_t _level;
1719         TALLOC_CTX *_mem_save_user0_0;
1720         TALLOC_CTX *_mem_save_user1_0;
1721         level = ndr_pull_get_switch_value(ndr, r);
1722         if (ndr_flags & NDR_SCALARS) {
1723                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
1724                 if (_level != level) {
1725                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1726                 }
1727                 switch (level) {
1728                         case 0: {
1729                                 uint32_t _ptr_user0;
1730                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user0));
1731                                 if (_ptr_user0) {
1732                                         NDR_PULL_ALLOC(ndr, r->user0);
1733                                 } else {
1734                                         r->user0 = NULL;
1735                                 }
1736                         break; }
1737
1738                         case 1: {
1739                                 uint32_t _ptr_user1;
1740                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user1));
1741                                 if (_ptr_user1) {
1742                                         NDR_PULL_ALLOC(ndr, r->user1);
1743                                 } else {
1744                                         r->user1 = NULL;
1745                                 }
1746                         break; }
1747
1748                         default:
1749                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1750                 }
1751         }
1752         if (ndr_flags & NDR_BUFFERS) {
1753                 switch (level) {
1754                         case 0:
1755                                 if (r->user0) {
1756                                         _mem_save_user0_0 = NDR_PULL_GET_MEM_CTX(ndr);
1757                                         NDR_PULL_SET_MEM_CTX(ndr, r->user0, 0);
1758                                         NDR_CHECK(ndr_pull_USER_INFO_0_CONTAINER(ndr, NDR_SCALARS|NDR_BUFFERS, r->user0));
1759                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user0_0, 0);
1760                                 }
1761                         break;
1762
1763                         case 1:
1764                                 if (r->user1) {
1765                                         _mem_save_user1_0 = NDR_PULL_GET_MEM_CTX(ndr);
1766                                         NDR_PULL_SET_MEM_CTX(ndr, r->user1, 0);
1767                                         NDR_CHECK(ndr_pull_USER_INFO_1_CONTAINER(ndr, NDR_SCALARS|NDR_BUFFERS, r->user1));
1768                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user1_0, 0);
1769                                 }
1770                         break;
1771
1772                         default:
1773                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1774                 }
1775         }
1776         return NDR_ERR_SUCCESS;
1777 }
1778
1779 _PUBLIC_ void ndr_print_WKS_USER_ENUM_UNION(struct ndr_print *ndr, const char *name, const union WKS_USER_ENUM_UNION *r)
1780 {
1781         int level;
1782         level = ndr_print_get_switch_value(ndr, r);
1783         ndr_print_union(ndr, name, level, "WKS_USER_ENUM_UNION");
1784         switch (level) {
1785                 case 0:
1786                         ndr_print_ptr(ndr, "user0", r->user0);
1787                         ndr->depth++;
1788                         if (r->user0) {
1789                                 ndr_print_USER_INFO_0_CONTAINER(ndr, "user0", r->user0);
1790                         }
1791                         ndr->depth--;
1792                 break;
1793
1794                 case 1:
1795                         ndr_print_ptr(ndr, "user1", r->user1);
1796                         ndr->depth++;
1797                         if (r->user1) {
1798                                 ndr_print_USER_INFO_1_CONTAINER(ndr, "user1", r->user1);
1799                         }
1800                         ndr->depth--;
1801                 break;
1802
1803                 default:
1804                         ndr_print_bad_level(ndr, name, level);
1805         }
1806 }
1807
1808 static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportInfo0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaTransportInfo0 *r)
1809 {
1810         if (ndr_flags & NDR_SCALARS) {
1811                 NDR_CHECK(ndr_push_align(ndr, 4));
1812                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->quality_of_service));
1813                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->vc_count));
1814                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
1815                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->address));
1816                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->wan_link));
1817         }
1818         if (ndr_flags & NDR_BUFFERS) {
1819                 if (r->name) {
1820                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
1821                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1822                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
1823                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
1824                 }
1825                 if (r->address) {
1826                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->address, CH_UTF16)));
1827                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1828                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->address, CH_UTF16)));
1829                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->address, ndr_charset_length(r->address, CH_UTF16), sizeof(uint16_t), CH_UTF16));
1830                 }
1831         }
1832         return NDR_ERR_SUCCESS;
1833 }
1834
1835 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportInfo0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaTransportInfo0 *r)
1836 {
1837         uint32_t _ptr_name;
1838         TALLOC_CTX *_mem_save_name_0;
1839         uint32_t _ptr_address;
1840         TALLOC_CTX *_mem_save_address_0;
1841         if (ndr_flags & NDR_SCALARS) {
1842                 NDR_CHECK(ndr_pull_align(ndr, 4));
1843                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->quality_of_service));
1844                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->vc_count));
1845                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
1846                 if (_ptr_name) {
1847                         NDR_PULL_ALLOC(ndr, r->name);
1848                 } else {
1849                         r->name = NULL;
1850                 }
1851                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_address));
1852                 if (_ptr_address) {
1853                         NDR_PULL_ALLOC(ndr, r->address);
1854                 } else {
1855                         r->address = NULL;
1856                 }
1857                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->wan_link));
1858         }
1859         if (ndr_flags & NDR_BUFFERS) {
1860                 if (r->name) {
1861                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1862                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
1863                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
1864                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
1865                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
1866                                 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));
1867                         }
1868                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
1869                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
1870                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
1871                 }
1872                 if (r->address) {
1873                         _mem_save_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
1874                         NDR_PULL_SET_MEM_CTX(ndr, r->address, 0);
1875                         NDR_CHECK(ndr_pull_array_size(ndr, &r->address));
1876                         NDR_CHECK(ndr_pull_array_length(ndr, &r->address));
1877                         if (ndr_get_array_length(ndr, &r->address) > ndr_get_array_size(ndr, &r->address)) {
1878                                 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));
1879                         }
1880                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->address), sizeof(uint16_t)));
1881                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->address, ndr_get_array_length(ndr, &r->address), sizeof(uint16_t), CH_UTF16));
1882                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_address_0, 0);
1883                 }
1884         }
1885         return NDR_ERR_SUCCESS;
1886 }
1887
1888 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportInfo0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaTransportInfo0 *r)
1889 {
1890         ndr_print_struct(ndr, name, "wkssvc_NetWkstaTransportInfo0");
1891         ndr->depth++;
1892         ndr_print_uint32(ndr, "quality_of_service", r->quality_of_service);
1893         ndr_print_uint32(ndr, "vc_count", r->vc_count);
1894         ndr_print_ptr(ndr, "name", r->name);
1895         ndr->depth++;
1896         if (r->name) {
1897                 ndr_print_string(ndr, "name", r->name);
1898         }
1899         ndr->depth--;
1900         ndr_print_ptr(ndr, "address", r->address);
1901         ndr->depth++;
1902         if (r->address) {
1903                 ndr_print_string(ndr, "address", r->address);
1904         }
1905         ndr->depth--;
1906         ndr_print_uint32(ndr, "wan_link", r->wan_link);
1907         ndr->depth--;
1908 }
1909
1910 static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportCtr0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaTransportCtr0 *r)
1911 {
1912         uint32_t cntr_array_1;
1913         if (ndr_flags & NDR_SCALARS) {
1914                 NDR_CHECK(ndr_push_align(ndr, 4));
1915                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1916                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
1917         }
1918         if (ndr_flags & NDR_BUFFERS) {
1919                 if (r->array) {
1920                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1921                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
1922                                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
1923                         }
1924                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
1925                                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
1926                         }
1927                 }
1928         }
1929         return NDR_ERR_SUCCESS;
1930 }
1931
1932 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportCtr0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaTransportCtr0 *r)
1933 {
1934         uint32_t _ptr_array;
1935         uint32_t cntr_array_1;
1936         TALLOC_CTX *_mem_save_array_0;
1937         TALLOC_CTX *_mem_save_array_1;
1938         if (ndr_flags & NDR_SCALARS) {
1939                 NDR_CHECK(ndr_pull_align(ndr, 4));
1940                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1941                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
1942                 if (_ptr_array) {
1943                         NDR_PULL_ALLOC(ndr, r->array);
1944                 } else {
1945                         r->array = NULL;
1946                 }
1947         }
1948         if (ndr_flags & NDR_BUFFERS) {
1949                 if (r->array) {
1950                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
1951                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
1952                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
1953                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
1954                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
1955                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
1956                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
1957                                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
1958                         }
1959                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
1960                                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
1961                         }
1962                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
1963                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
1964                 }
1965                 if (r->array) {
1966                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
1967                 }
1968         }
1969         return NDR_ERR_SUCCESS;
1970 }
1971
1972 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportCtr0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaTransportCtr0 *r)
1973 {
1974         uint32_t cntr_array_1;
1975         ndr_print_struct(ndr, name, "wkssvc_NetWkstaTransportCtr0");
1976         ndr->depth++;
1977         ndr_print_uint32(ndr, "count", r->count);
1978         ndr_print_ptr(ndr, "array", r->array);
1979         ndr->depth++;
1980         if (r->array) {
1981                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
1982                 ndr->depth++;
1983                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
1984                         char *idx_1=NULL;
1985                         asprintf(&idx_1, "[%d]", cntr_array_1);
1986                         if (idx_1) {
1987                                 ndr_print_wkssvc_NetWkstaTransportInfo0(ndr, "array", &r->array[cntr_array_1]);
1988                                 free(idx_1);
1989                         }
1990                 }
1991                 ndr->depth--;
1992         }
1993         ndr->depth--;
1994         ndr->depth--;
1995 }
1996
1997 static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportCtr(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetWkstaTransportCtr *r)
1998 {
1999         if (ndr_flags & NDR_SCALARS) {
2000                 int level = ndr_push_get_switch_value(ndr, r);
2001                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
2002                 switch (level) {
2003                         case 0:
2004                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
2005                         break;
2006
2007                         default:
2008                         break;
2009
2010                 }
2011         }
2012         if (ndr_flags & NDR_BUFFERS) {
2013                 int level = ndr_push_get_switch_value(ndr, r);
2014                 switch (level) {
2015                         case 0:
2016                                 if (r->ctr0) {
2017                                         NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
2018                                 }
2019                         break;
2020
2021                         default:
2022                         break;
2023
2024                 }
2025         }
2026         return NDR_ERR_SUCCESS;
2027 }
2028
2029 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportCtr(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetWkstaTransportCtr *r)
2030 {
2031         int level;
2032         uint32_t _level;
2033         TALLOC_CTX *_mem_save_ctr0_0;
2034         level = ndr_pull_get_switch_value(ndr, r);
2035         if (ndr_flags & NDR_SCALARS) {
2036                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
2037                 if (_level != level) {
2038                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
2039                 }
2040                 switch (level) {
2041                         case 0: {
2042                                 uint32_t _ptr_ctr0;
2043                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));
2044                                 if (_ptr_ctr0) {
2045                                         NDR_PULL_ALLOC(ndr, r->ctr0);
2046                                 } else {
2047                                         r->ctr0 = NULL;
2048                                 }
2049                         break; }
2050
2051                         default: {
2052                         break; }
2053
2054                 }
2055         }
2056         if (ndr_flags & NDR_BUFFERS) {
2057                 switch (level) {
2058                         case 0:
2059                                 if (r->ctr0) {
2060                                         _mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);
2061                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr0, 0);
2062                                         NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
2063                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);
2064                                 }
2065                         break;
2066
2067                         default:
2068                         break;
2069
2070                 }
2071         }
2072         return NDR_ERR_SUCCESS;
2073 }
2074
2075 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportCtr(struct ndr_print *ndr, const char *name, const union wkssvc_NetWkstaTransportCtr *r)
2076 {
2077         int level;
2078         level = ndr_print_get_switch_value(ndr, r);
2079         ndr_print_union(ndr, name, level, "wkssvc_NetWkstaTransportCtr");
2080         switch (level) {
2081                 case 0:
2082                         ndr_print_ptr(ndr, "ctr0", r->ctr0);
2083                         ndr->depth++;
2084                         if (r->ctr0) {
2085                                 ndr_print_wkssvc_NetWkstaTransportCtr0(ndr, "ctr0", r->ctr0);
2086                         }
2087                         ndr->depth--;
2088                 break;
2089
2090                 default:
2091                 break;
2092
2093         }
2094 }
2095
2096 static enum ndr_err_code ndr_push_wkssvc_PasswordBuffer(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_PasswordBuffer *r)
2097 {
2098         if (ndr_flags & NDR_SCALARS) {
2099                 NDR_CHECK(ndr_push_align(ndr, 1));
2100                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, 524));
2101         }
2102         if (ndr_flags & NDR_BUFFERS) {
2103         }
2104         return NDR_ERR_SUCCESS;
2105 }
2106
2107 static enum ndr_err_code ndr_pull_wkssvc_PasswordBuffer(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_PasswordBuffer *r)
2108 {
2109         if (ndr_flags & NDR_SCALARS) {
2110                 NDR_CHECK(ndr_pull_align(ndr, 1));
2111                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, 524));
2112         }
2113         if (ndr_flags & NDR_BUFFERS) {
2114         }
2115         return NDR_ERR_SUCCESS;
2116 }
2117
2118 _PUBLIC_ void ndr_print_wkssvc_PasswordBuffer(struct ndr_print *ndr, const char *name, const struct wkssvc_PasswordBuffer *r)
2119 {
2120         ndr_print_struct(ndr, name, "wkssvc_PasswordBuffer");
2121         ndr->depth++;
2122         ndr_print_array_uint8(ndr, "data", r->data, 524);
2123         ndr->depth--;
2124 }
2125
2126 static enum ndr_err_code ndr_push_wkssvc_joinflags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2127 {
2128         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2129         return NDR_ERR_SUCCESS;
2130 }
2131
2132 static enum ndr_err_code ndr_pull_wkssvc_joinflags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2133 {
2134         uint32_t v;
2135         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2136         *r = v;
2137         return NDR_ERR_SUCCESS;
2138 }
2139
2140 _PUBLIC_ void ndr_print_wkssvc_joinflags(struct ndr_print *ndr, const char *name, uint32_t r)
2141 {
2142         ndr_print_uint32(ndr, name, r);
2143         ndr->depth++;
2144         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_DEFER_SPN", WKSSVC_JOIN_FLAGS_DEFER_SPN, r);
2145         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_MACHINE_PWD_PASSED", WKSSVC_JOIN_FLAGS_MACHINE_PWD_PASSED, r);
2146         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_JOIN_UNSECURE", WKSSVC_JOIN_FLAGS_JOIN_UNSECURE, r);
2147         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_DOMAIN_JOIN_IF_JOINED", WKSSVC_JOIN_FLAGS_DOMAIN_JOIN_IF_JOINED, r);
2148         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_WIN9X_UPGRADE", WKSSVC_JOIN_FLAGS_WIN9X_UPGRADE, r);
2149         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_ACCOUNT_DELETE", WKSSVC_JOIN_FLAGS_ACCOUNT_DELETE, r);
2150         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE", WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE, r);
2151         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_JOIN_TYPE", WKSSVC_JOIN_FLAGS_JOIN_TYPE, r);
2152         ndr->depth--;
2153 }
2154
2155 static enum ndr_err_code ndr_push_wkssvc_renameflags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2156 {
2157         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2158         return NDR_ERR_SUCCESS;
2159 }
2160
2161 static enum ndr_err_code ndr_pull_wkssvc_renameflags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2162 {
2163         uint32_t v;
2164         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2165         *r = v;
2166         return NDR_ERR_SUCCESS;
2167 }
2168
2169 _PUBLIC_ void ndr_print_wkssvc_renameflags(struct ndr_print *ndr, const char *name, uint32_t r)
2170 {
2171         ndr_print_uint32(ndr, name, r);
2172         ndr->depth++;
2173         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE", WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE, r);
2174         ndr->depth--;
2175 }
2176
2177 static enum ndr_err_code ndr_push_wkssvc_NetWkstaGetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaGetInfo *r)
2178 {
2179         if (flags & NDR_IN) {
2180                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
2181                 if (r->in.server_name) {
2182                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
2183                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2184                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
2185                         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));
2186                 }
2187                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
2188         }
2189         if (flags & NDR_OUT) {
2190                 if (r->out.info == NULL) {
2191                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2192                 }
2193                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
2194                 NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
2195                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2196         }
2197         return NDR_ERR_SUCCESS;
2198 }
2199
2200 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaGetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaGetInfo *r)
2201 {
2202         uint32_t _ptr_server_name;
2203         TALLOC_CTX *_mem_save_server_name_0;
2204         TALLOC_CTX *_mem_save_info_0;
2205         if (flags & NDR_IN) {
2206                 ZERO_STRUCT(r->out);
2207
2208                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
2209                 if (_ptr_server_name) {
2210                         NDR_PULL_ALLOC(ndr, r->in.server_name);
2211                 } else {
2212                         r->in.server_name = NULL;
2213                 }
2214                 if (r->in.server_name) {
2215                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2216                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
2217                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
2218                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
2219                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
2220                                 return 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));
2221                         }
2222                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
2223                         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));
2224                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
2225                 }
2226                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
2227                 NDR_PULL_ALLOC(ndr, r->out.info);
2228                 ZERO_STRUCTP(r->out.info);
2229         }
2230         if (flags & NDR_OUT) {
2231                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2232                         NDR_PULL_ALLOC(ndr, r->out.info);
2233                 }
2234                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
2235                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
2236                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
2237                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
2238                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
2239                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2240         }
2241         return NDR_ERR_SUCCESS;
2242 }
2243
2244 _PUBLIC_ void ndr_print_wkssvc_NetWkstaGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaGetInfo *r)
2245 {
2246         ndr_print_struct(ndr, name, "wkssvc_NetWkstaGetInfo");
2247         ndr->depth++;
2248         if (flags & NDR_SET_VALUES) {
2249                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2250         }
2251         if (flags & NDR_IN) {
2252                 ndr_print_struct(ndr, "in", "wkssvc_NetWkstaGetInfo");
2253                 ndr->depth++;
2254                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
2255                 ndr->depth++;
2256                 if (r->in.server_name) {
2257                         ndr_print_string(ndr, "server_name", r->in.server_name);
2258                 }
2259                 ndr->depth--;
2260                 ndr_print_uint32(ndr, "level", r->in.level);
2261                 ndr->depth--;
2262         }
2263         if (flags & NDR_OUT) {
2264                 ndr_print_struct(ndr, "out", "wkssvc_NetWkstaGetInfo");
2265                 ndr->depth++;
2266                 ndr_print_ptr(ndr, "info", r->out.info);
2267                 ndr->depth++;
2268                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
2269                 ndr_print_wkssvc_NetWkstaInfo(ndr, "info", r->out.info);
2270                 ndr->depth--;
2271                 ndr_print_WERROR(ndr, "result", r->out.result);
2272                 ndr->depth--;
2273         }
2274         ndr->depth--;
2275 }
2276
2277 static enum ndr_err_code ndr_push_wkssvc_NetWkstaSetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaSetInfo *r)
2278 {
2279         if (flags & NDR_IN) {
2280                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
2281                 if (r->in.server_name) {
2282                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
2283                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2284                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
2285                         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));
2286                 }
2287                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
2288                 if (r->in.info == NULL) {
2289                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2290                 }
2291                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
2292                 NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
2293                 if (r->in.parm_error == NULL) {
2294                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2295                 }
2296                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_error));
2297         }
2298         if (flags & NDR_OUT) {
2299                 if (r->out.parm_error == NULL) {
2300                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2301                 }
2302                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_error));
2303                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2304         }
2305         return NDR_ERR_SUCCESS;
2306 }
2307
2308 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaSetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaSetInfo *r)
2309 {
2310         uint32_t _ptr_server_name;
2311         TALLOC_CTX *_mem_save_server_name_0;
2312         TALLOC_CTX *_mem_save_info_0;
2313         TALLOC_CTX *_mem_save_parm_error_0;
2314         if (flags & NDR_IN) {
2315                 ZERO_STRUCT(r->out);
2316
2317                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
2318                 if (_ptr_server_name) {
2319                         NDR_PULL_ALLOC(ndr, r->in.server_name);
2320                 } else {
2321                         r->in.server_name = NULL;
2322                 }
2323                 if (r->in.server_name) {
2324                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2325                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
2326                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
2327                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
2328                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
2329                                 return 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));
2330                         }
2331                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
2332                         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));
2333                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
2334                 }
2335                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
2336                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2337                         NDR_PULL_ALLOC(ndr, r->in.info);
2338                 }
2339                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
2340                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
2341                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
2342                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
2343                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
2344                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2345                         NDR_PULL_ALLOC(ndr, r->in.parm_error);
2346                 }
2347                 _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
2348                 NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_error, LIBNDR_FLAG_REF_ALLOC);
2349                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_error));
2350                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, LIBNDR_FLAG_REF_ALLOC);
2351                 NDR_PULL_ALLOC(ndr, r->out.parm_error);
2352                 *r->out.parm_error = *r->in.parm_error;
2353         }
2354         if (flags & NDR_OUT) {
2355                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2356                         NDR_PULL_ALLOC(ndr, r->out.parm_error);
2357                 }
2358                 _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
2359                 NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_error, LIBNDR_FLAG_REF_ALLOC);
2360                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_error));
2361                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, LIBNDR_FLAG_REF_ALLOC);
2362                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2363         }
2364         return NDR_ERR_SUCCESS;
2365 }
2366
2367 _PUBLIC_ void ndr_print_wkssvc_NetWkstaSetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaSetInfo *r)
2368 {
2369         ndr_print_struct(ndr, name, "wkssvc_NetWkstaSetInfo");
2370         ndr->depth++;
2371         if (flags & NDR_SET_VALUES) {
2372                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2373         }
2374         if (flags & NDR_IN) {
2375                 ndr_print_struct(ndr, "in", "wkssvc_NetWkstaSetInfo");
2376                 ndr->depth++;
2377                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
2378                 ndr->depth++;
2379                 if (r->in.server_name) {
2380                         ndr_print_string(ndr, "server_name", r->in.server_name);
2381                 }
2382                 ndr->depth--;
2383                 ndr_print_uint32(ndr, "level", r->in.level);
2384                 ndr_print_ptr(ndr, "info", r->in.info);
2385                 ndr->depth++;
2386                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
2387                 ndr_print_wkssvc_NetWkstaInfo(ndr, "info", r->in.info);
2388                 ndr->depth--;
2389                 ndr_print_ptr(ndr, "parm_error", r->in.parm_error);
2390                 ndr->depth++;
2391                 ndr_print_uint32(ndr, "parm_error", *r->in.parm_error);
2392                 ndr->depth--;
2393                 ndr->depth--;
2394         }
2395         if (flags & NDR_OUT) {
2396                 ndr_print_struct(ndr, "out", "wkssvc_NetWkstaSetInfo");
2397                 ndr->depth++;
2398                 ndr_print_ptr(ndr, "parm_error", r->out.parm_error);
2399                 ndr->depth++;
2400                 ndr_print_uint32(ndr, "parm_error", *r->out.parm_error);
2401                 ndr->depth--;
2402                 ndr_print_WERROR(ndr, "result", r->out.result);
2403                 ndr->depth--;
2404         }
2405         ndr->depth--;
2406 }
2407
2408 static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsers(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaEnumUsers *r)
2409 {
2410         if (flags & NDR_IN) {
2411                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
2412                 if (r->in.server_name) {
2413                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
2414                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2415                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
2416                         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));
2417                 }
2418                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
2419                 if (r->in.users == NULL) {
2420                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2421                 }
2422                 NDR_CHECK(ndr_push_WKS_USER_ENUM_UNION(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.users));
2423                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.prefmaxlen));
2424                 if (r->in.resumehandle == NULL) {
2425                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2426                 }
2427                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resumehandle));
2428         }
2429         if (flags & NDR_OUT) {
2430                 if (r->out.users == NULL) {
2431                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2432                 }
2433                 NDR_CHECK(ndr_push_WKS_USER_ENUM_UNION(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.users));
2434                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.entriesread));
2435                 if (r->out.entriesread) {
2436                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.entriesread));
2437                 }
2438                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.totalentries));
2439                 if (r->out.totalentries) {
2440                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
2441                 }
2442                 if (r->out.resumehandle == NULL) {
2443                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2444                 }
2445                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resumehandle));
2446                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2447         }
2448         return NDR_ERR_SUCCESS;
2449 }
2450
2451 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsers(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaEnumUsers *r)
2452 {
2453         uint32_t _ptr_server_name;
2454         uint32_t _ptr_entriesread;
2455         uint32_t _ptr_totalentries;
2456         TALLOC_CTX *_mem_save_server_name_0;
2457         TALLOC_CTX *_mem_save_users_0;
2458         TALLOC_CTX *_mem_save_entriesread_0;
2459         TALLOC_CTX *_mem_save_totalentries_0;
2460         TALLOC_CTX *_mem_save_resumehandle_0;
2461         if (flags & NDR_IN) {
2462                 ZERO_STRUCT(r->out);
2463
2464                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
2465                 if (_ptr_server_name) {
2466                         NDR_PULL_ALLOC(ndr, r->in.server_name);
2467                 } else {
2468                         r->in.server_name = NULL;
2469                 }
2470                 if (r->in.server_name) {
2471                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2472                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
2473                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
2474                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
2475                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
2476                                 return 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));
2477                         }
2478                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
2479                         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));
2480                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
2481                 }
2482                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
2483                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2484                         NDR_PULL_ALLOC(ndr, r->in.users);
2485                 }
2486                 _mem_save_users_0 = NDR_PULL_GET_MEM_CTX(ndr);
2487                 NDR_PULL_SET_MEM_CTX(ndr, r->in.users, LIBNDR_FLAG_REF_ALLOC);
2488                 NDR_CHECK(ndr_pull_WKS_USER_ENUM_UNION(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.users));
2489                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_users_0, LIBNDR_FLAG_REF_ALLOC);
2490                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.prefmaxlen));
2491                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2492                         NDR_PULL_ALLOC(ndr, r->in.resumehandle);
2493                 }
2494                 _mem_save_resumehandle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2495                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resumehandle, LIBNDR_FLAG_REF_ALLOC);
2496                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resumehandle));
2497                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resumehandle_0, LIBNDR_FLAG_REF_ALLOC);
2498                 NDR_PULL_ALLOC(ndr, r->out.users);
2499                 *r->out.users = *r->in.users;
2500                 NDR_PULL_ALLOC(ndr, r->out.resumehandle);
2501                 *r->out.resumehandle = *r->in.resumehandle;
2502         }
2503         if (flags & NDR_OUT) {
2504                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2505                         NDR_PULL_ALLOC(ndr, r->out.users);
2506                 }
2507                 _mem_save_users_0 = NDR_PULL_GET_MEM_CTX(ndr);
2508                 NDR_PULL_SET_MEM_CTX(ndr, r->out.users, LIBNDR_FLAG_REF_ALLOC);
2509                 NDR_CHECK(ndr_pull_WKS_USER_ENUM_UNION(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.users));
2510                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_users_0, LIBNDR_FLAG_REF_ALLOC);
2511                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entriesread));
2512                 if (_ptr_entriesread) {
2513                         NDR_PULL_ALLOC(ndr, r->out.entriesread);
2514                 } else {
2515                         r->out.entriesread = NULL;
2516                 }
2517                 if (r->out.entriesread) {
2518                         _mem_save_entriesread_0 = NDR_PULL_GET_MEM_CTX(ndr);
2519                         NDR_PULL_SET_MEM_CTX(ndr, r->out.entriesread, 0);
2520                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.entriesread));
2521                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entriesread_0, 0);
2522                 }
2523                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_totalentries));
2524                 if (_ptr_totalentries) {
2525                         NDR_PULL_ALLOC(ndr, r->out.totalentries);
2526                 } else {
2527                         r->out.totalentries = NULL;
2528                 }
2529                 if (r->out.totalentries) {
2530                         _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
2531                         NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, 0);
2532                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
2533                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, 0);
2534                 }
2535                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2536                         NDR_PULL_ALLOC(ndr, r->out.resumehandle);
2537                 }
2538                 _mem_save_resumehandle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2539                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resumehandle, LIBNDR_FLAG_REF_ALLOC);
2540                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resumehandle));
2541                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resumehandle_0, LIBNDR_FLAG_REF_ALLOC);
2542                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2543         }
2544         return NDR_ERR_SUCCESS;
2545 }
2546
2547 _PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsers(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaEnumUsers *r)
2548 {
2549         ndr_print_struct(ndr, name, "wkssvc_NetWkstaEnumUsers");
2550         ndr->depth++;
2551         if (flags & NDR_SET_VALUES) {
2552                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2553         }
2554         if (flags & NDR_IN) {
2555                 ndr_print_struct(ndr, "in", "wkssvc_NetWkstaEnumUsers");
2556                 ndr->depth++;
2557                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
2558                 ndr->depth++;
2559                 if (r->in.server_name) {
2560                         ndr_print_string(ndr, "server_name", r->in.server_name);
2561                 }
2562                 ndr->depth--;
2563                 ndr_print_uint32(ndr, "level", r->in.level);
2564                 ndr_print_ptr(ndr, "users", r->in.users);
2565                 ndr->depth++;
2566                 ndr_print_WKS_USER_ENUM_UNION(ndr, "users", r->in.users);
2567                 ndr->depth--;
2568                 ndr_print_uint32(ndr, "prefmaxlen", r->in.prefmaxlen);
2569                 ndr_print_ptr(ndr, "resumehandle", r->in.resumehandle);
2570                 ndr->depth++;
2571                 ndr_print_uint32(ndr, "resumehandle", *r->in.resumehandle);
2572                 ndr->depth--;
2573                 ndr->depth--;
2574         }
2575         if (flags & NDR_OUT) {
2576                 ndr_print_struct(ndr, "out", "wkssvc_NetWkstaEnumUsers");
2577                 ndr->depth++;
2578                 ndr_print_ptr(ndr, "users", r->out.users);
2579                 ndr->depth++;
2580                 ndr_print_WKS_USER_ENUM_UNION(ndr, "users", r->out.users);
2581                 ndr->depth--;
2582                 ndr_print_ptr(ndr, "entriesread", r->out.entriesread);
2583                 ndr->depth++;
2584                 if (r->out.entriesread) {
2585                         ndr_print_uint32(ndr, "entriesread", *r->out.entriesread);
2586                 }
2587                 ndr->depth--;
2588                 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
2589                 ndr->depth++;
2590                 if (r->out.totalentries) {
2591                         ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
2592                 }
2593                 ndr->depth--;
2594                 ndr_print_ptr(ndr, "resumehandle", r->out.resumehandle);
2595                 ndr->depth++;
2596                 ndr_print_uint32(ndr, "resumehandle", *r->out.resumehandle);
2597                 ndr->depth--;
2598                 ndr_print_WERROR(ndr, "result", r->out.result);
2599                 ndr->depth--;
2600         }
2601         ndr->depth--;
2602 }
2603
2604 static enum ndr_err_code ndr_push_WKSSVC_NETRWKSTAUSERGETINFO(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRWKSTAUSERGETINFO *r)
2605 {
2606         if (flags & NDR_IN) {
2607         }
2608         if (flags & NDR_OUT) {
2609                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2610         }
2611         return NDR_ERR_SUCCESS;
2612 }
2613
2614 static enum ndr_err_code ndr_pull_WKSSVC_NETRWKSTAUSERGETINFO(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRWKSTAUSERGETINFO *r)
2615 {
2616         if (flags & NDR_IN) {
2617         }
2618         if (flags & NDR_OUT) {
2619                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2620         }
2621         return NDR_ERR_SUCCESS;
2622 }
2623
2624 _PUBLIC_ void ndr_print_WKSSVC_NETRWKSTAUSERGETINFO(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRWKSTAUSERGETINFO *r)
2625 {
2626         ndr_print_struct(ndr, name, "WKSSVC_NETRWKSTAUSERGETINFO");
2627         ndr->depth++;
2628         if (flags & NDR_SET_VALUES) {
2629                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2630         }
2631         if (flags & NDR_IN) {
2632                 ndr_print_struct(ndr, "in", "WKSSVC_NETRWKSTAUSERGETINFO");
2633                 ndr->depth++;
2634                 ndr->depth--;
2635         }
2636         if (flags & NDR_OUT) {
2637                 ndr_print_struct(ndr, "out", "WKSSVC_NETRWKSTAUSERGETINFO");
2638                 ndr->depth++;
2639                 ndr_print_WERROR(ndr, "result", r->out.result);
2640                 ndr->depth--;
2641         }
2642         ndr->depth--;
2643 }
2644
2645 static enum ndr_err_code ndr_push_WKSSVC_NETRWKSTAUSERSETINFO(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRWKSTAUSERSETINFO *r)
2646 {
2647         if (flags & NDR_IN) {
2648         }
2649         if (flags & NDR_OUT) {
2650                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2651         }
2652         return NDR_ERR_SUCCESS;
2653 }
2654
2655 static enum ndr_err_code ndr_pull_WKSSVC_NETRWKSTAUSERSETINFO(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRWKSTAUSERSETINFO *r)
2656 {
2657         if (flags & NDR_IN) {
2658         }
2659         if (flags & NDR_OUT) {
2660                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2661         }
2662         return NDR_ERR_SUCCESS;
2663 }
2664
2665 _PUBLIC_ void ndr_print_WKSSVC_NETRWKSTAUSERSETINFO(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRWKSTAUSERSETINFO *r)
2666 {
2667         ndr_print_struct(ndr, name, "WKSSVC_NETRWKSTAUSERSETINFO");
2668         ndr->depth++;
2669         if (flags & NDR_SET_VALUES) {
2670                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2671         }
2672         if (flags & NDR_IN) {
2673                 ndr_print_struct(ndr, "in", "WKSSVC_NETRWKSTAUSERSETINFO");
2674                 ndr->depth++;
2675                 ndr->depth--;
2676         }
2677         if (flags & NDR_OUT) {
2678                 ndr_print_struct(ndr, "out", "WKSSVC_NETRWKSTAUSERSETINFO");
2679                 ndr->depth++;
2680                 ndr_print_WERROR(ndr, "result", r->out.result);
2681                 ndr->depth--;
2682         }
2683         ndr->depth--;
2684 }
2685
2686 static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportEnum(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaTransportEnum *r)
2687 {
2688         if (flags & NDR_IN) {
2689                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
2690                 if (r->in.server_name) {
2691                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
2692                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2693                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
2694                         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));
2695                 }
2696                 if (r->in.level == NULL) {
2697                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2698                 }
2699                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.level));
2700                 if (r->in.ctr == NULL) {
2701                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2702                 }
2703                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.ctr, *r->in.level));
2704                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
2705                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));
2706                 if (r->in.resume_handle == NULL) {
2707                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2708                 }
2709                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
2710         }
2711         if (flags & NDR_OUT) {
2712                 if (r->out.level == NULL) {
2713                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2714                 }
2715                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level));
2716                 if (r->out.ctr == NULL) {
2717                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2718                 }
2719                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level));
2720                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
2721                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.totalentries));
2722                 if (r->out.totalentries) {
2723                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
2724                 }
2725                 if (r->out.resume_handle == NULL) {
2726                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2727                 }
2728                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
2729                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2730         }
2731         return NDR_ERR_SUCCESS;
2732 }
2733
2734 static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportEnum(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaTransportEnum *r)
2735 {
2736         uint32_t _ptr_server_name;
2737         uint32_t _ptr_totalentries;
2738         TALLOC_CTX *_mem_save_server_name_0;
2739         TALLOC_CTX *_mem_save_level_0;
2740         TALLOC_CTX *_mem_save_ctr_0;
2741         TALLOC_CTX *_mem_save_totalentries_0;
2742         TALLOC_CTX *_mem_save_resume_handle_0;
2743         if (flags & NDR_IN) {
2744                 ZERO_STRUCT(r->out);
2745
2746                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
2747                 if (_ptr_server_name) {
2748                         NDR_PULL_ALLOC(ndr, r->in.server_name);
2749                 } else {
2750                         r->in.server_name = NULL;
2751                 }
2752                 if (r->in.server_name) {
2753                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2754                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
2755                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
2756                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
2757                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
2758                                 return 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));
2759                         }
2760                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
2761                         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));
2762                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
2763                 }
2764                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2765                         NDR_PULL_ALLOC(ndr, r->in.level);
2766                 }
2767                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
2768                 NDR_PULL_SET_MEM_CTX(ndr, r->in.level, LIBNDR_FLAG_REF_ALLOC);
2769                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.level));
2770                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
2771                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2772                         NDR_PULL_ALLOC(ndr, r->in.ctr);
2773                 }
2774                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
2775                 NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, LIBNDR_FLAG_REF_ALLOC);
2776                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.ctr, *r->in.level));
2777                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
2778                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
2779                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));
2780                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2781                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
2782                 }
2783                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2784                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
2785                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
2786                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
2787                 NDR_PULL_ALLOC(ndr, r->out.level);
2788                 *r->out.level = *r->in.level;
2789                 NDR_PULL_ALLOC(ndr, r->out.ctr);
2790                 *r->out.ctr = *r->in.ctr;
2791                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
2792                 *r->out.resume_handle = *r->in.resume_handle;
2793         }
2794         if (flags & NDR_OUT) {
2795                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2796                         NDR_PULL_ALLOC(ndr, r->out.level);
2797                 }
2798                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
2799                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level, LIBNDR_FLAG_REF_ALLOC);
2800                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level));
2801                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
2802                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2803                         NDR_PULL_ALLOC(ndr, r->out.ctr);
2804                 }
2805                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
2806                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
2807                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level));
2808                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
2809                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
2810                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_totalentries));
2811                 if (_ptr_totalentries) {
2812                         NDR_PULL_ALLOC(ndr, r->out.totalentries);
2813                 } else {
2814                         r->out.totalentries = NULL;
2815                 }
2816                 if (r->out.totalentries) {
2817                         _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
2818                         NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, 0);
2819                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
2820                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, 0);
2821                 }
2822                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2823                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
2824                 }
2825                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2826                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
2827                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
2828                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
2829                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2830         }
2831         return NDR_ERR_SUCCESS;
2832 }
2833
2834 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportEnum(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaTransportEnum *r)
2835 {
2836         ndr_print_struct(ndr, name, "wkssvc_NetWkstaTransportEnum");
2837         ndr->depth++;
2838         if (flags & NDR_SET_VALUES) {
2839                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2840         }
2841         if (flags & NDR_IN) {
2842                 ndr_print_struct(ndr, "in", "wkssvc_NetWkstaTransportEnum");
2843                 ndr->depth++;
2844                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
2845                 ndr->depth++;
2846                 if (r->in.server_name) {
2847                         ndr_print_string(ndr, "server_name", r->in.server_name);
2848                 }
2849                 ndr->depth--;
2850                 ndr_print_ptr(ndr, "level", r->in.level);
2851                 ndr->depth++;
2852                 ndr_print_uint32(ndr, "level", *r->in.level);
2853                 ndr->depth--;
2854                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
2855                 ndr->depth++;
2856                 ndr_print_set_switch_value(ndr, r->in.ctr, *r->in.level);
2857                 ndr_print_wkssvc_NetWkstaTransportCtr(ndr, "ctr", r->in.ctr);
2858                 ndr->depth--;
2859                 ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);
2860                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
2861                 ndr->depth++;
2862                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
2863                 ndr->depth--;
2864                 ndr->depth--;
2865         }
2866         if (flags & NDR_OUT) {
2867                 ndr_print_struct(ndr, "out", "wkssvc_NetWkstaTransportEnum");
2868                 ndr->depth++;
2869                 ndr_print_ptr(ndr, "level", r->out.level);
2870                 ndr->depth++;
2871                 ndr_print_uint32(ndr, "level", *r->out.level);
2872                 ndr->depth--;
2873                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
2874                 ndr->depth++;
2875                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level);
2876                 ndr_print_wkssvc_NetWkstaTransportCtr(ndr, "ctr", r->out.ctr);
2877                 ndr->depth--;
2878                 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
2879                 ndr->depth++;
2880                 if (r->out.totalentries) {
2881                         ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
2882                 }
2883                 ndr->depth--;
2884                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
2885                 ndr->depth++;
2886                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
2887                 ndr->depth--;
2888                 ndr_print_WERROR(ndr, "result", r->out.result);
2889                 ndr->depth--;
2890         }
2891         ndr->depth--;
2892 }
2893
2894 static enum ndr_err_code ndr_push_WKSSVC_NETRWKSTATRANSPORTADD(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRWKSTATRANSPORTADD *r)
2895 {
2896         if (flags & NDR_IN) {
2897         }
2898         if (flags & NDR_OUT) {
2899                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2900         }
2901         return NDR_ERR_SUCCESS;
2902 }
2903
2904 static enum ndr_err_code ndr_pull_WKSSVC_NETRWKSTATRANSPORTADD(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRWKSTATRANSPORTADD *r)
2905 {
2906         if (flags & NDR_IN) {
2907         }
2908         if (flags & NDR_OUT) {
2909                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2910         }
2911         return NDR_ERR_SUCCESS;
2912 }
2913
2914 _PUBLIC_ void ndr_print_WKSSVC_NETRWKSTATRANSPORTADD(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRWKSTATRANSPORTADD *r)
2915 {
2916         ndr_print_struct(ndr, name, "WKSSVC_NETRWKSTATRANSPORTADD");
2917         ndr->depth++;
2918         if (flags & NDR_SET_VALUES) {
2919                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2920         }
2921         if (flags & NDR_IN) {
2922                 ndr_print_struct(ndr, "in", "WKSSVC_NETRWKSTATRANSPORTADD");
2923                 ndr->depth++;
2924                 ndr->depth--;
2925         }
2926         if (flags & NDR_OUT) {
2927                 ndr_print_struct(ndr, "out", "WKSSVC_NETRWKSTATRANSPORTADD");
2928                 ndr->depth++;
2929                 ndr_print_WERROR(ndr, "result", r->out.result);
2930                 ndr->depth--;
2931         }
2932         ndr->depth--;
2933 }
2934
2935 static enum ndr_err_code ndr_push_WKSSVC_NETRWKSTATRANSPORTDEL(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRWKSTATRANSPORTDEL *r)
2936 {
2937         if (flags & NDR_IN) {
2938         }
2939         if (flags & NDR_OUT) {
2940                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2941         }
2942         return NDR_ERR_SUCCESS;
2943 }
2944
2945 static enum ndr_err_code ndr_pull_WKSSVC_NETRWKSTATRANSPORTDEL(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRWKSTATRANSPORTDEL *r)
2946 {
2947         if (flags & NDR_IN) {
2948         }
2949         if (flags & NDR_OUT) {
2950                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2951         }
2952         return NDR_ERR_SUCCESS;
2953 }
2954
2955 _PUBLIC_ void ndr_print_WKSSVC_NETRWKSTATRANSPORTDEL(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRWKSTATRANSPORTDEL *r)
2956 {
2957         ndr_print_struct(ndr, name, "WKSSVC_NETRWKSTATRANSPORTDEL");
2958         ndr->depth++;
2959         if (flags & NDR_SET_VALUES) {
2960                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2961         }
2962         if (flags & NDR_IN) {
2963                 ndr_print_struct(ndr, "in", "WKSSVC_NETRWKSTATRANSPORTDEL");
2964                 ndr->depth++;
2965                 ndr->depth--;
2966         }
2967         if (flags & NDR_OUT) {
2968                 ndr_print_struct(ndr, "out", "WKSSVC_NETRWKSTATRANSPORTDEL");
2969                 ndr->depth++;
2970                 ndr_print_WERROR(ndr, "result", r->out.result);
2971                 ndr->depth--;
2972         }
2973         ndr->depth--;
2974 }
2975
2976 static enum ndr_err_code ndr_push_WKSSVC_NETRUSEADD(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRUSEADD *r)
2977 {
2978         if (flags & NDR_IN) {
2979         }
2980         if (flags & NDR_OUT) {
2981                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2982         }
2983         return NDR_ERR_SUCCESS;
2984 }
2985
2986 static enum ndr_err_code ndr_pull_WKSSVC_NETRUSEADD(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRUSEADD *r)
2987 {
2988         if (flags & NDR_IN) {
2989         }
2990         if (flags & NDR_OUT) {
2991                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2992         }
2993         return NDR_ERR_SUCCESS;
2994 }
2995
2996 _PUBLIC_ void ndr_print_WKSSVC_NETRUSEADD(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRUSEADD *r)
2997 {
2998         ndr_print_struct(ndr, name, "WKSSVC_NETRUSEADD");
2999         ndr->depth++;
3000         if (flags & NDR_SET_VALUES) {
3001                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3002         }
3003         if (flags & NDR_IN) {
3004                 ndr_print_struct(ndr, "in", "WKSSVC_NETRUSEADD");
3005                 ndr->depth++;
3006                 ndr->depth--;
3007         }
3008         if (flags & NDR_OUT) {
3009                 ndr_print_struct(ndr, "out", "WKSSVC_NETRUSEADD");
3010                 ndr->depth++;
3011                 ndr_print_WERROR(ndr, "result", r->out.result);
3012                 ndr->depth--;
3013         }
3014         ndr->depth--;
3015 }
3016
3017 static enum ndr_err_code ndr_push_WKSSVC_NETRUSEGETINFO(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRUSEGETINFO *r)
3018 {
3019         if (flags & NDR_IN) {
3020         }
3021         if (flags & NDR_OUT) {
3022                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3023         }
3024         return NDR_ERR_SUCCESS;
3025 }
3026
3027 static enum ndr_err_code ndr_pull_WKSSVC_NETRUSEGETINFO(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRUSEGETINFO *r)
3028 {
3029         if (flags & NDR_IN) {
3030         }
3031         if (flags & NDR_OUT) {
3032                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3033         }
3034         return NDR_ERR_SUCCESS;
3035 }
3036
3037 _PUBLIC_ void ndr_print_WKSSVC_NETRUSEGETINFO(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRUSEGETINFO *r)
3038 {
3039         ndr_print_struct(ndr, name, "WKSSVC_NETRUSEGETINFO");
3040         ndr->depth++;
3041         if (flags & NDR_SET_VALUES) {
3042                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3043         }
3044         if (flags & NDR_IN) {
3045                 ndr_print_struct(ndr, "in", "WKSSVC_NETRUSEGETINFO");
3046                 ndr->depth++;
3047                 ndr->depth--;
3048         }
3049         if (flags & NDR_OUT) {
3050                 ndr_print_struct(ndr, "out", "WKSSVC_NETRUSEGETINFO");
3051                 ndr->depth++;
3052                 ndr_print_WERROR(ndr, "result", r->out.result);
3053                 ndr->depth--;
3054         }
3055         ndr->depth--;
3056 }
3057
3058 static enum ndr_err_code ndr_push_WKSSVC_NETRUSEDEL(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRUSEDEL *r)
3059 {
3060         if (flags & NDR_IN) {
3061         }
3062         if (flags & NDR_OUT) {
3063                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3064         }
3065         return NDR_ERR_SUCCESS;
3066 }
3067
3068 static enum ndr_err_code ndr_pull_WKSSVC_NETRUSEDEL(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRUSEDEL *r)
3069 {
3070         if (flags & NDR_IN) {
3071         }
3072         if (flags & NDR_OUT) {
3073                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3074         }
3075         return NDR_ERR_SUCCESS;
3076 }
3077
3078 _PUBLIC_ void ndr_print_WKSSVC_NETRUSEDEL(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRUSEDEL *r)
3079 {
3080         ndr_print_struct(ndr, name, "WKSSVC_NETRUSEDEL");
3081         ndr->depth++;
3082         if (flags & NDR_SET_VALUES) {
3083                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3084         }
3085         if (flags & NDR_IN) {
3086                 ndr_print_struct(ndr, "in", "WKSSVC_NETRUSEDEL");
3087                 ndr->depth++;
3088                 ndr->depth--;
3089         }
3090         if (flags & NDR_OUT) {
3091                 ndr_print_struct(ndr, "out", "WKSSVC_NETRUSEDEL");
3092                 ndr->depth++;
3093                 ndr_print_WERROR(ndr, "result", r->out.result);
3094                 ndr->depth--;
3095         }
3096         ndr->depth--;
3097 }
3098
3099 static enum ndr_err_code ndr_push_WKSSVC_NETRUSEENUM(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRUSEENUM *r)
3100 {
3101         if (flags & NDR_IN) {
3102         }
3103         if (flags & NDR_OUT) {
3104                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3105         }
3106         return NDR_ERR_SUCCESS;
3107 }
3108
3109 static enum ndr_err_code ndr_pull_WKSSVC_NETRUSEENUM(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRUSEENUM *r)
3110 {
3111         if (flags & NDR_IN) {
3112         }
3113         if (flags & NDR_OUT) {
3114                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3115         }
3116         return NDR_ERR_SUCCESS;
3117 }
3118
3119 _PUBLIC_ void ndr_print_WKSSVC_NETRUSEENUM(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRUSEENUM *r)
3120 {
3121         ndr_print_struct(ndr, name, "WKSSVC_NETRUSEENUM");
3122         ndr->depth++;
3123         if (flags & NDR_SET_VALUES) {
3124                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3125         }
3126         if (flags & NDR_IN) {
3127                 ndr_print_struct(ndr, "in", "WKSSVC_NETRUSEENUM");
3128                 ndr->depth++;
3129                 ndr->depth--;
3130         }
3131         if (flags & NDR_OUT) {
3132                 ndr_print_struct(ndr, "out", "WKSSVC_NETRUSEENUM");
3133                 ndr->depth++;
3134                 ndr_print_WERROR(ndr, "result", r->out.result);
3135                 ndr->depth--;
3136         }
3137         ndr->depth--;
3138 }
3139
3140 static enum ndr_err_code ndr_push_WKSSVC_NETRMESSAGEBUFFERSEND(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRMESSAGEBUFFERSEND *r)
3141 {
3142         if (flags & NDR_IN) {
3143         }
3144         if (flags & NDR_OUT) {
3145                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3146         }
3147         return NDR_ERR_SUCCESS;
3148 }
3149
3150 static enum ndr_err_code ndr_pull_WKSSVC_NETRMESSAGEBUFFERSEND(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRMESSAGEBUFFERSEND *r)
3151 {
3152         if (flags & NDR_IN) {
3153         }
3154         if (flags & NDR_OUT) {
3155                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3156         }
3157         return NDR_ERR_SUCCESS;
3158 }
3159
3160 _PUBLIC_ void ndr_print_WKSSVC_NETRMESSAGEBUFFERSEND(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRMESSAGEBUFFERSEND *r)
3161 {
3162         ndr_print_struct(ndr, name, "WKSSVC_NETRMESSAGEBUFFERSEND");
3163         ndr->depth++;
3164         if (flags & NDR_SET_VALUES) {
3165                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3166         }
3167         if (flags & NDR_IN) {
3168                 ndr_print_struct(ndr, "in", "WKSSVC_NETRMESSAGEBUFFERSEND");
3169                 ndr->depth++;
3170                 ndr->depth--;
3171         }
3172         if (flags & NDR_OUT) {
3173                 ndr_print_struct(ndr, "out", "WKSSVC_NETRMESSAGEBUFFERSEND");
3174                 ndr->depth++;
3175                 ndr_print_WERROR(ndr, "result", r->out.result);
3176                 ndr->depth--;
3177         }
3178         ndr->depth--;
3179 }
3180
3181 static enum ndr_err_code ndr_push_WKSSVC_NETRWORKSTATIONSTATISTICSGET(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRWORKSTATIONSTATISTICSGET *r)
3182 {
3183         if (flags & NDR_IN) {
3184         }
3185         if (flags & NDR_OUT) {
3186                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3187         }
3188         return NDR_ERR_SUCCESS;
3189 }
3190
3191 static enum ndr_err_code ndr_pull_WKSSVC_NETRWORKSTATIONSTATISTICSGET(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRWORKSTATIONSTATISTICSGET *r)
3192 {
3193         if (flags & NDR_IN) {
3194         }
3195         if (flags & NDR_OUT) {
3196                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3197         }
3198         return NDR_ERR_SUCCESS;
3199 }
3200
3201 _PUBLIC_ void ndr_print_WKSSVC_NETRWORKSTATIONSTATISTICSGET(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRWORKSTATIONSTATISTICSGET *r)
3202 {
3203         ndr_print_struct(ndr, name, "WKSSVC_NETRWORKSTATIONSTATISTICSGET");
3204         ndr->depth++;
3205         if (flags & NDR_SET_VALUES) {
3206                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3207         }
3208         if (flags & NDR_IN) {
3209                 ndr_print_struct(ndr, "in", "WKSSVC_NETRWORKSTATIONSTATISTICSGET");
3210                 ndr->depth++;
3211                 ndr->depth--;
3212         }
3213         if (flags & NDR_OUT) {
3214                 ndr_print_struct(ndr, "out", "WKSSVC_NETRWORKSTATIONSTATISTICSGET");
3215                 ndr->depth++;
3216                 ndr_print_WERROR(ndr, "result", r->out.result);
3217                 ndr->depth--;
3218         }
3219         ndr->depth--;
3220 }
3221
3222 static enum ndr_err_code ndr_push_WKSSVC_NETRLOGONDOMAINNAMEADD(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRLOGONDOMAINNAMEADD *r)
3223 {
3224         if (flags & NDR_IN) {
3225         }
3226         if (flags & NDR_OUT) {
3227                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3228         }
3229         return NDR_ERR_SUCCESS;
3230 }
3231
3232 static enum ndr_err_code ndr_pull_WKSSVC_NETRLOGONDOMAINNAMEADD(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRLOGONDOMAINNAMEADD *r)
3233 {
3234         if (flags & NDR_IN) {
3235         }
3236         if (flags & NDR_OUT) {
3237                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3238         }
3239         return NDR_ERR_SUCCESS;
3240 }
3241
3242 _PUBLIC_ void ndr_print_WKSSVC_NETRLOGONDOMAINNAMEADD(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRLOGONDOMAINNAMEADD *r)
3243 {
3244         ndr_print_struct(ndr, name, "WKSSVC_NETRLOGONDOMAINNAMEADD");
3245         ndr->depth++;
3246         if (flags & NDR_SET_VALUES) {
3247                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3248         }
3249         if (flags & NDR_IN) {
3250                 ndr_print_struct(ndr, "in", "WKSSVC_NETRLOGONDOMAINNAMEADD");
3251                 ndr->depth++;
3252                 ndr->depth--;
3253         }
3254         if (flags & NDR_OUT) {
3255                 ndr_print_struct(ndr, "out", "WKSSVC_NETRLOGONDOMAINNAMEADD");
3256                 ndr->depth++;
3257                 ndr_print_WERROR(ndr, "result", r->out.result);
3258                 ndr->depth--;
3259         }
3260         ndr->depth--;
3261 }
3262
3263 static enum ndr_err_code ndr_push_WKSSVC_NETRLOGONDOMAINNAMEDEL(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRLOGONDOMAINNAMEDEL *r)
3264 {
3265         if (flags & NDR_IN) {
3266         }
3267         if (flags & NDR_OUT) {
3268                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3269         }
3270         return NDR_ERR_SUCCESS;
3271 }
3272
3273 static enum ndr_err_code ndr_pull_WKSSVC_NETRLOGONDOMAINNAMEDEL(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRLOGONDOMAINNAMEDEL *r)
3274 {
3275         if (flags & NDR_IN) {
3276         }
3277         if (flags & NDR_OUT) {
3278                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3279         }
3280         return NDR_ERR_SUCCESS;
3281 }
3282
3283 _PUBLIC_ void ndr_print_WKSSVC_NETRLOGONDOMAINNAMEDEL(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRLOGONDOMAINNAMEDEL *r)
3284 {
3285         ndr_print_struct(ndr, name, "WKSSVC_NETRLOGONDOMAINNAMEDEL");
3286         ndr->depth++;
3287         if (flags & NDR_SET_VALUES) {
3288                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3289         }
3290         if (flags & NDR_IN) {
3291                 ndr_print_struct(ndr, "in", "WKSSVC_NETRLOGONDOMAINNAMEDEL");
3292                 ndr->depth++;
3293                 ndr->depth--;
3294         }
3295         if (flags & NDR_OUT) {
3296                 ndr_print_struct(ndr, "out", "WKSSVC_NETRLOGONDOMAINNAMEDEL");
3297                 ndr->depth++;
3298                 ndr_print_WERROR(ndr, "result", r->out.result);
3299                 ndr->depth--;
3300         }
3301         ndr->depth--;
3302 }
3303
3304 static enum ndr_err_code ndr_push_WKSSVC_NETRJOINDOMAIN(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRJOINDOMAIN *r)
3305 {
3306         if (flags & NDR_IN) {
3307         }
3308         if (flags & NDR_OUT) {
3309                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3310         }
3311         return NDR_ERR_SUCCESS;
3312 }
3313
3314 static enum ndr_err_code ndr_pull_WKSSVC_NETRJOINDOMAIN(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRJOINDOMAIN *r)
3315 {
3316         if (flags & NDR_IN) {
3317         }
3318         if (flags & NDR_OUT) {
3319                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3320         }
3321         return NDR_ERR_SUCCESS;
3322 }
3323
3324 _PUBLIC_ void ndr_print_WKSSVC_NETRJOINDOMAIN(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRJOINDOMAIN *r)
3325 {
3326         ndr_print_struct(ndr, name, "WKSSVC_NETRJOINDOMAIN");
3327         ndr->depth++;
3328         if (flags & NDR_SET_VALUES) {
3329                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3330         }
3331         if (flags & NDR_IN) {
3332                 ndr_print_struct(ndr, "in", "WKSSVC_NETRJOINDOMAIN");
3333                 ndr->depth++;
3334                 ndr->depth--;
3335         }
3336         if (flags & NDR_OUT) {
3337                 ndr_print_struct(ndr, "out", "WKSSVC_NETRJOINDOMAIN");
3338                 ndr->depth++;
3339                 ndr_print_WERROR(ndr, "result", r->out.result);
3340                 ndr->depth--;
3341         }
3342         ndr->depth--;
3343 }
3344
3345 static enum ndr_err_code ndr_push_WKSSVC_NETRUNJOINDOMAIN(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRUNJOINDOMAIN *r)
3346 {
3347         if (flags & NDR_IN) {
3348         }
3349         if (flags & NDR_OUT) {
3350                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3351         }
3352         return NDR_ERR_SUCCESS;
3353 }
3354
3355 static enum ndr_err_code ndr_pull_WKSSVC_NETRUNJOINDOMAIN(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRUNJOINDOMAIN *r)
3356 {
3357         if (flags & NDR_IN) {
3358         }
3359         if (flags & NDR_OUT) {
3360                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3361         }
3362         return NDR_ERR_SUCCESS;
3363 }
3364
3365 _PUBLIC_ void ndr_print_WKSSVC_NETRUNJOINDOMAIN(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRUNJOINDOMAIN *r)
3366 {
3367         ndr_print_struct(ndr, name, "WKSSVC_NETRUNJOINDOMAIN");
3368         ndr->depth++;
3369         if (flags & NDR_SET_VALUES) {
3370                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3371         }
3372         if (flags & NDR_IN) {
3373                 ndr_print_struct(ndr, "in", "WKSSVC_NETRUNJOINDOMAIN");
3374                 ndr->depth++;
3375                 ndr->depth--;
3376         }
3377         if (flags & NDR_OUT) {
3378                 ndr_print_struct(ndr, "out", "WKSSVC_NETRUNJOINDOMAIN");
3379                 ndr->depth++;
3380                 ndr_print_WERROR(ndr, "result", r->out.result);
3381                 ndr->depth--;
3382         }
3383         ndr->depth--;
3384 }
3385
3386 static enum ndr_err_code ndr_push_WKSSVC_NETRRENAMEMACHINEINDOMAIN(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRRENAMEMACHINEINDOMAIN *r)
3387 {
3388         if (flags & NDR_IN) {
3389         }
3390         if (flags & NDR_OUT) {
3391                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3392         }
3393         return NDR_ERR_SUCCESS;
3394 }
3395
3396 static enum ndr_err_code ndr_pull_WKSSVC_NETRRENAMEMACHINEINDOMAIN(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRRENAMEMACHINEINDOMAIN *r)
3397 {
3398         if (flags & NDR_IN) {
3399         }
3400         if (flags & NDR_OUT) {
3401                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3402         }
3403         return NDR_ERR_SUCCESS;
3404 }
3405
3406 _PUBLIC_ void ndr_print_WKSSVC_NETRRENAMEMACHINEINDOMAIN(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRRENAMEMACHINEINDOMAIN *r)
3407 {
3408         ndr_print_struct(ndr, name, "WKSSVC_NETRRENAMEMACHINEINDOMAIN");
3409         ndr->depth++;
3410         if (flags & NDR_SET_VALUES) {
3411                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3412         }
3413         if (flags & NDR_IN) {
3414                 ndr_print_struct(ndr, "in", "WKSSVC_NETRRENAMEMACHINEINDOMAIN");
3415                 ndr->depth++;
3416                 ndr->depth--;
3417         }
3418         if (flags & NDR_OUT) {
3419                 ndr_print_struct(ndr, "out", "WKSSVC_NETRRENAMEMACHINEINDOMAIN");
3420                 ndr->depth++;
3421                 ndr_print_WERROR(ndr, "result", r->out.result);
3422                 ndr->depth--;
3423         }
3424         ndr->depth--;
3425 }
3426
3427 static enum ndr_err_code ndr_push_WKSSVC_NETRVALIDATENAME(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRVALIDATENAME *r)
3428 {
3429         if (flags & NDR_IN) {
3430         }
3431         if (flags & NDR_OUT) {
3432                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3433         }
3434         return NDR_ERR_SUCCESS;
3435 }
3436
3437 static enum ndr_err_code ndr_pull_WKSSVC_NETRVALIDATENAME(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRVALIDATENAME *r)
3438 {
3439         if (flags & NDR_IN) {
3440         }
3441         if (flags & NDR_OUT) {
3442                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3443         }
3444         return NDR_ERR_SUCCESS;
3445 }
3446
3447 _PUBLIC_ void ndr_print_WKSSVC_NETRVALIDATENAME(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRVALIDATENAME *r)
3448 {
3449         ndr_print_struct(ndr, name, "WKSSVC_NETRVALIDATENAME");
3450         ndr->depth++;
3451         if (flags & NDR_SET_VALUES) {
3452                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3453         }
3454         if (flags & NDR_IN) {
3455                 ndr_print_struct(ndr, "in", "WKSSVC_NETRVALIDATENAME");
3456                 ndr->depth++;
3457                 ndr->depth--;
3458         }
3459         if (flags & NDR_OUT) {
3460                 ndr_print_struct(ndr, "out", "WKSSVC_NETRVALIDATENAME");
3461                 ndr->depth++;
3462                 ndr_print_WERROR(ndr, "result", r->out.result);
3463                 ndr->depth--;
3464         }
3465         ndr->depth--;
3466 }
3467
3468 static enum ndr_err_code ndr_push_WKSSVC_NETRGETJOININFORMATION(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRGETJOININFORMATION *r)
3469 {
3470         if (flags & NDR_IN) {
3471         }
3472         if (flags & NDR_OUT) {
3473                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3474         }
3475         return NDR_ERR_SUCCESS;
3476 }
3477
3478 static enum ndr_err_code ndr_pull_WKSSVC_NETRGETJOININFORMATION(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRGETJOININFORMATION *r)
3479 {
3480         if (flags & NDR_IN) {
3481         }
3482         if (flags & NDR_OUT) {
3483                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3484         }
3485         return NDR_ERR_SUCCESS;
3486 }
3487
3488 _PUBLIC_ void ndr_print_WKSSVC_NETRGETJOININFORMATION(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRGETJOININFORMATION *r)
3489 {
3490         ndr_print_struct(ndr, name, "WKSSVC_NETRGETJOININFORMATION");
3491         ndr->depth++;
3492         if (flags & NDR_SET_VALUES) {
3493                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3494         }
3495         if (flags & NDR_IN) {
3496                 ndr_print_struct(ndr, "in", "WKSSVC_NETRGETJOININFORMATION");
3497                 ndr->depth++;
3498                 ndr->depth--;
3499         }
3500         if (flags & NDR_OUT) {
3501                 ndr_print_struct(ndr, "out", "WKSSVC_NETRGETJOININFORMATION");
3502                 ndr->depth++;
3503                 ndr_print_WERROR(ndr, "result", r->out.result);
3504                 ndr->depth--;
3505         }
3506         ndr->depth--;
3507 }
3508
3509 static enum ndr_err_code ndr_push_WKSSVC_NETRGETJOINABLEOUS(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRGETJOINABLEOUS *r)
3510 {
3511         if (flags & NDR_IN) {
3512         }
3513         if (flags & NDR_OUT) {
3514                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3515         }
3516         return NDR_ERR_SUCCESS;
3517 }
3518
3519 static enum ndr_err_code ndr_pull_WKSSVC_NETRGETJOINABLEOUS(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRGETJOINABLEOUS *r)
3520 {
3521         if (flags & NDR_IN) {
3522         }
3523         if (flags & NDR_OUT) {
3524                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3525         }
3526         return NDR_ERR_SUCCESS;
3527 }
3528
3529 _PUBLIC_ void ndr_print_WKSSVC_NETRGETJOINABLEOUS(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRGETJOINABLEOUS *r)
3530 {
3531         ndr_print_struct(ndr, name, "WKSSVC_NETRGETJOINABLEOUS");
3532         ndr->depth++;
3533         if (flags & NDR_SET_VALUES) {
3534                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3535         }
3536         if (flags & NDR_IN) {
3537                 ndr_print_struct(ndr, "in", "WKSSVC_NETRGETJOINABLEOUS");
3538                 ndr->depth++;
3539                 ndr->depth--;
3540         }
3541         if (flags & NDR_OUT) {
3542                 ndr_print_struct(ndr, "out", "WKSSVC_NETRGETJOINABLEOUS");
3543                 ndr->depth++;
3544                 ndr_print_WERROR(ndr, "result", r->out.result);
3545                 ndr->depth--;
3546         }
3547         ndr->depth--;
3548 }
3549
3550 static enum ndr_err_code ndr_push_wkssvc_NetrJoinDomain2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrJoinDomain2 *r)
3551 {
3552         if (flags & NDR_IN) {
3553                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
3554                 if (r->in.server_name) {
3555                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
3556                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3557                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
3558                         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));
3559                 }
3560                 if (r->in.domain_name == NULL) {
3561                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3562                 }
3563                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
3564                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3565                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
3566                 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));
3567                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.account_name));
3568                 if (r->in.account_name) {
3569                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account_name, CH_UTF16)));
3570                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3571                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account_name, CH_UTF16)));
3572                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.account_name, ndr_charset_length(r->in.account_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3573                 }
3574                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.admin_account));
3575                 if (r->in.admin_account) {
3576                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.admin_account, CH_UTF16)));
3577                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3578                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.admin_account, CH_UTF16)));
3579                         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));
3580                 }
3581                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.encrypted_password));
3582                 if (r->in.encrypted_password) {
3583                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));
3584                 }
3585                 NDR_CHECK(ndr_push_wkssvc_joinflags(ndr, NDR_SCALARS, r->in.join_flags));
3586         }
3587         if (flags & NDR_OUT) {
3588                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3589         }
3590         return NDR_ERR_SUCCESS;
3591 }
3592
3593 static enum ndr_err_code ndr_pull_wkssvc_NetrJoinDomain2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrJoinDomain2 *r)
3594 {
3595         uint32_t _ptr_server_name;
3596         uint32_t _ptr_account_name;
3597         uint32_t _ptr_admin_account;
3598         uint32_t _ptr_encrypted_password;
3599         TALLOC_CTX *_mem_save_server_name_0;
3600         TALLOC_CTX *_mem_save_account_name_0;
3601         TALLOC_CTX *_mem_save_admin_account_0;
3602         TALLOC_CTX *_mem_save_encrypted_password_0;
3603         if (flags & NDR_IN) {
3604                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3605                 if (_ptr_server_name) {
3606                         NDR_PULL_ALLOC(ndr, r->in.server_name);
3607                 } else {
3608                         r->in.server_name = NULL;
3609                 }
3610                 if (r->in.server_name) {
3611                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3612                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
3613                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
3614                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
3615                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
3616                                 return 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));
3617                         }
3618                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
3619                         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));
3620                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3621                 }
3622                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
3623                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
3624                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
3625                         return 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));
3626                 }
3627                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
3628                 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));
3629                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account_name));
3630                 if (_ptr_account_name) {
3631                         NDR_PULL_ALLOC(ndr, r->in.account_name);
3632                 } else {
3633                         r->in.account_name = NULL;
3634                 }
3635                 if (r->in.account_name) {
3636                         _mem_save_account_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3637                         NDR_PULL_SET_MEM_CTX(ndr, r->in.account_name, 0);
3638                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.account_name));
3639                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.account_name));
3640                         if (ndr_get_array_length(ndr, &r->in.account_name) > ndr_get_array_size(ndr, &r->in.account_name)) {
3641                                 return 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_name), ndr_get_array_length(ndr, &r->in.account_name));
3642                         }
3643                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.account_name), sizeof(uint16_t)));
3644                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.account_name, ndr_get_array_length(ndr, &r->in.account_name), sizeof(uint16_t), CH_UTF16));
3645                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_0, 0);
3646                 }
3647                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_admin_account));
3648                 if (_ptr_admin_account) {
3649                         NDR_PULL_ALLOC(ndr, r->in.admin_account);
3650                 } else {
3651                         r->in.admin_account = NULL;
3652                 }
3653                 if (r->in.admin_account) {
3654                         _mem_save_admin_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
3655                         NDR_PULL_SET_MEM_CTX(ndr, r->in.admin_account, 0);
3656                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.admin_account));
3657                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.admin_account));
3658                         if (ndr_get_array_length(ndr, &r->in.admin_account) > ndr_get_array_size(ndr, &r->in.admin_account)) {
3659                                 return 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));
3660                         }
3661                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.admin_account), sizeof(uint16_t)));
3662                         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));
3663                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_admin_account_0, 0);
3664                 }
3665                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_encrypted_password));
3666                 if (_ptr_encrypted_password) {
3667                         NDR_PULL_ALLOC(ndr, r->in.encrypted_password);
3668                 } else {
3669                         r->in.encrypted_password = NULL;
3670                 }
3671                 if (r->in.encrypted_password) {
3672                         _mem_save_encrypted_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
3673                         NDR_PULL_SET_MEM_CTX(ndr, r->in.encrypted_password, 0);
3674                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));
3675                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_encrypted_password_0, 0);
3676                 }
3677                 NDR_CHECK(ndr_pull_wkssvc_joinflags(ndr, NDR_SCALARS, &r->in.join_flags));
3678         }
3679         if (flags & NDR_OUT) {
3680                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3681         }
3682         return NDR_ERR_SUCCESS;
3683 }
3684
3685 _PUBLIC_ void ndr_print_wkssvc_NetrJoinDomain2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrJoinDomain2 *r)
3686 {
3687         ndr_print_struct(ndr, name, "wkssvc_NetrJoinDomain2");
3688         ndr->depth++;
3689         if (flags & NDR_SET_VALUES) {
3690                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3691         }
3692         if (flags & NDR_IN) {
3693                 ndr_print_struct(ndr, "in", "wkssvc_NetrJoinDomain2");
3694                 ndr->depth++;
3695                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
3696                 ndr->depth++;
3697                 if (r->in.server_name) {
3698                         ndr_print_string(ndr, "server_name", r->in.server_name);
3699                 }
3700                 ndr->depth--;
3701                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
3702                 ndr->depth++;
3703                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
3704                 ndr->depth--;
3705                 ndr_print_ptr(ndr, "account_name", r->in.account_name);
3706                 ndr->depth++;
3707                 if (r->in.account_name) {
3708                         ndr_print_string(ndr, "account_name", r->in.account_name);
3709                 }
3710                 ndr->depth--;
3711                 ndr_print_ptr(ndr, "admin_account", r->in.admin_account);
3712                 ndr->depth++;
3713                 if (r->in.admin_account) {
3714                         ndr_print_string(ndr, "admin_account", r->in.admin_account);
3715                 }
3716                 ndr->depth--;
3717                 ndr_print_ptr(ndr, "encrypted_password", r->in.encrypted_password);
3718                 ndr->depth++;
3719                 if (r->in.encrypted_password) {
3720                         ndr_print_wkssvc_PasswordBuffer(ndr, "encrypted_password", r->in.encrypted_password);
3721                 }
3722                 ndr->depth--;
3723                 ndr_print_wkssvc_joinflags(ndr, "join_flags", r->in.join_flags);
3724                 ndr->depth--;
3725         }
3726         if (flags & NDR_OUT) {
3727                 ndr_print_struct(ndr, "out", "wkssvc_NetrJoinDomain2");
3728                 ndr->depth++;
3729                 ndr_print_WERROR(ndr, "result", r->out.result);
3730                 ndr->depth--;
3731         }
3732         ndr->depth--;
3733 }
3734
3735 static enum ndr_err_code ndr_push_wkssvc_NetrUnjoinDomain2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUnjoinDomain2 *r)
3736 {
3737         if (flags & NDR_IN) {
3738                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
3739                 if (r->in.server_name) {
3740                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
3741                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3742                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
3743                         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));
3744                 }
3745                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.account));
3746                 if (r->in.account) {
3747                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account, CH_UTF16)));
3748                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3749                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account, CH_UTF16)));
3750                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.account, ndr_charset_length(r->in.account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3751                 }
3752                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.encrypted_password));
3753                 if (r->in.encrypted_password) {
3754                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));
3755                 }
3756                 NDR_CHECK(ndr_push_wkssvc_joinflags(ndr, NDR_SCALARS, r->in.unjoin_flags));
3757         }
3758         if (flags & NDR_OUT) {
3759                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3760         }
3761         return NDR_ERR_SUCCESS;
3762 }
3763
3764 static enum ndr_err_code ndr_pull_wkssvc_NetrUnjoinDomain2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUnjoinDomain2 *r)
3765 {
3766         uint32_t _ptr_server_name;
3767         uint32_t _ptr_account;
3768         uint32_t _ptr_encrypted_password;
3769         TALLOC_CTX *_mem_save_server_name_0;
3770         TALLOC_CTX *_mem_save_account_0;
3771         TALLOC_CTX *_mem_save_encrypted_password_0;
3772         if (flags & NDR_IN) {
3773                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3774                 if (_ptr_server_name) {
3775                         NDR_PULL_ALLOC(ndr, r->in.server_name);
3776                 } else {
3777                         r->in.server_name = NULL;
3778                 }
3779                 if (r->in.server_name) {
3780                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3781                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
3782                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
3783                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
3784                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
3785                                 return 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));
3786                         }
3787                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
3788                         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));
3789                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3790                 }
3791                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account));
3792                 if (_ptr_account) {
3793                         NDR_PULL_ALLOC(ndr, r->in.account);
3794                 } else {
3795                         r->in.account = NULL;
3796                 }
3797                 if (r->in.account) {
3798                         _mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
3799                         NDR_PULL_SET_MEM_CTX(ndr, r->in.account, 0);
3800                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.account));
3801                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.account));
3802                         if (ndr_get_array_length(ndr, &r->in.account) > ndr_get_array_size(ndr, &r->in.account)) {
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->in.account), ndr_get_array_length(ndr, &r->in.account));
3804                         }
3805                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.account), sizeof(uint16_t)));
3806                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.account, ndr_get_array_length(ndr, &r->in.account), sizeof(uint16_t), CH_UTF16));
3807                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, 0);
3808                 }
3809                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_encrypted_password));
3810                 if (_ptr_encrypted_password) {
3811                         NDR_PULL_ALLOC(ndr, r->in.encrypted_password);
3812                 } else {
3813                         r->in.encrypted_password = NULL;
3814                 }
3815                 if (r->in.encrypted_password) {
3816                         _mem_save_encrypted_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
3817                         NDR_PULL_SET_MEM_CTX(ndr, r->in.encrypted_password, 0);
3818                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));
3819                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_encrypted_password_0, 0);
3820                 }
3821                 NDR_CHECK(ndr_pull_wkssvc_joinflags(ndr, NDR_SCALARS, &r->in.unjoin_flags));
3822         }
3823         if (flags & NDR_OUT) {
3824                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3825         }
3826         return NDR_ERR_SUCCESS;
3827 }
3828
3829 _PUBLIC_ void ndr_print_wkssvc_NetrUnjoinDomain2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUnjoinDomain2 *r)
3830 {
3831         ndr_print_struct(ndr, name, "wkssvc_NetrUnjoinDomain2");
3832         ndr->depth++;
3833         if (flags & NDR_SET_VALUES) {
3834                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3835         }
3836         if (flags & NDR_IN) {
3837                 ndr_print_struct(ndr, "in", "wkssvc_NetrUnjoinDomain2");
3838                 ndr->depth++;
3839                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
3840                 ndr->depth++;
3841                 if (r->in.server_name) {
3842                         ndr_print_string(ndr, "server_name", r->in.server_name);
3843                 }
3844                 ndr->depth--;
3845                 ndr_print_ptr(ndr, "account", r->in.account);
3846                 ndr->depth++;
3847                 if (r->in.account) {
3848                         ndr_print_string(ndr, "account", r->in.account);
3849                 }
3850                 ndr->depth--;
3851                 ndr_print_ptr(ndr, "encrypted_password", r->in.encrypted_password);
3852                 ndr->depth++;
3853                 if (r->in.encrypted_password) {
3854                         ndr_print_wkssvc_PasswordBuffer(ndr, "encrypted_password", r->in.encrypted_password);
3855                 }
3856                 ndr->depth--;
3857                 ndr_print_wkssvc_joinflags(ndr, "unjoin_flags", r->in.unjoin_flags);
3858                 ndr->depth--;
3859         }
3860         if (flags & NDR_OUT) {
3861                 ndr_print_struct(ndr, "out", "wkssvc_NetrUnjoinDomain2");
3862                 ndr->depth++;
3863                 ndr_print_WERROR(ndr, "result", r->out.result);
3864                 ndr->depth--;
3865         }
3866         ndr->depth--;
3867 }
3868
3869 static enum ndr_err_code ndr_push_wkssvc_NetrRenameMachineInDomain2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrRenameMachineInDomain2 *r)
3870 {
3871         if (flags & NDR_IN) {
3872                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
3873                 if (r->in.server_name) {
3874                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
3875                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3876                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
3877                         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));
3878                 }
3879                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.NewMachineName));
3880                 if (r->in.NewMachineName) {
3881                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewMachineName, CH_UTF16)));
3882                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3883                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewMachineName, CH_UTF16)));
3884                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.NewMachineName, ndr_charset_length(r->in.NewMachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3885                 }
3886                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
3887                 if (r->in.Account) {
3888                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
3889                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3890                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
3891                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3892                 }
3893                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
3894                 if (r->in.EncryptedPassword) {
3895                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
3896                 }
3897                 NDR_CHECK(ndr_push_wkssvc_renameflags(ndr, NDR_SCALARS, r->in.RenameOptions));
3898         }
3899         if (flags & NDR_OUT) {
3900                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3901         }
3902         return NDR_ERR_SUCCESS;
3903 }
3904
3905 static enum ndr_err_code ndr_pull_wkssvc_NetrRenameMachineInDomain2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrRenameMachineInDomain2 *r)
3906 {
3907         uint32_t _ptr_server_name;
3908         uint32_t _ptr_NewMachineName;
3909         uint32_t _ptr_Account;
3910         uint32_t _ptr_EncryptedPassword;
3911         TALLOC_CTX *_mem_save_server_name_0;
3912         TALLOC_CTX *_mem_save_NewMachineName_0;
3913         TALLOC_CTX *_mem_save_Account_0;
3914         TALLOC_CTX *_mem_save_EncryptedPassword_0;
3915         if (flags & NDR_IN) {
3916                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3917                 if (_ptr_server_name) {
3918                         NDR_PULL_ALLOC(ndr, r->in.server_name);
3919                 } else {
3920                         r->in.server_name = NULL;
3921                 }
3922                 if (r->in.server_name) {
3923                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3924                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
3925                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
3926                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
3927                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
3928                                 return 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));
3929                         }
3930                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
3931                         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));
3932                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3933                 }
3934                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_NewMachineName));
3935                 if (_ptr_NewMachineName) {
3936                         NDR_PULL_ALLOC(ndr, r->in.NewMachineName);
3937                 } else {
3938                         r->in.NewMachineName = NULL;
3939                 }
3940                 if (r->in.NewMachineName) {
3941                         _mem_save_NewMachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);
3942                         NDR_PULL_SET_MEM_CTX(ndr, r->in.NewMachineName, 0);
3943                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.NewMachineName));
3944                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.NewMachineName));
3945                         if (ndr_get_array_length(ndr, &r->in.NewMachineName) > ndr_get_array_size(ndr, &r->in.NewMachineName)) {
3946                                 return 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));
3947                         }
3948                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.NewMachineName), sizeof(uint16_t)));
3949                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.NewMachineName, ndr_get_array_length(ndr, &r->in.NewMachineName), sizeof(uint16_t), CH_UTF16));
3950                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_NewMachineName_0, 0);
3951                 }
3952                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
3953                 if (_ptr_Account) {
3954                         NDR_PULL_ALLOC(ndr, r->in.Account);
3955                 } else {
3956                         r->in.Account = NULL;
3957                 }
3958                 if (r->in.Account) {
3959                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
3960                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
3961                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
3962                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
3963                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
3964                                 return 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));
3965                         }
3966                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
3967                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
3968                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
3969                 }
3970                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
3971                 if (_ptr_EncryptedPassword) {
3972                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
3973                 } else {
3974                         r->in.EncryptedPassword = NULL;
3975                 }
3976                 if (r->in.EncryptedPassword) {
3977                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
3978                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
3979                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
3980                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
3981                 }
3982                 NDR_CHECK(ndr_pull_wkssvc_renameflags(ndr, NDR_SCALARS, &r->in.RenameOptions));
3983         }
3984         if (flags & NDR_OUT) {
3985                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3986         }
3987         return NDR_ERR_SUCCESS;
3988 }
3989
3990 _PUBLIC_ void ndr_print_wkssvc_NetrRenameMachineInDomain2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrRenameMachineInDomain2 *r)
3991 {
3992         ndr_print_struct(ndr, name, "wkssvc_NetrRenameMachineInDomain2");
3993         ndr->depth++;
3994         if (flags & NDR_SET_VALUES) {
3995                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3996         }
3997         if (flags & NDR_IN) {
3998                 ndr_print_struct(ndr, "in", "wkssvc_NetrRenameMachineInDomain2");
3999                 ndr->depth++;
4000                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
4001                 ndr->depth++;
4002                 if (r->in.server_name) {
4003                         ndr_print_string(ndr, "server_name", r->in.server_name);
4004                 }
4005                 ndr->depth--;
4006                 ndr_print_ptr(ndr, "NewMachineName", r->in.NewMachineName);
4007                 ndr->depth++;
4008                 if (r->in.NewMachineName) {
4009                         ndr_print_string(ndr, "NewMachineName", r->in.NewMachineName);
4010                 }
4011                 ndr->depth--;
4012                 ndr_print_ptr(ndr, "Account", r->in.Account);
4013                 ndr->depth++;
4014                 if (r->in.Account) {
4015                         ndr_print_string(ndr, "Account", r->in.Account);
4016                 }
4017                 ndr->depth--;
4018                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
4019                 ndr->depth++;
4020                 if (r->in.EncryptedPassword) {
4021                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
4022                 }
4023                 ndr->depth--;
4024                 ndr_print_wkssvc_renameflags(ndr, "RenameOptions", r->in.RenameOptions);
4025                 ndr->depth--;
4026         }
4027         if (flags & NDR_OUT) {
4028                 ndr_print_struct(ndr, "out", "wkssvc_NetrRenameMachineInDomain2");
4029                 ndr->depth++;
4030                 ndr_print_WERROR(ndr, "result", r->out.result);
4031                 ndr->depth--;
4032         }
4033         ndr->depth--;
4034 }
4035
4036 static enum ndr_err_code ndr_push_WKSSVC_NETRVALIDATENAME2(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRVALIDATENAME2 *r)
4037 {
4038         if (flags & NDR_IN) {
4039         }
4040         if (flags & NDR_OUT) {
4041                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4042         }
4043         return NDR_ERR_SUCCESS;
4044 }
4045
4046 static enum ndr_err_code ndr_pull_WKSSVC_NETRVALIDATENAME2(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRVALIDATENAME2 *r)
4047 {
4048         if (flags & NDR_IN) {
4049         }
4050         if (flags & NDR_OUT) {
4051                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4052         }
4053         return NDR_ERR_SUCCESS;
4054 }
4055
4056 _PUBLIC_ void ndr_print_WKSSVC_NETRVALIDATENAME2(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRVALIDATENAME2 *r)
4057 {
4058         ndr_print_struct(ndr, name, "WKSSVC_NETRVALIDATENAME2");
4059         ndr->depth++;
4060         if (flags & NDR_SET_VALUES) {
4061                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4062         }
4063         if (flags & NDR_IN) {
4064                 ndr_print_struct(ndr, "in", "WKSSVC_NETRVALIDATENAME2");
4065                 ndr->depth++;
4066                 ndr->depth--;
4067         }
4068         if (flags & NDR_OUT) {
4069                 ndr_print_struct(ndr, "out", "WKSSVC_NETRVALIDATENAME2");
4070                 ndr->depth++;
4071                 ndr_print_WERROR(ndr, "result", r->out.result);
4072                 ndr->depth--;
4073         }
4074         ndr->depth--;
4075 }
4076
4077 static enum ndr_err_code ndr_push_WKSSVC_NETRGETJOINABLEOUS2(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRGETJOINABLEOUS2 *r)
4078 {
4079         if (flags & NDR_IN) {
4080         }
4081         if (flags & NDR_OUT) {
4082                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4083         }
4084         return NDR_ERR_SUCCESS;
4085 }
4086
4087 static enum ndr_err_code ndr_pull_WKSSVC_NETRGETJOINABLEOUS2(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRGETJOINABLEOUS2 *r)
4088 {
4089         if (flags & NDR_IN) {
4090         }
4091         if (flags & NDR_OUT) {
4092                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4093         }
4094         return NDR_ERR_SUCCESS;
4095 }
4096
4097 _PUBLIC_ void ndr_print_WKSSVC_NETRGETJOINABLEOUS2(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRGETJOINABLEOUS2 *r)
4098 {
4099         ndr_print_struct(ndr, name, "WKSSVC_NETRGETJOINABLEOUS2");
4100         ndr->depth++;
4101         if (flags & NDR_SET_VALUES) {
4102                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4103         }
4104         if (flags & NDR_IN) {
4105                 ndr_print_struct(ndr, "in", "WKSSVC_NETRGETJOINABLEOUS2");
4106                 ndr->depth++;
4107                 ndr->depth--;
4108         }
4109         if (flags & NDR_OUT) {
4110                 ndr_print_struct(ndr, "out", "WKSSVC_NETRGETJOINABLEOUS2");
4111                 ndr->depth++;
4112                 ndr_print_WERROR(ndr, "result", r->out.result);
4113                 ndr->depth--;
4114         }
4115         ndr->depth--;
4116 }
4117
4118 static enum ndr_err_code ndr_push_wkssvc_NetrAddAlternateComputerName(struct ndr_push *ndr, int flags, const struct wkssvc_NetrAddAlternateComputerName *r)
4119 {
4120         if (flags & NDR_IN) {
4121                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
4122                 if (r->in.server_name) {
4123                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
4124                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4125                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
4126                         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));
4127                 }
4128                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.NewAlternateMachineName));
4129                 if (r->in.NewAlternateMachineName) {
4130                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewAlternateMachineName, CH_UTF16)));
4131                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4132                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewAlternateMachineName, CH_UTF16)));
4133                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.NewAlternateMachineName, ndr_charset_length(r->in.NewAlternateMachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4134                 }
4135                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
4136                 if (r->in.Account) {
4137                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
4138                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4139                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
4140                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4141                 }
4142                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
4143                 if (r->in.EncryptedPassword) {
4144                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
4145                 }
4146                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Reserved));
4147         }
4148         if (flags & NDR_OUT) {
4149                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4150         }
4151         return NDR_ERR_SUCCESS;
4152 }
4153
4154 static enum ndr_err_code ndr_pull_wkssvc_NetrAddAlternateComputerName(struct ndr_pull *ndr, int flags, struct wkssvc_NetrAddAlternateComputerName *r)
4155 {
4156         uint32_t _ptr_server_name;
4157         uint32_t _ptr_NewAlternateMachineName;
4158         uint32_t _ptr_Account;
4159         uint32_t _ptr_EncryptedPassword;
4160         TALLOC_CTX *_mem_save_server_name_0;
4161         TALLOC_CTX *_mem_save_NewAlternateMachineName_0;
4162         TALLOC_CTX *_mem_save_Account_0;
4163         TALLOC_CTX *_mem_save_EncryptedPassword_0;
4164         if (flags & NDR_IN) {
4165                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4166                 if (_ptr_server_name) {
4167                         NDR_PULL_ALLOC(ndr, r->in.server_name);
4168                 } else {
4169                         r->in.server_name = NULL;
4170                 }
4171                 if (r->in.server_name) {
4172                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4173                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
4174                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
4175                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
4176                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
4177                                 return 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));
4178                         }
4179                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
4180                         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));
4181                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4182                 }
4183                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_NewAlternateMachineName));
4184                 if (_ptr_NewAlternateMachineName) {
4185                         NDR_PULL_ALLOC(ndr, r->in.NewAlternateMachineName);
4186                 } else {
4187                         r->in.NewAlternateMachineName = NULL;
4188                 }
4189                 if (r->in.NewAlternateMachineName) {
4190                         _mem_save_NewAlternateMachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);
4191                         NDR_PULL_SET_MEM_CTX(ndr, r->in.NewAlternateMachineName, 0);
4192                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.NewAlternateMachineName));
4193                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.NewAlternateMachineName));
4194                         if (ndr_get_array_length(ndr, &r->in.NewAlternateMachineName) > ndr_get_array_size(ndr, &r->in.NewAlternateMachineName)) {
4195                                 return 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));
4196                         }
4197                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.NewAlternateMachineName), sizeof(uint16_t)));
4198                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.NewAlternateMachineName, ndr_get_array_length(ndr, &r->in.NewAlternateMachineName), sizeof(uint16_t), CH_UTF16));
4199                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_NewAlternateMachineName_0, 0);
4200                 }
4201                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
4202                 if (_ptr_Account) {
4203                         NDR_PULL_ALLOC(ndr, r->in.Account);
4204                 } else {
4205                         r->in.Account = NULL;
4206                 }
4207                 if (r->in.Account) {
4208                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
4209                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
4210                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
4211                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
4212                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
4213                                 return 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));
4214                         }
4215                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
4216                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
4217                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
4218                 }
4219                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
4220                 if (_ptr_EncryptedPassword) {
4221                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
4222                 } else {
4223                         r->in.EncryptedPassword = NULL;
4224                 }
4225                 if (r->in.EncryptedPassword) {
4226                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
4227                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
4228                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
4229                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
4230                 }
4231                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Reserved));
4232         }
4233         if (flags & NDR_OUT) {
4234                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4235         }
4236         return NDR_ERR_SUCCESS;
4237 }
4238
4239 _PUBLIC_ void ndr_print_wkssvc_NetrAddAlternateComputerName(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrAddAlternateComputerName *r)
4240 {
4241         ndr_print_struct(ndr, name, "wkssvc_NetrAddAlternateComputerName");
4242         ndr->depth++;
4243         if (flags & NDR_SET_VALUES) {
4244                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4245         }
4246         if (flags & NDR_IN) {
4247                 ndr_print_struct(ndr, "in", "wkssvc_NetrAddAlternateComputerName");
4248                 ndr->depth++;
4249                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
4250                 ndr->depth++;
4251                 if (r->in.server_name) {
4252                         ndr_print_string(ndr, "server_name", r->in.server_name);
4253                 }
4254                 ndr->depth--;
4255                 ndr_print_ptr(ndr, "NewAlternateMachineName", r->in.NewAlternateMachineName);
4256                 ndr->depth++;
4257                 if (r->in.NewAlternateMachineName) {
4258                         ndr_print_string(ndr, "NewAlternateMachineName", r->in.NewAlternateMachineName);
4259                 }
4260                 ndr->depth--;
4261                 ndr_print_ptr(ndr, "Account", r->in.Account);
4262                 ndr->depth++;
4263                 if (r->in.Account) {
4264                         ndr_print_string(ndr, "Account", r->in.Account);
4265                 }
4266                 ndr->depth--;
4267                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
4268                 ndr->depth++;
4269                 if (r->in.EncryptedPassword) {
4270                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
4271                 }
4272                 ndr->depth--;
4273                 ndr_print_uint32(ndr, "Reserved", r->in.Reserved);
4274                 ndr->depth--;
4275         }
4276         if (flags & NDR_OUT) {
4277                 ndr_print_struct(ndr, "out", "wkssvc_NetrAddAlternateComputerName");
4278                 ndr->depth++;
4279                 ndr_print_WERROR(ndr, "result", r->out.result);
4280                 ndr->depth--;
4281         }
4282         ndr->depth--;
4283 }
4284
4285 static enum ndr_err_code ndr_push_wkssvc_NetrRemoveAlternateComputerName(struct ndr_push *ndr, int flags, const struct wkssvc_NetrRemoveAlternateComputerName *r)
4286 {
4287         if (flags & NDR_IN) {
4288                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
4289                 if (r->in.server_name) {
4290                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
4291                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4292                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
4293                         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));
4294                 }
4295                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.AlternateMachineNameToRemove));
4296                 if (r->in.AlternateMachineNameToRemove) {
4297                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.AlternateMachineNameToRemove, CH_UTF16)));
4298                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4299                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.AlternateMachineNameToRemove, CH_UTF16)));
4300                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.AlternateMachineNameToRemove, ndr_charset_length(r->in.AlternateMachineNameToRemove, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4301                 }
4302                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
4303                 if (r->in.Account) {
4304                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
4305                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4306                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
4307                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4308                 }
4309                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
4310                 if (r->in.EncryptedPassword) {
4311                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
4312                 }
4313                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Reserved));
4314         }
4315         if (flags & NDR_OUT) {
4316                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4317         }
4318         return NDR_ERR_SUCCESS;
4319 }
4320
4321 static enum ndr_err_code ndr_pull_wkssvc_NetrRemoveAlternateComputerName(struct ndr_pull *ndr, int flags, struct wkssvc_NetrRemoveAlternateComputerName *r)
4322 {
4323         uint32_t _ptr_server_name;
4324         uint32_t _ptr_AlternateMachineNameToRemove;
4325         uint32_t _ptr_Account;
4326         uint32_t _ptr_EncryptedPassword;
4327         TALLOC_CTX *_mem_save_server_name_0;
4328         TALLOC_CTX *_mem_save_AlternateMachineNameToRemove_0;
4329         TALLOC_CTX *_mem_save_Account_0;
4330         TALLOC_CTX *_mem_save_EncryptedPassword_0;
4331         if (flags & NDR_IN) {
4332                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4333                 if (_ptr_server_name) {
4334                         NDR_PULL_ALLOC(ndr, r->in.server_name);
4335                 } else {
4336                         r->in.server_name = NULL;
4337                 }
4338                 if (r->in.server_name) {
4339                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4340                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
4341                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
4342                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
4343                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
4344                                 return 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));
4345                         }
4346                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
4347                         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));
4348                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4349                 }
4350                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_AlternateMachineNameToRemove));
4351                 if (_ptr_AlternateMachineNameToRemove) {
4352                         NDR_PULL_ALLOC(ndr, r->in.AlternateMachineNameToRemove);
4353                 } else {
4354                         r->in.AlternateMachineNameToRemove = NULL;
4355                 }
4356                 if (r->in.AlternateMachineNameToRemove) {
4357                         _mem_save_AlternateMachineNameToRemove_0 = NDR_PULL_GET_MEM_CTX(ndr);
4358                         NDR_PULL_SET_MEM_CTX(ndr, r->in.AlternateMachineNameToRemove, 0);
4359                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.AlternateMachineNameToRemove));
4360                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.AlternateMachineNameToRemove));
4361                         if (ndr_get_array_length(ndr, &r->in.AlternateMachineNameToRemove) > ndr_get_array_size(ndr, &r->in.AlternateMachineNameToRemove)) {
4362                                 return 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));
4363                         }
4364                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.AlternateMachineNameToRemove), sizeof(uint16_t)));
4365                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.AlternateMachineNameToRemove, ndr_get_array_length(ndr, &r->in.AlternateMachineNameToRemove), sizeof(uint16_t), CH_UTF16));
4366                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_AlternateMachineNameToRemove_0, 0);
4367                 }
4368                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
4369                 if (_ptr_Account) {
4370                         NDR_PULL_ALLOC(ndr, r->in.Account);
4371                 } else {
4372                         r->in.Account = NULL;
4373                 }
4374                 if (r->in.Account) {
4375                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
4376                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
4377                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
4378                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
4379                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
4380                                 return 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));
4381                         }
4382                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
4383                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
4384                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
4385                 }
4386                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
4387                 if (_ptr_EncryptedPassword) {
4388                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
4389                 } else {
4390                         r->in.EncryptedPassword = NULL;
4391                 }
4392                 if (r->in.EncryptedPassword) {
4393                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
4394                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
4395                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
4396                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
4397                 }
4398                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Reserved));
4399         }
4400         if (flags & NDR_OUT) {
4401                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4402         }
4403         return NDR_ERR_SUCCESS;
4404 }
4405
4406 _PUBLIC_ void ndr_print_wkssvc_NetrRemoveAlternateComputerName(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrRemoveAlternateComputerName *r)
4407 {
4408         ndr_print_struct(ndr, name, "wkssvc_NetrRemoveAlternateComputerName");
4409         ndr->depth++;
4410         if (flags & NDR_SET_VALUES) {
4411                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4412         }
4413         if (flags & NDR_IN) {
4414                 ndr_print_struct(ndr, "in", "wkssvc_NetrRemoveAlternateComputerName");
4415                 ndr->depth++;
4416                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
4417                 ndr->depth++;
4418                 if (r->in.server_name) {
4419                         ndr_print_string(ndr, "server_name", r->in.server_name);
4420                 }
4421                 ndr->depth--;
4422                 ndr_print_ptr(ndr, "AlternateMachineNameToRemove", r->in.AlternateMachineNameToRemove);
4423                 ndr->depth++;
4424                 if (r->in.AlternateMachineNameToRemove) {
4425                         ndr_print_string(ndr, "AlternateMachineNameToRemove", r->in.AlternateMachineNameToRemove);
4426                 }
4427                 ndr->depth--;
4428                 ndr_print_ptr(ndr, "Account", r->in.Account);
4429                 ndr->depth++;
4430                 if (r->in.Account) {
4431                         ndr_print_string(ndr, "Account", r->in.Account);
4432                 }
4433                 ndr->depth--;
4434                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
4435                 ndr->depth++;
4436                 if (r->in.EncryptedPassword) {
4437                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
4438                 }
4439                 ndr->depth--;
4440                 ndr_print_uint32(ndr, "Reserved", r->in.Reserved);
4441                 ndr->depth--;
4442         }
4443         if (flags & NDR_OUT) {
4444                 ndr_print_struct(ndr, "out", "wkssvc_NetrRemoveAlternateComputerName");
4445                 ndr->depth++;
4446                 ndr_print_WERROR(ndr, "result", r->out.result);
4447                 ndr->depth--;
4448         }
4449         ndr->depth--;
4450 }
4451
4452 static enum ndr_err_code ndr_push_WKSSVC_NETRSETPRIMARYCOMPUTERNAME(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRSETPRIMARYCOMPUTERNAME *r)
4453 {
4454         if (flags & NDR_IN) {
4455         }
4456         if (flags & NDR_OUT) {
4457                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4458         }
4459         return NDR_ERR_SUCCESS;
4460 }
4461
4462 static enum ndr_err_code ndr_pull_WKSSVC_NETRSETPRIMARYCOMPUTERNAME(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRSETPRIMARYCOMPUTERNAME *r)
4463 {
4464         if (flags & NDR_IN) {
4465         }
4466         if (flags & NDR_OUT) {
4467                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4468         }
4469         return NDR_ERR_SUCCESS;
4470 }
4471
4472 _PUBLIC_ void ndr_print_WKSSVC_NETRSETPRIMARYCOMPUTERNAME(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRSETPRIMARYCOMPUTERNAME *r)
4473 {
4474         ndr_print_struct(ndr, name, "WKSSVC_NETRSETPRIMARYCOMPUTERNAME");
4475         ndr->depth++;
4476         if (flags & NDR_SET_VALUES) {
4477                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4478         }
4479         if (flags & NDR_IN) {
4480                 ndr_print_struct(ndr, "in", "WKSSVC_NETRSETPRIMARYCOMPUTERNAME");
4481                 ndr->depth++;
4482                 ndr->depth--;
4483         }
4484         if (flags & NDR_OUT) {
4485                 ndr_print_struct(ndr, "out", "WKSSVC_NETRSETPRIMARYCOMPUTERNAME");
4486                 ndr->depth++;
4487                 ndr_print_WERROR(ndr, "result", r->out.result);
4488                 ndr->depth--;
4489         }
4490         ndr->depth--;
4491 }
4492
4493 static enum ndr_err_code ndr_push_WKSSVC_NETRENUMERATECOMPUTERNAMES(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRENUMERATECOMPUTERNAMES *r)
4494 {
4495         if (flags & NDR_IN) {
4496         }
4497         if (flags & NDR_OUT) {
4498                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4499         }
4500         return NDR_ERR_SUCCESS;
4501 }
4502
4503 static enum ndr_err_code ndr_pull_WKSSVC_NETRENUMERATECOMPUTERNAMES(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRENUMERATECOMPUTERNAMES *r)
4504 {
4505         if (flags & NDR_IN) {
4506         }
4507         if (flags & NDR_OUT) {
4508                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4509         }
4510         return NDR_ERR_SUCCESS;
4511 }
4512
4513 _PUBLIC_ void ndr_print_WKSSVC_NETRENUMERATECOMPUTERNAMES(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRENUMERATECOMPUTERNAMES *r)
4514 {
4515         ndr_print_struct(ndr, name, "WKSSVC_NETRENUMERATECOMPUTERNAMES");
4516         ndr->depth++;
4517         if (flags & NDR_SET_VALUES) {
4518                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4519         }
4520         if (flags & NDR_IN) {
4521                 ndr_print_struct(ndr, "in", "WKSSVC_NETRENUMERATECOMPUTERNAMES");
4522                 ndr->depth++;
4523                 ndr->depth--;
4524         }
4525         if (flags & NDR_OUT) {
4526                 ndr_print_struct(ndr, "out", "WKSSVC_NETRENUMERATECOMPUTERNAMES");
4527                 ndr->depth++;
4528                 ndr_print_WERROR(ndr, "result", r->out.result);
4529                 ndr->depth--;
4530         }
4531         ndr->depth--;
4532 }
4533
4534 static const struct ndr_interface_call wkssvc_calls[] = {
4535         {
4536                 "wkssvc_NetWkstaGetInfo",
4537                 sizeof(struct wkssvc_NetWkstaGetInfo),
4538                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaGetInfo,
4539                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaGetInfo,
4540                 (ndr_print_function_t) ndr_print_wkssvc_NetWkstaGetInfo,
4541                 false,
4542         },
4543         {
4544                 "wkssvc_NetWkstaSetInfo",
4545                 sizeof(struct wkssvc_NetWkstaSetInfo),
4546                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaSetInfo,
4547                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaSetInfo,
4548                 (ndr_print_function_t) ndr_print_wkssvc_NetWkstaSetInfo,
4549                 false,
4550         },
4551         {
4552                 "wkssvc_NetWkstaEnumUsers",
4553                 sizeof(struct wkssvc_NetWkstaEnumUsers),
4554                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaEnumUsers,
4555                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaEnumUsers,
4556                 (ndr_print_function_t) ndr_print_wkssvc_NetWkstaEnumUsers,
4557                 false,
4558         },
4559         {
4560                 "WKSSVC_NETRWKSTAUSERGETINFO",
4561                 sizeof(struct WKSSVC_NETRWKSTAUSERGETINFO),
4562                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRWKSTAUSERGETINFO,
4563                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRWKSTAUSERGETINFO,
4564                 (ndr_print_function_t) ndr_print_WKSSVC_NETRWKSTAUSERGETINFO,
4565                 false,
4566         },
4567         {
4568                 "WKSSVC_NETRWKSTAUSERSETINFO",
4569                 sizeof(struct WKSSVC_NETRWKSTAUSERSETINFO),
4570                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRWKSTAUSERSETINFO,
4571                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRWKSTAUSERSETINFO,
4572                 (ndr_print_function_t) ndr_print_WKSSVC_NETRWKSTAUSERSETINFO,
4573                 false,
4574         },
4575         {
4576                 "wkssvc_NetWkstaTransportEnum",
4577                 sizeof(struct wkssvc_NetWkstaTransportEnum),
4578                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaTransportEnum,
4579                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaTransportEnum,
4580                 (ndr_print_function_t) ndr_print_wkssvc_NetWkstaTransportEnum,
4581                 false,
4582         },
4583         {
4584                 "WKSSVC_NETRWKSTATRANSPORTADD",
4585                 sizeof(struct WKSSVC_NETRWKSTATRANSPORTADD),
4586                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRWKSTATRANSPORTADD,
4587                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRWKSTATRANSPORTADD,
4588                 (ndr_print_function_t) ndr_print_WKSSVC_NETRWKSTATRANSPORTADD,
4589                 false,
4590         },
4591         {
4592                 "WKSSVC_NETRWKSTATRANSPORTDEL",
4593                 sizeof(struct WKSSVC_NETRWKSTATRANSPORTDEL),
4594                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRWKSTATRANSPORTDEL,
4595                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRWKSTATRANSPORTDEL,
4596                 (ndr_print_function_t) ndr_print_WKSSVC_NETRWKSTATRANSPORTDEL,
4597                 false,
4598         },
4599         {
4600                 "WKSSVC_NETRUSEADD",
4601                 sizeof(struct WKSSVC_NETRUSEADD),
4602                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRUSEADD,
4603                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRUSEADD,
4604                 (ndr_print_function_t) ndr_print_WKSSVC_NETRUSEADD,
4605                 false,
4606         },
4607         {
4608                 "WKSSVC_NETRUSEGETINFO",
4609                 sizeof(struct WKSSVC_NETRUSEGETINFO),
4610                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRUSEGETINFO,
4611                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRUSEGETINFO,
4612                 (ndr_print_function_t) ndr_print_WKSSVC_NETRUSEGETINFO,
4613                 false,
4614         },
4615         {
4616                 "WKSSVC_NETRUSEDEL",
4617                 sizeof(struct WKSSVC_NETRUSEDEL),
4618                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRUSEDEL,
4619                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRUSEDEL,
4620                 (ndr_print_function_t) ndr_print_WKSSVC_NETRUSEDEL,
4621                 false,
4622         },
4623         {
4624                 "WKSSVC_NETRUSEENUM",
4625                 sizeof(struct WKSSVC_NETRUSEENUM),
4626                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRUSEENUM,
4627                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRUSEENUM,
4628                 (ndr_print_function_t) ndr_print_WKSSVC_NETRUSEENUM,
4629                 false,
4630         },
4631         {
4632                 "WKSSVC_NETRMESSAGEBUFFERSEND",
4633                 sizeof(struct WKSSVC_NETRMESSAGEBUFFERSEND),
4634                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRMESSAGEBUFFERSEND,
4635                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRMESSAGEBUFFERSEND,
4636                 (ndr_print_function_t) ndr_print_WKSSVC_NETRMESSAGEBUFFERSEND,
4637                 false,
4638         },
4639         {
4640                 "WKSSVC_NETRWORKSTATIONSTATISTICSGET",
4641                 sizeof(struct WKSSVC_NETRWORKSTATIONSTATISTICSGET),
4642                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRWORKSTATIONSTATISTICSGET,
4643                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRWORKSTATIONSTATISTICSGET,
4644                 (ndr_print_function_t) ndr_print_WKSSVC_NETRWORKSTATIONSTATISTICSGET,
4645                 false,
4646         },
4647         {
4648                 "WKSSVC_NETRLOGONDOMAINNAMEADD",
4649                 sizeof(struct WKSSVC_NETRLOGONDOMAINNAMEADD),
4650                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRLOGONDOMAINNAMEADD,
4651                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRLOGONDOMAINNAMEADD,
4652                 (ndr_print_function_t) ndr_print_WKSSVC_NETRLOGONDOMAINNAMEADD,
4653                 false,
4654         },
4655         {
4656                 "WKSSVC_NETRLOGONDOMAINNAMEDEL",
4657                 sizeof(struct WKSSVC_NETRLOGONDOMAINNAMEDEL),
4658                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRLOGONDOMAINNAMEDEL,
4659                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRLOGONDOMAINNAMEDEL,
4660                 (ndr_print_function_t) ndr_print_WKSSVC_NETRLOGONDOMAINNAMEDEL,
4661                 false,
4662         },
4663         {
4664                 "WKSSVC_NETRJOINDOMAIN",
4665                 sizeof(struct WKSSVC_NETRJOINDOMAIN),
4666                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRJOINDOMAIN,
4667                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRJOINDOMAIN,
4668                 (ndr_print_function_t) ndr_print_WKSSVC_NETRJOINDOMAIN,
4669                 false,
4670         },
4671         {
4672                 "WKSSVC_NETRUNJOINDOMAIN",
4673                 sizeof(struct WKSSVC_NETRUNJOINDOMAIN),
4674                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRUNJOINDOMAIN,
4675                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRUNJOINDOMAIN,
4676                 (ndr_print_function_t) ndr_print_WKSSVC_NETRUNJOINDOMAIN,
4677                 false,
4678         },
4679         {
4680                 "WKSSVC_NETRRENAMEMACHINEINDOMAIN",
4681                 sizeof(struct WKSSVC_NETRRENAMEMACHINEINDOMAIN),
4682                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRRENAMEMACHINEINDOMAIN,
4683                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRRENAMEMACHINEINDOMAIN,
4684                 (ndr_print_function_t) ndr_print_WKSSVC_NETRRENAMEMACHINEINDOMAIN,
4685                 false,
4686         },
4687         {
4688                 "WKSSVC_NETRVALIDATENAME",
4689                 sizeof(struct WKSSVC_NETRVALIDATENAME),
4690                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRVALIDATENAME,
4691                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRVALIDATENAME,
4692                 (ndr_print_function_t) ndr_print_WKSSVC_NETRVALIDATENAME,
4693                 false,
4694         },
4695         {
4696                 "WKSSVC_NETRGETJOININFORMATION",
4697                 sizeof(struct WKSSVC_NETRGETJOININFORMATION),
4698                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRGETJOININFORMATION,
4699                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRGETJOININFORMATION,
4700                 (ndr_print_function_t) ndr_print_WKSSVC_NETRGETJOININFORMATION,
4701                 false,
4702         },
4703         {
4704                 "WKSSVC_NETRGETJOINABLEOUS",
4705                 sizeof(struct WKSSVC_NETRGETJOINABLEOUS),
4706                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRGETJOINABLEOUS,
4707                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRGETJOINABLEOUS,
4708                 (ndr_print_function_t) ndr_print_WKSSVC_NETRGETJOINABLEOUS,
4709                 false,
4710         },
4711         {
4712                 "wkssvc_NetrJoinDomain2",
4713                 sizeof(struct wkssvc_NetrJoinDomain2),
4714                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrJoinDomain2,
4715                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrJoinDomain2,
4716                 (ndr_print_function_t) ndr_print_wkssvc_NetrJoinDomain2,
4717                 false,
4718         },
4719         {
4720                 "wkssvc_NetrUnjoinDomain2",
4721                 sizeof(struct wkssvc_NetrUnjoinDomain2),
4722                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUnjoinDomain2,
4723                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUnjoinDomain2,
4724                 (ndr_print_function_t) ndr_print_wkssvc_NetrUnjoinDomain2,
4725                 false,
4726         },
4727         {
4728                 "wkssvc_NetrRenameMachineInDomain2",
4729                 sizeof(struct wkssvc_NetrRenameMachineInDomain2),
4730                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrRenameMachineInDomain2,
4731                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrRenameMachineInDomain2,
4732                 (ndr_print_function_t) ndr_print_wkssvc_NetrRenameMachineInDomain2,
4733                 false,
4734         },
4735         {
4736                 "WKSSVC_NETRVALIDATENAME2",
4737                 sizeof(struct WKSSVC_NETRVALIDATENAME2),
4738                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRVALIDATENAME2,
4739                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRVALIDATENAME2,
4740                 (ndr_print_function_t) ndr_print_WKSSVC_NETRVALIDATENAME2,
4741                 false,
4742         },
4743         {
4744                 "WKSSVC_NETRGETJOINABLEOUS2",
4745                 sizeof(struct WKSSVC_NETRGETJOINABLEOUS2),
4746                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRGETJOINABLEOUS2,
4747                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRGETJOINABLEOUS2,
4748                 (ndr_print_function_t) ndr_print_WKSSVC_NETRGETJOINABLEOUS2,
4749                 false,
4750         },
4751         {
4752                 "wkssvc_NetrAddAlternateComputerName",
4753                 sizeof(struct wkssvc_NetrAddAlternateComputerName),
4754                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrAddAlternateComputerName,
4755                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrAddAlternateComputerName,
4756                 (ndr_print_function_t) ndr_print_wkssvc_NetrAddAlternateComputerName,
4757                 false,
4758         },
4759         {
4760                 "wkssvc_NetrRemoveAlternateComputerName",
4761                 sizeof(struct wkssvc_NetrRemoveAlternateComputerName),
4762                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrRemoveAlternateComputerName,
4763                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrRemoveAlternateComputerName,
4764                 (ndr_print_function_t) ndr_print_wkssvc_NetrRemoveAlternateComputerName,
4765                 false,
4766         },
4767         {
4768                 "WKSSVC_NETRSETPRIMARYCOMPUTERNAME",
4769                 sizeof(struct WKSSVC_NETRSETPRIMARYCOMPUTERNAME),
4770                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRSETPRIMARYCOMPUTERNAME,
4771                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRSETPRIMARYCOMPUTERNAME,
4772                 (ndr_print_function_t) ndr_print_WKSSVC_NETRSETPRIMARYCOMPUTERNAME,
4773                 false,
4774         },
4775         {
4776                 "WKSSVC_NETRENUMERATECOMPUTERNAMES",
4777                 sizeof(struct WKSSVC_NETRENUMERATECOMPUTERNAMES),
4778                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRENUMERATECOMPUTERNAMES,
4779                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRENUMERATECOMPUTERNAMES,
4780                 (ndr_print_function_t) ndr_print_WKSSVC_NETRENUMERATECOMPUTERNAMES,
4781                 false,
4782         },
4783         { NULL, 0, NULL, NULL, NULL, false }
4784 };
4785
4786 static const char * const wkssvc_endpoint_strings[] = {
4787         "ncacn_np:[\\pipe\\wkssvc]",
4788 };
4789
4790 static const struct ndr_interface_string_array wkssvc_endpoints = {
4791         .count  = 1,
4792         .names  = wkssvc_endpoint_strings
4793 };
4794
4795 static const char * const wkssvc_authservice_strings[] = {
4796         "host",
4797 };
4798
4799 static const struct ndr_interface_string_array wkssvc_authservices = {
4800         .count  = 1,
4801         .names  = wkssvc_authservice_strings
4802 };
4803
4804
4805 const struct ndr_interface_table ndr_table_wkssvc = {
4806         .name           = "wkssvc",
4807         .syntax_id      = {
4808                 {0x6bffd098,0xa112,0x3610,{0x98,0x33},{0x46,0xc3,0xf8,0x7e,0x34,0x5a}},
4809                 NDR_WKSSVC_VERSION
4810         },
4811         .helpstring     = NDR_WKSSVC_HELPSTRING,
4812         .num_calls      = 31,
4813         .calls          = wkssvc_calls,
4814         .endpoints      = &wkssvc_endpoints,
4815         .authservices   = &wkssvc_authservices
4816 };
4817