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 NTSTATUS 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 NT_STATUS_OK;
  32 }
  33
  34 NTSTATUS 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 NT_STATUS_OK;
  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 NTSTATUS 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 NT_STATUS_OK;
 141 }
 142
 143 NTSTATUS 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 NT_STATUS_OK;
 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 NTSTATUS 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 NT_STATUS_OK;
 277 }
 278
 279 NTSTATUS 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 NT_STATUS_OK;
 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 NTSTATUS 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 NT_STATUS_OK;
 425 }
 426
 427 NTSTATUS 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 NT_STATUS_OK;
 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 NTSTATUS 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 NT_STATUS_OK;
 523 }
 524
 525 NTSTATUS 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 NT_STATUS_OK;
 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 NTSTATUS 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 NT_STATUS_OK;
 553 }
 554
 555 NTSTATUS 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 NT_STATUS_OK;
 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 NTSTATUS 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 NT_STATUS_OK;
 583 }
 584
 585 NTSTATUS 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 NT_STATUS_OK;
 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 NTSTATUS 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 NT_STATUS_OK;
 613 }
 614
 615 NTSTATUS 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 NT_STATUS_OK;
 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 NTSTATUS 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 NT_STATUS_OK;
 643 }
 644
 645 NTSTATUS 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 NT_STATUS_OK;
 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 NTSTATUS 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 NT_STATUS_OK;
 673 }
 674
 675 NTSTATUS 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 NT_STATUS_OK;
 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 NTSTATUS 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 NT_STATUS_OK;
 703 }
 704
 705 NTSTATUS 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 NT_STATUS_OK;
 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 NTSTATUS 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 NT_STATUS_OK;
 733 }
 734
 735 NTSTATUS 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 NT_STATUS_OK;
 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 NTSTATUS 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 NT_STATUS_OK;
 894 }
 895
 896 NTSTATUS 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 NT_STATUS_OK;
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 NTSTATUS 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 NT_STATUS_OK;
1297 }
1298
1299 NTSTATUS 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 NT_STATUS_OK;
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 NTSTATUS 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 NT_STATUS_OK;
1362 }
1363
1364 NTSTATUS 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 NT_STATUS_OK;
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 NTSTATUS 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 NT_STATUS_OK;
1465 }
1466
1467 NTSTATUS 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 NT_STATUS_OK;
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 NTSTATUS 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 NT_STATUS_OK;
1608 }
1609
1610 NTSTATUS 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 NT_STATUS_OK;
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 NTSTATUS 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 NT_STATUS_OK;
1713 }
1714
1715 NTSTATUS 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 NT_STATUS_OK;
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 NTSTATUS 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 NT_STATUS_OK;
1833 }
1834
1835 NTSTATUS 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 NT_STATUS_OK;
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 NTSTATUS 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 NT_STATUS_OK;
1930 }
1931
1932 NTSTATUS 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 NT_STATUS_OK;
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 NTSTATUS 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 NT_STATUS_OK;
2027 }
2028
2029 NTSTATUS 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 NT_STATUS_OK;
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 NTSTATUS 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 NT_STATUS_OK;
2105 }
2106
2107 NTSTATUS 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 NT_STATUS_OK;
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 NTSTATUS 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 NT_STATUS_OK;
2130 }
2131
2132 NTSTATUS 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 NT_STATUS_OK;
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 NTSTATUS 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 NT_STATUS_OK;
2159 }
2160
2161 NTSTATUS 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 NT_STATUS_OK;
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 NTSTATUS 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) return NT_STATUS_INVALID_PARAMETER_MIX;
2191                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
2192                 NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
2193                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2194         }
2195         return NT_STATUS_OK;
2196 }
2197
2198 NTSTATUS ndr_pull_wkssvc_NetWkstaGetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaGetInfo *r)
2199 {
2200         uint32_t _ptr_server_name;
2201         TALLOC_CTX *_mem_save_server_name_0;
2202         TALLOC_CTX *_mem_save_info_0;
2203         if (flags & NDR_IN) {
2204                 ZERO_STRUCT(r->out);
2205
2206                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
2207                 if (_ptr_server_name) {
2208                         NDR_PULL_ALLOC(ndr, r->in.server_name);
2209                 } else {
2210                         r->in.server_name = NULL;
2211                 }
2212                 if (r->in.server_name) {
2213                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2214                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
2215                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
2216                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
2217                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
2218                                 return 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));
2219                         }
2220                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
2221                         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));
2222                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
2223                 }
2224                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
2225                 NDR_PULL_ALLOC(ndr, r->out.info);
2226                 ZERO_STRUCTP(r->out.info);
2227         }
2228         if (flags & NDR_OUT) {
2229                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2230                         NDR_PULL_ALLOC(ndr, r->out.info);
2231                 }
2232                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
2233                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
2234                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
2235                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
2236                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
2237                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2238         }
2239         return NT_STATUS_OK;
2240 }
2241
2242 _PUBLIC_ void ndr_print_wkssvc_NetWkstaGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaGetInfo *r)
2243 {
2244         ndr_print_struct(ndr, name, "wkssvc_NetWkstaGetInfo");
2245         ndr->depth++;
2246         if (flags & NDR_SET_VALUES) {
2247                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2248         }
2249         if (flags & NDR_IN) {
2250                 ndr_print_struct(ndr, "in", "wkssvc_NetWkstaGetInfo");
2251                 ndr->depth++;
2252                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
2253                 ndr->depth++;
2254                 if (r->in.server_name) {
2255                         ndr_print_string(ndr, "server_name", r->in.server_name);
2256                 }
2257                 ndr->depth--;
2258                 ndr_print_uint32(ndr, "level", r->in.level);
2259                 ndr->depth--;
2260         }
2261         if (flags & NDR_OUT) {
2262                 ndr_print_struct(ndr, "out", "wkssvc_NetWkstaGetInfo");
2263                 ndr->depth++;
2264                 ndr_print_ptr(ndr, "info", r->out.info);
2265                 ndr->depth++;
2266                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
2267                 ndr_print_wkssvc_NetWkstaInfo(ndr, "info", r->out.info);
2268                 ndr->depth--;
2269                 ndr_print_WERROR(ndr, "result", r->out.result);
2270                 ndr->depth--;
2271         }
2272         ndr->depth--;
2273 }
2274
2275 NTSTATUS ndr_push_wkssvc_NetWkstaSetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaSetInfo *r)
2276 {
2277         if (flags & NDR_IN) {
2278                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
2279                 if (r->in.server_name) {
2280                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
2281                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2282                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
2283                         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));
2284                 }
2285                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
2286                 if (r->in.info == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2287                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
2288                 NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
2289                 if (r->in.parm_error == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2290                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_error));
2291         }
2292         if (flags & NDR_OUT) {
2293                 if (r->out.parm_error == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2294                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_error));
2295                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2296         }
2297         return NT_STATUS_OK;
2298 }
2299
2300 NTSTATUS ndr_pull_wkssvc_NetWkstaSetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaSetInfo *r)
2301 {
2302         uint32_t _ptr_server_name;
2303         TALLOC_CTX *_mem_save_server_name_0;
2304         TALLOC_CTX *_mem_save_info_0;
2305         TALLOC_CTX *_mem_save_parm_error_0;
2306         if (flags & NDR_IN) {
2307                 ZERO_STRUCT(r->out);
2308
2309                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
2310                 if (_ptr_server_name) {
2311                         NDR_PULL_ALLOC(ndr, r->in.server_name);
2312                 } else {
2313                         r->in.server_name = NULL;
2314                 }
2315                 if (r->in.server_name) {
2316                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2317                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
2318                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
2319                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
2320                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
2321                                 return 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));
2322                         }
2323                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
2324                         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));
2325                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
2326                 }
2327                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
2328                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2329                         NDR_PULL_ALLOC(ndr, r->in.info);
2330                 }
2331                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
2332                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
2333                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
2334                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
2335                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
2336                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2337                         NDR_PULL_ALLOC(ndr, r->in.parm_error);
2338                 }
2339                 _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
2340                 NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_error, LIBNDR_FLAG_REF_ALLOC);
2341                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_error));
2342                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, LIBNDR_FLAG_REF_ALLOC);
2343                 NDR_PULL_ALLOC(ndr, r->out.parm_error);
2344                 *r->out.parm_error = *r->in.parm_error;
2345         }
2346         if (flags & NDR_OUT) {
2347                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2348                         NDR_PULL_ALLOC(ndr, r->out.parm_error);
2349                 }
2350                 _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
2351                 NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_error, LIBNDR_FLAG_REF_ALLOC);
2352                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_error));
2353                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, LIBNDR_FLAG_REF_ALLOC);
2354                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2355         }
2356         return NT_STATUS_OK;
2357 }
2358
2359 _PUBLIC_ void ndr_print_wkssvc_NetWkstaSetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaSetInfo *r)
2360 {
2361         ndr_print_struct(ndr, name, "wkssvc_NetWkstaSetInfo");
2362         ndr->depth++;
2363         if (flags & NDR_SET_VALUES) {
2364                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2365         }
2366         if (flags & NDR_IN) {
2367                 ndr_print_struct(ndr, "in", "wkssvc_NetWkstaSetInfo");
2368                 ndr->depth++;
2369                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
2370                 ndr->depth++;
2371                 if (r->in.server_name) {
2372                         ndr_print_string(ndr, "server_name", r->in.server_name);
2373                 }
2374                 ndr->depth--;
2375                 ndr_print_uint32(ndr, "level", r->in.level);
2376                 ndr_print_ptr(ndr, "info", r->in.info);
2377                 ndr->depth++;
2378                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
2379                 ndr_print_wkssvc_NetWkstaInfo(ndr, "info", r->in.info);
2380                 ndr->depth--;
2381                 ndr_print_ptr(ndr, "parm_error", r->in.parm_error);
2382                 ndr->depth++;
2383                 ndr_print_uint32(ndr, "parm_error", *r->in.parm_error);
2384                 ndr->depth--;
2385                 ndr->depth--;
2386         }
2387         if (flags & NDR_OUT) {
2388                 ndr_print_struct(ndr, "out", "wkssvc_NetWkstaSetInfo");
2389                 ndr->depth++;
2390                 ndr_print_ptr(ndr, "parm_error", r->out.parm_error);
2391                 ndr->depth++;
2392                 ndr_print_uint32(ndr, "parm_error", *r->out.parm_error);
2393                 ndr->depth--;
2394                 ndr_print_WERROR(ndr, "result", r->out.result);
2395                 ndr->depth--;
2396         }
2397         ndr->depth--;
2398 }
2399
2400 NTSTATUS ndr_push_wkssvc_NetWkstaEnumUsers(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaEnumUsers *r)
2401 {
2402         if (flags & NDR_IN) {
2403                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
2404                 if (r->in.server_name) {
2405                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
2406                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2407                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
2408                         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));
2409                 }
2410                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
2411                 if (r->in.users == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2412                 NDR_CHECK(ndr_push_WKS_USER_ENUM_UNION(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.users));
2413                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.prefmaxlen));
2414                 if (r->in.resumehandle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2415                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resumehandle));
2416         }
2417         if (flags & NDR_OUT) {
2418                 if (r->out.users == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2419                 NDR_CHECK(ndr_push_WKS_USER_ENUM_UNION(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.users));
2420                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.entriesread));
2421                 if (r->out.entriesread) {
2422                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.entriesread));
2423                 }
2424                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.totalentries));
2425                 if (r->out.totalentries) {
2426                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
2427                 }
2428                 if (r->out.resumehandle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2429                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resumehandle));
2430                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2431         }
2432         return NT_STATUS_OK;
2433 }
2434
2435 NTSTATUS ndr_pull_wkssvc_NetWkstaEnumUsers(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaEnumUsers *r)
2436 {
2437         uint32_t _ptr_server_name;
2438         uint32_t _ptr_entriesread;
2439         uint32_t _ptr_totalentries;
2440         TALLOC_CTX *_mem_save_server_name_0;
2441         TALLOC_CTX *_mem_save_users_0;
2442         TALLOC_CTX *_mem_save_entriesread_0;
2443         TALLOC_CTX *_mem_save_totalentries_0;
2444         TALLOC_CTX *_mem_save_resumehandle_0;
2445         if (flags & NDR_IN) {
2446                 ZERO_STRUCT(r->out);
2447
2448                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
2449                 if (_ptr_server_name) {
2450                         NDR_PULL_ALLOC(ndr, r->in.server_name);
2451                 } else {
2452                         r->in.server_name = NULL;
2453                 }
2454                 if (r->in.server_name) {
2455                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2456                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
2457                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
2458                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
2459                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
2460                                 return 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));
2461                         }
2462                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
2463                         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));
2464                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
2465                 }
2466                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
2467                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2468                         NDR_PULL_ALLOC(ndr, r->in.users);
2469                 }
2470                 _mem_save_users_0 = NDR_PULL_GET_MEM_CTX(ndr);
2471                 NDR_PULL_SET_MEM_CTX(ndr, r->in.users, LIBNDR_FLAG_REF_ALLOC);
2472                 NDR_CHECK(ndr_pull_WKS_USER_ENUM_UNION(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.users));
2473                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_users_0, LIBNDR_FLAG_REF_ALLOC);
2474                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.prefmaxlen));
2475                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2476                         NDR_PULL_ALLOC(ndr, r->in.resumehandle);
2477                 }
2478                 _mem_save_resumehandle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2479                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resumehandle, LIBNDR_FLAG_REF_ALLOC);
2480                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resumehandle));
2481                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resumehandle_0, LIBNDR_FLAG_REF_ALLOC);
2482                 NDR_PULL_ALLOC(ndr, r->out.users);
2483                 *r->out.users = *r->in.users;
2484                 NDR_PULL_ALLOC(ndr, r->out.resumehandle);
2485                 *r->out.resumehandle = *r->in.resumehandle;
2486         }
2487         if (flags & NDR_OUT) {
2488                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2489                         NDR_PULL_ALLOC(ndr, r->out.users);
2490                 }
2491                 _mem_save_users_0 = NDR_PULL_GET_MEM_CTX(ndr);
2492                 NDR_PULL_SET_MEM_CTX(ndr, r->out.users, LIBNDR_FLAG_REF_ALLOC);
2493                 NDR_CHECK(ndr_pull_WKS_USER_ENUM_UNION(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.users));
2494                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_users_0, LIBNDR_FLAG_REF_ALLOC);
2495                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entriesread));
2496                 if (_ptr_entriesread) {
2497                         NDR_PULL_ALLOC(ndr, r->out.entriesread);
2498                 } else {
2499                         r->out.entriesread = NULL;
2500                 }
2501                 if (r->out.entriesread) {
2502                         _mem_save_entriesread_0 = NDR_PULL_GET_MEM_CTX(ndr);
2503                         NDR_PULL_SET_MEM_CTX(ndr, r->out.entriesread, 0);
2504                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.entriesread));
2505                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entriesread_0, 0);
2506                 }
2507                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_totalentries));
2508                 if (_ptr_totalentries) {
2509                         NDR_PULL_ALLOC(ndr, r->out.totalentries);
2510                 } else {
2511                         r->out.totalentries = NULL;
2512                 }
2513                 if (r->out.totalentries) {
2514                         _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
2515                         NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, 0);
2516                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
2517                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, 0);
2518                 }
2519                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2520                         NDR_PULL_ALLOC(ndr, r->out.resumehandle);
2521                 }
2522                 _mem_save_resumehandle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2523                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resumehandle, LIBNDR_FLAG_REF_ALLOC);
2524                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resumehandle));
2525                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resumehandle_0, LIBNDR_FLAG_REF_ALLOC);
2526                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2527         }
2528         return NT_STATUS_OK;
2529 }
2530
2531 _PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsers(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaEnumUsers *r)
2532 {
2533         ndr_print_struct(ndr, name, "wkssvc_NetWkstaEnumUsers");
2534         ndr->depth++;
2535         if (flags & NDR_SET_VALUES) {
2536                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2537         }
2538         if (flags & NDR_IN) {
2539                 ndr_print_struct(ndr, "in", "wkssvc_NetWkstaEnumUsers");
2540                 ndr->depth++;
2541                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
2542                 ndr->depth++;
2543                 if (r->in.server_name) {
2544                         ndr_print_string(ndr, "server_name", r->in.server_name);
2545                 }
2546                 ndr->depth--;
2547                 ndr_print_uint32(ndr, "level", r->in.level);
2548                 ndr_print_ptr(ndr, "users", r->in.users);
2549                 ndr->depth++;
2550                 ndr_print_WKS_USER_ENUM_UNION(ndr, "users", r->in.users);
2551                 ndr->depth--;
2552                 ndr_print_uint32(ndr, "prefmaxlen", r->in.prefmaxlen);
2553                 ndr_print_ptr(ndr, "resumehandle", r->in.resumehandle);
2554                 ndr->depth++;
2555                 ndr_print_uint32(ndr, "resumehandle", *r->in.resumehandle);
2556                 ndr->depth--;
2557                 ndr->depth--;
2558         }
2559         if (flags & NDR_OUT) {
2560                 ndr_print_struct(ndr, "out", "wkssvc_NetWkstaEnumUsers");
2561                 ndr->depth++;
2562                 ndr_print_ptr(ndr, "users", r->out.users);
2563                 ndr->depth++;
2564                 ndr_print_WKS_USER_ENUM_UNION(ndr, "users", r->out.users);
2565                 ndr->depth--;
2566                 ndr_print_ptr(ndr, "entriesread", r->out.entriesread);
2567                 ndr->depth++;
2568                 if (r->out.entriesread) {
2569                         ndr_print_uint32(ndr, "entriesread", *r->out.entriesread);
2570                 }
2571                 ndr->depth--;
2572                 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
2573                 ndr->depth++;
2574                 if (r->out.totalentries) {
2575                         ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
2576                 }
2577                 ndr->depth--;
2578                 ndr_print_ptr(ndr, "resumehandle", r->out.resumehandle);
2579                 ndr->depth++;
2580                 ndr_print_uint32(ndr, "resumehandle", *r->out.resumehandle);
2581                 ndr->depth--;
2582                 ndr_print_WERROR(ndr, "result", r->out.result);
2583                 ndr->depth--;
2584         }
2585         ndr->depth--;
2586 }
2587
2588 NTSTATUS ndr_push_WKSSVC_NETRWKSTAUSERGETINFO(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRWKSTAUSERGETINFO *r)
2589 {
2590         if (flags & NDR_IN) {
2591         }
2592         if (flags & NDR_OUT) {
2593                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2594         }
2595         return NT_STATUS_OK;
2596 }
2597
2598 NTSTATUS ndr_pull_WKSSVC_NETRWKSTAUSERGETINFO(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRWKSTAUSERGETINFO *r)
2599 {
2600         if (flags & NDR_IN) {
2601         }
2602         if (flags & NDR_OUT) {
2603                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2604         }
2605         return NT_STATUS_OK;
2606 }
2607
2608 _PUBLIC_ void ndr_print_WKSSVC_NETRWKSTAUSERGETINFO(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRWKSTAUSERGETINFO *r)
2609 {
2610         ndr_print_struct(ndr, name, "WKSSVC_NETRWKSTAUSERGETINFO");
2611         ndr->depth++;
2612         if (flags & NDR_SET_VALUES) {
2613                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2614         }
2615         if (flags & NDR_IN) {
2616                 ndr_print_struct(ndr, "in", "WKSSVC_NETRWKSTAUSERGETINFO");
2617                 ndr->depth++;
2618                 ndr->depth--;
2619         }
2620         if (flags & NDR_OUT) {
2621                 ndr_print_struct(ndr, "out", "WKSSVC_NETRWKSTAUSERGETINFO");
2622                 ndr->depth++;
2623                 ndr_print_WERROR(ndr, "result", r->out.result);
2624                 ndr->depth--;
2625         }
2626         ndr->depth--;
2627 }
2628
2629 NTSTATUS ndr_push_WKSSVC_NETRWKSTAUSERSETINFO(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRWKSTAUSERSETINFO *r)
2630 {
2631         if (flags & NDR_IN) {
2632         }
2633         if (flags & NDR_OUT) {
2634                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2635         }
2636         return NT_STATUS_OK;
2637 }
2638
2639 NTSTATUS ndr_pull_WKSSVC_NETRWKSTAUSERSETINFO(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRWKSTAUSERSETINFO *r)
2640 {
2641         if (flags & NDR_IN) {
2642         }
2643         if (flags & NDR_OUT) {
2644                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2645         }
2646         return NT_STATUS_OK;
2647 }
2648
2649 _PUBLIC_ void ndr_print_WKSSVC_NETRWKSTAUSERSETINFO(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRWKSTAUSERSETINFO *r)
2650 {
2651         ndr_print_struct(ndr, name, "WKSSVC_NETRWKSTAUSERSETINFO");
2652         ndr->depth++;
2653         if (flags & NDR_SET_VALUES) {
2654                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2655         }
2656         if (flags & NDR_IN) {
2657                 ndr_print_struct(ndr, "in", "WKSSVC_NETRWKSTAUSERSETINFO");
2658                 ndr->depth++;
2659                 ndr->depth--;
2660         }
2661         if (flags & NDR_OUT) {
2662                 ndr_print_struct(ndr, "out", "WKSSVC_NETRWKSTAUSERSETINFO");
2663                 ndr->depth++;
2664                 ndr_print_WERROR(ndr, "result", r->out.result);
2665                 ndr->depth--;
2666         }
2667         ndr->depth--;
2668 }
2669
2670 NTSTATUS ndr_push_wkssvc_NetWkstaTransportEnum(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaTransportEnum *r)
2671 {
2672         if (flags & NDR_IN) {
2673                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
2674                 if (r->in.server_name) {
2675                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
2676                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2677                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
2678                         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));
2679                 }
2680                 if (r->in.level == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2681                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.level));
2682                 if (r->in.ctr == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2683                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.ctr, *r->in.level));
2684                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
2685                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));
2686                 if (r->in.resume_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2687                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
2688         }
2689         if (flags & NDR_OUT) {
2690                 if (r->out.level == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2691                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level));
2692                 if (r->out.ctr == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2693                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level));
2694                 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
2695                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.totalentries));
2696                 if (r->out.totalentries) {
2697                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
2698                 }
2699                 if (r->out.resume_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2700                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
2701                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2702         }
2703         return NT_STATUS_OK;
2704 }
2705
2706 NTSTATUS ndr_pull_wkssvc_NetWkstaTransportEnum(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaTransportEnum *r)
2707 {
2708         uint32_t _ptr_server_name;
2709         uint32_t _ptr_totalentries;
2710         TALLOC_CTX *_mem_save_server_name_0;
2711         TALLOC_CTX *_mem_save_level_0;
2712         TALLOC_CTX *_mem_save_ctr_0;
2713         TALLOC_CTX *_mem_save_totalentries_0;
2714         TALLOC_CTX *_mem_save_resume_handle_0;
2715         if (flags & NDR_IN) {
2716                 ZERO_STRUCT(r->out);
2717
2718                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
2719                 if (_ptr_server_name) {
2720                         NDR_PULL_ALLOC(ndr, r->in.server_name);
2721                 } else {
2722                         r->in.server_name = NULL;
2723                 }
2724                 if (r->in.server_name) {
2725                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2726                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
2727                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
2728                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
2729                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
2730                                 return 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));
2731                         }
2732                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
2733                         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));
2734                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
2735                 }
2736                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2737                         NDR_PULL_ALLOC(ndr, r->in.level);
2738                 }
2739                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
2740                 NDR_PULL_SET_MEM_CTX(ndr, r->in.level, LIBNDR_FLAG_REF_ALLOC);
2741                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.level));
2742                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
2743                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2744                         NDR_PULL_ALLOC(ndr, r->in.ctr);
2745                 }
2746                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
2747                 NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, LIBNDR_FLAG_REF_ALLOC);
2748                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.ctr, *r->in.level));
2749                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
2750                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
2751                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));
2752                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2753                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
2754                 }
2755                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2756                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
2757                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
2758                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
2759                 NDR_PULL_ALLOC(ndr, r->out.level);
2760                 *r->out.level = *r->in.level;
2761                 NDR_PULL_ALLOC(ndr, r->out.ctr);
2762                 *r->out.ctr = *r->in.ctr;
2763                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
2764                 *r->out.resume_handle = *r->in.resume_handle;
2765         }
2766         if (flags & NDR_OUT) {
2767                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2768                         NDR_PULL_ALLOC(ndr, r->out.level);
2769                 }
2770                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
2771                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level, LIBNDR_FLAG_REF_ALLOC);
2772                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level));
2773                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
2774                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2775                         NDR_PULL_ALLOC(ndr, r->out.ctr);
2776                 }
2777                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
2778                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
2779                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level));
2780                 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
2781                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
2782                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_totalentries));
2783                 if (_ptr_totalentries) {
2784                         NDR_PULL_ALLOC(ndr, r->out.totalentries);
2785                 } else {
2786                         r->out.totalentries = NULL;
2787                 }
2788                 if (r->out.totalentries) {
2789                         _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
2790                         NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, 0);
2791                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
2792                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, 0);
2793                 }
2794                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2795                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
2796                 }
2797                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2798                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
2799                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
2800                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
2801                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2802         }
2803         return NT_STATUS_OK;
2804 }
2805
2806 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportEnum(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaTransportEnum *r)
2807 {
2808         ndr_print_struct(ndr, name, "wkssvc_NetWkstaTransportEnum");
2809         ndr->depth++;
2810         if (flags & NDR_SET_VALUES) {
2811                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2812         }
2813         if (flags & NDR_IN) {
2814                 ndr_print_struct(ndr, "in", "wkssvc_NetWkstaTransportEnum");
2815                 ndr->depth++;
2816                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
2817                 ndr->depth++;
2818                 if (r->in.server_name) {
2819                         ndr_print_string(ndr, "server_name", r->in.server_name);
2820                 }
2821                 ndr->depth--;
2822                 ndr_print_ptr(ndr, "level", r->in.level);
2823                 ndr->depth++;
2824                 ndr_print_uint32(ndr, "level", *r->in.level);
2825                 ndr->depth--;
2826                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
2827                 ndr->depth++;
2828                 ndr_print_set_switch_value(ndr, r->in.ctr, *r->in.level);
2829                 ndr_print_wkssvc_NetWkstaTransportCtr(ndr, "ctr", r->in.ctr);
2830                 ndr->depth--;
2831                 ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);
2832                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
2833                 ndr->depth++;
2834                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
2835                 ndr->depth--;
2836                 ndr->depth--;
2837         }
2838         if (flags & NDR_OUT) {
2839                 ndr_print_struct(ndr, "out", "wkssvc_NetWkstaTransportEnum");
2840                 ndr->depth++;
2841                 ndr_print_ptr(ndr, "level", r->out.level);
2842                 ndr->depth++;
2843                 ndr_print_uint32(ndr, "level", *r->out.level);
2844                 ndr->depth--;
2845                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
2846                 ndr->depth++;
2847                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level);
2848                 ndr_print_wkssvc_NetWkstaTransportCtr(ndr, "ctr", r->out.ctr);
2849                 ndr->depth--;
2850                 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
2851                 ndr->depth++;
2852                 if (r->out.totalentries) {
2853                         ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
2854                 }
2855                 ndr->depth--;
2856                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
2857                 ndr->depth++;
2858                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
2859                 ndr->depth--;
2860                 ndr_print_WERROR(ndr, "result", r->out.result);
2861                 ndr->depth--;
2862         }
2863         ndr->depth--;
2864 }
2865
2866 NTSTATUS ndr_push_WKSSVC_NETRWKSTATRANSPORTADD(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRWKSTATRANSPORTADD *r)
2867 {
2868         if (flags & NDR_IN) {
2869         }
2870         if (flags & NDR_OUT) {
2871                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2872         }
2873         return NT_STATUS_OK;
2874 }
2875
2876 NTSTATUS ndr_pull_WKSSVC_NETRWKSTATRANSPORTADD(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRWKSTATRANSPORTADD *r)
2877 {
2878         if (flags & NDR_IN) {
2879         }
2880         if (flags & NDR_OUT) {
2881                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2882         }
2883         return NT_STATUS_OK;
2884 }
2885
2886 _PUBLIC_ void ndr_print_WKSSVC_NETRWKSTATRANSPORTADD(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRWKSTATRANSPORTADD *r)
2887 {
2888         ndr_print_struct(ndr, name, "WKSSVC_NETRWKSTATRANSPORTADD");
2889         ndr->depth++;
2890         if (flags & NDR_SET_VALUES) {
2891                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2892         }
2893         if (flags & NDR_IN) {
2894                 ndr_print_struct(ndr, "in", "WKSSVC_NETRWKSTATRANSPORTADD");
2895                 ndr->depth++;
2896                 ndr->depth--;
2897         }
2898         if (flags & NDR_OUT) {
2899                 ndr_print_struct(ndr, "out", "WKSSVC_NETRWKSTATRANSPORTADD");
2900                 ndr->depth++;
2901                 ndr_print_WERROR(ndr, "result", r->out.result);
2902                 ndr->depth--;
2903         }
2904         ndr->depth--;
2905 }
2906
2907 NTSTATUS ndr_push_WKSSVC_NETRWKSTATRANSPORTDEL(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRWKSTATRANSPORTDEL *r)
2908 {
2909         if (flags & NDR_IN) {
2910         }
2911         if (flags & NDR_OUT) {
2912                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2913         }
2914         return NT_STATUS_OK;
2915 }
2916
2917 NTSTATUS ndr_pull_WKSSVC_NETRWKSTATRANSPORTDEL(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRWKSTATRANSPORTDEL *r)
2918 {
2919         if (flags & NDR_IN) {
2920         }
2921         if (flags & NDR_OUT) {
2922                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2923         }
2924         return NT_STATUS_OK;
2925 }
2926
2927 _PUBLIC_ void ndr_print_WKSSVC_NETRWKSTATRANSPORTDEL(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRWKSTATRANSPORTDEL *r)
2928 {
2929         ndr_print_struct(ndr, name, "WKSSVC_NETRWKSTATRANSPORTDEL");
2930         ndr->depth++;
2931         if (flags & NDR_SET_VALUES) {
2932                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2933         }
2934         if (flags & NDR_IN) {
2935                 ndr_print_struct(ndr, "in", "WKSSVC_NETRWKSTATRANSPORTDEL");
2936                 ndr->depth++;
2937                 ndr->depth--;
2938         }
2939         if (flags & NDR_OUT) {
2940                 ndr_print_struct(ndr, "out", "WKSSVC_NETRWKSTATRANSPORTDEL");
2941                 ndr->depth++;
2942                 ndr_print_WERROR(ndr, "result", r->out.result);
2943                 ndr->depth--;
2944         }
2945         ndr->depth--;
2946 }
2947
2948 NTSTATUS ndr_push_WKSSVC_NETRUSEADD(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRUSEADD *r)
2949 {
2950         if (flags & NDR_IN) {
2951         }
2952         if (flags & NDR_OUT) {
2953                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2954         }
2955         return NT_STATUS_OK;
2956 }
2957
2958 NTSTATUS ndr_pull_WKSSVC_NETRUSEADD(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRUSEADD *r)
2959 {
2960         if (flags & NDR_IN) {
2961         }
2962         if (flags & NDR_OUT) {
2963                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2964         }
2965         return NT_STATUS_OK;
2966 }
2967
2968 _PUBLIC_ void ndr_print_WKSSVC_NETRUSEADD(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRUSEADD *r)
2969 {
2970         ndr_print_struct(ndr, name, "WKSSVC_NETRUSEADD");
2971         ndr->depth++;
2972         if (flags & NDR_SET_VALUES) {
2973                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2974         }
2975         if (flags & NDR_IN) {
2976                 ndr_print_struct(ndr, "in", "WKSSVC_NETRUSEADD");
2977                 ndr->depth++;
2978                 ndr->depth--;
2979         }
2980         if (flags & NDR_OUT) {
2981                 ndr_print_struct(ndr, "out", "WKSSVC_NETRUSEADD");
2982                 ndr->depth++;
2983                 ndr_print_WERROR(ndr, "result", r->out.result);
2984                 ndr->depth--;
2985         }
2986         ndr->depth--;
2987 }
2988
2989 NTSTATUS ndr_push_WKSSVC_NETRUSEGETINFO(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRUSEGETINFO *r)
2990 {
2991         if (flags & NDR_IN) {
2992         }
2993         if (flags & NDR_OUT) {
2994                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2995         }
2996         return NT_STATUS_OK;
2997 }
2998
2999 NTSTATUS ndr_pull_WKSSVC_NETRUSEGETINFO(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRUSEGETINFO *r)
3000 {
3001         if (flags & NDR_IN) {
3002         }
3003         if (flags & NDR_OUT) {
3004                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3005         }
3006         return NT_STATUS_OK;
3007 }
3008
3009 _PUBLIC_ void ndr_print_WKSSVC_NETRUSEGETINFO(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRUSEGETINFO *r)
3010 {
3011         ndr_print_struct(ndr, name, "WKSSVC_NETRUSEGETINFO");
3012         ndr->depth++;
3013         if (flags & NDR_SET_VALUES) {
3014                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3015         }
3016         if (flags & NDR_IN) {
3017                 ndr_print_struct(ndr, "in", "WKSSVC_NETRUSEGETINFO");
3018                 ndr->depth++;
3019                 ndr->depth--;
3020         }
3021         if (flags & NDR_OUT) {
3022                 ndr_print_struct(ndr, "out", "WKSSVC_NETRUSEGETINFO");
3023                 ndr->depth++;
3024                 ndr_print_WERROR(ndr, "result", r->out.result);
3025                 ndr->depth--;
3026         }
3027         ndr->depth--;
3028 }
3029
3030 NTSTATUS ndr_push_WKSSVC_NETRUSEDEL(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRUSEDEL *r)
3031 {
3032         if (flags & NDR_IN) {
3033         }
3034         if (flags & NDR_OUT) {
3035                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3036         }
3037         return NT_STATUS_OK;
3038 }
3039
3040 NTSTATUS ndr_pull_WKSSVC_NETRUSEDEL(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRUSEDEL *r)
3041 {
3042         if (flags & NDR_IN) {
3043         }
3044         if (flags & NDR_OUT) {
3045                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3046         }
3047         return NT_STATUS_OK;
3048 }
3049
3050 _PUBLIC_ void ndr_print_WKSSVC_NETRUSEDEL(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRUSEDEL *r)
3051 {
3052         ndr_print_struct(ndr, name, "WKSSVC_NETRUSEDEL");
3053         ndr->depth++;
3054         if (flags & NDR_SET_VALUES) {
3055                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3056         }
3057         if (flags & NDR_IN) {
3058                 ndr_print_struct(ndr, "in", "WKSSVC_NETRUSEDEL");
3059                 ndr->depth++;
3060                 ndr->depth--;
3061         }
3062         if (flags & NDR_OUT) {
3063                 ndr_print_struct(ndr, "out", "WKSSVC_NETRUSEDEL");
3064                 ndr->depth++;
3065                 ndr_print_WERROR(ndr, "result", r->out.result);
3066                 ndr->depth--;
3067         }
3068         ndr->depth--;
3069 }
3070
3071 NTSTATUS ndr_push_WKSSVC_NETRUSEENUM(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRUSEENUM *r)
3072 {
3073         if (flags & NDR_IN) {
3074         }
3075         if (flags & NDR_OUT) {
3076                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3077         }
3078         return NT_STATUS_OK;
3079 }
3080
3081 NTSTATUS ndr_pull_WKSSVC_NETRUSEENUM(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRUSEENUM *r)
3082 {
3083         if (flags & NDR_IN) {
3084         }
3085         if (flags & NDR_OUT) {
3086                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3087         }
3088         return NT_STATUS_OK;
3089 }
3090
3091 _PUBLIC_ void ndr_print_WKSSVC_NETRUSEENUM(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRUSEENUM *r)
3092 {
3093         ndr_print_struct(ndr, name, "WKSSVC_NETRUSEENUM");
3094         ndr->depth++;
3095         if (flags & NDR_SET_VALUES) {
3096                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3097         }
3098         if (flags & NDR_IN) {
3099                 ndr_print_struct(ndr, "in", "WKSSVC_NETRUSEENUM");
3100                 ndr->depth++;
3101                 ndr->depth--;
3102         }
3103         if (flags & NDR_OUT) {
3104                 ndr_print_struct(ndr, "out", "WKSSVC_NETRUSEENUM");
3105                 ndr->depth++;
3106                 ndr_print_WERROR(ndr, "result", r->out.result);
3107                 ndr->depth--;
3108         }
3109         ndr->depth--;
3110 }
3111
3112 NTSTATUS ndr_push_WKSSVC_NETRMESSAGEBUFFERSEND(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRMESSAGEBUFFERSEND *r)
3113 {
3114         if (flags & NDR_IN) {
3115         }
3116         if (flags & NDR_OUT) {
3117                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3118         }
3119         return NT_STATUS_OK;
3120 }
3121
3122 NTSTATUS ndr_pull_WKSSVC_NETRMESSAGEBUFFERSEND(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRMESSAGEBUFFERSEND *r)
3123 {
3124         if (flags & NDR_IN) {
3125         }
3126         if (flags & NDR_OUT) {
3127                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3128         }
3129         return NT_STATUS_OK;
3130 }
3131
3132 _PUBLIC_ void ndr_print_WKSSVC_NETRMESSAGEBUFFERSEND(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRMESSAGEBUFFERSEND *r)
3133 {
3134         ndr_print_struct(ndr, name, "WKSSVC_NETRMESSAGEBUFFERSEND");
3135         ndr->depth++;
3136         if (flags & NDR_SET_VALUES) {
3137                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3138         }
3139         if (flags & NDR_IN) {
3140                 ndr_print_struct(ndr, "in", "WKSSVC_NETRMESSAGEBUFFERSEND");
3141                 ndr->depth++;
3142                 ndr->depth--;
3143         }
3144         if (flags & NDR_OUT) {
3145                 ndr_print_struct(ndr, "out", "WKSSVC_NETRMESSAGEBUFFERSEND");
3146                 ndr->depth++;
3147                 ndr_print_WERROR(ndr, "result", r->out.result);
3148                 ndr->depth--;
3149         }
3150         ndr->depth--;
3151 }
3152
3153 NTSTATUS ndr_push_WKSSVC_NETRWORKSTATIONSTATISTICSGET(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRWORKSTATIONSTATISTICSGET *r)
3154 {
3155         if (flags & NDR_IN) {
3156         }
3157         if (flags & NDR_OUT) {
3158                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3159         }
3160         return NT_STATUS_OK;
3161 }
3162
3163 NTSTATUS ndr_pull_WKSSVC_NETRWORKSTATIONSTATISTICSGET(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRWORKSTATIONSTATISTICSGET *r)
3164 {
3165         if (flags & NDR_IN) {
3166         }
3167         if (flags & NDR_OUT) {
3168                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3169         }
3170         return NT_STATUS_OK;
3171 }
3172
3173 _PUBLIC_ void ndr_print_WKSSVC_NETRWORKSTATIONSTATISTICSGET(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRWORKSTATIONSTATISTICSGET *r)
3174 {
3175         ndr_print_struct(ndr, name, "WKSSVC_NETRWORKSTATIONSTATISTICSGET");
3176         ndr->depth++;
3177         if (flags & NDR_SET_VALUES) {
3178                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3179         }
3180         if (flags & NDR_IN) {
3181                 ndr_print_struct(ndr, "in", "WKSSVC_NETRWORKSTATIONSTATISTICSGET");
3182                 ndr->depth++;
3183                 ndr->depth--;
3184         }
3185         if (flags & NDR_OUT) {
3186                 ndr_print_struct(ndr, "out", "WKSSVC_NETRWORKSTATIONSTATISTICSGET");
3187                 ndr->depth++;
3188                 ndr_print_WERROR(ndr, "result", r->out.result);
3189                 ndr->depth--;
3190         }
3191         ndr->depth--;
3192 }
3193
3194 NTSTATUS ndr_push_WKSSVC_NETRLOGONDOMAINNAMEADD(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRLOGONDOMAINNAMEADD *r)
3195 {
3196         if (flags & NDR_IN) {
3197         }
3198         if (flags & NDR_OUT) {
3199                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3200         }
3201         return NT_STATUS_OK;
3202 }
3203
3204 NTSTATUS ndr_pull_WKSSVC_NETRLOGONDOMAINNAMEADD(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRLOGONDOMAINNAMEADD *r)
3205 {
3206         if (flags & NDR_IN) {
3207         }
3208         if (flags & NDR_OUT) {
3209                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3210         }
3211         return NT_STATUS_OK;
3212 }
3213
3214 _PUBLIC_ void ndr_print_WKSSVC_NETRLOGONDOMAINNAMEADD(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRLOGONDOMAINNAMEADD *r)
3215 {
3216         ndr_print_struct(ndr, name, "WKSSVC_NETRLOGONDOMAINNAMEADD");
3217         ndr->depth++;
3218         if (flags & NDR_SET_VALUES) {
3219                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3220         }
3221         if (flags & NDR_IN) {
3222                 ndr_print_struct(ndr, "in", "WKSSVC_NETRLOGONDOMAINNAMEADD");
3223                 ndr->depth++;
3224                 ndr->depth--;
3225         }
3226         if (flags & NDR_OUT) {
3227                 ndr_print_struct(ndr, "out", "WKSSVC_NETRLOGONDOMAINNAMEADD");
3228                 ndr->depth++;
3229                 ndr_print_WERROR(ndr, "result", r->out.result);
3230                 ndr->depth--;
3231         }
3232         ndr->depth--;
3233 }
3234
3235 NTSTATUS ndr_push_WKSSVC_NETRLOGONDOMAINNAMEDEL(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRLOGONDOMAINNAMEDEL *r)
3236 {
3237         if (flags & NDR_IN) {
3238         }
3239         if (flags & NDR_OUT) {
3240                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3241         }
3242         return NT_STATUS_OK;
3243 }
3244
3245 NTSTATUS ndr_pull_WKSSVC_NETRLOGONDOMAINNAMEDEL(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRLOGONDOMAINNAMEDEL *r)
3246 {
3247         if (flags & NDR_IN) {
3248         }
3249         if (flags & NDR_OUT) {
3250                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3251         }
3252         return NT_STATUS_OK;
3253 }
3254
3255 _PUBLIC_ void ndr_print_WKSSVC_NETRLOGONDOMAINNAMEDEL(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRLOGONDOMAINNAMEDEL *r)
3256 {
3257         ndr_print_struct(ndr, name, "WKSSVC_NETRLOGONDOMAINNAMEDEL");
3258         ndr->depth++;
3259         if (flags & NDR_SET_VALUES) {
3260                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3261         }
3262         if (flags & NDR_IN) {
3263                 ndr_print_struct(ndr, "in", "WKSSVC_NETRLOGONDOMAINNAMEDEL");
3264                 ndr->depth++;
3265                 ndr->depth--;
3266         }
3267         if (flags & NDR_OUT) {
3268                 ndr_print_struct(ndr, "out", "WKSSVC_NETRLOGONDOMAINNAMEDEL");
3269                 ndr->depth++;
3270                 ndr_print_WERROR(ndr, "result", r->out.result);
3271                 ndr->depth--;
3272         }
3273         ndr->depth--;
3274 }
3275
3276 NTSTATUS ndr_push_WKSSVC_NETRJOINDOMAIN(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRJOINDOMAIN *r)
3277 {
3278         if (flags & NDR_IN) {
3279         }
3280         if (flags & NDR_OUT) {
3281                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3282         }
3283         return NT_STATUS_OK;
3284 }
3285
3286 NTSTATUS ndr_pull_WKSSVC_NETRJOINDOMAIN(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRJOINDOMAIN *r)
3287 {
3288         if (flags & NDR_IN) {
3289         }
3290         if (flags & NDR_OUT) {
3291                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3292         }
3293         return NT_STATUS_OK;
3294 }
3295
3296 _PUBLIC_ void ndr_print_WKSSVC_NETRJOINDOMAIN(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRJOINDOMAIN *r)
3297 {
3298         ndr_print_struct(ndr, name, "WKSSVC_NETRJOINDOMAIN");
3299         ndr->depth++;
3300         if (flags & NDR_SET_VALUES) {
3301                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3302         }
3303         if (flags & NDR_IN) {
3304                 ndr_print_struct(ndr, "in", "WKSSVC_NETRJOINDOMAIN");
3305                 ndr->depth++;
3306                 ndr->depth--;
3307         }
3308         if (flags & NDR_OUT) {
3309                 ndr_print_struct(ndr, "out", "WKSSVC_NETRJOINDOMAIN");
3310                 ndr->depth++;
3311                 ndr_print_WERROR(ndr, "result", r->out.result);
3312                 ndr->depth--;
3313         }
3314         ndr->depth--;
3315 }
3316
3317 NTSTATUS ndr_push_WKSSVC_NETRUNJOINDOMAIN(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRUNJOINDOMAIN *r)
3318 {
3319         if (flags & NDR_IN) {
3320         }
3321         if (flags & NDR_OUT) {
3322                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3323         }
3324         return NT_STATUS_OK;
3325 }
3326
3327 NTSTATUS ndr_pull_WKSSVC_NETRUNJOINDOMAIN(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRUNJOINDOMAIN *r)
3328 {
3329         if (flags & NDR_IN) {
3330         }
3331         if (flags & NDR_OUT) {
3332                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3333         }
3334         return NT_STATUS_OK;
3335 }
3336
3337 _PUBLIC_ void ndr_print_WKSSVC_NETRUNJOINDOMAIN(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRUNJOINDOMAIN *r)
3338 {
3339         ndr_print_struct(ndr, name, "WKSSVC_NETRUNJOINDOMAIN");
3340         ndr->depth++;
3341         if (flags & NDR_SET_VALUES) {
3342                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3343         }
3344         if (flags & NDR_IN) {
3345                 ndr_print_struct(ndr, "in", "WKSSVC_NETRUNJOINDOMAIN");
3346                 ndr->depth++;
3347                 ndr->depth--;
3348         }
3349         if (flags & NDR_OUT) {
3350                 ndr_print_struct(ndr, "out", "WKSSVC_NETRUNJOINDOMAIN");
3351                 ndr->depth++;
3352                 ndr_print_WERROR(ndr, "result", r->out.result);
3353                 ndr->depth--;
3354         }
3355         ndr->depth--;
3356 }
3357
3358 NTSTATUS ndr_push_WKSSVC_NETRRENAMEMACHINEINDOMAIN(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRRENAMEMACHINEINDOMAIN *r)
3359 {
3360         if (flags & NDR_IN) {
3361         }
3362         if (flags & NDR_OUT) {
3363                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3364         }
3365         return NT_STATUS_OK;
3366 }
3367
3368 NTSTATUS ndr_pull_WKSSVC_NETRRENAMEMACHINEINDOMAIN(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRRENAMEMACHINEINDOMAIN *r)
3369 {
3370         if (flags & NDR_IN) {
3371         }
3372         if (flags & NDR_OUT) {
3373                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3374         }
3375         return NT_STATUS_OK;
3376 }
3377
3378 _PUBLIC_ void ndr_print_WKSSVC_NETRRENAMEMACHINEINDOMAIN(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRRENAMEMACHINEINDOMAIN *r)
3379 {
3380         ndr_print_struct(ndr, name, "WKSSVC_NETRRENAMEMACHINEINDOMAIN");
3381         ndr->depth++;
3382         if (flags & NDR_SET_VALUES) {
3383                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3384         }
3385         if (flags & NDR_IN) {
3386                 ndr_print_struct(ndr, "in", "WKSSVC_NETRRENAMEMACHINEINDOMAIN");
3387                 ndr->depth++;
3388                 ndr->depth--;
3389         }
3390         if (flags & NDR_OUT) {
3391                 ndr_print_struct(ndr, "out", "WKSSVC_NETRRENAMEMACHINEINDOMAIN");
3392                 ndr->depth++;
3393                 ndr_print_WERROR(ndr, "result", r->out.result);
3394                 ndr->depth--;
3395         }
3396         ndr->depth--;
3397 }
3398
3399 NTSTATUS ndr_push_WKSSVC_NETRVALIDATENAME(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRVALIDATENAME *r)
3400 {
3401         if (flags & NDR_IN) {
3402         }
3403         if (flags & NDR_OUT) {
3404                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3405         }
3406         return NT_STATUS_OK;
3407 }
3408
3409 NTSTATUS ndr_pull_WKSSVC_NETRVALIDATENAME(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRVALIDATENAME *r)
3410 {
3411         if (flags & NDR_IN) {
3412         }
3413         if (flags & NDR_OUT) {
3414                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3415         }
3416         return NT_STATUS_OK;
3417 }
3418
3419 _PUBLIC_ void ndr_print_WKSSVC_NETRVALIDATENAME(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRVALIDATENAME *r)
3420 {
3421         ndr_print_struct(ndr, name, "WKSSVC_NETRVALIDATENAME");
3422         ndr->depth++;
3423         if (flags & NDR_SET_VALUES) {
3424                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3425         }
3426         if (flags & NDR_IN) {
3427                 ndr_print_struct(ndr, "in", "WKSSVC_NETRVALIDATENAME");
3428                 ndr->depth++;
3429                 ndr->depth--;
3430         }
3431         if (flags & NDR_OUT) {
3432                 ndr_print_struct(ndr, "out", "WKSSVC_NETRVALIDATENAME");
3433                 ndr->depth++;
3434                 ndr_print_WERROR(ndr, "result", r->out.result);
3435                 ndr->depth--;
3436         }
3437         ndr->depth--;
3438 }
3439
3440 NTSTATUS ndr_push_WKSSVC_NETRGETJOININFORMATION(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRGETJOININFORMATION *r)
3441 {
3442         if (flags & NDR_IN) {
3443         }
3444         if (flags & NDR_OUT) {
3445                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3446         }
3447         return NT_STATUS_OK;
3448 }
3449
3450 NTSTATUS ndr_pull_WKSSVC_NETRGETJOININFORMATION(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRGETJOININFORMATION *r)
3451 {
3452         if (flags & NDR_IN) {
3453         }
3454         if (flags & NDR_OUT) {
3455                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3456         }
3457         return NT_STATUS_OK;
3458 }
3459
3460 _PUBLIC_ void ndr_print_WKSSVC_NETRGETJOININFORMATION(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRGETJOININFORMATION *r)
3461 {
3462         ndr_print_struct(ndr, name, "WKSSVC_NETRGETJOININFORMATION");
3463         ndr->depth++;
3464         if (flags & NDR_SET_VALUES) {
3465                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3466         }
3467         if (flags & NDR_IN) {
3468                 ndr_print_struct(ndr, "in", "WKSSVC_NETRGETJOININFORMATION");
3469                 ndr->depth++;
3470                 ndr->depth--;
3471         }
3472         if (flags & NDR_OUT) {
3473                 ndr_print_struct(ndr, "out", "WKSSVC_NETRGETJOININFORMATION");
3474                 ndr->depth++;
3475                 ndr_print_WERROR(ndr, "result", r->out.result);
3476                 ndr->depth--;
3477         }
3478         ndr->depth--;
3479 }
3480
3481 NTSTATUS ndr_push_WKSSVC_NETRGETJOINABLEOUS(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRGETJOINABLEOUS *r)
3482 {
3483         if (flags & NDR_IN) {
3484         }
3485         if (flags & NDR_OUT) {
3486                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3487         }
3488         return NT_STATUS_OK;
3489 }
3490
3491 NTSTATUS ndr_pull_WKSSVC_NETRGETJOINABLEOUS(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRGETJOINABLEOUS *r)
3492 {
3493         if (flags & NDR_IN) {
3494         }
3495         if (flags & NDR_OUT) {
3496                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3497         }
3498         return NT_STATUS_OK;
3499 }
3500
3501 _PUBLIC_ void ndr_print_WKSSVC_NETRGETJOINABLEOUS(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRGETJOINABLEOUS *r)
3502 {
3503         ndr_print_struct(ndr, name, "WKSSVC_NETRGETJOINABLEOUS");
3504         ndr->depth++;
3505         if (flags & NDR_SET_VALUES) {
3506                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3507         }
3508         if (flags & NDR_IN) {
3509                 ndr_print_struct(ndr, "in", "WKSSVC_NETRGETJOINABLEOUS");
3510                 ndr->depth++;
3511                 ndr->depth--;
3512         }
3513         if (flags & NDR_OUT) {
3514                 ndr_print_struct(ndr, "out", "WKSSVC_NETRGETJOINABLEOUS");
3515                 ndr->depth++;
3516                 ndr_print_WERROR(ndr, "result", r->out.result);
3517                 ndr->depth--;
3518         }
3519         ndr->depth--;
3520 }
3521
3522 NTSTATUS ndr_push_wkssvc_NetrJoinDomain2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrJoinDomain2 *r)
3523 {
3524         if (flags & NDR_IN) {
3525                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
3526                 if (r->in.server_name) {
3527                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
3528                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3529                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
3530                         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));
3531                 }
3532                 if (r->in.domain_name == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3533                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
3534                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3535                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
3536                 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));
3537                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.account_name));
3538                 if (r->in.account_name) {
3539                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account_name, CH_UTF16)));
3540                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3541                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account_name, CH_UTF16)));
3542                         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));
3543                 }
3544                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.admin_account));
3545                 if (r->in.admin_account) {
3546                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.admin_account, CH_UTF16)));
3547                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3548                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.admin_account, CH_UTF16)));
3549                         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));
3550                 }
3551                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.encrypted_password));
3552                 if (r->in.encrypted_password) {
3553                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));
3554                 }
3555                 NDR_CHECK(ndr_push_wkssvc_joinflags(ndr, NDR_SCALARS, r->in.join_flags));
3556         }
3557         if (flags & NDR_OUT) {
3558                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3559         }
3560         return NT_STATUS_OK;
3561 }
3562
3563 NTSTATUS ndr_pull_wkssvc_NetrJoinDomain2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrJoinDomain2 *r)
3564 {
3565         uint32_t _ptr_server_name;
3566         uint32_t _ptr_account_name;
3567         uint32_t _ptr_admin_account;
3568         uint32_t _ptr_encrypted_password;
3569         TALLOC_CTX *_mem_save_server_name_0;
3570         TALLOC_CTX *_mem_save_account_name_0;
3571         TALLOC_CTX *_mem_save_admin_account_0;
3572         TALLOC_CTX *_mem_save_encrypted_password_0;
3573         if (flags & NDR_IN) {
3574                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3575                 if (_ptr_server_name) {
3576                         NDR_PULL_ALLOC(ndr, r->in.server_name);
3577                 } else {
3578                         r->in.server_name = NULL;
3579                 }
3580                 if (r->in.server_name) {
3581                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3582                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
3583                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
3584                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
3585                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
3586                                 return 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));
3587                         }
3588                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
3589                         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));
3590                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3591                 }
3592                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
3593                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
3594                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
3595                         return 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));
3596                 }
3597                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
3598                 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));
3599                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account_name));
3600                 if (_ptr_account_name) {
3601                         NDR_PULL_ALLOC(ndr, r->in.account_name);
3602                 } else {
3603                         r->in.account_name = NULL;
3604                 }
3605                 if (r->in.account_name) {
3606                         _mem_save_account_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3607                         NDR_PULL_SET_MEM_CTX(ndr, r->in.account_name, 0);
3608                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.account_name));
3609                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.account_name));
3610                         if (ndr_get_array_length(ndr, &r->in.account_name) > ndr_get_array_size(ndr, &r->in.account_name)) {
3611                                 return 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));
3612                         }
3613                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.account_name), sizeof(uint16_t)));
3614                         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));
3615                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_0, 0);
3616                 }
3617                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_admin_account));
3618                 if (_ptr_admin_account) {
3619                         NDR_PULL_ALLOC(ndr, r->in.admin_account);
3620                 } else {
3621                         r->in.admin_account = NULL;
3622                 }
3623                 if (r->in.admin_account) {
3624                         _mem_save_admin_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
3625                         NDR_PULL_SET_MEM_CTX(ndr, r->in.admin_account, 0);
3626                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.admin_account));
3627                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.admin_account));
3628                         if (ndr_get_array_length(ndr, &r->in.admin_account) > ndr_get_array_size(ndr, &r->in.admin_account)) {
3629                                 return 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));
3630                         }
3631                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.admin_account), sizeof(uint16_t)));
3632                         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));
3633                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_admin_account_0, 0);
3634                 }
3635                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_encrypted_password));
3636                 if (_ptr_encrypted_password) {
3637                         NDR_PULL_ALLOC(ndr, r->in.encrypted_password);
3638                 } else {
3639                         r->in.encrypted_password = NULL;
3640                 }
3641                 if (r->in.encrypted_password) {
3642                         _mem_save_encrypted_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
3643                         NDR_PULL_SET_MEM_CTX(ndr, r->in.encrypted_password, 0);
3644                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));
3645                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_encrypted_password_0, 0);
3646                 }
3647                 NDR_CHECK(ndr_pull_wkssvc_joinflags(ndr, NDR_SCALARS, &r->in.join_flags));
3648         }
3649         if (flags & NDR_OUT) {
3650                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3651         }
3652         return NT_STATUS_OK;
3653 }
3654
3655 _PUBLIC_ void ndr_print_wkssvc_NetrJoinDomain2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrJoinDomain2 *r)
3656 {
3657         ndr_print_struct(ndr, name, "wkssvc_NetrJoinDomain2");
3658         ndr->depth++;
3659         if (flags & NDR_SET_VALUES) {
3660                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3661         }
3662         if (flags & NDR_IN) {
3663                 ndr_print_struct(ndr, "in", "wkssvc_NetrJoinDomain2");
3664                 ndr->depth++;
3665                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
3666                 ndr->depth++;
3667                 if (r->in.server_name) {
3668                         ndr_print_string(ndr, "server_name", r->in.server_name);
3669                 }
3670                 ndr->depth--;
3671                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
3672                 ndr->depth++;
3673                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
3674                 ndr->depth--;
3675                 ndr_print_ptr(ndr, "account_name", r->in.account_name);
3676                 ndr->depth++;
3677                 if (r->in.account_name) {
3678                         ndr_print_string(ndr, "account_name", r->in.account_name);
3679                 }
3680                 ndr->depth--;
3681                 ndr_print_ptr(ndr, "admin_account", r->in.admin_account);
3682                 ndr->depth++;
3683                 if (r->in.admin_account) {
3684                         ndr_print_string(ndr, "admin_account", r->in.admin_account);
3685                 }
3686                 ndr->depth--;
3687                 ndr_print_ptr(ndr, "encrypted_password", r->in.encrypted_password);
3688                 ndr->depth++;
3689                 if (r->in.encrypted_password) {
3690                         ndr_print_wkssvc_PasswordBuffer(ndr, "encrypted_password", r->in.encrypted_password);
3691                 }
3692                 ndr->depth--;
3693                 ndr_print_wkssvc_joinflags(ndr, "join_flags", r->in.join_flags);
3694                 ndr->depth--;
3695         }
3696         if (flags & NDR_OUT) {
3697                 ndr_print_struct(ndr, "out", "wkssvc_NetrJoinDomain2");
3698                 ndr->depth++;
3699                 ndr_print_WERROR(ndr, "result", r->out.result);
3700                 ndr->depth--;
3701         }
3702         ndr->depth--;
3703 }
3704
3705 NTSTATUS ndr_push_wkssvc_NetrUnjoinDomain2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUnjoinDomain2 *r)
3706 {
3707         if (flags & NDR_IN) {
3708                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
3709                 if (r->in.server_name) {
3710                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
3711                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3712                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
3713                         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));
3714                 }
3715                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.account));
3716                 if (r->in.account) {
3717                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account, CH_UTF16)));
3718                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3719                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account, CH_UTF16)));
3720                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.account, ndr_charset_length(r->in.account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3721                 }
3722                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.encrypted_password));
3723                 if (r->in.encrypted_password) {
3724                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));
3725                 }
3726                 NDR_CHECK(ndr_push_wkssvc_joinflags(ndr, NDR_SCALARS, r->in.unjoin_flags));
3727         }
3728         if (flags & NDR_OUT) {
3729                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3730         }
3731         return NT_STATUS_OK;
3732 }
3733
3734 NTSTATUS ndr_pull_wkssvc_NetrUnjoinDomain2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUnjoinDomain2 *r)
3735 {
3736         uint32_t _ptr_server_name;
3737         uint32_t _ptr_account;
3738         uint32_t _ptr_encrypted_password;
3739         TALLOC_CTX *_mem_save_server_name_0;
3740         TALLOC_CTX *_mem_save_account_0;
3741         TALLOC_CTX *_mem_save_encrypted_password_0;
3742         if (flags & NDR_IN) {
3743                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3744                 if (_ptr_server_name) {
3745                         NDR_PULL_ALLOC(ndr, r->in.server_name);
3746                 } else {
3747                         r->in.server_name = NULL;
3748                 }
3749                 if (r->in.server_name) {
3750                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3751                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
3752                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
3753                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
3754                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
3755                                 return 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));
3756                         }
3757                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
3758                         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));
3759                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3760                 }
3761                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account));
3762                 if (_ptr_account) {
3763                         NDR_PULL_ALLOC(ndr, r->in.account);
3764                 } else {
3765                         r->in.account = NULL;
3766                 }
3767                 if (r->in.account) {
3768                         _mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
3769                         NDR_PULL_SET_MEM_CTX(ndr, r->in.account, 0);
3770                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.account));
3771                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.account));
3772                         if (ndr_get_array_length(ndr, &r->in.account) > ndr_get_array_size(ndr, &r->in.account)) {
3773                                 return 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));
3774                         }
3775                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.account), sizeof(uint16_t)));
3776                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.account, ndr_get_array_length(ndr, &r->in.account), sizeof(uint16_t), CH_UTF16));
3777                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, 0);
3778                 }
3779                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_encrypted_password));
3780                 if (_ptr_encrypted_password) {
3781                         NDR_PULL_ALLOC(ndr, r->in.encrypted_password);
3782                 } else {
3783                         r->in.encrypted_password = NULL;
3784                 }
3785                 if (r->in.encrypted_password) {
3786                         _mem_save_encrypted_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
3787                         NDR_PULL_SET_MEM_CTX(ndr, r->in.encrypted_password, 0);
3788                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));
3789                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_encrypted_password_0, 0);
3790                 }
3791                 NDR_CHECK(ndr_pull_wkssvc_joinflags(ndr, NDR_SCALARS, &r->in.unjoin_flags));
3792         }
3793         if (flags & NDR_OUT) {
3794                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3795         }
3796         return NT_STATUS_OK;
3797 }
3798
3799 _PUBLIC_ void ndr_print_wkssvc_NetrUnjoinDomain2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUnjoinDomain2 *r)
3800 {
3801         ndr_print_struct(ndr, name, "wkssvc_NetrUnjoinDomain2");
3802         ndr->depth++;
3803         if (flags & NDR_SET_VALUES) {
3804                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3805         }
3806         if (flags & NDR_IN) {
3807                 ndr_print_struct(ndr, "in", "wkssvc_NetrUnjoinDomain2");
3808                 ndr->depth++;
3809                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
3810                 ndr->depth++;
3811                 if (r->in.server_name) {
3812                         ndr_print_string(ndr, "server_name", r->in.server_name);
3813                 }
3814                 ndr->depth--;
3815                 ndr_print_ptr(ndr, "account", r->in.account);
3816                 ndr->depth++;
3817                 if (r->in.account) {
3818                         ndr_print_string(ndr, "account", r->in.account);
3819                 }
3820                 ndr->depth--;
3821                 ndr_print_ptr(ndr, "encrypted_password", r->in.encrypted_password);
3822                 ndr->depth++;
3823                 if (r->in.encrypted_password) {
3824                         ndr_print_wkssvc_PasswordBuffer(ndr, "encrypted_password", r->in.encrypted_password);
3825                 }
3826                 ndr->depth--;
3827                 ndr_print_wkssvc_joinflags(ndr, "unjoin_flags", r->in.unjoin_flags);
3828                 ndr->depth--;
3829         }
3830         if (flags & NDR_OUT) {
3831                 ndr_print_struct(ndr, "out", "wkssvc_NetrUnjoinDomain2");
3832                 ndr->depth++;
3833                 ndr_print_WERROR(ndr, "result", r->out.result);
3834                 ndr->depth--;
3835         }
3836         ndr->depth--;
3837 }
3838
3839 NTSTATUS ndr_push_wkssvc_NetrRenameMachineInDomain2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrRenameMachineInDomain2 *r)
3840 {
3841         if (flags & NDR_IN) {
3842                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
3843                 if (r->in.server_name) {
3844                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
3845                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3846                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
3847                         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));
3848                 }
3849                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.NewMachineName));
3850                 if (r->in.NewMachineName) {
3851                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewMachineName, CH_UTF16)));
3852                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3853                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewMachineName, CH_UTF16)));
3854                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.NewMachineName, ndr_charset_length(r->in.NewMachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3855                 }
3856                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
3857                 if (r->in.Account) {
3858                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
3859                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3860                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
3861                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3862                 }
3863                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
3864                 if (r->in.EncryptedPassword) {
3865                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
3866                 }
3867                 NDR_CHECK(ndr_push_wkssvc_renameflags(ndr, NDR_SCALARS, r->in.RenameOptions));
3868         }
3869         if (flags & NDR_OUT) {
3870                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3871         }
3872         return NT_STATUS_OK;
3873 }
3874
3875 NTSTATUS ndr_pull_wkssvc_NetrRenameMachineInDomain2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrRenameMachineInDomain2 *r)
3876 {
3877         uint32_t _ptr_server_name;
3878         uint32_t _ptr_NewMachineName;
3879         uint32_t _ptr_Account;
3880         uint32_t _ptr_EncryptedPassword;
3881         TALLOC_CTX *_mem_save_server_name_0;
3882         TALLOC_CTX *_mem_save_NewMachineName_0;
3883         TALLOC_CTX *_mem_save_Account_0;
3884         TALLOC_CTX *_mem_save_EncryptedPassword_0;
3885         if (flags & NDR_IN) {
3886                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3887                 if (_ptr_server_name) {
3888                         NDR_PULL_ALLOC(ndr, r->in.server_name);
3889                 } else {
3890                         r->in.server_name = NULL;
3891                 }
3892                 if (r->in.server_name) {
3893                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3894                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
3895                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
3896                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
3897                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
3898                                 return 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));
3899                         }
3900                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
3901                         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));
3902                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3903                 }
3904                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_NewMachineName));
3905                 if (_ptr_NewMachineName) {
3906                         NDR_PULL_ALLOC(ndr, r->in.NewMachineName);
3907                 } else {
3908                         r->in.NewMachineName = NULL;
3909                 }
3910                 if (r->in.NewMachineName) {
3911                         _mem_save_NewMachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);
3912                         NDR_PULL_SET_MEM_CTX(ndr, r->in.NewMachineName, 0);
3913                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.NewMachineName));
3914                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.NewMachineName));
3915                         if (ndr_get_array_length(ndr, &r->in.NewMachineName) > ndr_get_array_size(ndr, &r->in.NewMachineName)) {
3916                                 return 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));
3917                         }
3918                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.NewMachineName), sizeof(uint16_t)));
3919                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.NewMachineName, ndr_get_array_length(ndr, &r->in.NewMachineName), sizeof(uint16_t), CH_UTF16));
3920                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_NewMachineName_0, 0);
3921                 }
3922                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
3923                 if (_ptr_Account) {
3924                         NDR_PULL_ALLOC(ndr, r->in.Account);
3925                 } else {
3926                         r->in.Account = NULL;
3927                 }
3928                 if (r->in.Account) {
3929                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
3930                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
3931                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
3932                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
3933                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
3934                                 return 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));
3935                         }
3936                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
3937                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
3938                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
3939                 }
3940                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
3941                 if (_ptr_EncryptedPassword) {
3942                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
3943                 } else {
3944                         r->in.EncryptedPassword = NULL;
3945                 }
3946                 if (r->in.EncryptedPassword) {
3947                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
3948                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
3949                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
3950                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
3951                 }
3952                 NDR_CHECK(ndr_pull_wkssvc_renameflags(ndr, NDR_SCALARS, &r->in.RenameOptions));
3953         }
3954         if (flags & NDR_OUT) {
3955                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3956         }
3957         return NT_STATUS_OK;
3958 }
3959
3960 _PUBLIC_ void ndr_print_wkssvc_NetrRenameMachineInDomain2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrRenameMachineInDomain2 *r)
3961 {
3962         ndr_print_struct(ndr, name, "wkssvc_NetrRenameMachineInDomain2");
3963         ndr->depth++;
3964         if (flags & NDR_SET_VALUES) {
3965                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3966         }
3967         if (flags & NDR_IN) {
3968                 ndr_print_struct(ndr, "in", "wkssvc_NetrRenameMachineInDomain2");
3969                 ndr->depth++;
3970                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
3971                 ndr->depth++;
3972                 if (r->in.server_name) {
3973                         ndr_print_string(ndr, "server_name", r->in.server_name);
3974                 }
3975                 ndr->depth--;
3976                 ndr_print_ptr(ndr, "NewMachineName", r->in.NewMachineName);
3977                 ndr->depth++;
3978                 if (r->in.NewMachineName) {
3979                         ndr_print_string(ndr, "NewMachineName", r->in.NewMachineName);
3980                 }
3981                 ndr->depth--;
3982                 ndr_print_ptr(ndr, "Account", r->in.Account);
3983                 ndr->depth++;
3984                 if (r->in.Account) {
3985                         ndr_print_string(ndr, "Account", r->in.Account);
3986                 }
3987                 ndr->depth--;
3988                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
3989                 ndr->depth++;
3990                 if (r->in.EncryptedPassword) {
3991                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
3992                 }
3993                 ndr->depth--;
3994                 ndr_print_wkssvc_renameflags(ndr, "RenameOptions", r->in.RenameOptions);
3995                 ndr->depth--;
3996         }
3997         if (flags & NDR_OUT) {
3998                 ndr_print_struct(ndr, "out", "wkssvc_NetrRenameMachineInDomain2");
3999                 ndr->depth++;
4000                 ndr_print_WERROR(ndr, "result", r->out.result);
4001                 ndr->depth--;
4002         }
4003         ndr->depth--;
4004 }
4005
4006 NTSTATUS ndr_push_WKSSVC_NETRVALIDATENAME2(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRVALIDATENAME2 *r)
4007 {
4008         if (flags & NDR_IN) {
4009         }
4010         if (flags & NDR_OUT) {
4011                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4012         }
4013         return NT_STATUS_OK;
4014 }
4015
4016 NTSTATUS ndr_pull_WKSSVC_NETRVALIDATENAME2(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRVALIDATENAME2 *r)
4017 {
4018         if (flags & NDR_IN) {
4019         }
4020         if (flags & NDR_OUT) {
4021                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4022         }
4023         return NT_STATUS_OK;
4024 }
4025
4026 _PUBLIC_ void ndr_print_WKSSVC_NETRVALIDATENAME2(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRVALIDATENAME2 *r)
4027 {
4028         ndr_print_struct(ndr, name, "WKSSVC_NETRVALIDATENAME2");
4029         ndr->depth++;
4030         if (flags & NDR_SET_VALUES) {
4031                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4032         }
4033         if (flags & NDR_IN) {
4034                 ndr_print_struct(ndr, "in", "WKSSVC_NETRVALIDATENAME2");
4035                 ndr->depth++;
4036                 ndr->depth--;
4037         }
4038         if (flags & NDR_OUT) {
4039                 ndr_print_struct(ndr, "out", "WKSSVC_NETRVALIDATENAME2");
4040                 ndr->depth++;
4041                 ndr_print_WERROR(ndr, "result", r->out.result);
4042                 ndr->depth--;
4043         }
4044         ndr->depth--;
4045 }
4046
4047 NTSTATUS ndr_push_WKSSVC_NETRGETJOINABLEOUS2(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRGETJOINABLEOUS2 *r)
4048 {
4049         if (flags & NDR_IN) {
4050         }
4051         if (flags & NDR_OUT) {
4052                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4053         }
4054         return NT_STATUS_OK;
4055 }
4056
4057 NTSTATUS ndr_pull_WKSSVC_NETRGETJOINABLEOUS2(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRGETJOINABLEOUS2 *r)
4058 {
4059         if (flags & NDR_IN) {
4060         }
4061         if (flags & NDR_OUT) {
4062                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4063         }
4064         return NT_STATUS_OK;
4065 }
4066
4067 _PUBLIC_ void ndr_print_WKSSVC_NETRGETJOINABLEOUS2(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRGETJOINABLEOUS2 *r)
4068 {
4069         ndr_print_struct(ndr, name, "WKSSVC_NETRGETJOINABLEOUS2");
4070         ndr->depth++;
4071         if (flags & NDR_SET_VALUES) {
4072                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4073         }
4074         if (flags & NDR_IN) {
4075                 ndr_print_struct(ndr, "in", "WKSSVC_NETRGETJOINABLEOUS2");
4076                 ndr->depth++;
4077                 ndr->depth--;
4078         }
4079         if (flags & NDR_OUT) {
4080                 ndr_print_struct(ndr, "out", "WKSSVC_NETRGETJOINABLEOUS2");
4081                 ndr->depth++;
4082                 ndr_print_WERROR(ndr, "result", r->out.result);
4083                 ndr->depth--;
4084         }
4085         ndr->depth--;
4086 }
4087
4088 NTSTATUS ndr_push_wkssvc_NetrAddAlternateComputerName(struct ndr_push *ndr, int flags, const struct wkssvc_NetrAddAlternateComputerName *r)
4089 {
4090         if (flags & NDR_IN) {
4091                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
4092                 if (r->in.server_name) {
4093                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
4094                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4095                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
4096                         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));
4097                 }
4098                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.NewAlternateMachineName));
4099                 if (r->in.NewAlternateMachineName) {
4100                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewAlternateMachineName, CH_UTF16)));
4101                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4102                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewAlternateMachineName, CH_UTF16)));
4103                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.NewAlternateMachineName, ndr_charset_length(r->in.NewAlternateMachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4104                 }
4105                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
4106                 if (r->in.Account) {
4107                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
4108                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4109                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
4110                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4111                 }
4112                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
4113                 if (r->in.EncryptedPassword) {
4114                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
4115                 }
4116                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Reserved));
4117         }
4118         if (flags & NDR_OUT) {
4119                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4120         }
4121         return NT_STATUS_OK;
4122 }
4123
4124 NTSTATUS ndr_pull_wkssvc_NetrAddAlternateComputerName(struct ndr_pull *ndr, int flags, struct wkssvc_NetrAddAlternateComputerName *r)
4125 {
4126         uint32_t _ptr_server_name;
4127         uint32_t _ptr_NewAlternateMachineName;
4128         uint32_t _ptr_Account;
4129         uint32_t _ptr_EncryptedPassword;
4130         TALLOC_CTX *_mem_save_server_name_0;
4131         TALLOC_CTX *_mem_save_NewAlternateMachineName_0;
4132         TALLOC_CTX *_mem_save_Account_0;
4133         TALLOC_CTX *_mem_save_EncryptedPassword_0;
4134         if (flags & NDR_IN) {
4135                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4136                 if (_ptr_server_name) {
4137                         NDR_PULL_ALLOC(ndr, r->in.server_name);
4138                 } else {
4139                         r->in.server_name = NULL;
4140                 }
4141                 if (r->in.server_name) {
4142                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4143                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
4144                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
4145                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
4146                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
4147                                 return 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));
4148                         }
4149                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
4150                         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));
4151                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4152                 }
4153                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_NewAlternateMachineName));
4154                 if (_ptr_NewAlternateMachineName) {
4155                         NDR_PULL_ALLOC(ndr, r->in.NewAlternateMachineName);
4156                 } else {
4157                         r->in.NewAlternateMachineName = NULL;
4158                 }
4159                 if (r->in.NewAlternateMachineName) {
4160                         _mem_save_NewAlternateMachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);
4161                         NDR_PULL_SET_MEM_CTX(ndr, r->in.NewAlternateMachineName, 0);
4162                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.NewAlternateMachineName));
4163                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.NewAlternateMachineName));
4164                         if (ndr_get_array_length(ndr, &r->in.NewAlternateMachineName) > ndr_get_array_size(ndr, &r->in.NewAlternateMachineName)) {
4165                                 return 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));
4166                         }
4167                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.NewAlternateMachineName), sizeof(uint16_t)));
4168                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.NewAlternateMachineName, ndr_get_array_length(ndr, &r->in.NewAlternateMachineName), sizeof(uint16_t), CH_UTF16));
4169                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_NewAlternateMachineName_0, 0);
4170                 }
4171                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
4172                 if (_ptr_Account) {
4173                         NDR_PULL_ALLOC(ndr, r->in.Account);
4174                 } else {
4175                         r->in.Account = NULL;
4176                 }
4177                 if (r->in.Account) {
4178                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
4179                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
4180                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
4181                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
4182                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
4183                                 return 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));
4184                         }
4185                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
4186                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
4187                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
4188                 }
4189                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
4190                 if (_ptr_EncryptedPassword) {
4191                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
4192                 } else {
4193                         r->in.EncryptedPassword = NULL;
4194                 }
4195                 if (r->in.EncryptedPassword) {
4196                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
4197                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
4198                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
4199                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
4200                 }
4201                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Reserved));
4202         }
4203         if (flags & NDR_OUT) {
4204                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4205         }
4206         return NT_STATUS_OK;
4207 }
4208
4209 _PUBLIC_ void ndr_print_wkssvc_NetrAddAlternateComputerName(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrAddAlternateComputerName *r)
4210 {
4211         ndr_print_struct(ndr, name, "wkssvc_NetrAddAlternateComputerName");
4212         ndr->depth++;
4213         if (flags & NDR_SET_VALUES) {
4214                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4215         }
4216         if (flags & NDR_IN) {
4217                 ndr_print_struct(ndr, "in", "wkssvc_NetrAddAlternateComputerName");
4218                 ndr->depth++;
4219                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
4220                 ndr->depth++;
4221                 if (r->in.server_name) {
4222                         ndr_print_string(ndr, "server_name", r->in.server_name);
4223                 }
4224                 ndr->depth--;
4225                 ndr_print_ptr(ndr, "NewAlternateMachineName", r->in.NewAlternateMachineName);
4226                 ndr->depth++;
4227                 if (r->in.NewAlternateMachineName) {
4228                         ndr_print_string(ndr, "NewAlternateMachineName", r->in.NewAlternateMachineName);
4229                 }
4230                 ndr->depth--;
4231                 ndr_print_ptr(ndr, "Account", r->in.Account);
4232                 ndr->depth++;
4233                 if (r->in.Account) {
4234                         ndr_print_string(ndr, "Account", r->in.Account);
4235                 }
4236                 ndr->depth--;
4237                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
4238                 ndr->depth++;
4239                 if (r->in.EncryptedPassword) {
4240                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
4241                 }
4242                 ndr->depth--;
4243                 ndr_print_uint32(ndr, "Reserved", r->in.Reserved);
4244                 ndr->depth--;
4245         }
4246         if (flags & NDR_OUT) {
4247                 ndr_print_struct(ndr, "out", "wkssvc_NetrAddAlternateComputerName");
4248                 ndr->depth++;
4249                 ndr_print_WERROR(ndr, "result", r->out.result);
4250                 ndr->depth--;
4251         }
4252         ndr->depth--;
4253 }
4254
4255 NTSTATUS ndr_push_wkssvc_NetrRemoveAlternateComputerName(struct ndr_push *ndr, int flags, const struct wkssvc_NetrRemoveAlternateComputerName *r)
4256 {
4257         if (flags & NDR_IN) {
4258                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
4259                 if (r->in.server_name) {
4260                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
4261                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4262                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
4263                         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));
4264                 }
4265                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.AlternateMachineNameToRemove));
4266                 if (r->in.AlternateMachineNameToRemove) {
4267                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.AlternateMachineNameToRemove, CH_UTF16)));
4268                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4269                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.AlternateMachineNameToRemove, CH_UTF16)));
4270                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.AlternateMachineNameToRemove, ndr_charset_length(r->in.AlternateMachineNameToRemove, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4271                 }
4272                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
4273                 if (r->in.Account) {
4274                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
4275                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4276                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
4277                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4278                 }
4279                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
4280                 if (r->in.EncryptedPassword) {
4281                         NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
4282                 }
4283                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Reserved));
4284         }
4285         if (flags & NDR_OUT) {
4286                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4287         }
4288         return NT_STATUS_OK;
4289 }
4290
4291 NTSTATUS ndr_pull_wkssvc_NetrRemoveAlternateComputerName(struct ndr_pull *ndr, int flags, struct wkssvc_NetrRemoveAlternateComputerName *r)
4292 {
4293         uint32_t _ptr_server_name;
4294         uint32_t _ptr_AlternateMachineNameToRemove;
4295         uint32_t _ptr_Account;
4296         uint32_t _ptr_EncryptedPassword;
4297         TALLOC_CTX *_mem_save_server_name_0;
4298         TALLOC_CTX *_mem_save_AlternateMachineNameToRemove_0;
4299         TALLOC_CTX *_mem_save_Account_0;
4300         TALLOC_CTX *_mem_save_EncryptedPassword_0;
4301         if (flags & NDR_IN) {
4302                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4303                 if (_ptr_server_name) {
4304                         NDR_PULL_ALLOC(ndr, r->in.server_name);
4305                 } else {
4306                         r->in.server_name = NULL;
4307                 }
4308                 if (r->in.server_name) {
4309                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4310                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
4311                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
4312                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
4313                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
4314                                 return 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));
4315                         }
4316                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
4317                         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));
4318                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4319                 }
4320                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_AlternateMachineNameToRemove));
4321                 if (_ptr_AlternateMachineNameToRemove) {
4322                         NDR_PULL_ALLOC(ndr, r->in.AlternateMachineNameToRemove);
4323                 } else {
4324                         r->in.AlternateMachineNameToRemove = NULL;
4325                 }
4326                 if (r->in.AlternateMachineNameToRemove) {
4327                         _mem_save_AlternateMachineNameToRemove_0 = NDR_PULL_GET_MEM_CTX(ndr);
4328                         NDR_PULL_SET_MEM_CTX(ndr, r->in.AlternateMachineNameToRemove, 0);
4329                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.AlternateMachineNameToRemove));
4330                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.AlternateMachineNameToRemove));
4331                         if (ndr_get_array_length(ndr, &r->in.AlternateMachineNameToRemove) > ndr_get_array_size(ndr, &r->in.AlternateMachineNameToRemove)) {
4332                                 return 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));
4333                         }
4334                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.AlternateMachineNameToRemove), sizeof(uint16_t)));
4335                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.AlternateMachineNameToRemove, ndr_get_array_length(ndr, &r->in.AlternateMachineNameToRemove), sizeof(uint16_t), CH_UTF16));
4336                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_AlternateMachineNameToRemove_0, 0);
4337                 }
4338                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
4339                 if (_ptr_Account) {
4340                         NDR_PULL_ALLOC(ndr, r->in.Account);
4341                 } else {
4342                         r->in.Account = NULL;
4343                 }
4344                 if (r->in.Account) {
4345                         _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
4346                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
4347                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
4348                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
4349                         if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
4350                                 return 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));
4351                         }
4352                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
4353                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
4354                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
4355                 }
4356                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
4357                 if (_ptr_EncryptedPassword) {
4358                         NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
4359                 } else {
4360                         r->in.EncryptedPassword = NULL;
4361                 }
4362                 if (r->in.EncryptedPassword) {
4363                         _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
4364                         NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
4365                         NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
4366                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
4367                 }
4368                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Reserved));
4369         }
4370         if (flags & NDR_OUT) {
4371                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4372         }
4373         return NT_STATUS_OK;
4374 }
4375
4376 _PUBLIC_ void ndr_print_wkssvc_NetrRemoveAlternateComputerName(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrRemoveAlternateComputerName *r)
4377 {
4378         ndr_print_struct(ndr, name, "wkssvc_NetrRemoveAlternateComputerName");
4379         ndr->depth++;
4380         if (flags & NDR_SET_VALUES) {
4381                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4382         }
4383         if (flags & NDR_IN) {
4384                 ndr_print_struct(ndr, "in", "wkssvc_NetrRemoveAlternateComputerName");
4385                 ndr->depth++;
4386                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
4387                 ndr->depth++;
4388                 if (r->in.server_name) {
4389                         ndr_print_string(ndr, "server_name", r->in.server_name);
4390                 }
4391                 ndr->depth--;
4392                 ndr_print_ptr(ndr, "AlternateMachineNameToRemove", r->in.AlternateMachineNameToRemove);
4393                 ndr->depth++;
4394                 if (r->in.AlternateMachineNameToRemove) {
4395                         ndr_print_string(ndr, "AlternateMachineNameToRemove", r->in.AlternateMachineNameToRemove);
4396                 }
4397                 ndr->depth--;
4398                 ndr_print_ptr(ndr, "Account", r->in.Account);
4399                 ndr->depth++;
4400                 if (r->in.Account) {
4401                         ndr_print_string(ndr, "Account", r->in.Account);
4402                 }
4403                 ndr->depth--;
4404                 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
4405                 ndr->depth++;
4406                 if (r->in.EncryptedPassword) {
4407                         ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
4408                 }
4409                 ndr->depth--;
4410                 ndr_print_uint32(ndr, "Reserved", r->in.Reserved);
4411                 ndr->depth--;
4412         }
4413         if (flags & NDR_OUT) {
4414                 ndr_print_struct(ndr, "out", "wkssvc_NetrRemoveAlternateComputerName");
4415                 ndr->depth++;
4416                 ndr_print_WERROR(ndr, "result", r->out.result);
4417                 ndr->depth--;
4418         }
4419         ndr->depth--;
4420 }
4421
4422 NTSTATUS ndr_push_WKSSVC_NETRSETPRIMARYCOMPUTERNAME(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRSETPRIMARYCOMPUTERNAME *r)
4423 {
4424         if (flags & NDR_IN) {
4425         }
4426         if (flags & NDR_OUT) {
4427                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4428         }
4429         return NT_STATUS_OK;
4430 }
4431
4432 NTSTATUS ndr_pull_WKSSVC_NETRSETPRIMARYCOMPUTERNAME(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRSETPRIMARYCOMPUTERNAME *r)
4433 {
4434         if (flags & NDR_IN) {
4435         }
4436         if (flags & NDR_OUT) {
4437                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4438         }
4439         return NT_STATUS_OK;
4440 }
4441
4442 _PUBLIC_ void ndr_print_WKSSVC_NETRSETPRIMARYCOMPUTERNAME(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRSETPRIMARYCOMPUTERNAME *r)
4443 {
4444         ndr_print_struct(ndr, name, "WKSSVC_NETRSETPRIMARYCOMPUTERNAME");
4445         ndr->depth++;
4446         if (flags & NDR_SET_VALUES) {
4447                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4448         }
4449         if (flags & NDR_IN) {
4450                 ndr_print_struct(ndr, "in", "WKSSVC_NETRSETPRIMARYCOMPUTERNAME");
4451                 ndr->depth++;
4452                 ndr->depth--;
4453         }
4454         if (flags & NDR_OUT) {
4455                 ndr_print_struct(ndr, "out", "WKSSVC_NETRSETPRIMARYCOMPUTERNAME");
4456                 ndr->depth++;
4457                 ndr_print_WERROR(ndr, "result", r->out.result);
4458                 ndr->depth--;
4459         }
4460         ndr->depth--;
4461 }
4462
4463 NTSTATUS ndr_push_WKSSVC_NETRENUMERATECOMPUTERNAMES(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRENUMERATECOMPUTERNAMES *r)
4464 {
4465         if (flags & NDR_IN) {
4466         }
4467         if (flags & NDR_OUT) {
4468                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4469         }
4470         return NT_STATUS_OK;
4471 }
4472
4473 NTSTATUS ndr_pull_WKSSVC_NETRENUMERATECOMPUTERNAMES(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRENUMERATECOMPUTERNAMES *r)
4474 {
4475         if (flags & NDR_IN) {
4476         }
4477         if (flags & NDR_OUT) {
4478                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4479         }
4480         return NT_STATUS_OK;
4481 }
4482
4483 _PUBLIC_ void ndr_print_WKSSVC_NETRENUMERATECOMPUTERNAMES(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRENUMERATECOMPUTERNAMES *r)
4484 {
4485         ndr_print_struct(ndr, name, "WKSSVC_NETRENUMERATECOMPUTERNAMES");
4486         ndr->depth++;
4487         if (flags & NDR_SET_VALUES) {
4488                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4489         }
4490         if (flags & NDR_IN) {
4491                 ndr_print_struct(ndr, "in", "WKSSVC_NETRENUMERATECOMPUTERNAMES");
4492                 ndr->depth++;
4493                 ndr->depth--;
4494         }
4495         if (flags & NDR_OUT) {
4496                 ndr_print_struct(ndr, "out", "WKSSVC_NETRENUMERATECOMPUTERNAMES");
4497                 ndr->depth++;
4498                 ndr_print_WERROR(ndr, "result", r->out.result);
4499                 ndr->depth--;
4500         }
4501         ndr->depth--;
4502 }
4503
4504 const struct ndr_interface_call wkssvc_calls[] = {
4505         {
4506                 "wkssvc_NetWkstaGetInfo",
4507                 sizeof(struct wkssvc_NetWkstaGetInfo),
4508                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaGetInfo,
4509                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaGetInfo,
4510                 (ndr_print_function_t) ndr_print_wkssvc_NetWkstaGetInfo,
4511                 False,
4512         },
4513         {
4514                 "wkssvc_NetWkstaSetInfo",
4515                 sizeof(struct wkssvc_NetWkstaSetInfo),
4516                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaSetInfo,
4517                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaSetInfo,
4518                 (ndr_print_function_t) ndr_print_wkssvc_NetWkstaSetInfo,
4519                 False,
4520         },
4521         {
4522                 "wkssvc_NetWkstaEnumUsers",
4523                 sizeof(struct wkssvc_NetWkstaEnumUsers),
4524                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaEnumUsers,
4525                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaEnumUsers,
4526                 (ndr_print_function_t) ndr_print_wkssvc_NetWkstaEnumUsers,
4527                 False,
4528         },
4529         {
4530                 "WKSSVC_NETRWKSTAUSERGETINFO",
4531                 sizeof(struct WKSSVC_NETRWKSTAUSERGETINFO),
4532                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRWKSTAUSERGETINFO,
4533                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRWKSTAUSERGETINFO,
4534                 (ndr_print_function_t) ndr_print_WKSSVC_NETRWKSTAUSERGETINFO,
4535                 False,
4536         },
4537         {
4538                 "WKSSVC_NETRWKSTAUSERSETINFO",
4539                 sizeof(struct WKSSVC_NETRWKSTAUSERSETINFO),
4540                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRWKSTAUSERSETINFO,
4541                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRWKSTAUSERSETINFO,
4542                 (ndr_print_function_t) ndr_print_WKSSVC_NETRWKSTAUSERSETINFO,
4543                 False,
4544         },
4545         {
4546                 "wkssvc_NetWkstaTransportEnum",
4547                 sizeof(struct wkssvc_NetWkstaTransportEnum),
4548                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaTransportEnum,
4549                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaTransportEnum,
4550                 (ndr_print_function_t) ndr_print_wkssvc_NetWkstaTransportEnum,
4551                 False,
4552         },
4553         {
4554                 "WKSSVC_NETRWKSTATRANSPORTADD",
4555                 sizeof(struct WKSSVC_NETRWKSTATRANSPORTADD),
4556                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRWKSTATRANSPORTADD,
4557                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRWKSTATRANSPORTADD,
4558                 (ndr_print_function_t) ndr_print_WKSSVC_NETRWKSTATRANSPORTADD,
4559                 False,
4560         },
4561         {
4562                 "WKSSVC_NETRWKSTATRANSPORTDEL",
4563                 sizeof(struct WKSSVC_NETRWKSTATRANSPORTDEL),
4564                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRWKSTATRANSPORTDEL,
4565                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRWKSTATRANSPORTDEL,
4566                 (ndr_print_function_t) ndr_print_WKSSVC_NETRWKSTATRANSPORTDEL,
4567                 False,
4568         },
4569         {
4570                 "WKSSVC_NETRUSEADD",
4571                 sizeof(struct WKSSVC_NETRUSEADD),
4572                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRUSEADD,
4573                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRUSEADD,
4574                 (ndr_print_function_t) ndr_print_WKSSVC_NETRUSEADD,
4575                 False,
4576         },
4577         {
4578                 "WKSSVC_NETRUSEGETINFO",
4579                 sizeof(struct WKSSVC_NETRUSEGETINFO),
4580                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRUSEGETINFO,
4581                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRUSEGETINFO,
4582                 (ndr_print_function_t) ndr_print_WKSSVC_NETRUSEGETINFO,
4583                 False,
4584         },
4585         {
4586                 "WKSSVC_NETRUSEDEL",
4587                 sizeof(struct WKSSVC_NETRUSEDEL),
4588                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRUSEDEL,
4589                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRUSEDEL,
4590                 (ndr_print_function_t) ndr_print_WKSSVC_NETRUSEDEL,
4591                 False,
4592         },
4593         {
4594                 "WKSSVC_NETRUSEENUM",
4595                 sizeof(struct WKSSVC_NETRUSEENUM),
4596                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRUSEENUM,
4597                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRUSEENUM,
4598                 (ndr_print_function_t) ndr_print_WKSSVC_NETRUSEENUM,
4599                 False,
4600         },
4601         {
4602                 "WKSSVC_NETRMESSAGEBUFFERSEND",
4603                 sizeof(struct WKSSVC_NETRMESSAGEBUFFERSEND),
4604                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRMESSAGEBUFFERSEND,
4605                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRMESSAGEBUFFERSEND,
4606                 (ndr_print_function_t) ndr_print_WKSSVC_NETRMESSAGEBUFFERSEND,
4607                 False,
4608         },
4609         {
4610                 "WKSSVC_NETRWORKSTATIONSTATISTICSGET",
4611                 sizeof(struct WKSSVC_NETRWORKSTATIONSTATISTICSGET),
4612                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRWORKSTATIONSTATISTICSGET,
4613                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRWORKSTATIONSTATISTICSGET,
4614                 (ndr_print_function_t) ndr_print_WKSSVC_NETRWORKSTATIONSTATISTICSGET,
4615                 False,
4616         },
4617         {
4618                 "WKSSVC_NETRLOGONDOMAINNAMEADD",
4619                 sizeof(struct WKSSVC_NETRLOGONDOMAINNAMEADD),
4620                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRLOGONDOMAINNAMEADD,
4621                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRLOGONDOMAINNAMEADD,
4622                 (ndr_print_function_t) ndr_print_WKSSVC_NETRLOGONDOMAINNAMEADD,
4623                 False,
4624         },
4625         {
4626                 "WKSSVC_NETRLOGONDOMAINNAMEDEL",
4627                 sizeof(struct WKSSVC_NETRLOGONDOMAINNAMEDEL),
4628                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRLOGONDOMAINNAMEDEL,
4629                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRLOGONDOMAINNAMEDEL,
4630                 (ndr_print_function_t) ndr_print_WKSSVC_NETRLOGONDOMAINNAMEDEL,
4631                 False,
4632         },
4633         {
4634                 "WKSSVC_NETRJOINDOMAIN",
4635                 sizeof(struct WKSSVC_NETRJOINDOMAIN),
4636                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRJOINDOMAIN,
4637                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRJOINDOMAIN,
4638                 (ndr_print_function_t) ndr_print_WKSSVC_NETRJOINDOMAIN,
4639                 False,
4640         },
4641         {
4642                 "WKSSVC_NETRUNJOINDOMAIN",
4643                 sizeof(struct WKSSVC_NETRUNJOINDOMAIN),
4644                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRUNJOINDOMAIN,
4645                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRUNJOINDOMAIN,
4646                 (ndr_print_function_t) ndr_print_WKSSVC_NETRUNJOINDOMAIN,
4647                 False,
4648         },
4649         {
4650                 "WKSSVC_NETRRENAMEMACHINEINDOMAIN",
4651                 sizeof(struct WKSSVC_NETRRENAMEMACHINEINDOMAIN),
4652                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRRENAMEMACHINEINDOMAIN,
4653                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRRENAMEMACHINEINDOMAIN,
4654                 (ndr_print_function_t) ndr_print_WKSSVC_NETRRENAMEMACHINEINDOMAIN,
4655                 False,
4656         },
4657         {
4658                 "WKSSVC_NETRVALIDATENAME",
4659                 sizeof(struct WKSSVC_NETRVALIDATENAME),
4660                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRVALIDATENAME,
4661                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRVALIDATENAME,
4662                 (ndr_print_function_t) ndr_print_WKSSVC_NETRVALIDATENAME,
4663                 False,
4664         },
4665         {
4666                 "WKSSVC_NETRGETJOININFORMATION",
4667                 sizeof(struct WKSSVC_NETRGETJOININFORMATION),
4668                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRGETJOININFORMATION,
4669                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRGETJOININFORMATION,
4670                 (ndr_print_function_t) ndr_print_WKSSVC_NETRGETJOININFORMATION,
4671                 False,
4672         },
4673         {
4674                 "WKSSVC_NETRGETJOINABLEOUS",
4675                 sizeof(struct WKSSVC_NETRGETJOINABLEOUS),
4676                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRGETJOINABLEOUS,
4677                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRGETJOINABLEOUS,
4678                 (ndr_print_function_t) ndr_print_WKSSVC_NETRGETJOINABLEOUS,
4679                 False,
4680         },
4681         {
4682                 "wkssvc_NetrJoinDomain2",
4683                 sizeof(struct wkssvc_NetrJoinDomain2),
4684                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrJoinDomain2,
4685                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrJoinDomain2,
4686                 (ndr_print_function_t) ndr_print_wkssvc_NetrJoinDomain2,
4687                 False,
4688         },
4689         {
4690                 "wkssvc_NetrUnjoinDomain2",
4691                 sizeof(struct wkssvc_NetrUnjoinDomain2),
4692                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUnjoinDomain2,
4693                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUnjoinDomain2,
4694                 (ndr_print_function_t) ndr_print_wkssvc_NetrUnjoinDomain2,
4695                 False,
4696         },
4697         {
4698                 "wkssvc_NetrRenameMachineInDomain2",
4699                 sizeof(struct wkssvc_NetrRenameMachineInDomain2),
4700                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrRenameMachineInDomain2,
4701                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrRenameMachineInDomain2,
4702                 (ndr_print_function_t) ndr_print_wkssvc_NetrRenameMachineInDomain2,
4703                 False,
4704         },
4705         {
4706                 "WKSSVC_NETRVALIDATENAME2",
4707                 sizeof(struct WKSSVC_NETRVALIDATENAME2),
4708                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRVALIDATENAME2,
4709                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRVALIDATENAME2,
4710                 (ndr_print_function_t) ndr_print_WKSSVC_NETRVALIDATENAME2,
4711                 False,
4712         },
4713         {
4714                 "WKSSVC_NETRGETJOINABLEOUS2",
4715                 sizeof(struct WKSSVC_NETRGETJOINABLEOUS2),
4716                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRGETJOINABLEOUS2,
4717                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRGETJOINABLEOUS2,
4718                 (ndr_print_function_t) ndr_print_WKSSVC_NETRGETJOINABLEOUS2,
4719                 False,
4720         },
4721         {
4722                 "wkssvc_NetrAddAlternateComputerName",
4723                 sizeof(struct wkssvc_NetrAddAlternateComputerName),
4724                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrAddAlternateComputerName,
4725                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrAddAlternateComputerName,
4726                 (ndr_print_function_t) ndr_print_wkssvc_NetrAddAlternateComputerName,
4727                 False,
4728         },
4729         {
4730                 "wkssvc_NetrRemoveAlternateComputerName",
4731                 sizeof(struct wkssvc_NetrRemoveAlternateComputerName),
4732                 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrRemoveAlternateComputerName,
4733                 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrRemoveAlternateComputerName,
4734                 (ndr_print_function_t) ndr_print_wkssvc_NetrRemoveAlternateComputerName,
4735                 False,
4736         },
4737         {
4738                 "WKSSVC_NETRSETPRIMARYCOMPUTERNAME",
4739                 sizeof(struct WKSSVC_NETRSETPRIMARYCOMPUTERNAME),
4740                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRSETPRIMARYCOMPUTERNAME,
4741                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRSETPRIMARYCOMPUTERNAME,
4742                 (ndr_print_function_t) ndr_print_WKSSVC_NETRSETPRIMARYCOMPUTERNAME,
4743                 False,
4744         },
4745         {
4746                 "WKSSVC_NETRENUMERATECOMPUTERNAMES",
4747                 sizeof(struct WKSSVC_NETRENUMERATECOMPUTERNAMES),
4748                 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRENUMERATECOMPUTERNAMES,
4749                 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRENUMERATECOMPUTERNAMES,
4750                 (ndr_print_function_t) ndr_print_WKSSVC_NETRENUMERATECOMPUTERNAMES,
4751                 False,
4752         },
4753         { NULL, 0, NULL, NULL, NULL, False }
4754 };
4755
4756 const char * const wkssvc_endpoint_strings[] = {
4757         "ncacn_np:[\\pipe\\wkssvc]",
4758 };
4759
4760 const struct ndr_interface_string_array wkssvc_endpoints = {
4761         .count  = 1,
4762         .names  = wkssvc_endpoint_strings
4763 };
4764
4765 const char * const wkssvc_authservice_strings[] = {
4766         "host",
4767 };
4768
4769 const struct ndr_interface_string_array wkssvc_authservices = {
4770         .count  = 1,
4771         .names  = wkssvc_authservice_strings
4772 };
4773
4774
4775 const struct ndr_interface_table dcerpc_table_wkssvc = {
4776         .name           = "wkssvc",
4777         .syntax_id      = {
4778                 {0x6bffd098,0xa112,0x3610,{0x98,0x33},{0x46,0xc3,0xf8,0x7e,0x34,0x5a}},
4779                 DCERPC_WKSSVC_VERSION
4780         },
4781         .helpstring     = DCERPC_WKSSVC_HELPSTRING,
4782         .num_calls      = 31,
4783         .calls          = wkssvc_calls,
4784         .endpoints      = &wkssvc_endpoints,
4785         .authservices   = &wkssvc_authservices
4786 };
4787