source/librpc/gen_ndr/ndr_srvsvc.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "librpc/gen_ndr/ndr_srvsvc.h"
   5
   6 #include "librpc/gen_ndr/ndr_security.h"
   7 #include "librpc/gen_ndr/ndr_svcctl.h"
   8 static enum ndr_err_code ndr_push_srvsvc_NetCharDevInfo0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevInfo0 *r)
   9 {
  10         if (ndr_flags & NDR_SCALARS) {
  11                 NDR_CHECK(ndr_push_align(ndr, 4));
  12                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->device));
  13         }
  14         if (ndr_flags & NDR_BUFFERS) {
  15                 if (r->device) {
  16                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->device, CH_UTF16)));
  17                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  18                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->device, CH_UTF16)));
  19                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device, ndr_charset_length(r->device, CH_UTF16), sizeof(uint16_t), CH_UTF16));
  20                 }
  21         }
  22         return NDR_ERR_SUCCESS;
  23 }
  24
  25 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevInfo0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevInfo0 *r)
  26 {
  27         uint32_t _ptr_device;
  28         TALLOC_CTX *_mem_save_device_0;
  29         if (ndr_flags & NDR_SCALARS) {
  30                 NDR_CHECK(ndr_pull_align(ndr, 4));
  31                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_device));
  32                 if (_ptr_device) {
  33                         NDR_PULL_ALLOC(ndr, r->device);
  34                 } else {
  35                         r->device = NULL;
  36                 }
  37         }
  38         if (ndr_flags & NDR_BUFFERS) {
  39                 if (r->device) {
  40                         _mem_save_device_0 = NDR_PULL_GET_MEM_CTX(ndr);
  41                         NDR_PULL_SET_MEM_CTX(ndr, r->device, 0);
  42                         NDR_CHECK(ndr_pull_array_size(ndr, &r->device));
  43                         NDR_CHECK(ndr_pull_array_length(ndr, &r->device));
  44                         if (ndr_get_array_length(ndr, &r->device) > ndr_get_array_size(ndr, &r->device)) {
  45                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->device), ndr_get_array_length(ndr, &r->device));
  46                         }
  47                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->device), sizeof(uint16_t)));
  48                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device, ndr_get_array_length(ndr, &r->device), sizeof(uint16_t), CH_UTF16));
  49                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_device_0, 0);
  50                 }
  51         }
  52         return NDR_ERR_SUCCESS;
  53 }
  54
  55 _PUBLIC_ void ndr_print_srvsvc_NetCharDevInfo0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevInfo0 *r)
  56 {
  57         ndr_print_struct(ndr, name, "srvsvc_NetCharDevInfo0");
  58         ndr->depth++;
  59         ndr_print_ptr(ndr, "device", r->device);
  60         ndr->depth++;
  61         if (r->device) {
  62                 ndr_print_string(ndr, "device", r->device);
  63         }
  64         ndr->depth--;
  65         ndr->depth--;
  66 }
  67
  68 static enum ndr_err_code ndr_push_srvsvc_NetCharDevCtr0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevCtr0 *r)
  69 {
  70         uint32_t cntr_array_1;
  71         if (ndr_flags & NDR_SCALARS) {
  72                 NDR_CHECK(ndr_push_align(ndr, 4));
  73                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
  74                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
  75         }
  76         if (ndr_flags & NDR_BUFFERS) {
  77                 if (r->array) {
  78                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
  79                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
  80                                 NDR_CHECK(ndr_push_srvsvc_NetCharDevInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
  81                         }
  82                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
  83                                 NDR_CHECK(ndr_push_srvsvc_NetCharDevInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
  84                         }
  85                 }
  86         }
  87         return NDR_ERR_SUCCESS;
  88 }
  89
  90 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevCtr0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevCtr0 *r)
  91 {
  92         uint32_t _ptr_array;
  93         uint32_t cntr_array_1;
  94         TALLOC_CTX *_mem_save_array_0;
  95         TALLOC_CTX *_mem_save_array_1;
  96         if (ndr_flags & NDR_SCALARS) {
  97                 NDR_CHECK(ndr_pull_align(ndr, 4));
  98                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
  99                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
 100                 if (_ptr_array) {
 101                         NDR_PULL_ALLOC(ndr, r->array);
 102                 } else {
 103                         r->array = NULL;
 104                 }
 105         }
 106         if (ndr_flags & NDR_BUFFERS) {
 107                 if (r->array) {
 108                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
 109                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
 110                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
 111                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
 112                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
 113                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
 114                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
 115                                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
 116                         }
 117                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
 118                                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
 119                         }
 120                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
 121                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
 122                 }
 123                 if (r->array) {
 124                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
 125                 }
 126         }
 127         return NDR_ERR_SUCCESS;
 128 }
 129
 130 _PUBLIC_ void ndr_print_srvsvc_NetCharDevCtr0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevCtr0 *r)
 131 {
 132         uint32_t cntr_array_1;
 133         ndr_print_struct(ndr, name, "srvsvc_NetCharDevCtr0");
 134         ndr->depth++;
 135         ndr_print_uint32(ndr, "count", r->count);
 136         ndr_print_ptr(ndr, "array", r->array);
 137         ndr->depth++;
 138         if (r->array) {
 139                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
 140                 ndr->depth++;
 141                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
 142                         char *idx_1=NULL;
 143                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
 144                                 ndr_print_srvsvc_NetCharDevInfo0(ndr, "array", &r->array[cntr_array_1]);
 145                                 free(idx_1);
 146                         }
 147                 }
 148                 ndr->depth--;
 149         }
 150         ndr->depth--;
 151         ndr->depth--;
 152 }
 153
 154 static enum ndr_err_code ndr_push_srvsvc_NetCharDevInfo1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevInfo1 *r)
 155 {
 156         if (ndr_flags & NDR_SCALARS) {
 157                 NDR_CHECK(ndr_push_align(ndr, 4));
 158                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->device));
 159                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
 160                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
 161                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
 162         }
 163         if (ndr_flags & NDR_BUFFERS) {
 164                 if (r->device) {
 165                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->device, CH_UTF16)));
 166                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 167                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->device, CH_UTF16)));
 168                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device, ndr_charset_length(r->device, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 169                 }
 170                 if (r->user) {
 171                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
 172                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 173                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
 174                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 175                 }
 176         }
 177         return NDR_ERR_SUCCESS;
 178 }
 179
 180 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevInfo1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevInfo1 *r)
 181 {
 182         uint32_t _ptr_device;
 183         TALLOC_CTX *_mem_save_device_0;
 184         uint32_t _ptr_user;
 185         TALLOC_CTX *_mem_save_user_0;
 186         if (ndr_flags & NDR_SCALARS) {
 187                 NDR_CHECK(ndr_pull_align(ndr, 4));
 188                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_device));
 189                 if (_ptr_device) {
 190                         NDR_PULL_ALLOC(ndr, r->device);
 191                 } else {
 192                         r->device = NULL;
 193                 }
 194                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
 195                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
 196                 if (_ptr_user) {
 197                         NDR_PULL_ALLOC(ndr, r->user);
 198                 } else {
 199                         r->user = NULL;
 200                 }
 201                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
 202         }
 203         if (ndr_flags & NDR_BUFFERS) {
 204                 if (r->device) {
 205                         _mem_save_device_0 = NDR_PULL_GET_MEM_CTX(ndr);
 206                         NDR_PULL_SET_MEM_CTX(ndr, r->device, 0);
 207                         NDR_CHECK(ndr_pull_array_size(ndr, &r->device));
 208                         NDR_CHECK(ndr_pull_array_length(ndr, &r->device));
 209                         if (ndr_get_array_length(ndr, &r->device) > ndr_get_array_size(ndr, &r->device)) {
 210                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->device), ndr_get_array_length(ndr, &r->device));
 211                         }
 212                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->device), sizeof(uint16_t)));
 213                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device, ndr_get_array_length(ndr, &r->device), sizeof(uint16_t), CH_UTF16));
 214                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_device_0, 0);
 215                 }
 216                 if (r->user) {
 217                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
 218                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
 219                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
 220                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
 221                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
 222                                 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));
 223                         }
 224                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
 225                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
 226                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
 227                 }
 228         }
 229         return NDR_ERR_SUCCESS;
 230 }
 231
 232 _PUBLIC_ void ndr_print_srvsvc_NetCharDevInfo1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevInfo1 *r)
 233 {
 234         ndr_print_struct(ndr, name, "srvsvc_NetCharDevInfo1");
 235         ndr->depth++;
 236         ndr_print_ptr(ndr, "device", r->device);
 237         ndr->depth++;
 238         if (r->device) {
 239                 ndr_print_string(ndr, "device", r->device);
 240         }
 241         ndr->depth--;
 242         ndr_print_uint32(ndr, "status", r->status);
 243         ndr_print_ptr(ndr, "user", r->user);
 244         ndr->depth++;
 245         if (r->user) {
 246                 ndr_print_string(ndr, "user", r->user);
 247         }
 248         ndr->depth--;
 249         ndr_print_uint32(ndr, "time", r->time);
 250         ndr->depth--;
 251 }
 252
 253 static enum ndr_err_code ndr_push_srvsvc_NetCharDevCtr1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevCtr1 *r)
 254 {
 255         uint32_t cntr_array_1;
 256         if (ndr_flags & NDR_SCALARS) {
 257                 NDR_CHECK(ndr_push_align(ndr, 4));
 258                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 259                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
 260         }
 261         if (ndr_flags & NDR_BUFFERS) {
 262                 if (r->array) {
 263                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 264                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
 265                                 NDR_CHECK(ndr_push_srvsvc_NetCharDevInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
 266                         }
 267                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
 268                                 NDR_CHECK(ndr_push_srvsvc_NetCharDevInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
 269                         }
 270                 }
 271         }
 272         return NDR_ERR_SUCCESS;
 273 }
 274
 275 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevCtr1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevCtr1 *r)
 276 {
 277         uint32_t _ptr_array;
 278         uint32_t cntr_array_1;
 279         TALLOC_CTX *_mem_save_array_0;
 280         TALLOC_CTX *_mem_save_array_1;
 281         if (ndr_flags & NDR_SCALARS) {
 282                 NDR_CHECK(ndr_pull_align(ndr, 4));
 283                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 284                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
 285                 if (_ptr_array) {
 286                         NDR_PULL_ALLOC(ndr, r->array);
 287                 } else {
 288                         r->array = NULL;
 289                 }
 290         }
 291         if (ndr_flags & NDR_BUFFERS) {
 292                 if (r->array) {
 293                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
 294                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
 295                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
 296                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
 297                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
 298                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
 299                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
 300                                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
 301                         }
 302                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
 303                                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
 304                         }
 305                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
 306                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
 307                 }
 308                 if (r->array) {
 309                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
 310                 }
 311         }
 312         return NDR_ERR_SUCCESS;
 313 }
 314
 315 _PUBLIC_ void ndr_print_srvsvc_NetCharDevCtr1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevCtr1 *r)
 316 {
 317         uint32_t cntr_array_1;
 318         ndr_print_struct(ndr, name, "srvsvc_NetCharDevCtr1");
 319         ndr->depth++;
 320         ndr_print_uint32(ndr, "count", r->count);
 321         ndr_print_ptr(ndr, "array", r->array);
 322         ndr->depth++;
 323         if (r->array) {
 324                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
 325                 ndr->depth++;
 326                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
 327                         char *idx_1=NULL;
 328                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
 329                                 ndr_print_srvsvc_NetCharDevInfo1(ndr, "array", &r->array[cntr_array_1]);
 330                                 free(idx_1);
 331                         }
 332                 }
 333                 ndr->depth--;
 334         }
 335         ndr->depth--;
 336         ndr->depth--;
 337 }
 338
 339 static enum ndr_err_code ndr_push_srvsvc_NetCharDevInfo(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetCharDevInfo *r)
 340 {
 341         if (ndr_flags & NDR_SCALARS) {
 342                 int level = ndr_push_get_switch_value(ndr, r);
 343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
 344                 switch (level) {
 345                         case 0: {
 346                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
 347                         break; }
 348
 349                         case 1: {
 350                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
 351                         break; }
 352
 353                         default: {
 354                         break; }
 355
 356                 }
 357         }
 358         if (ndr_flags & NDR_BUFFERS) {
 359                 int level = ndr_push_get_switch_value(ndr, r);
 360                 switch (level) {
 361                         case 0:
 362                                 if (r->info0) {
 363                                         NDR_CHECK(ndr_push_srvsvc_NetCharDevInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
 364                                 }
 365                         break;
 366
 367                         case 1:
 368                                 if (r->info1) {
 369                                         NDR_CHECK(ndr_push_srvsvc_NetCharDevInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
 370                                 }
 371                         break;
 372
 373                         default:
 374                         break;
 375
 376                 }
 377         }
 378         return NDR_ERR_SUCCESS;
 379 }
 380
 381 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevInfo(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetCharDevInfo *r)
 382 {
 383         int level;
 384         uint32_t _level;
 385         TALLOC_CTX *_mem_save_info0_0;
 386         TALLOC_CTX *_mem_save_info1_0;
 387         level = ndr_pull_get_switch_value(ndr, r);
 388         if (ndr_flags & NDR_SCALARS) {
 389                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
 390                 if (_level != level) {
 391                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
 392                 }
 393                 switch (level) {
 394                         case 0: {
 395                                 uint32_t _ptr_info0;
 396                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
 397                                 if (_ptr_info0) {
 398                                         NDR_PULL_ALLOC(ndr, r->info0);
 399                                 } else {
 400                                         r->info0 = NULL;
 401                                 }
 402                         break; }
 403
 404                         case 1: {
 405                                 uint32_t _ptr_info1;
 406                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
 407                                 if (_ptr_info1) {
 408                                         NDR_PULL_ALLOC(ndr, r->info1);
 409                                 } else {
 410                                         r->info1 = NULL;
 411                                 }
 412                         break; }
 413
 414                         default: {
 415                         break; }
 416
 417                 }
 418         }
 419         if (ndr_flags & NDR_BUFFERS) {
 420                 switch (level) {
 421                         case 0:
 422                                 if (r->info0) {
 423                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
 424                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
 425                                         NDR_CHECK(ndr_pull_srvsvc_NetCharDevInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
 426                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
 427                                 }
 428                         break;
 429
 430                         case 1:
 431                                 if (r->info1) {
 432                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
 433                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
 434                                         NDR_CHECK(ndr_pull_srvsvc_NetCharDevInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
 435                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
 436                                 }
 437                         break;
 438
 439                         default:
 440                         break;
 441
 442                 }
 443         }
 444         return NDR_ERR_SUCCESS;
 445 }
 446
 447 _PUBLIC_ void ndr_print_srvsvc_NetCharDevInfo(struct ndr_print *ndr, const char *name, const union srvsvc_NetCharDevInfo *r)
 448 {
 449         int level;
 450         level = ndr_print_get_switch_value(ndr, r);
 451         ndr_print_union(ndr, name, level, "srvsvc_NetCharDevInfo");
 452         switch (level) {
 453                 case 0:
 454                         ndr_print_ptr(ndr, "info0", r->info0);
 455                         ndr->depth++;
 456                         if (r->info0) {
 457                                 ndr_print_srvsvc_NetCharDevInfo0(ndr, "info0", r->info0);
 458                         }
 459                         ndr->depth--;
 460                 break;
 461
 462                 case 1:
 463                         ndr_print_ptr(ndr, "info1", r->info1);
 464                         ndr->depth++;
 465                         if (r->info1) {
 466                                 ndr_print_srvsvc_NetCharDevInfo1(ndr, "info1", r->info1);
 467                         }
 468                         ndr->depth--;
 469                 break;
 470
 471                 default:
 472                 break;
 473
 474         }
 475 }
 476
 477 static enum ndr_err_code ndr_push_srvsvc_NetCharDevCtr(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetCharDevCtr *r)
 478 {
 479         if (ndr_flags & NDR_SCALARS) {
 480                 int level = ndr_push_get_switch_value(ndr, r);
 481                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
 482                 switch (level) {
 483                         case 0: {
 484                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
 485                         break; }
 486
 487                         case 1: {
 488                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
 489                         break; }
 490
 491                         default: {
 492                         break; }
 493
 494                 }
 495         }
 496         if (ndr_flags & NDR_BUFFERS) {
 497                 int level = ndr_push_get_switch_value(ndr, r);
 498                 switch (level) {
 499                         case 0:
 500                                 if (r->ctr0) {
 501                                         NDR_CHECK(ndr_push_srvsvc_NetCharDevCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
 502                                 }
 503                         break;
 504
 505                         case 1:
 506                                 if (r->ctr1) {
 507                                         NDR_CHECK(ndr_push_srvsvc_NetCharDevCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
 508                                 }
 509                         break;
 510
 511                         default:
 512                         break;
 513
 514                 }
 515         }
 516         return NDR_ERR_SUCCESS;
 517 }
 518
 519 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevCtr(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetCharDevCtr *r)
 520 {
 521         int level;
 522         uint32_t _level;
 523         TALLOC_CTX *_mem_save_ctr0_0;
 524         TALLOC_CTX *_mem_save_ctr1_0;
 525         level = ndr_pull_get_switch_value(ndr, r);
 526         if (ndr_flags & NDR_SCALARS) {
 527                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
 528                 if (_level != level) {
 529                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
 530                 }
 531                 switch (level) {
 532                         case 0: {
 533                                 uint32_t _ptr_ctr0;
 534                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));
 535                                 if (_ptr_ctr0) {
 536                                         NDR_PULL_ALLOC(ndr, r->ctr0);
 537                                 } else {
 538                                         r->ctr0 = NULL;
 539                                 }
 540                         break; }
 541
 542                         case 1: {
 543                                 uint32_t _ptr_ctr1;
 544                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
 545                                 if (_ptr_ctr1) {
 546                                         NDR_PULL_ALLOC(ndr, r->ctr1);
 547                                 } else {
 548                                         r->ctr1 = NULL;
 549                                 }
 550                         break; }
 551
 552                         default: {
 553                         break; }
 554
 555                 }
 556         }
 557         if (ndr_flags & NDR_BUFFERS) {
 558                 switch (level) {
 559                         case 0:
 560                                 if (r->ctr0) {
 561                                         _mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);
 562                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr0, 0);
 563                                         NDR_CHECK(ndr_pull_srvsvc_NetCharDevCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
 564                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);
 565                                 }
 566                         break;
 567
 568                         case 1:
 569                                 if (r->ctr1) {
 570                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
 571                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
 572                                         NDR_CHECK(ndr_pull_srvsvc_NetCharDevCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
 573                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
 574                                 }
 575                         break;
 576
 577                         default:
 578                         break;
 579
 580                 }
 581         }
 582         return NDR_ERR_SUCCESS;
 583 }
 584
 585 _PUBLIC_ void ndr_print_srvsvc_NetCharDevCtr(struct ndr_print *ndr, const char *name, const union srvsvc_NetCharDevCtr *r)
 586 {
 587         int level;
 588         level = ndr_print_get_switch_value(ndr, r);
 589         ndr_print_union(ndr, name, level, "srvsvc_NetCharDevCtr");
 590         switch (level) {
 591                 case 0:
 592                         ndr_print_ptr(ndr, "ctr0", r->ctr0);
 593                         ndr->depth++;
 594                         if (r->ctr0) {
 595                                 ndr_print_srvsvc_NetCharDevCtr0(ndr, "ctr0", r->ctr0);
 596                         }
 597                         ndr->depth--;
 598                 break;
 599
 600                 case 1:
 601                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
 602                         ndr->depth++;
 603                         if (r->ctr1) {
 604                                 ndr_print_srvsvc_NetCharDevCtr1(ndr, "ctr1", r->ctr1);
 605                         }
 606                         ndr->depth--;
 607                 break;
 608
 609                 default:
 610                 break;
 611
 612         }
 613 }
 614
 615 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQInfo0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevQInfo0 *r)
 616 {
 617         if (ndr_flags & NDR_SCALARS) {
 618                 NDR_CHECK(ndr_push_align(ndr, 4));
 619                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->device));
 620         }
 621         if (ndr_flags & NDR_BUFFERS) {
 622                 if (r->device) {
 623                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->device, CH_UTF16)));
 624                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 625                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->device, CH_UTF16)));
 626                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device, ndr_charset_length(r->device, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 627                 }
 628         }
 629         return NDR_ERR_SUCCESS;
 630 }
 631
 632 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQInfo0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevQInfo0 *r)
 633 {
 634         uint32_t _ptr_device;
 635         TALLOC_CTX *_mem_save_device_0;
 636         if (ndr_flags & NDR_SCALARS) {
 637                 NDR_CHECK(ndr_pull_align(ndr, 4));
 638                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_device));
 639                 if (_ptr_device) {
 640                         NDR_PULL_ALLOC(ndr, r->device);
 641                 } else {
 642                         r->device = NULL;
 643                 }
 644         }
 645         if (ndr_flags & NDR_BUFFERS) {
 646                 if (r->device) {
 647                         _mem_save_device_0 = NDR_PULL_GET_MEM_CTX(ndr);
 648                         NDR_PULL_SET_MEM_CTX(ndr, r->device, 0);
 649                         NDR_CHECK(ndr_pull_array_size(ndr, &r->device));
 650                         NDR_CHECK(ndr_pull_array_length(ndr, &r->device));
 651                         if (ndr_get_array_length(ndr, &r->device) > ndr_get_array_size(ndr, &r->device)) {
 652                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->device), ndr_get_array_length(ndr, &r->device));
 653                         }
 654                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->device), sizeof(uint16_t)));
 655                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device, ndr_get_array_length(ndr, &r->device), sizeof(uint16_t), CH_UTF16));
 656                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_device_0, 0);
 657                 }
 658         }
 659         return NDR_ERR_SUCCESS;
 660 }
 661
 662 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQInfo0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevQInfo0 *r)
 663 {
 664         ndr_print_struct(ndr, name, "srvsvc_NetCharDevQInfo0");
 665         ndr->depth++;
 666         ndr_print_ptr(ndr, "device", r->device);
 667         ndr->depth++;
 668         if (r->device) {
 669                 ndr_print_string(ndr, "device", r->device);
 670         }
 671         ndr->depth--;
 672         ndr->depth--;
 673 }
 674
 675 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQCtr0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevQCtr0 *r)
 676 {
 677         uint32_t cntr_array_1;
 678         if (ndr_flags & NDR_SCALARS) {
 679                 NDR_CHECK(ndr_push_align(ndr, 4));
 680                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 681                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
 682         }
 683         if (ndr_flags & NDR_BUFFERS) {
 684                 if (r->array) {
 685                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 686                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
 687                                 NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
 688                         }
 689                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
 690                                 NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
 691                         }
 692                 }
 693         }
 694         return NDR_ERR_SUCCESS;
 695 }
 696
 697 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQCtr0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevQCtr0 *r)
 698 {
 699         uint32_t _ptr_array;
 700         uint32_t cntr_array_1;
 701         TALLOC_CTX *_mem_save_array_0;
 702         TALLOC_CTX *_mem_save_array_1;
 703         if (ndr_flags & NDR_SCALARS) {
 704                 NDR_CHECK(ndr_pull_align(ndr, 4));
 705                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 706                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
 707                 if (_ptr_array) {
 708                         NDR_PULL_ALLOC(ndr, r->array);
 709                 } else {
 710                         r->array = NULL;
 711                 }
 712         }
 713         if (ndr_flags & NDR_BUFFERS) {
 714                 if (r->array) {
 715                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
 716                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
 717                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
 718                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
 719                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
 720                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
 721                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
 722                                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
 723                         }
 724                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
 725                                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
 726                         }
 727                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
 728                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
 729                 }
 730                 if (r->array) {
 731                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
 732                 }
 733         }
 734         return NDR_ERR_SUCCESS;
 735 }
 736
 737 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQCtr0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevQCtr0 *r)
 738 {
 739         uint32_t cntr_array_1;
 740         ndr_print_struct(ndr, name, "srvsvc_NetCharDevQCtr0");
 741         ndr->depth++;
 742         ndr_print_uint32(ndr, "count", r->count);
 743         ndr_print_ptr(ndr, "array", r->array);
 744         ndr->depth++;
 745         if (r->array) {
 746                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
 747                 ndr->depth++;
 748                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
 749                         char *idx_1=NULL;
 750                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
 751                                 ndr_print_srvsvc_NetCharDevQInfo0(ndr, "array", &r->array[cntr_array_1]);
 752                                 free(idx_1);
 753                         }
 754                 }
 755                 ndr->depth--;
 756         }
 757         ndr->depth--;
 758         ndr->depth--;
 759 }
 760
 761 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQInfo1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevQInfo1 *r)
 762 {
 763         if (ndr_flags & NDR_SCALARS) {
 764                 NDR_CHECK(ndr_push_align(ndr, 4));
 765                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->device));
 766                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
 767                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devices));
 768                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->users));
 769                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_ahead));
 770         }
 771         if (ndr_flags & NDR_BUFFERS) {
 772                 if (r->device) {
 773                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->device, CH_UTF16)));
 774                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 775                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->device, CH_UTF16)));
 776                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device, ndr_charset_length(r->device, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 777                 }
 778                 if (r->devices) {
 779                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->devices, CH_UTF16)));
 780                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 781                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->devices, CH_UTF16)));
 782                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->devices, ndr_charset_length(r->devices, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 783                 }
 784         }
 785         return NDR_ERR_SUCCESS;
 786 }
 787
 788 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQInfo1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevQInfo1 *r)
 789 {
 790         uint32_t _ptr_device;
 791         TALLOC_CTX *_mem_save_device_0;
 792         uint32_t _ptr_devices;
 793         TALLOC_CTX *_mem_save_devices_0;
 794         if (ndr_flags & NDR_SCALARS) {
 795                 NDR_CHECK(ndr_pull_align(ndr, 4));
 796                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_device));
 797                 if (_ptr_device) {
 798                         NDR_PULL_ALLOC(ndr, r->device);
 799                 } else {
 800                         r->device = NULL;
 801                 }
 802                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
 803                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devices));
 804                 if (_ptr_devices) {
 805                         NDR_PULL_ALLOC(ndr, r->devices);
 806                 } else {
 807                         r->devices = NULL;
 808                 }
 809                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->users));
 810                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_ahead));
 811         }
 812         if (ndr_flags & NDR_BUFFERS) {
 813                 if (r->device) {
 814                         _mem_save_device_0 = NDR_PULL_GET_MEM_CTX(ndr);
 815                         NDR_PULL_SET_MEM_CTX(ndr, r->device, 0);
 816                         NDR_CHECK(ndr_pull_array_size(ndr, &r->device));
 817                         NDR_CHECK(ndr_pull_array_length(ndr, &r->device));
 818                         if (ndr_get_array_length(ndr, &r->device) > ndr_get_array_size(ndr, &r->device)) {
 819                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->device), ndr_get_array_length(ndr, &r->device));
 820                         }
 821                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->device), sizeof(uint16_t)));
 822                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device, ndr_get_array_length(ndr, &r->device), sizeof(uint16_t), CH_UTF16));
 823                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_device_0, 0);
 824                 }
 825                 if (r->devices) {
 826                         _mem_save_devices_0 = NDR_PULL_GET_MEM_CTX(ndr);
 827                         NDR_PULL_SET_MEM_CTX(ndr, r->devices, 0);
 828                         NDR_CHECK(ndr_pull_array_size(ndr, &r->devices));
 829                         NDR_CHECK(ndr_pull_array_length(ndr, &r->devices));
 830                         if (ndr_get_array_length(ndr, &r->devices) > ndr_get_array_size(ndr, &r->devices)) {
 831                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->devices), ndr_get_array_length(ndr, &r->devices));
 832                         }
 833                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->devices), sizeof(uint16_t)));
 834                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->devices, ndr_get_array_length(ndr, &r->devices), sizeof(uint16_t), CH_UTF16));
 835                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devices_0, 0);
 836                 }
 837         }
 838         return NDR_ERR_SUCCESS;
 839 }
 840
 841 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQInfo1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevQInfo1 *r)
 842 {
 843         ndr_print_struct(ndr, name, "srvsvc_NetCharDevQInfo1");
 844         ndr->depth++;
 845         ndr_print_ptr(ndr, "device", r->device);
 846         ndr->depth++;
 847         if (r->device) {
 848                 ndr_print_string(ndr, "device", r->device);
 849         }
 850         ndr->depth--;
 851         ndr_print_uint32(ndr, "priority", r->priority);
 852         ndr_print_ptr(ndr, "devices", r->devices);
 853         ndr->depth++;
 854         if (r->devices) {
 855                 ndr_print_string(ndr, "devices", r->devices);
 856         }
 857         ndr->depth--;
 858         ndr_print_uint32(ndr, "users", r->users);
 859         ndr_print_uint32(ndr, "num_ahead", r->num_ahead);
 860         ndr->depth--;
 861 }
 862
 863 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQCtr1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevQCtr1 *r)
 864 {
 865         uint32_t cntr_array_1;
 866         if (ndr_flags & NDR_SCALARS) {
 867                 NDR_CHECK(ndr_push_align(ndr, 4));
 868                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 869                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
 870         }
 871         if (ndr_flags & NDR_BUFFERS) {
 872                 if (r->array) {
 873                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 874                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
 875                                 NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
 876                         }
 877                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
 878                                 NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
 879                         }
 880                 }
 881         }
 882         return NDR_ERR_SUCCESS;
 883 }
 884
 885 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQCtr1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevQCtr1 *r)
 886 {
 887         uint32_t _ptr_array;
 888         uint32_t cntr_array_1;
 889         TALLOC_CTX *_mem_save_array_0;
 890         TALLOC_CTX *_mem_save_array_1;
 891         if (ndr_flags & NDR_SCALARS) {
 892                 NDR_CHECK(ndr_pull_align(ndr, 4));
 893                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 894                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
 895                 if (_ptr_array) {
 896                         NDR_PULL_ALLOC(ndr, r->array);
 897                 } else {
 898                         r->array = NULL;
 899                 }
 900         }
 901         if (ndr_flags & NDR_BUFFERS) {
 902                 if (r->array) {
 903                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
 904                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
 905                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
 906                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
 907                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
 908                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
 909                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
 910                                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
 911                         }
 912                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
 913                                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
 914                         }
 915                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
 916                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
 917                 }
 918                 if (r->array) {
 919                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
 920                 }
 921         }
 922         return NDR_ERR_SUCCESS;
 923 }
 924
 925 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQCtr1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevQCtr1 *r)
 926 {
 927         uint32_t cntr_array_1;
 928         ndr_print_struct(ndr, name, "srvsvc_NetCharDevQCtr1");
 929         ndr->depth++;
 930         ndr_print_uint32(ndr, "count", r->count);
 931         ndr_print_ptr(ndr, "array", r->array);
 932         ndr->depth++;
 933         if (r->array) {
 934                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
 935                 ndr->depth++;
 936                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
 937                         char *idx_1=NULL;
 938                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
 939                                 ndr_print_srvsvc_NetCharDevQInfo1(ndr, "array", &r->array[cntr_array_1]);
 940                                 free(idx_1);
 941                         }
 942                 }
 943                 ndr->depth--;
 944         }
 945         ndr->depth--;
 946         ndr->depth--;
 947 }
 948
 949 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQInfo(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetCharDevQInfo *r)
 950 {
 951         if (ndr_flags & NDR_SCALARS) {
 952                 int level = ndr_push_get_switch_value(ndr, r);
 953                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
 954                 switch (level) {
 955                         case 0: {
 956                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
 957                         break; }
 958
 959                         case 1: {
 960                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
 961                         break; }
 962
 963                         default: {
 964                         break; }
 965
 966                 }
 967         }
 968         if (ndr_flags & NDR_BUFFERS) {
 969                 int level = ndr_push_get_switch_value(ndr, r);
 970                 switch (level) {
 971                         case 0:
 972                                 if (r->info0) {
 973                                         NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
 974                                 }
 975                         break;
 976
 977                         case 1:
 978                                 if (r->info1) {
 979                                         NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
 980                                 }
 981                         break;
 982
 983                         default:
 984                         break;
 985
 986                 }
 987         }
 988         return NDR_ERR_SUCCESS;
 989 }
 990
 991 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQInfo(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetCharDevQInfo *r)
 992 {
 993         int level;
 994         uint32_t _level;
 995         TALLOC_CTX *_mem_save_info0_0;
 996         TALLOC_CTX *_mem_save_info1_0;
 997         level = ndr_pull_get_switch_value(ndr, r);
 998         if (ndr_flags & NDR_SCALARS) {
 999                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
1000                 if (_level != level) {
1001                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1002                 }
1003                 switch (level) {
1004                         case 0: {
1005                                 uint32_t _ptr_info0;
1006                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
1007                                 if (_ptr_info0) {
1008                                         NDR_PULL_ALLOC(ndr, r->info0);
1009                                 } else {
1010                                         r->info0 = NULL;
1011                                 }
1012                         break; }
1013
1014                         case 1: {
1015                                 uint32_t _ptr_info1;
1016                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
1017                                 if (_ptr_info1) {
1018                                         NDR_PULL_ALLOC(ndr, r->info1);
1019                                 } else {
1020                                         r->info1 = NULL;
1021                                 }
1022                         break; }
1023
1024                         default: {
1025                         break; }
1026
1027                 }
1028         }
1029         if (ndr_flags & NDR_BUFFERS) {
1030                 switch (level) {
1031                         case 0:
1032                                 if (r->info0) {
1033                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
1034                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
1035                                         NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
1036                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
1037                                 }
1038                         break;
1039
1040                         case 1:
1041                                 if (r->info1) {
1042                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
1043                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
1044                                         NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
1045                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
1046                                 }
1047                         break;
1048
1049                         default:
1050                         break;
1051
1052                 }
1053         }
1054         return NDR_ERR_SUCCESS;
1055 }
1056
1057 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQInfo(struct ndr_print *ndr, const char *name, const union srvsvc_NetCharDevQInfo *r)
1058 {
1059         int level;
1060         level = ndr_print_get_switch_value(ndr, r);
1061         ndr_print_union(ndr, name, level, "srvsvc_NetCharDevQInfo");
1062         switch (level) {
1063                 case 0:
1064                         ndr_print_ptr(ndr, "info0", r->info0);
1065                         ndr->depth++;
1066                         if (r->info0) {
1067                                 ndr_print_srvsvc_NetCharDevQInfo0(ndr, "info0", r->info0);
1068                         }
1069                         ndr->depth--;
1070                 break;
1071
1072                 case 1:
1073                         ndr_print_ptr(ndr, "info1", r->info1);
1074                         ndr->depth++;
1075                         if (r->info1) {
1076                                 ndr_print_srvsvc_NetCharDevQInfo1(ndr, "info1", r->info1);
1077                         }
1078                         ndr->depth--;
1079                 break;
1080
1081                 default:
1082                 break;
1083
1084         }
1085 }
1086
1087 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQCtr(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetCharDevQCtr *r)
1088 {
1089         if (ndr_flags & NDR_SCALARS) {
1090                 int level = ndr_push_get_switch_value(ndr, r);
1091                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
1092                 switch (level) {
1093                         case 0: {
1094                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
1095                         break; }
1096
1097                         case 1: {
1098                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
1099                         break; }
1100
1101                         default: {
1102                         break; }
1103
1104                 }
1105         }
1106         if (ndr_flags & NDR_BUFFERS) {
1107                 int level = ndr_push_get_switch_value(ndr, r);
1108                 switch (level) {
1109                         case 0:
1110                                 if (r->ctr0) {
1111                                         NDR_CHECK(ndr_push_srvsvc_NetCharDevQCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
1112                                 }
1113                         break;
1114
1115                         case 1:
1116                                 if (r->ctr1) {
1117                                         NDR_CHECK(ndr_push_srvsvc_NetCharDevQCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
1118                                 }
1119                         break;
1120
1121                         default:
1122                         break;
1123
1124                 }
1125         }
1126         return NDR_ERR_SUCCESS;
1127 }
1128
1129 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQCtr(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetCharDevQCtr *r)
1130 {
1131         int level;
1132         uint32_t _level;
1133         TALLOC_CTX *_mem_save_ctr0_0;
1134         TALLOC_CTX *_mem_save_ctr1_0;
1135         level = ndr_pull_get_switch_value(ndr, r);
1136         if (ndr_flags & NDR_SCALARS) {
1137                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
1138                 if (_level != level) {
1139                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1140                 }
1141                 switch (level) {
1142                         case 0: {
1143                                 uint32_t _ptr_ctr0;
1144                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));
1145                                 if (_ptr_ctr0) {
1146                                         NDR_PULL_ALLOC(ndr, r->ctr0);
1147                                 } else {
1148                                         r->ctr0 = NULL;
1149                                 }
1150                         break; }
1151
1152                         case 1: {
1153                                 uint32_t _ptr_ctr1;
1154                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
1155                                 if (_ptr_ctr1) {
1156                                         NDR_PULL_ALLOC(ndr, r->ctr1);
1157                                 } else {
1158                                         r->ctr1 = NULL;
1159                                 }
1160                         break; }
1161
1162                         default: {
1163                         break; }
1164
1165                 }
1166         }
1167         if (ndr_flags & NDR_BUFFERS) {
1168                 switch (level) {
1169                         case 0:
1170                                 if (r->ctr0) {
1171                                         _mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);
1172                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr0, 0);
1173                                         NDR_CHECK(ndr_pull_srvsvc_NetCharDevQCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
1174                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);
1175                                 }
1176                         break;
1177
1178                         case 1:
1179                                 if (r->ctr1) {
1180                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
1181                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
1182                                         NDR_CHECK(ndr_pull_srvsvc_NetCharDevQCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
1183                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
1184                                 }
1185                         break;
1186
1187                         default:
1188                         break;
1189
1190                 }
1191         }
1192         return NDR_ERR_SUCCESS;
1193 }
1194
1195 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQCtr(struct ndr_print *ndr, const char *name, const union srvsvc_NetCharDevQCtr *r)
1196 {
1197         int level;
1198         level = ndr_print_get_switch_value(ndr, r);
1199         ndr_print_union(ndr, name, level, "srvsvc_NetCharDevQCtr");
1200         switch (level) {
1201                 case 0:
1202                         ndr_print_ptr(ndr, "ctr0", r->ctr0);
1203                         ndr->depth++;
1204                         if (r->ctr0) {
1205                                 ndr_print_srvsvc_NetCharDevQCtr0(ndr, "ctr0", r->ctr0);
1206                         }
1207                         ndr->depth--;
1208                 break;
1209
1210                 case 1:
1211                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
1212                         ndr->depth++;
1213                         if (r->ctr1) {
1214                                 ndr_print_srvsvc_NetCharDevQCtr1(ndr, "ctr1", r->ctr1);
1215                         }
1216                         ndr->depth--;
1217                 break;
1218
1219                 default:
1220                 break;
1221
1222         }
1223 }
1224
1225 static enum ndr_err_code ndr_push_srvsvc_NetConnInfo0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetConnInfo0 *r)
1226 {
1227         if (ndr_flags & NDR_SCALARS) {
1228                 NDR_CHECK(ndr_push_align(ndr, 4));
1229                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->conn_id));
1230         }
1231         if (ndr_flags & NDR_BUFFERS) {
1232         }
1233         return NDR_ERR_SUCCESS;
1234 }
1235
1236 static enum ndr_err_code ndr_pull_srvsvc_NetConnInfo0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetConnInfo0 *r)
1237 {
1238         if (ndr_flags & NDR_SCALARS) {
1239                 NDR_CHECK(ndr_pull_align(ndr, 4));
1240                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->conn_id));
1241         }
1242         if (ndr_flags & NDR_BUFFERS) {
1243         }
1244         return NDR_ERR_SUCCESS;
1245 }
1246
1247 _PUBLIC_ void ndr_print_srvsvc_NetConnInfo0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetConnInfo0 *r)
1248 {
1249         ndr_print_struct(ndr, name, "srvsvc_NetConnInfo0");
1250         ndr->depth++;
1251         ndr_print_uint32(ndr, "conn_id", r->conn_id);
1252         ndr->depth--;
1253 }
1254
1255 static enum ndr_err_code ndr_push_srvsvc_NetConnCtr0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetConnCtr0 *r)
1256 {
1257         uint32_t cntr_array_1;
1258         if (ndr_flags & NDR_SCALARS) {
1259                 NDR_CHECK(ndr_push_align(ndr, 4));
1260                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1261                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
1262         }
1263         if (ndr_flags & NDR_BUFFERS) {
1264                 if (r->array) {
1265                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1266                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
1267                                 NDR_CHECK(ndr_push_srvsvc_NetConnInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
1268                         }
1269                 }
1270         }
1271         return NDR_ERR_SUCCESS;
1272 }
1273
1274 static enum ndr_err_code ndr_pull_srvsvc_NetConnCtr0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetConnCtr0 *r)
1275 {
1276         uint32_t _ptr_array;
1277         uint32_t cntr_array_1;
1278         TALLOC_CTX *_mem_save_array_0;
1279         TALLOC_CTX *_mem_save_array_1;
1280         if (ndr_flags & NDR_SCALARS) {
1281                 NDR_CHECK(ndr_pull_align(ndr, 4));
1282                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1283                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
1284                 if (_ptr_array) {
1285                         NDR_PULL_ALLOC(ndr, r->array);
1286                 } else {
1287                         r->array = NULL;
1288                 }
1289         }
1290         if (ndr_flags & NDR_BUFFERS) {
1291                 if (r->array) {
1292                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
1293                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
1294                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
1295                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
1296                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
1297                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
1298                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
1299                                 NDR_CHECK(ndr_pull_srvsvc_NetConnInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
1300                         }
1301                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
1302                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
1303                 }
1304                 if (r->array) {
1305                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
1306                 }
1307         }
1308         return NDR_ERR_SUCCESS;
1309 }
1310
1311 _PUBLIC_ void ndr_print_srvsvc_NetConnCtr0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetConnCtr0 *r)
1312 {
1313         uint32_t cntr_array_1;
1314         ndr_print_struct(ndr, name, "srvsvc_NetConnCtr0");
1315         ndr->depth++;
1316         ndr_print_uint32(ndr, "count", r->count);
1317         ndr_print_ptr(ndr, "array", r->array);
1318         ndr->depth++;
1319         if (r->array) {
1320                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
1321                 ndr->depth++;
1322                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
1323                         char *idx_1=NULL;
1324                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
1325                                 ndr_print_srvsvc_NetConnInfo0(ndr, "array", &r->array[cntr_array_1]);
1326                                 free(idx_1);
1327                         }
1328                 }
1329                 ndr->depth--;
1330         }
1331         ndr->depth--;
1332         ndr->depth--;
1333 }
1334
1335 static enum ndr_err_code ndr_push_srvsvc_NetConnInfo1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetConnInfo1 *r)
1336 {
1337         if (ndr_flags & NDR_SCALARS) {
1338                 NDR_CHECK(ndr_push_align(ndr, 4));
1339                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->conn_id));
1340                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->conn_type));
1341                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_open));
1342                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_users));
1343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->conn_time));
1344                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
1345                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->share));
1346         }
1347         if (ndr_flags & NDR_BUFFERS) {
1348                 if (r->user) {
1349                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
1350                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1351                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
1352                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
1353                 }
1354                 if (r->share) {
1355                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->share, CH_UTF16)));
1356                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1357                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->share, CH_UTF16)));
1358                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->share, ndr_charset_length(r->share, CH_UTF16), sizeof(uint16_t), CH_UTF16));
1359                 }
1360         }
1361         return NDR_ERR_SUCCESS;
1362 }
1363
1364 static enum ndr_err_code ndr_pull_srvsvc_NetConnInfo1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetConnInfo1 *r)
1365 {
1366         uint32_t _ptr_user;
1367         TALLOC_CTX *_mem_save_user_0;
1368         uint32_t _ptr_share;
1369         TALLOC_CTX *_mem_save_share_0;
1370         if (ndr_flags & NDR_SCALARS) {
1371                 NDR_CHECK(ndr_pull_align(ndr, 4));
1372                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->conn_id));
1373                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->conn_type));
1374                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_open));
1375                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_users));
1376                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->conn_time));
1377                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
1378                 if (_ptr_user) {
1379                         NDR_PULL_ALLOC(ndr, r->user);
1380                 } else {
1381                         r->user = NULL;
1382                 }
1383                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_share));
1384                 if (_ptr_share) {
1385                         NDR_PULL_ALLOC(ndr, r->share);
1386                 } else {
1387                         r->share = NULL;
1388                 }
1389         }
1390         if (ndr_flags & NDR_BUFFERS) {
1391                 if (r->user) {
1392                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
1393                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
1394                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
1395                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
1396                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
1397                                 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));
1398                         }
1399                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
1400                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
1401                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
1402                 }
1403                 if (r->share) {
1404                         _mem_save_share_0 = NDR_PULL_GET_MEM_CTX(ndr);
1405                         NDR_PULL_SET_MEM_CTX(ndr, r->share, 0);
1406                         NDR_CHECK(ndr_pull_array_size(ndr, &r->share));
1407                         NDR_CHECK(ndr_pull_array_length(ndr, &r->share));
1408                         if (ndr_get_array_length(ndr, &r->share) > ndr_get_array_size(ndr, &r->share)) {
1409                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->share), ndr_get_array_length(ndr, &r->share));
1410                         }
1411                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->share), sizeof(uint16_t)));
1412                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->share, ndr_get_array_length(ndr, &r->share), sizeof(uint16_t), CH_UTF16));
1413                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_share_0, 0);
1414                 }
1415         }
1416         return NDR_ERR_SUCCESS;
1417 }
1418
1419 _PUBLIC_ void ndr_print_srvsvc_NetConnInfo1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetConnInfo1 *r)
1420 {
1421         ndr_print_struct(ndr, name, "srvsvc_NetConnInfo1");
1422         ndr->depth++;
1423         ndr_print_uint32(ndr, "conn_id", r->conn_id);
1424         ndr_print_uint32(ndr, "conn_type", r->conn_type);
1425         ndr_print_uint32(ndr, "num_open", r->num_open);
1426         ndr_print_uint32(ndr, "num_users", r->num_users);
1427         ndr_print_uint32(ndr, "conn_time", r->conn_time);
1428         ndr_print_ptr(ndr, "user", r->user);
1429         ndr->depth++;
1430         if (r->user) {
1431                 ndr_print_string(ndr, "user", r->user);
1432         }
1433         ndr->depth--;
1434         ndr_print_ptr(ndr, "share", r->share);
1435         ndr->depth++;
1436         if (r->share) {
1437                 ndr_print_string(ndr, "share", r->share);
1438         }
1439         ndr->depth--;
1440         ndr->depth--;
1441 }
1442
1443 static enum ndr_err_code ndr_push_srvsvc_NetConnCtr1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetConnCtr1 *r)
1444 {
1445         uint32_t cntr_array_1;
1446         if (ndr_flags & NDR_SCALARS) {
1447                 NDR_CHECK(ndr_push_align(ndr, 4));
1448                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1449                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
1450         }
1451         if (ndr_flags & NDR_BUFFERS) {
1452                 if (r->array) {
1453                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1454                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
1455                                 NDR_CHECK(ndr_push_srvsvc_NetConnInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
1456                         }
1457                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
1458                                 NDR_CHECK(ndr_push_srvsvc_NetConnInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
1459                         }
1460                 }
1461         }
1462         return NDR_ERR_SUCCESS;
1463 }
1464
1465 static enum ndr_err_code ndr_pull_srvsvc_NetConnCtr1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetConnCtr1 *r)
1466 {
1467         uint32_t _ptr_array;
1468         uint32_t cntr_array_1;
1469         TALLOC_CTX *_mem_save_array_0;
1470         TALLOC_CTX *_mem_save_array_1;
1471         if (ndr_flags & NDR_SCALARS) {
1472                 NDR_CHECK(ndr_pull_align(ndr, 4));
1473                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1474                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
1475                 if (_ptr_array) {
1476                         NDR_PULL_ALLOC(ndr, r->array);
1477                 } else {
1478                         r->array = NULL;
1479                 }
1480         }
1481         if (ndr_flags & NDR_BUFFERS) {
1482                 if (r->array) {
1483                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
1484                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
1485                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
1486                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
1487                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
1488                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
1489                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
1490                                 NDR_CHECK(ndr_pull_srvsvc_NetConnInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
1491                         }
1492                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
1493                                 NDR_CHECK(ndr_pull_srvsvc_NetConnInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
1494                         }
1495                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
1496                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
1497                 }
1498                 if (r->array) {
1499                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
1500                 }
1501         }
1502         return NDR_ERR_SUCCESS;
1503 }
1504
1505 _PUBLIC_ void ndr_print_srvsvc_NetConnCtr1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetConnCtr1 *r)
1506 {
1507         uint32_t cntr_array_1;
1508         ndr_print_struct(ndr, name, "srvsvc_NetConnCtr1");
1509         ndr->depth++;
1510         ndr_print_uint32(ndr, "count", r->count);
1511         ndr_print_ptr(ndr, "array", r->array);
1512         ndr->depth++;
1513         if (r->array) {
1514                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
1515                 ndr->depth++;
1516                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
1517                         char *idx_1=NULL;
1518                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
1519                                 ndr_print_srvsvc_NetConnInfo1(ndr, "array", &r->array[cntr_array_1]);
1520                                 free(idx_1);
1521                         }
1522                 }
1523                 ndr->depth--;
1524         }
1525         ndr->depth--;
1526         ndr->depth--;
1527 }
1528
1529 static enum ndr_err_code ndr_push_srvsvc_NetConnCtr(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetConnCtr *r)
1530 {
1531         if (ndr_flags & NDR_SCALARS) {
1532                 int level = ndr_push_get_switch_value(ndr, r);
1533                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
1534                 switch (level) {
1535                         case 0: {
1536                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
1537                         break; }
1538
1539                         case 1: {
1540                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
1541                         break; }
1542
1543                         default: {
1544                         break; }
1545
1546                 }
1547         }
1548         if (ndr_flags & NDR_BUFFERS) {
1549                 int level = ndr_push_get_switch_value(ndr, r);
1550                 switch (level) {
1551                         case 0:
1552                                 if (r->ctr0) {
1553                                         NDR_CHECK(ndr_push_srvsvc_NetConnCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
1554                                 }
1555                         break;
1556
1557                         case 1:
1558                                 if (r->ctr1) {
1559                                         NDR_CHECK(ndr_push_srvsvc_NetConnCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
1560                                 }
1561                         break;
1562
1563                         default:
1564                         break;
1565
1566                 }
1567         }
1568         return NDR_ERR_SUCCESS;
1569 }
1570
1571 static enum ndr_err_code ndr_pull_srvsvc_NetConnCtr(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetConnCtr *r)
1572 {
1573         int level;
1574         uint32_t _level;
1575         TALLOC_CTX *_mem_save_ctr0_0;
1576         TALLOC_CTX *_mem_save_ctr1_0;
1577         level = ndr_pull_get_switch_value(ndr, r);
1578         if (ndr_flags & NDR_SCALARS) {
1579                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
1580                 if (_level != level) {
1581                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1582                 }
1583                 switch (level) {
1584                         case 0: {
1585                                 uint32_t _ptr_ctr0;
1586                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));
1587                                 if (_ptr_ctr0) {
1588                                         NDR_PULL_ALLOC(ndr, r->ctr0);
1589                                 } else {
1590                                         r->ctr0 = NULL;
1591                                 }
1592                         break; }
1593
1594                         case 1: {
1595                                 uint32_t _ptr_ctr1;
1596                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
1597                                 if (_ptr_ctr1) {
1598                                         NDR_PULL_ALLOC(ndr, r->ctr1);
1599                                 } else {
1600                                         r->ctr1 = NULL;
1601                                 }
1602                         break; }
1603
1604                         default: {
1605                         break; }
1606
1607                 }
1608         }
1609         if (ndr_flags & NDR_BUFFERS) {
1610                 switch (level) {
1611                         case 0:
1612                                 if (r->ctr0) {
1613                                         _mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);
1614                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr0, 0);
1615                                         NDR_CHECK(ndr_pull_srvsvc_NetConnCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
1616                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);
1617                                 }
1618                         break;
1619
1620                         case 1:
1621                                 if (r->ctr1) {
1622                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
1623                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
1624                                         NDR_CHECK(ndr_pull_srvsvc_NetConnCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
1625                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
1626                                 }
1627                         break;
1628
1629                         default:
1630                         break;
1631
1632                 }
1633         }
1634         return NDR_ERR_SUCCESS;
1635 }
1636
1637 _PUBLIC_ void ndr_print_srvsvc_NetConnCtr(struct ndr_print *ndr, const char *name, const union srvsvc_NetConnCtr *r)
1638 {
1639         int level;
1640         level = ndr_print_get_switch_value(ndr, r);
1641         ndr_print_union(ndr, name, level, "srvsvc_NetConnCtr");
1642         switch (level) {
1643                 case 0:
1644                         ndr_print_ptr(ndr, "ctr0", r->ctr0);
1645                         ndr->depth++;
1646                         if (r->ctr0) {
1647                                 ndr_print_srvsvc_NetConnCtr0(ndr, "ctr0", r->ctr0);
1648                         }
1649                         ndr->depth--;
1650                 break;
1651
1652                 case 1:
1653                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
1654                         ndr->depth++;
1655                         if (r->ctr1) {
1656                                 ndr_print_srvsvc_NetConnCtr1(ndr, "ctr1", r->ctr1);
1657                         }
1658                         ndr->depth--;
1659                 break;
1660
1661                 default:
1662                 break;
1663
1664         }
1665 }
1666
1667 static enum ndr_err_code ndr_push_srvsvc_NetFileInfo2(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetFileInfo2 *r)
1668 {
1669         if (ndr_flags & NDR_SCALARS) {
1670                 NDR_CHECK(ndr_push_align(ndr, 4));
1671                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->fid));
1672         }
1673         if (ndr_flags & NDR_BUFFERS) {
1674         }
1675         return NDR_ERR_SUCCESS;
1676 }
1677
1678 static enum ndr_err_code ndr_pull_srvsvc_NetFileInfo2(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetFileInfo2 *r)
1679 {
1680         if (ndr_flags & NDR_SCALARS) {
1681                 NDR_CHECK(ndr_pull_align(ndr, 4));
1682                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->fid));
1683         }
1684         if (ndr_flags & NDR_BUFFERS) {
1685         }
1686         return NDR_ERR_SUCCESS;
1687 }
1688
1689 _PUBLIC_ void ndr_print_srvsvc_NetFileInfo2(struct ndr_print *ndr, const char *name, const struct srvsvc_NetFileInfo2 *r)
1690 {
1691         ndr_print_struct(ndr, name, "srvsvc_NetFileInfo2");
1692         ndr->depth++;
1693         ndr_print_uint32(ndr, "fid", r->fid);
1694         ndr->depth--;
1695 }
1696
1697 static enum ndr_err_code ndr_push_srvsvc_NetFileCtr2(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetFileCtr2 *r)
1698 {
1699         uint32_t cntr_array_1;
1700         if (ndr_flags & NDR_SCALARS) {
1701                 NDR_CHECK(ndr_push_align(ndr, 4));
1702                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1703                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
1704         }
1705         if (ndr_flags & NDR_BUFFERS) {
1706                 if (r->array) {
1707                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1708                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
1709                                 NDR_CHECK(ndr_push_srvsvc_NetFileInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
1710                         }
1711                 }
1712         }
1713         return NDR_ERR_SUCCESS;
1714 }
1715
1716 static enum ndr_err_code ndr_pull_srvsvc_NetFileCtr2(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetFileCtr2 *r)
1717 {
1718         uint32_t _ptr_array;
1719         uint32_t cntr_array_1;
1720         TALLOC_CTX *_mem_save_array_0;
1721         TALLOC_CTX *_mem_save_array_1;
1722         if (ndr_flags & NDR_SCALARS) {
1723                 NDR_CHECK(ndr_pull_align(ndr, 4));
1724                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1725                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
1726                 if (_ptr_array) {
1727                         NDR_PULL_ALLOC(ndr, r->array);
1728                 } else {
1729                         r->array = NULL;
1730                 }
1731         }
1732         if (ndr_flags & NDR_BUFFERS) {
1733                 if (r->array) {
1734                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
1735                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
1736                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
1737                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
1738                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
1739                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
1740                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
1741                                 NDR_CHECK(ndr_pull_srvsvc_NetFileInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
1742                         }
1743                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
1744                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
1745                 }
1746                 if (r->array) {
1747                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
1748                 }
1749         }
1750         return NDR_ERR_SUCCESS;
1751 }
1752
1753 _PUBLIC_ void ndr_print_srvsvc_NetFileCtr2(struct ndr_print *ndr, const char *name, const struct srvsvc_NetFileCtr2 *r)
1754 {
1755         uint32_t cntr_array_1;
1756         ndr_print_struct(ndr, name, "srvsvc_NetFileCtr2");
1757         ndr->depth++;
1758         ndr_print_uint32(ndr, "count", r->count);
1759         ndr_print_ptr(ndr, "array", r->array);
1760         ndr->depth++;
1761         if (r->array) {
1762                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
1763                 ndr->depth++;
1764                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
1765                         char *idx_1=NULL;
1766                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
1767                                 ndr_print_srvsvc_NetFileInfo2(ndr, "array", &r->array[cntr_array_1]);
1768                                 free(idx_1);
1769                         }
1770                 }
1771                 ndr->depth--;
1772         }
1773         ndr->depth--;
1774         ndr->depth--;
1775 }
1776
1777 static enum ndr_err_code ndr_push_srvsvc_NetFileInfo3(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetFileInfo3 *r)
1778 {
1779         if (ndr_flags & NDR_SCALARS) {
1780                 NDR_CHECK(ndr_push_align(ndr, 4));
1781                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->fid));
1782                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->permissions));
1783                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_locks));
1784                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->path));
1785                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
1786         }
1787         if (ndr_flags & NDR_BUFFERS) {
1788                 if (r->path) {
1789                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));
1790                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1791                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));
1792                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->path, ndr_charset_length(r->path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
1793                 }
1794                 if (r->user) {
1795                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
1796                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1797                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
1798                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
1799                 }
1800         }
1801         return NDR_ERR_SUCCESS;
1802 }
1803
1804 static enum ndr_err_code ndr_pull_srvsvc_NetFileInfo3(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetFileInfo3 *r)
1805 {
1806         uint32_t _ptr_path;
1807         TALLOC_CTX *_mem_save_path_0;
1808         uint32_t _ptr_user;
1809         TALLOC_CTX *_mem_save_user_0;
1810         if (ndr_flags & NDR_SCALARS) {
1811                 NDR_CHECK(ndr_pull_align(ndr, 4));
1812                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->fid));
1813                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->permissions));
1814                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_locks));
1815                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_path));
1816                 if (_ptr_path) {
1817                         NDR_PULL_ALLOC(ndr, r->path);
1818                 } else {
1819                         r->path = NULL;
1820                 }
1821                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
1822                 if (_ptr_user) {
1823                         NDR_PULL_ALLOC(ndr, r->user);
1824                 } else {
1825                         r->user = NULL;
1826                 }
1827         }
1828         if (ndr_flags & NDR_BUFFERS) {
1829                 if (r->path) {
1830                         _mem_save_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
1831                         NDR_PULL_SET_MEM_CTX(ndr, r->path, 0);
1832                         NDR_CHECK(ndr_pull_array_size(ndr, &r->path));
1833                         NDR_CHECK(ndr_pull_array_length(ndr, &r->path));
1834                         if (ndr_get_array_length(ndr, &r->path) > ndr_get_array_size(ndr, &r->path)) {
1835                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->path), ndr_get_array_length(ndr, &r->path));
1836                         }
1837                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->path), sizeof(uint16_t)));
1838                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->path, ndr_get_array_length(ndr, &r->path), sizeof(uint16_t), CH_UTF16));
1839                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_path_0, 0);
1840                 }
1841                 if (r->user) {
1842                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
1843                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
1844                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
1845                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
1846                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
1847                                 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));
1848                         }
1849                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
1850                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
1851                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
1852                 }
1853         }
1854         return NDR_ERR_SUCCESS;
1855 }
1856
1857 _PUBLIC_ void ndr_print_srvsvc_NetFileInfo3(struct ndr_print *ndr, const char *name, const struct srvsvc_NetFileInfo3 *r)
1858 {
1859         ndr_print_struct(ndr, name, "srvsvc_NetFileInfo3");
1860         ndr->depth++;
1861         ndr_print_uint32(ndr, "fid", r->fid);
1862         ndr_print_uint32(ndr, "permissions", r->permissions);
1863         ndr_print_uint32(ndr, "num_locks", r->num_locks);
1864         ndr_print_ptr(ndr, "path", r->path);
1865         ndr->depth++;
1866         if (r->path) {
1867                 ndr_print_string(ndr, "path", r->path);
1868         }
1869         ndr->depth--;
1870         ndr_print_ptr(ndr, "user", r->user);
1871         ndr->depth++;
1872         if (r->user) {
1873                 ndr_print_string(ndr, "user", r->user);
1874         }
1875         ndr->depth--;
1876         ndr->depth--;
1877 }
1878
1879 static enum ndr_err_code ndr_push_srvsvc_NetFileCtr3(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetFileCtr3 *r)
1880 {
1881         uint32_t cntr_array_1;
1882         if (ndr_flags & NDR_SCALARS) {
1883                 NDR_CHECK(ndr_push_align(ndr, 4));
1884                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1885                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
1886         }
1887         if (ndr_flags & NDR_BUFFERS) {
1888                 if (r->array) {
1889                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1890                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
1891                                 NDR_CHECK(ndr_push_srvsvc_NetFileInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
1892                         }
1893                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
1894                                 NDR_CHECK(ndr_push_srvsvc_NetFileInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
1895                         }
1896                 }
1897         }
1898         return NDR_ERR_SUCCESS;
1899 }
1900
1901 static enum ndr_err_code ndr_pull_srvsvc_NetFileCtr3(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetFileCtr3 *r)
1902 {
1903         uint32_t _ptr_array;
1904         uint32_t cntr_array_1;
1905         TALLOC_CTX *_mem_save_array_0;
1906         TALLOC_CTX *_mem_save_array_1;
1907         if (ndr_flags & NDR_SCALARS) {
1908                 NDR_CHECK(ndr_pull_align(ndr, 4));
1909                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1910                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
1911                 if (_ptr_array) {
1912                         NDR_PULL_ALLOC(ndr, r->array);
1913                 } else {
1914                         r->array = NULL;
1915                 }
1916         }
1917         if (ndr_flags & NDR_BUFFERS) {
1918                 if (r->array) {
1919                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
1920                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
1921                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
1922                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
1923                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
1924                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
1925                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
1926                                 NDR_CHECK(ndr_pull_srvsvc_NetFileInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
1927                         }
1928                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
1929                                 NDR_CHECK(ndr_pull_srvsvc_NetFileInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
1930                         }
1931                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
1932                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
1933                 }
1934                 if (r->array) {
1935                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
1936                 }
1937         }
1938         return NDR_ERR_SUCCESS;
1939 }
1940
1941 _PUBLIC_ void ndr_print_srvsvc_NetFileCtr3(struct ndr_print *ndr, const char *name, const struct srvsvc_NetFileCtr3 *r)
1942 {
1943         uint32_t cntr_array_1;
1944         ndr_print_struct(ndr, name, "srvsvc_NetFileCtr3");
1945         ndr->depth++;
1946         ndr_print_uint32(ndr, "count", r->count);
1947         ndr_print_ptr(ndr, "array", r->array);
1948         ndr->depth++;
1949         if (r->array) {
1950                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
1951                 ndr->depth++;
1952                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
1953                         char *idx_1=NULL;
1954                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
1955                                 ndr_print_srvsvc_NetFileInfo3(ndr, "array", &r->array[cntr_array_1]);
1956                                 free(idx_1);
1957                         }
1958                 }
1959                 ndr->depth--;
1960         }
1961         ndr->depth--;
1962         ndr->depth--;
1963 }
1964
1965 static enum ndr_err_code ndr_push_srvsvc_NetFileInfo(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetFileInfo *r)
1966 {
1967         if (ndr_flags & NDR_SCALARS) {
1968                 int level = ndr_push_get_switch_value(ndr, r);
1969                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
1970                 switch (level) {
1971                         case 2: {
1972                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
1973                         break; }
1974
1975                         case 3: {
1976                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
1977                         break; }
1978
1979                         default: {
1980                         break; }
1981
1982                 }
1983         }
1984         if (ndr_flags & NDR_BUFFERS) {
1985                 int level = ndr_push_get_switch_value(ndr, r);
1986                 switch (level) {
1987                         case 2:
1988                                 if (r->info2) {
1989                                         NDR_CHECK(ndr_push_srvsvc_NetFileInfo2(ndr, NDR_SCALARS, r->info2));
1990                                 }
1991                         break;
1992
1993                         case 3:
1994                                 if (r->info3) {
1995                                         NDR_CHECK(ndr_push_srvsvc_NetFileInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
1996                                 }
1997                         break;
1998
1999                         default:
2000                         break;
2001
2002                 }
2003         }
2004         return NDR_ERR_SUCCESS;
2005 }
2006
2007 static enum ndr_err_code ndr_pull_srvsvc_NetFileInfo(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetFileInfo *r)
2008 {
2009         int level;
2010         uint32_t _level;
2011         TALLOC_CTX *_mem_save_info2_0;
2012         TALLOC_CTX *_mem_save_info3_0;
2013         level = ndr_pull_get_switch_value(ndr, r);
2014         if (ndr_flags & NDR_SCALARS) {
2015                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
2016                 if (_level != level) {
2017                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
2018                 }
2019                 switch (level) {
2020                         case 2: {
2021                                 uint32_t _ptr_info2;
2022                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
2023                                 if (_ptr_info2) {
2024                                         NDR_PULL_ALLOC(ndr, r->info2);
2025                                 } else {
2026                                         r->info2 = NULL;
2027                                 }
2028                         break; }
2029
2030                         case 3: {
2031                                 uint32_t _ptr_info3;
2032                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
2033                                 if (_ptr_info3) {
2034                                         NDR_PULL_ALLOC(ndr, r->info3);
2035                                 } else {
2036                                         r->info3 = NULL;
2037                                 }
2038                         break; }
2039
2040                         default: {
2041                         break; }
2042
2043                 }
2044         }
2045         if (ndr_flags & NDR_BUFFERS) {
2046                 switch (level) {
2047                         case 2:
2048                                 if (r->info2) {
2049                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
2050                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
2051                                         NDR_CHECK(ndr_pull_srvsvc_NetFileInfo2(ndr, NDR_SCALARS, r->info2));
2052                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
2053                                 }
2054                         break;
2055
2056                         case 3:
2057                                 if (r->info3) {
2058                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
2059                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
2060                                         NDR_CHECK(ndr_pull_srvsvc_NetFileInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
2061                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
2062                                 }
2063                         break;
2064
2065                         default:
2066                         break;
2067
2068                 }
2069         }
2070         return NDR_ERR_SUCCESS;
2071 }
2072
2073 _PUBLIC_ void ndr_print_srvsvc_NetFileInfo(struct ndr_print *ndr, const char *name, const union srvsvc_NetFileInfo *r)
2074 {
2075         int level;
2076         level = ndr_print_get_switch_value(ndr, r);
2077         ndr_print_union(ndr, name, level, "srvsvc_NetFileInfo");
2078         switch (level) {
2079                 case 2:
2080                         ndr_print_ptr(ndr, "info2", r->info2);
2081                         ndr->depth++;
2082                         if (r->info2) {
2083                                 ndr_print_srvsvc_NetFileInfo2(ndr, "info2", r->info2);
2084                         }
2085                         ndr->depth--;
2086                 break;
2087
2088                 case 3:
2089                         ndr_print_ptr(ndr, "info3", r->info3);
2090                         ndr->depth++;
2091                         if (r->info3) {
2092                                 ndr_print_srvsvc_NetFileInfo3(ndr, "info3", r->info3);
2093                         }
2094                         ndr->depth--;
2095                 break;
2096
2097                 default:
2098                 break;
2099
2100         }
2101 }
2102
2103 static enum ndr_err_code ndr_push_srvsvc_NetFileCtr(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetFileCtr *r)
2104 {
2105         if (ndr_flags & NDR_SCALARS) {
2106                 int level = ndr_push_get_switch_value(ndr, r);
2107                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
2108                 switch (level) {
2109                         case 2: {
2110                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr2));
2111                         break; }
2112
2113                         case 3: {
2114                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr3));
2115                         break; }
2116
2117                         default: {
2118                         break; }
2119
2120                 }
2121         }
2122         if (ndr_flags & NDR_BUFFERS) {
2123                 int level = ndr_push_get_switch_value(ndr, r);
2124                 switch (level) {
2125                         case 2:
2126                                 if (r->ctr2) {
2127                                         NDR_CHECK(ndr_push_srvsvc_NetFileCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
2128                                 }
2129                         break;
2130
2131                         case 3:
2132                                 if (r->ctr3) {
2133                                         NDR_CHECK(ndr_push_srvsvc_NetFileCtr3(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr3));
2134                                 }
2135                         break;
2136
2137                         default:
2138                         break;
2139
2140                 }
2141         }
2142         return NDR_ERR_SUCCESS;
2143 }
2144
2145 static enum ndr_err_code ndr_pull_srvsvc_NetFileCtr(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetFileCtr *r)
2146 {
2147         int level;
2148         uint32_t _level;
2149         TALLOC_CTX *_mem_save_ctr2_0;
2150         TALLOC_CTX *_mem_save_ctr3_0;
2151         level = ndr_pull_get_switch_value(ndr, r);
2152         if (ndr_flags & NDR_SCALARS) {
2153                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
2154                 if (_level != level) {
2155                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
2156                 }
2157                 switch (level) {
2158                         case 2: {
2159                                 uint32_t _ptr_ctr2;
2160                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr2));
2161                                 if (_ptr_ctr2) {
2162                                         NDR_PULL_ALLOC(ndr, r->ctr2);
2163                                 } else {
2164                                         r->ctr2 = NULL;
2165                                 }
2166                         break; }
2167
2168                         case 3: {
2169                                 uint32_t _ptr_ctr3;
2170                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr3));
2171                                 if (_ptr_ctr3) {
2172                                         NDR_PULL_ALLOC(ndr, r->ctr3);
2173                                 } else {
2174                                         r->ctr3 = NULL;
2175                                 }
2176                         break; }
2177
2178                         default: {
2179                         break; }
2180
2181                 }
2182         }
2183         if (ndr_flags & NDR_BUFFERS) {
2184                 switch (level) {
2185                         case 2:
2186                                 if (r->ctr2) {
2187                                         _mem_save_ctr2_0 = NDR_PULL_GET_MEM_CTX(ndr);
2188                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr2, 0);
2189                                         NDR_CHECK(ndr_pull_srvsvc_NetFileCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
2190                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr2_0, 0);
2191                                 }
2192                         break;
2193
2194                         case 3:
2195                                 if (r->ctr3) {
2196                                         _mem_save_ctr3_0 = NDR_PULL_GET_MEM_CTX(ndr);
2197                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr3, 0);
2198                                         NDR_CHECK(ndr_pull_srvsvc_NetFileCtr3(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr3));
2199                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr3_0, 0);
2200                                 }
2201                         break;
2202
2203                         default:
2204                         break;
2205
2206                 }
2207         }
2208         return NDR_ERR_SUCCESS;
2209 }
2210
2211 _PUBLIC_ void ndr_print_srvsvc_NetFileCtr(struct ndr_print *ndr, const char *name, const union srvsvc_NetFileCtr *r)
2212 {
2213         int level;
2214         level = ndr_print_get_switch_value(ndr, r);
2215         ndr_print_union(ndr, name, level, "srvsvc_NetFileCtr");
2216         switch (level) {
2217                 case 2:
2218                         ndr_print_ptr(ndr, "ctr2", r->ctr2);
2219                         ndr->depth++;
2220                         if (r->ctr2) {
2221                                 ndr_print_srvsvc_NetFileCtr2(ndr, "ctr2", r->ctr2);
2222                         }
2223                         ndr->depth--;
2224                 break;
2225
2226                 case 3:
2227                         ndr_print_ptr(ndr, "ctr3", r->ctr3);
2228                         ndr->depth++;
2229                         if (r->ctr3) {
2230                                 ndr_print_srvsvc_NetFileCtr3(ndr, "ctr3", r->ctr3);
2231                         }
2232                         ndr->depth--;
2233                 break;
2234
2235                 default:
2236                 break;
2237
2238         }
2239 }
2240
2241 static enum ndr_err_code ndr_push_srvsvc_NetSessInfo0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessInfo0 *r)
2242 {
2243         if (ndr_flags & NDR_SCALARS) {
2244                 NDR_CHECK(ndr_push_align(ndr, 4));
2245                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
2246         }
2247         if (ndr_flags & NDR_BUFFERS) {
2248                 if (r->client) {
2249                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
2250                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2251                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
2252                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2253                 }
2254         }
2255         return NDR_ERR_SUCCESS;
2256 }
2257
2258 static enum ndr_err_code ndr_pull_srvsvc_NetSessInfo0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessInfo0 *r)
2259 {
2260         uint32_t _ptr_client;
2261         TALLOC_CTX *_mem_save_client_0;
2262         if (ndr_flags & NDR_SCALARS) {
2263                 NDR_CHECK(ndr_pull_align(ndr, 4));
2264                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
2265                 if (_ptr_client) {
2266                         NDR_PULL_ALLOC(ndr, r->client);
2267                 } else {
2268                         r->client = NULL;
2269                 }
2270         }
2271         if (ndr_flags & NDR_BUFFERS) {
2272                 if (r->client) {
2273                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
2274                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
2275                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
2276                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
2277                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
2278                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->client), ndr_get_array_length(ndr, &r->client));
2279                         }
2280                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
2281                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
2282                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
2283                 }
2284         }
2285         return NDR_ERR_SUCCESS;
2286 }
2287
2288 _PUBLIC_ void ndr_print_srvsvc_NetSessInfo0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessInfo0 *r)
2289 {
2290         ndr_print_struct(ndr, name, "srvsvc_NetSessInfo0");
2291         ndr->depth++;
2292         ndr_print_ptr(ndr, "client", r->client);
2293         ndr->depth++;
2294         if (r->client) {
2295                 ndr_print_string(ndr, "client", r->client);
2296         }
2297         ndr->depth--;
2298         ndr->depth--;
2299 }
2300
2301 static enum ndr_err_code ndr_push_srvsvc_NetSessCtr0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessCtr0 *r)
2302 {
2303         uint32_t cntr_array_1;
2304         if (ndr_flags & NDR_SCALARS) {
2305                 NDR_CHECK(ndr_push_align(ndr, 4));
2306                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2307                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
2308         }
2309         if (ndr_flags & NDR_BUFFERS) {
2310                 if (r->array) {
2311                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2312                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2313                                 NDR_CHECK(ndr_push_srvsvc_NetSessInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
2314                         }
2315                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2316                                 NDR_CHECK(ndr_push_srvsvc_NetSessInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
2317                         }
2318                 }
2319         }
2320         return NDR_ERR_SUCCESS;
2321 }
2322
2323 static enum ndr_err_code ndr_pull_srvsvc_NetSessCtr0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessCtr0 *r)
2324 {
2325         uint32_t _ptr_array;
2326         uint32_t cntr_array_1;
2327         TALLOC_CTX *_mem_save_array_0;
2328         TALLOC_CTX *_mem_save_array_1;
2329         if (ndr_flags & NDR_SCALARS) {
2330                 NDR_CHECK(ndr_pull_align(ndr, 4));
2331                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2332                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
2333                 if (_ptr_array) {
2334                         NDR_PULL_ALLOC(ndr, r->array);
2335                 } else {
2336                         r->array = NULL;
2337                 }
2338         }
2339         if (ndr_flags & NDR_BUFFERS) {
2340                 if (r->array) {
2341                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
2342                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
2343                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
2344                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
2345                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
2346                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
2347                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2348                                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
2349                         }
2350                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2351                                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
2352                         }
2353                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
2354                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
2355                 }
2356                 if (r->array) {
2357                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
2358                 }
2359         }
2360         return NDR_ERR_SUCCESS;
2361 }
2362
2363 _PUBLIC_ void ndr_print_srvsvc_NetSessCtr0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessCtr0 *r)
2364 {
2365         uint32_t cntr_array_1;
2366         ndr_print_struct(ndr, name, "srvsvc_NetSessCtr0");
2367         ndr->depth++;
2368         ndr_print_uint32(ndr, "count", r->count);
2369         ndr_print_ptr(ndr, "array", r->array);
2370         ndr->depth++;
2371         if (r->array) {
2372                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
2373                 ndr->depth++;
2374                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
2375                         char *idx_1=NULL;
2376                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
2377                                 ndr_print_srvsvc_NetSessInfo0(ndr, "array", &r->array[cntr_array_1]);
2378                                 free(idx_1);
2379                         }
2380                 }
2381                 ndr->depth--;
2382         }
2383         ndr->depth--;
2384         ndr->depth--;
2385 }
2386
2387 static enum ndr_err_code ndr_push_srvsvc_NetSessInfo1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessInfo1 *r)
2388 {
2389         if (ndr_flags & NDR_SCALARS) {
2390                 NDR_CHECK(ndr_push_align(ndr, 4));
2391                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
2392                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
2393                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_open));
2394                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
2395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idle_time));
2396                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->user_flags));
2397         }
2398         if (ndr_flags & NDR_BUFFERS) {
2399                 if (r->client) {
2400                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
2401                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2402                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
2403                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2404                 }
2405                 if (r->user) {
2406                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
2407                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2408                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
2409                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2410                 }
2411         }
2412         return NDR_ERR_SUCCESS;
2413 }
2414
2415 static enum ndr_err_code ndr_pull_srvsvc_NetSessInfo1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessInfo1 *r)
2416 {
2417         uint32_t _ptr_client;
2418         TALLOC_CTX *_mem_save_client_0;
2419         uint32_t _ptr_user;
2420         TALLOC_CTX *_mem_save_user_0;
2421         if (ndr_flags & NDR_SCALARS) {
2422                 NDR_CHECK(ndr_pull_align(ndr, 4));
2423                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
2424                 if (_ptr_client) {
2425                         NDR_PULL_ALLOC(ndr, r->client);
2426                 } else {
2427                         r->client = NULL;
2428                 }
2429                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
2430                 if (_ptr_user) {
2431                         NDR_PULL_ALLOC(ndr, r->user);
2432                 } else {
2433                         r->user = NULL;
2434                 }
2435                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_open));
2436                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
2437                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idle_time));
2438                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->user_flags));
2439         }
2440         if (ndr_flags & NDR_BUFFERS) {
2441                 if (r->client) {
2442                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
2443                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
2444                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
2445                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
2446                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
2447                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->client), ndr_get_array_length(ndr, &r->client));
2448                         }
2449                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
2450                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
2451                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
2452                 }
2453                 if (r->user) {
2454                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
2455                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
2456                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
2457                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
2458                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
2459                                 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));
2460                         }
2461                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
2462                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
2463                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
2464                 }
2465         }
2466         return NDR_ERR_SUCCESS;
2467 }
2468
2469 _PUBLIC_ void ndr_print_srvsvc_NetSessInfo1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessInfo1 *r)
2470 {
2471         ndr_print_struct(ndr, name, "srvsvc_NetSessInfo1");
2472         ndr->depth++;
2473         ndr_print_ptr(ndr, "client", r->client);
2474         ndr->depth++;
2475         if (r->client) {
2476                 ndr_print_string(ndr, "client", r->client);
2477         }
2478         ndr->depth--;
2479         ndr_print_ptr(ndr, "user", r->user);
2480         ndr->depth++;
2481         if (r->user) {
2482                 ndr_print_string(ndr, "user", r->user);
2483         }
2484         ndr->depth--;
2485         ndr_print_uint32(ndr, "num_open", r->num_open);
2486         ndr_print_uint32(ndr, "time", r->time);
2487         ndr_print_uint32(ndr, "idle_time", r->idle_time);
2488         ndr_print_uint32(ndr, "user_flags", r->user_flags);
2489         ndr->depth--;
2490 }
2491
2492 static enum ndr_err_code ndr_push_srvsvc_NetSessCtr1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessCtr1 *r)
2493 {
2494         uint32_t cntr_array_1;
2495         if (ndr_flags & NDR_SCALARS) {
2496                 NDR_CHECK(ndr_push_align(ndr, 4));
2497                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2498                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
2499         }
2500         if (ndr_flags & NDR_BUFFERS) {
2501                 if (r->array) {
2502                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2503                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2504                                 NDR_CHECK(ndr_push_srvsvc_NetSessInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
2505                         }
2506                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2507                                 NDR_CHECK(ndr_push_srvsvc_NetSessInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
2508                         }
2509                 }
2510         }
2511         return NDR_ERR_SUCCESS;
2512 }
2513
2514 static enum ndr_err_code ndr_pull_srvsvc_NetSessCtr1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessCtr1 *r)
2515 {
2516         uint32_t _ptr_array;
2517         uint32_t cntr_array_1;
2518         TALLOC_CTX *_mem_save_array_0;
2519         TALLOC_CTX *_mem_save_array_1;
2520         if (ndr_flags & NDR_SCALARS) {
2521                 NDR_CHECK(ndr_pull_align(ndr, 4));
2522                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2523                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
2524                 if (_ptr_array) {
2525                         NDR_PULL_ALLOC(ndr, r->array);
2526                 } else {
2527                         r->array = NULL;
2528                 }
2529         }
2530         if (ndr_flags & NDR_BUFFERS) {
2531                 if (r->array) {
2532                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
2533                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
2534                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
2535                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
2536                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
2537                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
2538                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2539                                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
2540                         }
2541                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2542                                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
2543                         }
2544                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
2545                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
2546                 }
2547                 if (r->array) {
2548                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
2549                 }
2550         }
2551         return NDR_ERR_SUCCESS;
2552 }
2553
2554 _PUBLIC_ void ndr_print_srvsvc_NetSessCtr1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessCtr1 *r)
2555 {
2556         uint32_t cntr_array_1;
2557         ndr_print_struct(ndr, name, "srvsvc_NetSessCtr1");
2558         ndr->depth++;
2559         ndr_print_uint32(ndr, "count", r->count);
2560         ndr_print_ptr(ndr, "array", r->array);
2561         ndr->depth++;
2562         if (r->array) {
2563                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
2564                 ndr->depth++;
2565                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
2566                         char *idx_1=NULL;
2567                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
2568                                 ndr_print_srvsvc_NetSessInfo1(ndr, "array", &r->array[cntr_array_1]);
2569                                 free(idx_1);
2570                         }
2571                 }
2572                 ndr->depth--;
2573         }
2574         ndr->depth--;
2575         ndr->depth--;
2576 }
2577
2578 static enum ndr_err_code ndr_push_srvsvc_NetSessInfo2(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessInfo2 *r)
2579 {
2580         if (ndr_flags & NDR_SCALARS) {
2581                 NDR_CHECK(ndr_push_align(ndr, 4));
2582                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
2583                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
2584                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_open));
2585                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
2586                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idle_time));
2587                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->user_flags));
2588                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client_type));
2589         }
2590         if (ndr_flags & NDR_BUFFERS) {
2591                 if (r->client) {
2592                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
2593                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2594                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
2595                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2596                 }
2597                 if (r->user) {
2598                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
2599                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2600                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
2601                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2602                 }
2603                 if (r->client_type) {
2604                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client_type, CH_UTF16)));
2605                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2606                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client_type, CH_UTF16)));
2607                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client_type, ndr_charset_length(r->client_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2608                 }
2609         }
2610         return NDR_ERR_SUCCESS;
2611 }
2612
2613 static enum ndr_err_code ndr_pull_srvsvc_NetSessInfo2(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessInfo2 *r)
2614 {
2615         uint32_t _ptr_client;
2616         TALLOC_CTX *_mem_save_client_0;
2617         uint32_t _ptr_user;
2618         TALLOC_CTX *_mem_save_user_0;
2619         uint32_t _ptr_client_type;
2620         TALLOC_CTX *_mem_save_client_type_0;
2621         if (ndr_flags & NDR_SCALARS) {
2622                 NDR_CHECK(ndr_pull_align(ndr, 4));
2623                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
2624                 if (_ptr_client) {
2625                         NDR_PULL_ALLOC(ndr, r->client);
2626                 } else {
2627                         r->client = NULL;
2628                 }
2629                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
2630                 if (_ptr_user) {
2631                         NDR_PULL_ALLOC(ndr, r->user);
2632                 } else {
2633                         r->user = NULL;
2634                 }
2635                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_open));
2636                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
2637                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idle_time));
2638                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->user_flags));
2639                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client_type));
2640                 if (_ptr_client_type) {
2641                         NDR_PULL_ALLOC(ndr, r->client_type);
2642                 } else {
2643                         r->client_type = NULL;
2644                 }
2645         }
2646         if (ndr_flags & NDR_BUFFERS) {
2647                 if (r->client) {
2648                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
2649                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
2650                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
2651                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
2652                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
2653                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->client), ndr_get_array_length(ndr, &r->client));
2654                         }
2655                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
2656                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
2657                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
2658                 }
2659                 if (r->user) {
2660                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
2661                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
2662                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
2663                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
2664                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
2665                                 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));
2666                         }
2667                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
2668                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
2669                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
2670                 }
2671                 if (r->client_type) {
2672                         _mem_save_client_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
2673                         NDR_PULL_SET_MEM_CTX(ndr, r->client_type, 0);
2674                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client_type));
2675                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client_type));
2676                         if (ndr_get_array_length(ndr, &r->client_type) > ndr_get_array_size(ndr, &r->client_type)) {
2677                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->client_type), ndr_get_array_length(ndr, &r->client_type));
2678                         }
2679                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client_type), sizeof(uint16_t)));
2680                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client_type, ndr_get_array_length(ndr, &r->client_type), sizeof(uint16_t), CH_UTF16));
2681                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_type_0, 0);
2682                 }
2683         }
2684         return NDR_ERR_SUCCESS;
2685 }
2686
2687 _PUBLIC_ void ndr_print_srvsvc_NetSessInfo2(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessInfo2 *r)
2688 {
2689         ndr_print_struct(ndr, name, "srvsvc_NetSessInfo2");
2690         ndr->depth++;
2691         ndr_print_ptr(ndr, "client", r->client);
2692         ndr->depth++;
2693         if (r->client) {
2694                 ndr_print_string(ndr, "client", r->client);
2695         }
2696         ndr->depth--;
2697         ndr_print_ptr(ndr, "user", r->user);
2698         ndr->depth++;
2699         if (r->user) {
2700                 ndr_print_string(ndr, "user", r->user);
2701         }
2702         ndr->depth--;
2703         ndr_print_uint32(ndr, "num_open", r->num_open);
2704         ndr_print_uint32(ndr, "time", r->time);
2705         ndr_print_uint32(ndr, "idle_time", r->idle_time);
2706         ndr_print_uint32(ndr, "user_flags", r->user_flags);
2707         ndr_print_ptr(ndr, "client_type", r->client_type);
2708         ndr->depth++;
2709         if (r->client_type) {
2710                 ndr_print_string(ndr, "client_type", r->client_type);
2711         }
2712         ndr->depth--;
2713         ndr->depth--;
2714 }
2715
2716 static enum ndr_err_code ndr_push_srvsvc_NetSessCtr2(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessCtr2 *r)
2717 {
2718         uint32_t cntr_array_1;
2719         if (ndr_flags & NDR_SCALARS) {
2720                 NDR_CHECK(ndr_push_align(ndr, 4));
2721                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2722                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
2723         }
2724         if (ndr_flags & NDR_BUFFERS) {
2725                 if (r->array) {
2726                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2727                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2728                                 NDR_CHECK(ndr_push_srvsvc_NetSessInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
2729                         }
2730                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2731                                 NDR_CHECK(ndr_push_srvsvc_NetSessInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
2732                         }
2733                 }
2734         }
2735         return NDR_ERR_SUCCESS;
2736 }
2737
2738 static enum ndr_err_code ndr_pull_srvsvc_NetSessCtr2(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessCtr2 *r)
2739 {
2740         uint32_t _ptr_array;
2741         uint32_t cntr_array_1;
2742         TALLOC_CTX *_mem_save_array_0;
2743         TALLOC_CTX *_mem_save_array_1;
2744         if (ndr_flags & NDR_SCALARS) {
2745                 NDR_CHECK(ndr_pull_align(ndr, 4));
2746                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2747                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
2748                 if (_ptr_array) {
2749                         NDR_PULL_ALLOC(ndr, r->array);
2750                 } else {
2751                         r->array = NULL;
2752                 }
2753         }
2754         if (ndr_flags & NDR_BUFFERS) {
2755                 if (r->array) {
2756                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
2757                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
2758                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
2759                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
2760                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
2761                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
2762                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2763                                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
2764                         }
2765                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2766                                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
2767                         }
2768                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
2769                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
2770                 }
2771                 if (r->array) {
2772                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
2773                 }
2774         }
2775         return NDR_ERR_SUCCESS;
2776 }
2777
2778 _PUBLIC_ void ndr_print_srvsvc_NetSessCtr2(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessCtr2 *r)
2779 {
2780         uint32_t cntr_array_1;
2781         ndr_print_struct(ndr, name, "srvsvc_NetSessCtr2");
2782         ndr->depth++;
2783         ndr_print_uint32(ndr, "count", r->count);
2784         ndr_print_ptr(ndr, "array", r->array);
2785         ndr->depth++;
2786         if (r->array) {
2787                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
2788                 ndr->depth++;
2789                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
2790                         char *idx_1=NULL;
2791                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
2792                                 ndr_print_srvsvc_NetSessInfo2(ndr, "array", &r->array[cntr_array_1]);
2793                                 free(idx_1);
2794                         }
2795                 }
2796                 ndr->depth--;
2797         }
2798         ndr->depth--;
2799         ndr->depth--;
2800 }
2801
2802 static enum ndr_err_code ndr_push_srvsvc_NetSessInfo10(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessInfo10 *r)
2803 {
2804         if (ndr_flags & NDR_SCALARS) {
2805                 NDR_CHECK(ndr_push_align(ndr, 4));
2806                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
2807                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
2808                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
2809                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idle_time));
2810         }
2811         if (ndr_flags & NDR_BUFFERS) {
2812                 if (r->client) {
2813                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
2814                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2815                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
2816                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2817                 }
2818                 if (r->user) {
2819                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
2820                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2821                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
2822                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2823                 }
2824         }
2825         return NDR_ERR_SUCCESS;
2826 }
2827
2828 static enum ndr_err_code ndr_pull_srvsvc_NetSessInfo10(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessInfo10 *r)
2829 {
2830         uint32_t _ptr_client;
2831         TALLOC_CTX *_mem_save_client_0;
2832         uint32_t _ptr_user;
2833         TALLOC_CTX *_mem_save_user_0;
2834         if (ndr_flags & NDR_SCALARS) {
2835                 NDR_CHECK(ndr_pull_align(ndr, 4));
2836                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
2837                 if (_ptr_client) {
2838                         NDR_PULL_ALLOC(ndr, r->client);
2839                 } else {
2840                         r->client = NULL;
2841                 }
2842                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
2843                 if (_ptr_user) {
2844                         NDR_PULL_ALLOC(ndr, r->user);
2845                 } else {
2846                         r->user = NULL;
2847                 }
2848                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
2849                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idle_time));
2850         }
2851         if (ndr_flags & NDR_BUFFERS) {
2852                 if (r->client) {
2853                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
2854                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
2855                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
2856                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
2857                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
2858                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->client), ndr_get_array_length(ndr, &r->client));
2859                         }
2860                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
2861                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
2862                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
2863                 }
2864                 if (r->user) {
2865                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
2866                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
2867                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
2868                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
2869                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
2870                                 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));
2871                         }
2872                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
2873                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
2874                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
2875                 }
2876         }
2877         return NDR_ERR_SUCCESS;
2878 }
2879
2880 _PUBLIC_ void ndr_print_srvsvc_NetSessInfo10(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessInfo10 *r)
2881 {
2882         ndr_print_struct(ndr, name, "srvsvc_NetSessInfo10");
2883         ndr->depth++;
2884         ndr_print_ptr(ndr, "client", r->client);
2885         ndr->depth++;
2886         if (r->client) {
2887                 ndr_print_string(ndr, "client", r->client);
2888         }
2889         ndr->depth--;
2890         ndr_print_ptr(ndr, "user", r->user);
2891         ndr->depth++;
2892         if (r->user) {
2893                 ndr_print_string(ndr, "user", r->user);
2894         }
2895         ndr->depth--;
2896         ndr_print_uint32(ndr, "time", r->time);
2897         ndr_print_uint32(ndr, "idle_time", r->idle_time);
2898         ndr->depth--;
2899 }
2900
2901 static enum ndr_err_code ndr_push_srvsvc_NetSessCtr10(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessCtr10 *r)
2902 {
2903         uint32_t cntr_array_1;
2904         if (ndr_flags & NDR_SCALARS) {
2905                 NDR_CHECK(ndr_push_align(ndr, 4));
2906                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2907                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
2908         }
2909         if (ndr_flags & NDR_BUFFERS) {
2910                 if (r->array) {
2911                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2912                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2913                                 NDR_CHECK(ndr_push_srvsvc_NetSessInfo10(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
2914                         }
2915                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2916                                 NDR_CHECK(ndr_push_srvsvc_NetSessInfo10(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
2917                         }
2918                 }
2919         }
2920         return NDR_ERR_SUCCESS;
2921 }
2922
2923 static enum ndr_err_code ndr_pull_srvsvc_NetSessCtr10(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessCtr10 *r)
2924 {
2925         uint32_t _ptr_array;
2926         uint32_t cntr_array_1;
2927         TALLOC_CTX *_mem_save_array_0;
2928         TALLOC_CTX *_mem_save_array_1;
2929         if (ndr_flags & NDR_SCALARS) {
2930                 NDR_CHECK(ndr_pull_align(ndr, 4));
2931                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2932                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
2933                 if (_ptr_array) {
2934                         NDR_PULL_ALLOC(ndr, r->array);
2935                 } else {
2936                         r->array = NULL;
2937                 }
2938         }
2939         if (ndr_flags & NDR_BUFFERS) {
2940                 if (r->array) {
2941                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
2942                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
2943                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
2944                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
2945                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
2946                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
2947                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2948                                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfo10(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
2949                         }
2950                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2951                                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfo10(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
2952                         }
2953                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
2954                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
2955                 }
2956                 if (r->array) {
2957                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
2958                 }
2959         }
2960         return NDR_ERR_SUCCESS;
2961 }
2962
2963 _PUBLIC_ void ndr_print_srvsvc_NetSessCtr10(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessCtr10 *r)
2964 {
2965         uint32_t cntr_array_1;
2966         ndr_print_struct(ndr, name, "srvsvc_NetSessCtr10");
2967         ndr->depth++;
2968         ndr_print_uint32(ndr, "count", r->count);
2969         ndr_print_ptr(ndr, "array", r->array);
2970         ndr->depth++;
2971         if (r->array) {
2972                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
2973                 ndr->depth++;
2974                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
2975                         char *idx_1=NULL;
2976                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
2977                                 ndr_print_srvsvc_NetSessInfo10(ndr, "array", &r->array[cntr_array_1]);
2978                                 free(idx_1);
2979                         }
2980                 }
2981                 ndr->depth--;
2982         }
2983         ndr->depth--;
2984         ndr->depth--;
2985 }
2986
2987 static enum ndr_err_code ndr_push_srvsvc_NetSessInfo502(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessInfo502 *r)
2988 {
2989         if (ndr_flags & NDR_SCALARS) {
2990                 NDR_CHECK(ndr_push_align(ndr, 4));
2991                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
2992                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
2993                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_open));
2994                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
2995                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idle_time));
2996                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->user_flags));
2997                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client_type));
2998                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport));
2999         }
3000         if (ndr_flags & NDR_BUFFERS) {
3001                 if (r->client) {
3002                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
3003                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3004                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
3005                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3006                 }
3007                 if (r->user) {
3008                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
3009                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3010                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
3011                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3012                 }
3013                 if (r->client_type) {
3014                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client_type, CH_UTF16)));
3015                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3016                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client_type, CH_UTF16)));
3017                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client_type, ndr_charset_length(r->client_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3018                 }
3019                 if (r->transport) {
3020                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->transport, CH_UTF16)));
3021                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3022                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->transport, CH_UTF16)));
3023                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->transport, ndr_charset_length(r->transport, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3024                 }
3025         }
3026         return NDR_ERR_SUCCESS;
3027 }
3028
3029 static enum ndr_err_code ndr_pull_srvsvc_NetSessInfo502(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessInfo502 *r)
3030 {
3031         uint32_t _ptr_client;
3032         TALLOC_CTX *_mem_save_client_0;
3033         uint32_t _ptr_user;
3034         TALLOC_CTX *_mem_save_user_0;
3035         uint32_t _ptr_client_type;
3036         TALLOC_CTX *_mem_save_client_type_0;
3037         uint32_t _ptr_transport;
3038         TALLOC_CTX *_mem_save_transport_0;
3039         if (ndr_flags & NDR_SCALARS) {
3040                 NDR_CHECK(ndr_pull_align(ndr, 4));
3041                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
3042                 if (_ptr_client) {
3043                         NDR_PULL_ALLOC(ndr, r->client);
3044                 } else {
3045                         r->client = NULL;
3046                 }
3047                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
3048                 if (_ptr_user) {
3049                         NDR_PULL_ALLOC(ndr, r->user);
3050                 } else {
3051                         r->user = NULL;
3052                 }
3053                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_open));
3054                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3055                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idle_time));
3056                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->user_flags));
3057                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client_type));
3058                 if (_ptr_client_type) {
3059                         NDR_PULL_ALLOC(ndr, r->client_type);
3060                 } else {
3061                         r->client_type = NULL;
3062                 }
3063                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport));
3064                 if (_ptr_transport) {
3065                         NDR_PULL_ALLOC(ndr, r->transport);
3066                 } else {
3067                         r->transport = NULL;
3068                 }
3069         }
3070         if (ndr_flags & NDR_BUFFERS) {
3071                 if (r->client) {
3072                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
3073                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
3074                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
3075                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
3076                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
3077                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->client), ndr_get_array_length(ndr, &r->client));
3078                         }
3079                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
3080                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
3081                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
3082                 }
3083                 if (r->user) {
3084                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
3085                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
3086                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
3087                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
3088                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
3089                                 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));
3090                         }
3091                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
3092                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
3093                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
3094                 }
3095                 if (r->client_type) {
3096                         _mem_save_client_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3097                         NDR_PULL_SET_MEM_CTX(ndr, r->client_type, 0);
3098                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client_type));
3099                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client_type));
3100                         if (ndr_get_array_length(ndr, &r->client_type) > ndr_get_array_size(ndr, &r->client_type)) {
3101                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->client_type), ndr_get_array_length(ndr, &r->client_type));
3102                         }
3103                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client_type), sizeof(uint16_t)));
3104                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client_type, ndr_get_array_length(ndr, &r->client_type), sizeof(uint16_t), CH_UTF16));
3105                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_type_0, 0);
3106                 }
3107                 if (r->transport) {
3108                         _mem_save_transport_0 = NDR_PULL_GET_MEM_CTX(ndr);
3109                         NDR_PULL_SET_MEM_CTX(ndr, r->transport, 0);
3110                         NDR_CHECK(ndr_pull_array_size(ndr, &r->transport));
3111                         NDR_CHECK(ndr_pull_array_length(ndr, &r->transport));
3112                         if (ndr_get_array_length(ndr, &r->transport) > ndr_get_array_size(ndr, &r->transport)) {
3113                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->transport), ndr_get_array_length(ndr, &r->transport));
3114                         }
3115                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->transport), sizeof(uint16_t)));
3116                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->transport, ndr_get_array_length(ndr, &r->transport), sizeof(uint16_t), CH_UTF16));
3117                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_0, 0);
3118                 }
3119         }
3120         return NDR_ERR_SUCCESS;
3121 }
3122
3123 _PUBLIC_ void ndr_print_srvsvc_NetSessInfo502(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessInfo502 *r)
3124 {
3125         ndr_print_struct(ndr, name, "srvsvc_NetSessInfo502");
3126         ndr->depth++;
3127         ndr_print_ptr(ndr, "client", r->client);
3128         ndr->depth++;
3129         if (r->client) {
3130                 ndr_print_string(ndr, "client", r->client);
3131         }
3132         ndr->depth--;
3133         ndr_print_ptr(ndr, "user", r->user);
3134         ndr->depth++;
3135         if (r->user) {
3136                 ndr_print_string(ndr, "user", r->user);
3137         }
3138         ndr->depth--;
3139         ndr_print_uint32(ndr, "num_open", r->num_open);
3140         ndr_print_uint32(ndr, "time", r->time);
3141         ndr_print_uint32(ndr, "idle_time", r->idle_time);
3142         ndr_print_uint32(ndr, "user_flags", r->user_flags);
3143         ndr_print_ptr(ndr, "client_type", r->client_type);
3144         ndr->depth++;
3145         if (r->client_type) {
3146                 ndr_print_string(ndr, "client_type", r->client_type);
3147         }
3148         ndr->depth--;
3149         ndr_print_ptr(ndr, "transport", r->transport);
3150         ndr->depth++;
3151         if (r->transport) {
3152                 ndr_print_string(ndr, "transport", r->transport);
3153         }
3154         ndr->depth--;
3155         ndr->depth--;
3156 }
3157
3158 static enum ndr_err_code ndr_push_srvsvc_NetSessCtr502(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessCtr502 *r)
3159 {
3160         uint32_t cntr_array_1;
3161         if (ndr_flags & NDR_SCALARS) {
3162                 NDR_CHECK(ndr_push_align(ndr, 4));
3163                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3164                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
3165         }
3166         if (ndr_flags & NDR_BUFFERS) {
3167                 if (r->array) {
3168                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3169                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3170                                 NDR_CHECK(ndr_push_srvsvc_NetSessInfo502(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
3171                         }
3172                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3173                                 NDR_CHECK(ndr_push_srvsvc_NetSessInfo502(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
3174                         }
3175                 }
3176         }
3177         return NDR_ERR_SUCCESS;
3178 }
3179
3180 static enum ndr_err_code ndr_pull_srvsvc_NetSessCtr502(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessCtr502 *r)
3181 {
3182         uint32_t _ptr_array;
3183         uint32_t cntr_array_1;
3184         TALLOC_CTX *_mem_save_array_0;
3185         TALLOC_CTX *_mem_save_array_1;
3186         if (ndr_flags & NDR_SCALARS) {
3187                 NDR_CHECK(ndr_pull_align(ndr, 4));
3188                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3189                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
3190                 if (_ptr_array) {
3191                         NDR_PULL_ALLOC(ndr, r->array);
3192                 } else {
3193                         r->array = NULL;
3194                 }
3195         }
3196         if (ndr_flags & NDR_BUFFERS) {
3197                 if (r->array) {
3198                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
3199                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
3200                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
3201                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
3202                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
3203                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
3204                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3205                                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfo502(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
3206                         }
3207                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3208                                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfo502(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
3209                         }
3210                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
3211                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
3212                 }
3213                 if (r->array) {
3214                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
3215                 }
3216         }
3217         return NDR_ERR_SUCCESS;
3218 }
3219
3220 _PUBLIC_ void ndr_print_srvsvc_NetSessCtr502(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessCtr502 *r)
3221 {
3222         uint32_t cntr_array_1;
3223         ndr_print_struct(ndr, name, "srvsvc_NetSessCtr502");
3224         ndr->depth++;
3225         ndr_print_uint32(ndr, "count", r->count);
3226         ndr_print_ptr(ndr, "array", r->array);
3227         ndr->depth++;
3228         if (r->array) {
3229                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
3230                 ndr->depth++;
3231                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
3232                         char *idx_1=NULL;
3233                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
3234                                 ndr_print_srvsvc_NetSessInfo502(ndr, "array", &r->array[cntr_array_1]);
3235                                 free(idx_1);
3236                         }
3237                 }
3238                 ndr->depth--;
3239         }
3240         ndr->depth--;
3241         ndr->depth--;
3242 }
3243
3244 static enum ndr_err_code ndr_push_srvsvc_NetSessCtr(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetSessCtr *r)
3245 {
3246         if (ndr_flags & NDR_SCALARS) {
3247                 int level = ndr_push_get_switch_value(ndr, r);
3248                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
3249                 switch (level) {
3250                         case 0: {
3251                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
3252                         break; }
3253
3254                         case 1: {
3255                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
3256                         break; }
3257
3258                         case 2: {
3259                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr2));
3260                         break; }
3261
3262                         case 10: {
3263                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr10));
3264                         break; }
3265
3266                         case 502: {
3267                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr502));
3268                         break; }
3269
3270                         default: {
3271                         break; }
3272
3273                 }
3274         }
3275         if (ndr_flags & NDR_BUFFERS) {
3276                 int level = ndr_push_get_switch_value(ndr, r);
3277                 switch (level) {
3278                         case 0:
3279                                 if (r->ctr0) {
3280                                         NDR_CHECK(ndr_push_srvsvc_NetSessCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
3281                                 }
3282                         break;
3283
3284                         case 1:
3285                                 if (r->ctr1) {
3286                                         NDR_CHECK(ndr_push_srvsvc_NetSessCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
3287                                 }
3288                         break;
3289
3290                         case 2:
3291                                 if (r->ctr2) {
3292                                         NDR_CHECK(ndr_push_srvsvc_NetSessCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
3293                                 }
3294                         break;
3295
3296                         case 10:
3297                                 if (r->ctr10) {
3298                                         NDR_CHECK(ndr_push_srvsvc_NetSessCtr10(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr10));
3299                                 }
3300                         break;
3301
3302                         case 502:
3303                                 if (r->ctr502) {
3304                                         NDR_CHECK(ndr_push_srvsvc_NetSessCtr502(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr502));
3305                                 }
3306                         break;
3307
3308                         default:
3309                         break;
3310
3311                 }
3312         }
3313         return NDR_ERR_SUCCESS;
3314 }
3315
3316 static enum ndr_err_code ndr_pull_srvsvc_NetSessCtr(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetSessCtr *r)
3317 {
3318         int level;
3319         uint32_t _level;
3320         TALLOC_CTX *_mem_save_ctr0_0;
3321         TALLOC_CTX *_mem_save_ctr1_0;
3322         TALLOC_CTX *_mem_save_ctr2_0;
3323         TALLOC_CTX *_mem_save_ctr10_0;
3324         TALLOC_CTX *_mem_save_ctr502_0;
3325         level = ndr_pull_get_switch_value(ndr, r);
3326         if (ndr_flags & NDR_SCALARS) {
3327                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
3328                 if (_level != level) {
3329                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
3330                 }
3331                 switch (level) {
3332                         case 0: {
3333                                 uint32_t _ptr_ctr0;
3334                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));
3335                                 if (_ptr_ctr0) {
3336                                         NDR_PULL_ALLOC(ndr, r->ctr0);
3337                                 } else {
3338                                         r->ctr0 = NULL;
3339                                 }
3340                         break; }
3341
3342                         case 1: {
3343                                 uint32_t _ptr_ctr1;
3344                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
3345                                 if (_ptr_ctr1) {
3346                                         NDR_PULL_ALLOC(ndr, r->ctr1);
3347                                 } else {
3348                                         r->ctr1 = NULL;
3349                                 }
3350                         break; }
3351
3352                         case 2: {
3353                                 uint32_t _ptr_ctr2;
3354                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr2));
3355                                 if (_ptr_ctr2) {
3356                                         NDR_PULL_ALLOC(ndr, r->ctr2);
3357                                 } else {
3358                                         r->ctr2 = NULL;
3359                                 }
3360                         break; }
3361
3362                         case 10: {
3363                                 uint32_t _ptr_ctr10;
3364                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr10));
3365                                 if (_ptr_ctr10) {
3366                                         NDR_PULL_ALLOC(ndr, r->ctr10);
3367                                 } else {
3368                                         r->ctr10 = NULL;
3369                                 }
3370                         break; }
3371
3372                         case 502: {
3373                                 uint32_t _ptr_ctr502;
3374                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr502));
3375                                 if (_ptr_ctr502) {
3376                                         NDR_PULL_ALLOC(ndr, r->ctr502);
3377                                 } else {
3378                                         r->ctr502 = NULL;
3379                                 }
3380                         break; }
3381
3382                         default: {
3383                         break; }
3384
3385                 }
3386         }
3387         if (ndr_flags & NDR_BUFFERS) {
3388                 switch (level) {
3389                         case 0:
3390                                 if (r->ctr0) {
3391                                         _mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);
3392                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr0, 0);
3393                                         NDR_CHECK(ndr_pull_srvsvc_NetSessCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
3394                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);
3395                                 }
3396                         break;
3397
3398                         case 1:
3399                                 if (r->ctr1) {
3400                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
3401                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
3402                                         NDR_CHECK(ndr_pull_srvsvc_NetSessCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
3403                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
3404                                 }
3405                         break;
3406
3407                         case 2:
3408                                 if (r->ctr2) {
3409                                         _mem_save_ctr2_0 = NDR_PULL_GET_MEM_CTX(ndr);
3410                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr2, 0);
3411                                         NDR_CHECK(ndr_pull_srvsvc_NetSessCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
3412                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr2_0, 0);
3413                                 }
3414                         break;
3415
3416                         case 10:
3417                                 if (r->ctr10) {
3418                                         _mem_save_ctr10_0 = NDR_PULL_GET_MEM_CTX(ndr);
3419                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr10, 0);
3420                                         NDR_CHECK(ndr_pull_srvsvc_NetSessCtr10(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr10));
3421                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr10_0, 0);
3422                                 }
3423                         break;
3424
3425                         case 502:
3426                                 if (r->ctr502) {
3427                                         _mem_save_ctr502_0 = NDR_PULL_GET_MEM_CTX(ndr);
3428                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr502, 0);
3429                                         NDR_CHECK(ndr_pull_srvsvc_NetSessCtr502(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr502));
3430                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr502_0, 0);
3431                                 }
3432                         break;
3433
3434                         default:
3435                         break;
3436
3437                 }
3438         }
3439         return NDR_ERR_SUCCESS;
3440 }
3441
3442 _PUBLIC_ void ndr_print_srvsvc_NetSessCtr(struct ndr_print *ndr, const char *name, const union srvsvc_NetSessCtr *r)
3443 {
3444         int level;
3445         level = ndr_print_get_switch_value(ndr, r);
3446         ndr_print_union(ndr, name, level, "srvsvc_NetSessCtr");
3447         switch (level) {
3448                 case 0:
3449                         ndr_print_ptr(ndr, "ctr0", r->ctr0);
3450                         ndr->depth++;
3451                         if (r->ctr0) {
3452                                 ndr_print_srvsvc_NetSessCtr0(ndr, "ctr0", r->ctr0);
3453                         }
3454                         ndr->depth--;
3455                 break;
3456
3457                 case 1:
3458                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
3459                         ndr->depth++;
3460                         if (r->ctr1) {
3461                                 ndr_print_srvsvc_NetSessCtr1(ndr, "ctr1", r->ctr1);
3462                         }
3463                         ndr->depth--;
3464                 break;
3465
3466                 case 2:
3467                         ndr_print_ptr(ndr, "ctr2", r->ctr2);
3468                         ndr->depth++;
3469                         if (r->ctr2) {
3470                                 ndr_print_srvsvc_NetSessCtr2(ndr, "ctr2", r->ctr2);
3471                         }
3472                         ndr->depth--;
3473                 break;
3474
3475                 case 10:
3476                         ndr_print_ptr(ndr, "ctr10", r->ctr10);
3477                         ndr->depth++;
3478                         if (r->ctr10) {
3479                                 ndr_print_srvsvc_NetSessCtr10(ndr, "ctr10", r->ctr10);
3480                         }
3481                         ndr->depth--;
3482                 break;
3483
3484                 case 502:
3485                         ndr_print_ptr(ndr, "ctr502", r->ctr502);
3486                         ndr->depth++;
3487                         if (r->ctr502) {
3488                                 ndr_print_srvsvc_NetSessCtr502(ndr, "ctr502", r->ctr502);
3489                         }
3490                         ndr->depth--;
3491                 break;
3492
3493                 default:
3494                 break;
3495
3496         }
3497 }
3498
3499 static enum ndr_err_code ndr_push_srvsvc_ShareType(struct ndr_push *ndr, int ndr_flags, enum srvsvc_ShareType r)
3500 {
3501         {
3502                 uint32_t _flags_save_ENUM = ndr->flags;
3503                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3504                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3505                 ndr->flags = _flags_save_ENUM;
3506         }
3507         return NDR_ERR_SUCCESS;
3508 }
3509
3510 static enum ndr_err_code ndr_pull_srvsvc_ShareType(struct ndr_pull *ndr, int ndr_flags, enum srvsvc_ShareType *r)
3511 {
3512         uint32_t v;
3513         {
3514                 uint32_t _flags_save_ENUM = ndr->flags;
3515                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3516                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3517                 *r = v;
3518                 ndr->flags = _flags_save_ENUM;
3519         }
3520         return NDR_ERR_SUCCESS;
3521 }
3522
3523 _PUBLIC_ void ndr_print_srvsvc_ShareType(struct ndr_print *ndr, const char *name, enum srvsvc_ShareType r)
3524 {
3525         const char *val = NULL;
3526
3527         {
3528                 uint32_t _flags_save_ENUM = ndr->flags;
3529                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3530                 switch (r) {
3531                         case STYPE_DISKTREE: val = "STYPE_DISKTREE"; break;
3532                         case STYPE_DISKTREE_TEMPORARY: val = "STYPE_DISKTREE_TEMPORARY"; break;
3533                         case STYPE_DISKTREE_HIDDEN: val = "STYPE_DISKTREE_HIDDEN"; break;
3534                         case STYPE_PRINTQ: val = "STYPE_PRINTQ"; break;
3535                         case STYPE_PRINTQ_TEMPORARY: val = "STYPE_PRINTQ_TEMPORARY"; break;
3536                         case STYPE_PRINTQ_HIDDEN: val = "STYPE_PRINTQ_HIDDEN"; break;
3537                         case STYPE_DEVICE: val = "STYPE_DEVICE"; break;
3538                         case STYPE_DEVICE_TEMPORARY: val = "STYPE_DEVICE_TEMPORARY"; break;
3539                         case STYPE_DEVICE_HIDDEN: val = "STYPE_DEVICE_HIDDEN"; break;
3540                         case STYPE_IPC: val = "STYPE_IPC"; break;
3541                         case STYPE_IPC_TEMPORARY: val = "STYPE_IPC_TEMPORARY"; break;
3542                         case STYPE_IPC_HIDDEN: val = "STYPE_IPC_HIDDEN"; break;
3543                 }
3544                 ndr_print_enum(ndr, name, "ENUM", val, r);
3545                 ndr->flags = _flags_save_ENUM;
3546         }
3547 }
3548
3549 static enum ndr_err_code ndr_push_srvsvc_NetShareInfo0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo0 *r)
3550 {
3551         if (ndr_flags & NDR_SCALARS) {
3552                 NDR_CHECK(ndr_push_align(ndr, 4));
3553                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
3554         }
3555         if (ndr_flags & NDR_BUFFERS) {
3556                 if (r->name) {
3557                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
3558                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3559                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
3560                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3561                 }
3562         }
3563         return NDR_ERR_SUCCESS;
3564 }
3565
3566 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo0 *r)
3567 {
3568         uint32_t _ptr_name;
3569         TALLOC_CTX *_mem_save_name_0;
3570         if (ndr_flags & NDR_SCALARS) {
3571                 NDR_CHECK(ndr_pull_align(ndr, 4));
3572                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
3573                 if (_ptr_name) {
3574                         NDR_PULL_ALLOC(ndr, r->name);
3575                 } else {
3576                         r->name = NULL;
3577                 }
3578         }
3579         if (ndr_flags & NDR_BUFFERS) {
3580                 if (r->name) {
3581                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3582                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
3583                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
3584                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
3585                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->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->name), ndr_get_array_length(ndr, &r->name));
3587                         }
3588                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
3589                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
3590                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
3591                 }
3592         }
3593         return NDR_ERR_SUCCESS;
3594 }
3595
3596 _PUBLIC_ void ndr_print_srvsvc_NetShareInfo0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo0 *r)
3597 {
3598         ndr_print_struct(ndr, name, "srvsvc_NetShareInfo0");
3599         ndr->depth++;
3600         ndr_print_ptr(ndr, "name", r->name);
3601         ndr->depth++;
3602         if (r->name) {
3603                 ndr_print_string(ndr, "name", r->name);
3604         }
3605         ndr->depth--;
3606         ndr->depth--;
3607 }
3608
3609 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr0 *r)
3610 {
3611         uint32_t cntr_array_1;
3612         if (ndr_flags & NDR_SCALARS) {
3613                 NDR_CHECK(ndr_push_align(ndr, 4));
3614                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3615                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
3616         }
3617         if (ndr_flags & NDR_BUFFERS) {
3618                 if (r->array) {
3619                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3620                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3621                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
3622                         }
3623                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3624                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
3625                         }
3626                 }
3627         }
3628         return NDR_ERR_SUCCESS;
3629 }
3630
3631 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr0 *r)
3632 {
3633         uint32_t _ptr_array;
3634         uint32_t cntr_array_1;
3635         TALLOC_CTX *_mem_save_array_0;
3636         TALLOC_CTX *_mem_save_array_1;
3637         if (ndr_flags & NDR_SCALARS) {
3638                 NDR_CHECK(ndr_pull_align(ndr, 4));
3639                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3640                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
3641                 if (_ptr_array) {
3642                         NDR_PULL_ALLOC(ndr, r->array);
3643                 } else {
3644                         r->array = NULL;
3645                 }
3646         }
3647         if (ndr_flags & NDR_BUFFERS) {
3648                 if (r->array) {
3649                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
3650                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
3651                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
3652                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
3653                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
3654                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
3655                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3656                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
3657                         }
3658                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3659                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
3660                         }
3661                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
3662                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
3663                 }
3664                 if (r->array) {
3665                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
3666                 }
3667         }
3668         return NDR_ERR_SUCCESS;
3669 }
3670
3671 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr0 *r)
3672 {
3673         uint32_t cntr_array_1;
3674         ndr_print_struct(ndr, name, "srvsvc_NetShareCtr0");
3675         ndr->depth++;
3676         ndr_print_uint32(ndr, "count", r->count);
3677         ndr_print_ptr(ndr, "array", r->array);
3678         ndr->depth++;
3679         if (r->array) {
3680                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
3681                 ndr->depth++;
3682                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
3683                         char *idx_1=NULL;
3684                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
3685                                 ndr_print_srvsvc_NetShareInfo0(ndr, "array", &r->array[cntr_array_1]);
3686                                 free(idx_1);
3687                         }
3688                 }
3689                 ndr->depth--;
3690         }
3691         ndr->depth--;
3692         ndr->depth--;
3693 }
3694
3695 static enum ndr_err_code ndr_push_srvsvc_NetShareInfo1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo1 *r)
3696 {
3697         if (ndr_flags & NDR_SCALARS) {
3698                 NDR_CHECK(ndr_push_align(ndr, 4));
3699                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
3700                 NDR_CHECK(ndr_push_srvsvc_ShareType(ndr, NDR_SCALARS, r->type));
3701                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
3702         }
3703         if (ndr_flags & NDR_BUFFERS) {
3704                 if (r->name) {
3705                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
3706                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3707                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
3708                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3709                 }
3710                 if (r->comment) {
3711                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
3712                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3713                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
3714                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3715                 }
3716         }
3717         return NDR_ERR_SUCCESS;
3718 }
3719
3720 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo1 *r)
3721 {
3722         uint32_t _ptr_name;
3723         TALLOC_CTX *_mem_save_name_0;
3724         uint32_t _ptr_comment;
3725         TALLOC_CTX *_mem_save_comment_0;
3726         if (ndr_flags & NDR_SCALARS) {
3727                 NDR_CHECK(ndr_pull_align(ndr, 4));
3728                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
3729                 if (_ptr_name) {
3730                         NDR_PULL_ALLOC(ndr, r->name);
3731                 } else {
3732                         r->name = NULL;
3733                 }
3734                 NDR_CHECK(ndr_pull_srvsvc_ShareType(ndr, NDR_SCALARS, &r->type));
3735                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
3736                 if (_ptr_comment) {
3737                         NDR_PULL_ALLOC(ndr, r->comment);
3738                 } else {
3739                         r->comment = NULL;
3740                 }
3741         }
3742         if (ndr_flags & NDR_BUFFERS) {
3743                 if (r->name) {
3744                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3745                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
3746                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
3747                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
3748                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
3749                                 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));
3750                         }
3751                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
3752                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
3753                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
3754                 }
3755                 if (r->comment) {
3756                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
3757                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
3758                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
3759                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
3760                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
3761                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
3762                         }
3763                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
3764                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
3765                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
3766                 }
3767         }
3768         return NDR_ERR_SUCCESS;
3769 }
3770
3771 _PUBLIC_ void ndr_print_srvsvc_NetShareInfo1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo1 *r)
3772 {
3773         ndr_print_struct(ndr, name, "srvsvc_NetShareInfo1");
3774         ndr->depth++;
3775         ndr_print_ptr(ndr, "name", r->name);
3776         ndr->depth++;
3777         if (r->name) {
3778                 ndr_print_string(ndr, "name", r->name);
3779         }
3780         ndr->depth--;
3781         ndr_print_srvsvc_ShareType(ndr, "type", r->type);
3782         ndr_print_ptr(ndr, "comment", r->comment);
3783         ndr->depth++;
3784         if (r->comment) {
3785                 ndr_print_string(ndr, "comment", r->comment);
3786         }
3787         ndr->depth--;
3788         ndr->depth--;
3789 }
3790
3791 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr1 *r)
3792 {
3793         uint32_t cntr_array_1;
3794         if (ndr_flags & NDR_SCALARS) {
3795                 NDR_CHECK(ndr_push_align(ndr, 4));
3796                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3797                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
3798         }
3799         if (ndr_flags & NDR_BUFFERS) {
3800                 if (r->array) {
3801                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3802                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3803                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
3804                         }
3805                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3806                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
3807                         }
3808                 }
3809         }
3810         return NDR_ERR_SUCCESS;
3811 }
3812
3813 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr1 *r)
3814 {
3815         uint32_t _ptr_array;
3816         uint32_t cntr_array_1;
3817         TALLOC_CTX *_mem_save_array_0;
3818         TALLOC_CTX *_mem_save_array_1;
3819         if (ndr_flags & NDR_SCALARS) {
3820                 NDR_CHECK(ndr_pull_align(ndr, 4));
3821                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3822                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
3823                 if (_ptr_array) {
3824                         NDR_PULL_ALLOC(ndr, r->array);
3825                 } else {
3826                         r->array = NULL;
3827                 }
3828         }
3829         if (ndr_flags & NDR_BUFFERS) {
3830                 if (r->array) {
3831                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
3832                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
3833                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
3834                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
3835                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
3836                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
3837                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3838                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
3839                         }
3840                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3841                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
3842                         }
3843                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
3844                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
3845                 }
3846                 if (r->array) {
3847                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
3848                 }
3849         }
3850         return NDR_ERR_SUCCESS;
3851 }
3852
3853 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr1 *r)
3854 {
3855         uint32_t cntr_array_1;
3856         ndr_print_struct(ndr, name, "srvsvc_NetShareCtr1");
3857         ndr->depth++;
3858         ndr_print_uint32(ndr, "count", r->count);
3859         ndr_print_ptr(ndr, "array", r->array);
3860         ndr->depth++;
3861         if (r->array) {
3862                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
3863                 ndr->depth++;
3864                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
3865                         char *idx_1=NULL;
3866                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
3867                                 ndr_print_srvsvc_NetShareInfo1(ndr, "array", &r->array[cntr_array_1]);
3868                                 free(idx_1);
3869                         }
3870                 }
3871                 ndr->depth--;
3872         }
3873         ndr->depth--;
3874         ndr->depth--;
3875 }
3876
3877 static enum ndr_err_code ndr_push_srvsvc_NetShareInfo2(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo2 *r)
3878 {
3879         if (ndr_flags & NDR_SCALARS) {
3880                 NDR_CHECK(ndr_push_align(ndr, 4));
3881                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
3882                 NDR_CHECK(ndr_push_srvsvc_ShareType(ndr, NDR_SCALARS, r->type));
3883                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
3884                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->permissions));
3885                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_users));
3886                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->current_users));
3887                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->path));
3888                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->password));
3889         }
3890         if (ndr_flags & NDR_BUFFERS) {
3891                 if (r->name) {
3892                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
3893                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3894                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
3895                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3896                 }
3897                 if (r->comment) {
3898                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
3899                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3900                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
3901                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3902                 }
3903                 if (r->path) {
3904                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));
3905                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3906                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));
3907                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->path, ndr_charset_length(r->path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3908                 }
3909                 if (r->password) {
3910                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));
3911                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3912                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));
3913                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->password, ndr_charset_length(r->password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3914                 }
3915         }
3916         return NDR_ERR_SUCCESS;
3917 }
3918
3919 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo2(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo2 *r)
3920 {
3921         uint32_t _ptr_name;
3922         TALLOC_CTX *_mem_save_name_0;
3923         uint32_t _ptr_comment;
3924         TALLOC_CTX *_mem_save_comment_0;
3925         uint32_t _ptr_path;
3926         TALLOC_CTX *_mem_save_path_0;
3927         uint32_t _ptr_password;
3928         TALLOC_CTX *_mem_save_password_0;
3929         if (ndr_flags & NDR_SCALARS) {
3930                 NDR_CHECK(ndr_pull_align(ndr, 4));
3931                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
3932                 if (_ptr_name) {
3933                         NDR_PULL_ALLOC(ndr, r->name);
3934                 } else {
3935                         r->name = NULL;
3936                 }
3937                 NDR_CHECK(ndr_pull_srvsvc_ShareType(ndr, NDR_SCALARS, &r->type));
3938                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
3939                 if (_ptr_comment) {
3940                         NDR_PULL_ALLOC(ndr, r->comment);
3941                 } else {
3942                         r->comment = NULL;
3943                 }
3944                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->permissions));
3945                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_users));
3946                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->current_users));
3947                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_path));
3948                 if (_ptr_path) {
3949                         NDR_PULL_ALLOC(ndr, r->path);
3950                 } else {
3951                         r->path = NULL;
3952                 }
3953                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
3954                 if (_ptr_password) {
3955                         NDR_PULL_ALLOC(ndr, r->password);
3956                 } else {
3957                         r->password = NULL;
3958                 }
3959         }
3960         if (ndr_flags & NDR_BUFFERS) {
3961                 if (r->name) {
3962                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3963                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
3964                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
3965                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
3966                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
3967                                 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));
3968                         }
3969                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
3970                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
3971                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
3972                 }
3973                 if (r->comment) {
3974                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
3975                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
3976                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
3977                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
3978                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
3979                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
3980                         }
3981                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
3982                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
3983                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
3984                 }
3985                 if (r->path) {
3986                         _mem_save_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
3987                         NDR_PULL_SET_MEM_CTX(ndr, r->path, 0);
3988                         NDR_CHECK(ndr_pull_array_size(ndr, &r->path));
3989                         NDR_CHECK(ndr_pull_array_length(ndr, &r->path));
3990                         if (ndr_get_array_length(ndr, &r->path) > ndr_get_array_size(ndr, &r->path)) {
3991                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->path), ndr_get_array_length(ndr, &r->path));
3992                         }
3993                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->path), sizeof(uint16_t)));
3994                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->path, ndr_get_array_length(ndr, &r->path), sizeof(uint16_t), CH_UTF16));
3995                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_path_0, 0);
3996                 }
3997                 if (r->password) {
3998                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
3999                         NDR_PULL_SET_MEM_CTX(ndr, r->password, 0);
4000                         NDR_CHECK(ndr_pull_array_size(ndr, &r->password));
4001                         NDR_CHECK(ndr_pull_array_length(ndr, &r->password));
4002                         if (ndr_get_array_length(ndr, &r->password) > ndr_get_array_size(ndr, &r->password)) {
4003                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->password), ndr_get_array_length(ndr, &r->password));
4004                         }
4005                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t)));
4006                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->password, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t), CH_UTF16));
4007                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
4008                 }
4009         }
4010         return NDR_ERR_SUCCESS;
4011 }
4012
4013 _PUBLIC_ void ndr_print_srvsvc_NetShareInfo2(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo2 *r)
4014 {
4015         ndr_print_struct(ndr, name, "srvsvc_NetShareInfo2");
4016         ndr->depth++;
4017         ndr_print_ptr(ndr, "name", r->name);
4018         ndr->depth++;
4019         if (r->name) {
4020                 ndr_print_string(ndr, "name", r->name);
4021         }
4022         ndr->depth--;
4023         ndr_print_srvsvc_ShareType(ndr, "type", r->type);
4024         ndr_print_ptr(ndr, "comment", r->comment);
4025         ndr->depth++;
4026         if (r->comment) {
4027                 ndr_print_string(ndr, "comment", r->comment);
4028         }
4029         ndr->depth--;
4030         ndr_print_uint32(ndr, "permissions", r->permissions);
4031         ndr_print_uint32(ndr, "max_users", r->max_users);
4032         ndr_print_uint32(ndr, "current_users", r->current_users);
4033         ndr_print_ptr(ndr, "path", r->path);
4034         ndr->depth++;
4035         if (r->path) {
4036                 ndr_print_string(ndr, "path", r->path);
4037         }
4038         ndr->depth--;
4039         ndr_print_ptr(ndr, "password", r->password);
4040         ndr->depth++;
4041         if (r->password) {
4042                 ndr_print_string(ndr, "password", r->password);
4043         }
4044         ndr->depth--;
4045         ndr->depth--;
4046 }
4047
4048 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr2(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr2 *r)
4049 {
4050         uint32_t cntr_array_1;
4051         if (ndr_flags & NDR_SCALARS) {
4052                 NDR_CHECK(ndr_push_align(ndr, 4));
4053                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4054                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
4055         }
4056         if (ndr_flags & NDR_BUFFERS) {
4057                 if (r->array) {
4058                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4059                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4060                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4061                         }
4062                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4063                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4064                         }
4065                 }
4066         }
4067         return NDR_ERR_SUCCESS;
4068 }
4069
4070 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr2(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr2 *r)
4071 {
4072         uint32_t _ptr_array;
4073         uint32_t cntr_array_1;
4074         TALLOC_CTX *_mem_save_array_0;
4075         TALLOC_CTX *_mem_save_array_1;
4076         if (ndr_flags & NDR_SCALARS) {
4077                 NDR_CHECK(ndr_pull_align(ndr, 4));
4078                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4079                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
4080                 if (_ptr_array) {
4081                         NDR_PULL_ALLOC(ndr, r->array);
4082                 } else {
4083                         r->array = NULL;
4084                 }
4085         }
4086         if (ndr_flags & NDR_BUFFERS) {
4087                 if (r->array) {
4088                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4089                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4090                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
4091                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
4092                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4093                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4094                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4095                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4096                         }
4097                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4098                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4099                         }
4100                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
4101                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
4102                 }
4103                 if (r->array) {
4104                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
4105                 }
4106         }
4107         return NDR_ERR_SUCCESS;
4108 }
4109
4110 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr2(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr2 *r)
4111 {
4112         uint32_t cntr_array_1;
4113         ndr_print_struct(ndr, name, "srvsvc_NetShareCtr2");
4114         ndr->depth++;
4115         ndr_print_uint32(ndr, "count", r->count);
4116         ndr_print_ptr(ndr, "array", r->array);
4117         ndr->depth++;
4118         if (r->array) {
4119                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
4120                 ndr->depth++;
4121                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
4122                         char *idx_1=NULL;
4123                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
4124                                 ndr_print_srvsvc_NetShareInfo2(ndr, "array", &r->array[cntr_array_1]);
4125                                 free(idx_1);
4126                         }
4127                 }
4128                 ndr->depth--;
4129         }
4130         ndr->depth--;
4131         ndr->depth--;
4132 }
4133
4134 static enum ndr_err_code ndr_push_srvsvc_NetShareInfo501(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo501 *r)
4135 {
4136         if (ndr_flags & NDR_SCALARS) {
4137                 NDR_CHECK(ndr_push_align(ndr, 4));
4138                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
4139                 NDR_CHECK(ndr_push_srvsvc_ShareType(ndr, NDR_SCALARS, r->type));
4140                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
4141                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->csc_policy));
4142         }
4143         if (ndr_flags & NDR_BUFFERS) {
4144                 if (r->name) {
4145                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
4146                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4147                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
4148                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4149                 }
4150                 if (r->comment) {
4151                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
4152                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4153                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
4154                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4155                 }
4156         }
4157         return NDR_ERR_SUCCESS;
4158 }
4159
4160 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo501(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo501 *r)
4161 {
4162         uint32_t _ptr_name;
4163         TALLOC_CTX *_mem_save_name_0;
4164         uint32_t _ptr_comment;
4165         TALLOC_CTX *_mem_save_comment_0;
4166         if (ndr_flags & NDR_SCALARS) {
4167                 NDR_CHECK(ndr_pull_align(ndr, 4));
4168                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
4169                 if (_ptr_name) {
4170                         NDR_PULL_ALLOC(ndr, r->name);
4171                 } else {
4172                         r->name = NULL;
4173                 }
4174                 NDR_CHECK(ndr_pull_srvsvc_ShareType(ndr, NDR_SCALARS, &r->type));
4175                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
4176                 if (_ptr_comment) {
4177                         NDR_PULL_ALLOC(ndr, r->comment);
4178                 } else {
4179                         r->comment = NULL;
4180                 }
4181                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->csc_policy));
4182         }
4183         if (ndr_flags & NDR_BUFFERS) {
4184                 if (r->name) {
4185                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4186                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
4187                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
4188                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
4189                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
4190                                 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));
4191                         }
4192                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
4193                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
4194                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
4195                 }
4196                 if (r->comment) {
4197                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
4198                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
4199                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
4200                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
4201                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
4202                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
4203                         }
4204                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
4205                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
4206                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
4207                 }
4208         }
4209         return NDR_ERR_SUCCESS;
4210 }
4211
4212 _PUBLIC_ void ndr_print_srvsvc_NetShareInfo501(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo501 *r)
4213 {
4214         ndr_print_struct(ndr, name, "srvsvc_NetShareInfo501");
4215         ndr->depth++;
4216         ndr_print_ptr(ndr, "name", r->name);
4217         ndr->depth++;
4218         if (r->name) {
4219                 ndr_print_string(ndr, "name", r->name);
4220         }
4221         ndr->depth--;
4222         ndr_print_srvsvc_ShareType(ndr, "type", r->type);
4223         ndr_print_ptr(ndr, "comment", r->comment);
4224         ndr->depth++;
4225         if (r->comment) {
4226                 ndr_print_string(ndr, "comment", r->comment);
4227         }
4228         ndr->depth--;
4229         ndr_print_uint32(ndr, "csc_policy", r->csc_policy);
4230         ndr->depth--;
4231 }
4232
4233 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr501(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr501 *r)
4234 {
4235         uint32_t cntr_array_1;
4236         if (ndr_flags & NDR_SCALARS) {
4237                 NDR_CHECK(ndr_push_align(ndr, 4));
4238                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4239                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
4240         }
4241         if (ndr_flags & NDR_BUFFERS) {
4242                 if (r->array) {
4243                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4244                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4245                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo501(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4246                         }
4247                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4248                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo501(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4249                         }
4250                 }
4251         }
4252         return NDR_ERR_SUCCESS;
4253 }
4254
4255 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr501(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr501 *r)
4256 {
4257         uint32_t _ptr_array;
4258         uint32_t cntr_array_1;
4259         TALLOC_CTX *_mem_save_array_0;
4260         TALLOC_CTX *_mem_save_array_1;
4261         if (ndr_flags & NDR_SCALARS) {
4262                 NDR_CHECK(ndr_pull_align(ndr, 4));
4263                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4264                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
4265                 if (_ptr_array) {
4266                         NDR_PULL_ALLOC(ndr, r->array);
4267                 } else {
4268                         r->array = NULL;
4269                 }
4270         }
4271         if (ndr_flags & NDR_BUFFERS) {
4272                 if (r->array) {
4273                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4274                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4275                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
4276                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
4277                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4278                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4279                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4280                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo501(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4281                         }
4282                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4283                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo501(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4284                         }
4285                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
4286                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
4287                 }
4288                 if (r->array) {
4289                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
4290                 }
4291         }
4292         return NDR_ERR_SUCCESS;
4293 }
4294
4295 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr501(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr501 *r)
4296 {
4297         uint32_t cntr_array_1;
4298         ndr_print_struct(ndr, name, "srvsvc_NetShareCtr501");
4299         ndr->depth++;
4300         ndr_print_uint32(ndr, "count", r->count);
4301         ndr_print_ptr(ndr, "array", r->array);
4302         ndr->depth++;
4303         if (r->array) {
4304                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
4305                 ndr->depth++;
4306                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
4307                         char *idx_1=NULL;
4308                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
4309                                 ndr_print_srvsvc_NetShareInfo501(ndr, "array", &r->array[cntr_array_1]);
4310                                 free(idx_1);
4311                         }
4312                 }
4313                 ndr->depth--;
4314         }
4315         ndr->depth--;
4316         ndr->depth--;
4317 }
4318
4319 static enum ndr_err_code ndr_push_srvsvc_NetShareInfo502(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo502 *r)
4320 {
4321         if (ndr_flags & NDR_SCALARS) {
4322                 NDR_CHECK(ndr_push_align(ndr, 4));
4323                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
4324                 NDR_CHECK(ndr_push_srvsvc_ShareType(ndr, NDR_SCALARS, r->type));
4325                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
4326                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->permissions));
4327                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->max_users));
4328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->current_users));
4329                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->path));
4330                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->password));
4331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
4332                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sd));
4333         }
4334         if (ndr_flags & NDR_BUFFERS) {
4335                 if (r->name) {
4336                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
4337                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4338                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
4339                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4340                 }
4341                 if (r->comment) {
4342                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
4343                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4344                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
4345                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4346                 }
4347                 if (r->path) {
4348                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));
4349                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4350                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));
4351                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->path, ndr_charset_length(r->path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4352                 }
4353                 if (r->password) {
4354                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));
4355                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4356                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));
4357                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->password, ndr_charset_length(r->password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4358                 }
4359                 if (r->sd) {
4360                         {
4361                                 struct ndr_push *_ndr_sd;
4362                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_sd, 4, -1));
4363                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_sd, NDR_SCALARS|NDR_BUFFERS, r->sd));
4364                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_sd, 4, -1));
4365                         }
4366                 }
4367         }
4368         return NDR_ERR_SUCCESS;
4369 }
4370
4371 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo502(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo502 *r)
4372 {
4373         uint32_t _ptr_name;
4374         TALLOC_CTX *_mem_save_name_0;
4375         uint32_t _ptr_comment;
4376         TALLOC_CTX *_mem_save_comment_0;
4377         uint32_t _ptr_path;
4378         TALLOC_CTX *_mem_save_path_0;
4379         uint32_t _ptr_password;
4380         TALLOC_CTX *_mem_save_password_0;
4381         uint32_t _ptr_sd;
4382         TALLOC_CTX *_mem_save_sd_0;
4383         if (ndr_flags & NDR_SCALARS) {
4384                 NDR_CHECK(ndr_pull_align(ndr, 4));
4385                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
4386                 if (_ptr_name) {
4387                         NDR_PULL_ALLOC(ndr, r->name);
4388                 } else {
4389                         r->name = NULL;
4390                 }
4391                 NDR_CHECK(ndr_pull_srvsvc_ShareType(ndr, NDR_SCALARS, &r->type));
4392                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
4393                 if (_ptr_comment) {
4394                         NDR_PULL_ALLOC(ndr, r->comment);
4395                 } else {
4396                         r->comment = NULL;
4397                 }
4398                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->permissions));
4399                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->max_users));
4400                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->current_users));
4401                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_path));
4402                 if (_ptr_path) {
4403                         NDR_PULL_ALLOC(ndr, r->path);
4404                 } else {
4405                         r->path = NULL;
4406                 }
4407                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
4408                 if (_ptr_password) {
4409                         NDR_PULL_ALLOC(ndr, r->password);
4410                 } else {
4411                         r->password = NULL;
4412                 }
4413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
4414                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sd));
4415                 if (_ptr_sd) {
4416                         NDR_PULL_ALLOC(ndr, r->sd);
4417                 } else {
4418                         r->sd = NULL;
4419                 }
4420         }
4421         if (ndr_flags & NDR_BUFFERS) {
4422                 if (r->name) {
4423                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4424                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
4425                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
4426                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
4427                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
4428                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));
4429                         }
4430                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
4431                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
4432                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
4433                 }
4434                 if (r->comment) {
4435                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
4436                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
4437                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
4438                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
4439                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
4440                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
4441                         }
4442                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
4443                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
4444                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
4445                 }
4446                 if (r->path) {
4447                         _mem_save_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
4448                         NDR_PULL_SET_MEM_CTX(ndr, r->path, 0);
4449                         NDR_CHECK(ndr_pull_array_size(ndr, &r->path));
4450                         NDR_CHECK(ndr_pull_array_length(ndr, &r->path));
4451                         if (ndr_get_array_length(ndr, &r->path) > ndr_get_array_size(ndr, &r->path)) {
4452                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->path), ndr_get_array_length(ndr, &r->path));
4453                         }
4454                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->path), sizeof(uint16_t)));
4455                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->path, ndr_get_array_length(ndr, &r->path), sizeof(uint16_t), CH_UTF16));
4456                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_path_0, 0);
4457                 }
4458                 if (r->password) {
4459                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
4460                         NDR_PULL_SET_MEM_CTX(ndr, r->password, 0);
4461                         NDR_CHECK(ndr_pull_array_size(ndr, &r->password));
4462                         NDR_CHECK(ndr_pull_array_length(ndr, &r->password));
4463                         if (ndr_get_array_length(ndr, &r->password) > ndr_get_array_size(ndr, &r->password)) {
4464                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->password), ndr_get_array_length(ndr, &r->password));
4465                         }
4466                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t)));
4467                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->password, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t), CH_UTF16));
4468                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
4469                 }
4470                 if (r->sd) {
4471                         _mem_save_sd_0 = NDR_PULL_GET_MEM_CTX(ndr);
4472                         NDR_PULL_SET_MEM_CTX(ndr, r->sd, 0);
4473                         {
4474                                 struct ndr_pull *_ndr_sd;
4475                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_sd, 4, -1));
4476                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_sd, NDR_SCALARS|NDR_BUFFERS, r->sd));
4477                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_sd, 4, -1));
4478                         }
4479                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_0, 0);
4480                 }
4481         }
4482         return NDR_ERR_SUCCESS;
4483 }
4484
4485 _PUBLIC_ void ndr_print_srvsvc_NetShareInfo502(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo502 *r)
4486 {
4487         ndr_print_struct(ndr, name, "srvsvc_NetShareInfo502");
4488         ndr->depth++;
4489         ndr_print_ptr(ndr, "name", r->name);
4490         ndr->depth++;
4491         if (r->name) {
4492                 ndr_print_string(ndr, "name", r->name);
4493         }
4494         ndr->depth--;
4495         ndr_print_srvsvc_ShareType(ndr, "type", r->type);
4496         ndr_print_ptr(ndr, "comment", r->comment);
4497         ndr->depth++;
4498         if (r->comment) {
4499                 ndr_print_string(ndr, "comment", r->comment);
4500         }
4501         ndr->depth--;
4502         ndr_print_uint32(ndr, "permissions", r->permissions);
4503         ndr_print_int32(ndr, "max_users", r->max_users);
4504         ndr_print_uint32(ndr, "current_users", r->current_users);
4505         ndr_print_ptr(ndr, "path", r->path);
4506         ndr->depth++;
4507         if (r->path) {
4508                 ndr_print_string(ndr, "path", r->path);
4509         }
4510         ndr->depth--;
4511         ndr_print_ptr(ndr, "password", r->password);
4512         ndr->depth++;
4513         if (r->password) {
4514                 ndr_print_string(ndr, "password", r->password);
4515         }
4516         ndr->depth--;
4517         ndr_print_uint32(ndr, "unknown", r->unknown);
4518         ndr_print_ptr(ndr, "sd", r->sd);
4519         ndr->depth++;
4520         if (r->sd) {
4521                 ndr_print_security_descriptor(ndr, "sd", r->sd);
4522         }
4523         ndr->depth--;
4524         ndr->depth--;
4525 }
4526
4527 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr502(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr502 *r)
4528 {
4529         uint32_t cntr_array_1;
4530         if (ndr_flags & NDR_SCALARS) {
4531                 NDR_CHECK(ndr_push_align(ndr, 4));
4532                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4533                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
4534         }
4535         if (ndr_flags & NDR_BUFFERS) {
4536                 if (r->array) {
4537                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4538                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4539                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo502(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4540                         }
4541                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4542                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo502(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4543                         }
4544                 }
4545         }
4546         return NDR_ERR_SUCCESS;
4547 }
4548
4549 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr502(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr502 *r)
4550 {
4551         uint32_t _ptr_array;
4552         uint32_t cntr_array_1;
4553         TALLOC_CTX *_mem_save_array_0;
4554         TALLOC_CTX *_mem_save_array_1;
4555         if (ndr_flags & NDR_SCALARS) {
4556                 NDR_CHECK(ndr_pull_align(ndr, 4));
4557                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4558                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
4559                 if (_ptr_array) {
4560                         NDR_PULL_ALLOC(ndr, r->array);
4561                 } else {
4562                         r->array = NULL;
4563                 }
4564         }
4565         if (ndr_flags & NDR_BUFFERS) {
4566                 if (r->array) {
4567                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4568                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4569                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
4570                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
4571                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4572                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4573                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4574                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo502(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4575                         }
4576                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4577                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo502(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4578                         }
4579                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
4580                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
4581                 }
4582                 if (r->array) {
4583                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
4584                 }
4585         }
4586         return NDR_ERR_SUCCESS;
4587 }
4588
4589 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr502(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr502 *r)
4590 {
4591         uint32_t cntr_array_1;
4592         ndr_print_struct(ndr, name, "srvsvc_NetShareCtr502");
4593         ndr->depth++;
4594         ndr_print_uint32(ndr, "count", r->count);
4595         ndr_print_ptr(ndr, "array", r->array);
4596         ndr->depth++;
4597         if (r->array) {
4598                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
4599                 ndr->depth++;
4600                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
4601                         char *idx_1=NULL;
4602                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
4603                                 ndr_print_srvsvc_NetShareInfo502(ndr, "array", &r->array[cntr_array_1]);
4604                                 free(idx_1);
4605                         }
4606                 }
4607                 ndr->depth--;
4608         }
4609         ndr->depth--;
4610         ndr->depth--;
4611 }
4612
4613 static enum ndr_err_code ndr_push_srvsvc_NetShareInfo1004(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo1004 *r)
4614 {
4615         if (ndr_flags & NDR_SCALARS) {
4616                 NDR_CHECK(ndr_push_align(ndr, 4));
4617                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
4618         }
4619         if (ndr_flags & NDR_BUFFERS) {
4620                 if (r->comment) {
4621                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
4622                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4623                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
4624                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4625                 }
4626         }
4627         return NDR_ERR_SUCCESS;
4628 }
4629
4630 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo1004(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo1004 *r)
4631 {
4632         uint32_t _ptr_comment;
4633         TALLOC_CTX *_mem_save_comment_0;
4634         if (ndr_flags & NDR_SCALARS) {
4635                 NDR_CHECK(ndr_pull_align(ndr, 4));
4636                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
4637                 if (_ptr_comment) {
4638                         NDR_PULL_ALLOC(ndr, r->comment);
4639                 } else {
4640                         r->comment = NULL;
4641                 }
4642         }
4643         if (ndr_flags & NDR_BUFFERS) {
4644                 if (r->comment) {
4645                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
4646                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
4647                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
4648                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
4649                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
4650                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
4651                         }
4652                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
4653                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
4654                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
4655                 }
4656         }
4657         return NDR_ERR_SUCCESS;
4658 }
4659
4660 _PUBLIC_ void ndr_print_srvsvc_NetShareInfo1004(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo1004 *r)
4661 {
4662         ndr_print_struct(ndr, name, "srvsvc_NetShareInfo1004");
4663         ndr->depth++;
4664         ndr_print_ptr(ndr, "comment", r->comment);
4665         ndr->depth++;
4666         if (r->comment) {
4667                 ndr_print_string(ndr, "comment", r->comment);
4668         }
4669         ndr->depth--;
4670         ndr->depth--;
4671 }
4672
4673 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr1004(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr1004 *r)
4674 {
4675         uint32_t cntr_array_1;
4676         if (ndr_flags & NDR_SCALARS) {
4677                 NDR_CHECK(ndr_push_align(ndr, 4));
4678                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4679                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
4680         }
4681         if (ndr_flags & NDR_BUFFERS) {
4682                 if (r->array) {
4683                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4684                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4685                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo1004(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4686                         }
4687                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4688                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo1004(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4689                         }
4690                 }
4691         }
4692         return NDR_ERR_SUCCESS;
4693 }
4694
4695 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr1004(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr1004 *r)
4696 {
4697         uint32_t _ptr_array;
4698         uint32_t cntr_array_1;
4699         TALLOC_CTX *_mem_save_array_0;
4700         TALLOC_CTX *_mem_save_array_1;
4701         if (ndr_flags & NDR_SCALARS) {
4702                 NDR_CHECK(ndr_pull_align(ndr, 4));
4703                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4704                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
4705                 if (_ptr_array) {
4706                         NDR_PULL_ALLOC(ndr, r->array);
4707                 } else {
4708                         r->array = NULL;
4709                 }
4710         }
4711         if (ndr_flags & NDR_BUFFERS) {
4712                 if (r->array) {
4713                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4714                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4715                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
4716                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
4717                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4718                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4719                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4720                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1004(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4721                         }
4722                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4723                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1004(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4724                         }
4725                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
4726                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
4727                 }
4728                 if (r->array) {
4729                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
4730                 }
4731         }
4732         return NDR_ERR_SUCCESS;
4733 }
4734
4735 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr1004(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr1004 *r)
4736 {
4737         uint32_t cntr_array_1;
4738         ndr_print_struct(ndr, name, "srvsvc_NetShareCtr1004");
4739         ndr->depth++;
4740         ndr_print_uint32(ndr, "count", r->count);
4741         ndr_print_ptr(ndr, "array", r->array);
4742         ndr->depth++;
4743         if (r->array) {
4744                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
4745                 ndr->depth++;
4746                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
4747                         char *idx_1=NULL;
4748                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
4749                                 ndr_print_srvsvc_NetShareInfo1004(ndr, "array", &r->array[cntr_array_1]);
4750                                 free(idx_1);
4751                         }
4752                 }
4753                 ndr->depth--;
4754         }
4755         ndr->depth--;
4756         ndr->depth--;
4757 }
4758
4759 static enum ndr_err_code ndr_push_NetShareInfo1005Flags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
4760 {
4761         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4762         return NDR_ERR_SUCCESS;
4763 }
4764
4765 static enum ndr_err_code ndr_pull_NetShareInfo1005Flags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
4766 {
4767         uint32_t v;
4768         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4769         *r = v;
4770         return NDR_ERR_SUCCESS;
4771 }
4772
4773 _PUBLIC_ void ndr_print_NetShareInfo1005Flags(struct ndr_print *ndr, const char *name, uint32_t r)
4774 {
4775         ndr_print_uint32(ndr, name, r);
4776         ndr->depth++;
4777         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SHARE_1005_IN_DFS", SHARE_1005_IN_DFS, r);
4778         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SHARE_1005_DFS_ROOT", SHARE_1005_DFS_ROOT, r);
4779         ndr->depth--;
4780 }
4781
4782 static enum ndr_err_code ndr_push_srvsvc_NetShareInfo1005(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo1005 *r)
4783 {
4784         if (ndr_flags & NDR_SCALARS) {
4785                 NDR_CHECK(ndr_push_align(ndr, 4));
4786                 NDR_CHECK(ndr_push_NetShareInfo1005Flags(ndr, NDR_SCALARS, r->dfs_flags));
4787         }
4788         if (ndr_flags & NDR_BUFFERS) {
4789         }
4790         return NDR_ERR_SUCCESS;
4791 }
4792
4793 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo1005(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo1005 *r)
4794 {
4795         if (ndr_flags & NDR_SCALARS) {
4796                 NDR_CHECK(ndr_pull_align(ndr, 4));
4797                 NDR_CHECK(ndr_pull_NetShareInfo1005Flags(ndr, NDR_SCALARS, &r->dfs_flags));
4798         }
4799         if (ndr_flags & NDR_BUFFERS) {
4800         }
4801         return NDR_ERR_SUCCESS;
4802 }
4803
4804 _PUBLIC_ void ndr_print_srvsvc_NetShareInfo1005(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo1005 *r)
4805 {
4806         ndr_print_struct(ndr, name, "srvsvc_NetShareInfo1005");
4807         ndr->depth++;
4808         ndr_print_NetShareInfo1005Flags(ndr, "dfs_flags", r->dfs_flags);
4809         ndr->depth--;
4810 }
4811
4812 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr1005(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr1005 *r)
4813 {
4814         uint32_t cntr_array_1;
4815         if (ndr_flags & NDR_SCALARS) {
4816                 NDR_CHECK(ndr_push_align(ndr, 4));
4817                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4818                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
4819         }
4820         if (ndr_flags & NDR_BUFFERS) {
4821                 if (r->array) {
4822                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4823                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4824                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo1005(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4825                         }
4826                 }
4827         }
4828         return NDR_ERR_SUCCESS;
4829 }
4830
4831 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr1005(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr1005 *r)
4832 {
4833         uint32_t _ptr_array;
4834         uint32_t cntr_array_1;
4835         TALLOC_CTX *_mem_save_array_0;
4836         TALLOC_CTX *_mem_save_array_1;
4837         if (ndr_flags & NDR_SCALARS) {
4838                 NDR_CHECK(ndr_pull_align(ndr, 4));
4839                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4840                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
4841                 if (_ptr_array) {
4842                         NDR_PULL_ALLOC(ndr, r->array);
4843                 } else {
4844                         r->array = NULL;
4845                 }
4846         }
4847         if (ndr_flags & NDR_BUFFERS) {
4848                 if (r->array) {
4849                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4850                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4851                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
4852                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
4853                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4854                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4855                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4856                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1005(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4857                         }
4858                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
4859                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
4860                 }
4861                 if (r->array) {
4862                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
4863                 }
4864         }
4865         return NDR_ERR_SUCCESS;
4866 }
4867
4868 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr1005(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr1005 *r)
4869 {
4870         uint32_t cntr_array_1;
4871         ndr_print_struct(ndr, name, "srvsvc_NetShareCtr1005");
4872         ndr->depth++;
4873         ndr_print_uint32(ndr, "count", r->count);
4874         ndr_print_ptr(ndr, "array", r->array);
4875         ndr->depth++;
4876         if (r->array) {
4877                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
4878                 ndr->depth++;
4879                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
4880                         char *idx_1=NULL;
4881                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
4882                                 ndr_print_srvsvc_NetShareInfo1005(ndr, "array", &r->array[cntr_array_1]);
4883                                 free(idx_1);
4884                         }
4885                 }
4886                 ndr->depth--;
4887         }
4888         ndr->depth--;
4889         ndr->depth--;
4890 }
4891
4892 static enum ndr_err_code ndr_push_srvsvc_NetShareInfo1006(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo1006 *r)
4893 {
4894         if (ndr_flags & NDR_SCALARS) {
4895                 NDR_CHECK(ndr_push_align(ndr, 4));
4896                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->max_users));
4897         }
4898         if (ndr_flags & NDR_BUFFERS) {
4899         }
4900         return NDR_ERR_SUCCESS;
4901 }
4902
4903 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo1006(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo1006 *r)
4904 {
4905         if (ndr_flags & NDR_SCALARS) {
4906                 NDR_CHECK(ndr_pull_align(ndr, 4));
4907                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->max_users));
4908         }
4909         if (ndr_flags & NDR_BUFFERS) {
4910         }
4911         return NDR_ERR_SUCCESS;
4912 }
4913
4914 _PUBLIC_ void ndr_print_srvsvc_NetShareInfo1006(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo1006 *r)
4915 {
4916         ndr_print_struct(ndr, name, "srvsvc_NetShareInfo1006");
4917         ndr->depth++;
4918         ndr_print_int32(ndr, "max_users", r->max_users);
4919         ndr->depth--;
4920 }
4921
4922 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr1006(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr1006 *r)
4923 {
4924         uint32_t cntr_array_1;
4925         if (ndr_flags & NDR_SCALARS) {
4926                 NDR_CHECK(ndr_push_align(ndr, 4));
4927                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4928                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
4929         }
4930         if (ndr_flags & NDR_BUFFERS) {
4931                 if (r->array) {
4932                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4933                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4934                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo1006(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4935                         }
4936                 }
4937         }
4938         return NDR_ERR_SUCCESS;
4939 }
4940
4941 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr1006(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr1006 *r)
4942 {
4943         uint32_t _ptr_array;
4944         uint32_t cntr_array_1;
4945         TALLOC_CTX *_mem_save_array_0;
4946         TALLOC_CTX *_mem_save_array_1;
4947         if (ndr_flags & NDR_SCALARS) {
4948                 NDR_CHECK(ndr_pull_align(ndr, 4));
4949                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4950                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
4951                 if (_ptr_array) {
4952                         NDR_PULL_ALLOC(ndr, r->array);
4953                 } else {
4954                         r->array = NULL;
4955                 }
4956         }
4957         if (ndr_flags & NDR_BUFFERS) {
4958                 if (r->array) {
4959                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4960                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4961                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
4962                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
4963                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4964                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4965                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4966                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1006(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4967                         }
4968                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
4969                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
4970                 }
4971                 if (r->array) {
4972                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
4973                 }
4974         }
4975         return NDR_ERR_SUCCESS;
4976 }
4977
4978 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr1006(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr1006 *r)
4979 {
4980         uint32_t cntr_array_1;
4981         ndr_print_struct(ndr, name, "srvsvc_NetShareCtr1006");
4982         ndr->depth++;
4983         ndr_print_uint32(ndr, "count", r->count);
4984         ndr_print_ptr(ndr, "array", r->array);
4985         ndr->depth++;
4986         if (r->array) {
4987                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
4988                 ndr->depth++;
4989                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
4990                         char *idx_1=NULL;
4991                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
4992                                 ndr_print_srvsvc_NetShareInfo1006(ndr, "array", &r->array[cntr_array_1]);
4993                                 free(idx_1);
4994                         }
4995                 }
4996                 ndr->depth--;
4997         }
4998         ndr->depth--;
4999         ndr->depth--;
5000 }
5001
5002 static enum ndr_err_code ndr_push_srvsvc_NetShareInfo1007(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo1007 *r)
5003 {
5004         if (ndr_flags & NDR_SCALARS) {
5005                 NDR_CHECK(ndr_push_align(ndr, 4));
5006                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
5007                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->alternate_directory_name));
5008         }
5009         if (ndr_flags & NDR_BUFFERS) {
5010                 if (r->alternate_directory_name) {
5011                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->alternate_directory_name, CH_UTF16)));
5012                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5013                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->alternate_directory_name, CH_UTF16)));
5014                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->alternate_directory_name, ndr_charset_length(r->alternate_directory_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5015                 }
5016         }
5017         return NDR_ERR_SUCCESS;
5018 }
5019
5020 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo1007(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo1007 *r)
5021 {
5022         uint32_t _ptr_alternate_directory_name;
5023         TALLOC_CTX *_mem_save_alternate_directory_name_0;
5024         if (ndr_flags & NDR_SCALARS) {
5025                 NDR_CHECK(ndr_pull_align(ndr, 4));
5026                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
5027                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_alternate_directory_name));
5028                 if (_ptr_alternate_directory_name) {
5029                         NDR_PULL_ALLOC(ndr, r->alternate_directory_name);
5030                 } else {
5031                         r->alternate_directory_name = NULL;
5032                 }
5033         }
5034         if (ndr_flags & NDR_BUFFERS) {
5035                 if (r->alternate_directory_name) {
5036                         _mem_save_alternate_directory_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5037                         NDR_PULL_SET_MEM_CTX(ndr, r->alternate_directory_name, 0);
5038                         NDR_CHECK(ndr_pull_array_size(ndr, &r->alternate_directory_name));
5039                         NDR_CHECK(ndr_pull_array_length(ndr, &r->alternate_directory_name));
5040                         if (ndr_get_array_length(ndr, &r->alternate_directory_name) > ndr_get_array_size(ndr, &r->alternate_directory_name)) {
5041                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->alternate_directory_name), ndr_get_array_length(ndr, &r->alternate_directory_name));
5042                         }
5043                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->alternate_directory_name), sizeof(uint16_t)));
5044                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->alternate_directory_name, ndr_get_array_length(ndr, &r->alternate_directory_name), sizeof(uint16_t), CH_UTF16));
5045                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alternate_directory_name_0, 0);
5046                 }
5047         }
5048         return NDR_ERR_SUCCESS;
5049 }
5050
5051 _PUBLIC_ void ndr_print_srvsvc_NetShareInfo1007(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo1007 *r)
5052 {
5053         ndr_print_struct(ndr, name, "srvsvc_NetShareInfo1007");
5054         ndr->depth++;
5055         ndr_print_uint32(ndr, "flags", r->flags);
5056         ndr_print_ptr(ndr, "alternate_directory_name", r->alternate_directory_name);
5057         ndr->depth++;
5058         if (r->alternate_directory_name) {
5059                 ndr_print_string(ndr, "alternate_directory_name", r->alternate_directory_name);
5060         }
5061         ndr->depth--;
5062         ndr->depth--;
5063 }
5064
5065 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr1007(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr1007 *r)
5066 {
5067         uint32_t cntr_array_1;
5068         if (ndr_flags & NDR_SCALARS) {
5069                 NDR_CHECK(ndr_push_align(ndr, 4));
5070                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5071                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
5072         }
5073         if (ndr_flags & NDR_BUFFERS) {
5074                 if (r->array) {
5075                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5076                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5077                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo1007(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5078                         }
5079                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5080                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo1007(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5081                         }
5082                 }
5083         }
5084         return NDR_ERR_SUCCESS;
5085 }
5086
5087 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr1007(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr1007 *r)
5088 {
5089         uint32_t _ptr_array;
5090         uint32_t cntr_array_1;
5091         TALLOC_CTX *_mem_save_array_0;
5092         TALLOC_CTX *_mem_save_array_1;
5093         if (ndr_flags & NDR_SCALARS) {
5094                 NDR_CHECK(ndr_pull_align(ndr, 4));
5095                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5096                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
5097                 if (_ptr_array) {
5098                         NDR_PULL_ALLOC(ndr, r->array);
5099                 } else {
5100                         r->array = NULL;
5101                 }
5102         }
5103         if (ndr_flags & NDR_BUFFERS) {
5104                 if (r->array) {
5105                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5106                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5107                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
5108                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
5109                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5110                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5111                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5112                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1007(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5113                         }
5114                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5115                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1007(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5116                         }
5117                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
5118                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
5119                 }
5120                 if (r->array) {
5121                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
5122                 }
5123         }
5124         return NDR_ERR_SUCCESS;
5125 }
5126
5127 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr1007(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr1007 *r)
5128 {
5129         uint32_t cntr_array_1;
5130         ndr_print_struct(ndr, name, "srvsvc_NetShareCtr1007");
5131         ndr->depth++;
5132         ndr_print_uint32(ndr, "count", r->count);
5133         ndr_print_ptr(ndr, "array", r->array);
5134         ndr->depth++;
5135         if (r->array) {
5136                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
5137                 ndr->depth++;
5138                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
5139                         char *idx_1=NULL;
5140                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
5141                                 ndr_print_srvsvc_NetShareInfo1007(ndr, "array", &r->array[cntr_array_1]);
5142                                 free(idx_1);
5143                         }
5144                 }
5145                 ndr->depth--;
5146         }
5147         ndr->depth--;
5148         ndr->depth--;
5149 }
5150
5151 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr1501(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr1501 *r)
5152 {
5153         uint32_t cntr_array_1;
5154         if (ndr_flags & NDR_SCALARS) {
5155                 NDR_CHECK(ndr_push_align(ndr, 4));
5156                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5157                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
5158         }
5159         if (ndr_flags & NDR_BUFFERS) {
5160                 if (r->array) {
5161                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5162                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5163                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5164                         }
5165                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5166                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5167                         }
5168                 }
5169         }
5170         return NDR_ERR_SUCCESS;
5171 }
5172
5173 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr1501(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr1501 *r)
5174 {
5175         uint32_t _ptr_array;
5176         uint32_t cntr_array_1;
5177         TALLOC_CTX *_mem_save_array_0;
5178         TALLOC_CTX *_mem_save_array_1;
5179         if (ndr_flags & NDR_SCALARS) {
5180                 NDR_CHECK(ndr_pull_align(ndr, 4));
5181                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5182                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
5183                 if (_ptr_array) {
5184                         NDR_PULL_ALLOC(ndr, r->array);
5185                 } else {
5186                         r->array = NULL;
5187                 }
5188         }
5189         if (ndr_flags & NDR_BUFFERS) {
5190                 if (r->array) {
5191                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5192                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5193                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
5194                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
5195                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5196                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5197                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5198                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5199                         }
5200                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5201                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5202                         }
5203                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
5204                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
5205                 }
5206                 if (r->array) {
5207                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
5208                 }
5209         }
5210         return NDR_ERR_SUCCESS;
5211 }
5212
5213 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr1501(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr1501 *r)
5214 {
5215         uint32_t cntr_array_1;
5216         ndr_print_struct(ndr, name, "srvsvc_NetShareCtr1501");
5217         ndr->depth++;
5218         ndr_print_uint32(ndr, "count", r->count);
5219         ndr_print_ptr(ndr, "array", r->array);
5220         ndr->depth++;
5221         if (r->array) {
5222                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
5223                 ndr->depth++;
5224                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
5225                         char *idx_1=NULL;
5226                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
5227                                 ndr_print_sec_desc_buf(ndr, "array", &r->array[cntr_array_1]);
5228                                 free(idx_1);
5229                         }
5230                 }
5231                 ndr->depth--;
5232         }
5233         ndr->depth--;
5234         ndr->depth--;
5235 }
5236
5237 static enum ndr_err_code ndr_push_srvsvc_NetShareInfo(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetShareInfo *r)
5238 {
5239         if (ndr_flags & NDR_SCALARS) {
5240                 int level = ndr_push_get_switch_value(ndr, r);
5241                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5242                 switch (level) {
5243                         case 0: {
5244                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
5245                         break; }
5246
5247                         case 1: {
5248                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
5249                         break; }
5250
5251                         case 2: {
5252                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
5253                         break; }
5254
5255                         case 501: {
5256                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info501));
5257                         break; }
5258
5259                         case 502: {
5260                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info502));
5261                         break; }
5262
5263                         case 1004: {
5264                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1004));
5265                         break; }
5266
5267                         case 1005: {
5268                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1005));
5269                         break; }
5270
5271                         case 1006: {
5272                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1006));
5273                         break; }
5274
5275                         case 1007: {
5276                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1007));
5277                         break; }
5278
5279                         case 1501: {
5280                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1501));
5281                         break; }
5282
5283                         default: {
5284                         break; }
5285
5286                 }
5287         }
5288         if (ndr_flags & NDR_BUFFERS) {
5289                 int level = ndr_push_get_switch_value(ndr, r);
5290                 switch (level) {
5291                         case 0:
5292                                 if (r->info0) {
5293                                         NDR_CHECK(ndr_push_srvsvc_NetShareInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
5294                                 }
5295                         break;
5296
5297                         case 1:
5298                                 if (r->info1) {
5299                                         NDR_CHECK(ndr_push_srvsvc_NetShareInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
5300                                 }
5301                         break;
5302
5303                         case 2:
5304                                 if (r->info2) {
5305                                         NDR_CHECK(ndr_push_srvsvc_NetShareInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
5306                                 }
5307                         break;
5308
5309                         case 501:
5310                                 if (r->info501) {
5311                                         NDR_CHECK(ndr_push_srvsvc_NetShareInfo501(ndr, NDR_SCALARS|NDR_BUFFERS, r->info501));
5312                                 }
5313                         break;
5314
5315                         case 502:
5316                                 if (r->info502) {
5317                                         NDR_CHECK(ndr_push_srvsvc_NetShareInfo502(ndr, NDR_SCALARS|NDR_BUFFERS, r->info502));
5318                                 }
5319                         break;
5320
5321                         case 1004:
5322                                 if (r->info1004) {
5323                                         NDR_CHECK(ndr_push_srvsvc_NetShareInfo1004(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1004));
5324                                 }
5325                         break;
5326
5327                         case 1005:
5328                                 if (r->info1005) {
5329                                         NDR_CHECK(ndr_push_srvsvc_NetShareInfo1005(ndr, NDR_SCALARS, r->info1005));
5330                                 }
5331                         break;
5332
5333                         case 1006:
5334                                 if (r->info1006) {
5335                                         NDR_CHECK(ndr_push_srvsvc_NetShareInfo1006(ndr, NDR_SCALARS, r->info1006));
5336                                 }
5337                         break;
5338
5339                         case 1007:
5340                                 if (r->info1007) {
5341                                         NDR_CHECK(ndr_push_srvsvc_NetShareInfo1007(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1007));
5342                                 }
5343                         break;
5344
5345                         case 1501:
5346                                 if (r->info1501) {
5347                                         NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1501));
5348                                 }
5349                         break;
5350
5351                         default:
5352                         break;
5353
5354                 }
5355         }
5356         return NDR_ERR_SUCCESS;
5357 }
5358
5359 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetShareInfo *r)
5360 {
5361         int level;
5362         uint32_t _level;
5363         TALLOC_CTX *_mem_save_info0_0;
5364         TALLOC_CTX *_mem_save_info1_0;
5365         TALLOC_CTX *_mem_save_info2_0;
5366         TALLOC_CTX *_mem_save_info501_0;
5367         TALLOC_CTX *_mem_save_info502_0;
5368         TALLOC_CTX *_mem_save_info1004_0;
5369         TALLOC_CTX *_mem_save_info1005_0;
5370         TALLOC_CTX *_mem_save_info1006_0;
5371         TALLOC_CTX *_mem_save_info1007_0;
5372         TALLOC_CTX *_mem_save_info1501_0;
5373         level = ndr_pull_get_switch_value(ndr, r);
5374         if (ndr_flags & NDR_SCALARS) {
5375                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5376                 if (_level != level) {
5377                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5378                 }
5379                 switch (level) {
5380                         case 0: {
5381                                 uint32_t _ptr_info0;
5382                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
5383                                 if (_ptr_info0) {
5384                                         NDR_PULL_ALLOC(ndr, r->info0);
5385                                 } else {
5386                                         r->info0 = NULL;
5387                                 }
5388                         break; }
5389
5390                         case 1: {
5391                                 uint32_t _ptr_info1;
5392                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
5393                                 if (_ptr_info1) {
5394                                         NDR_PULL_ALLOC(ndr, r->info1);
5395                                 } else {
5396                                         r->info1 = NULL;
5397                                 }
5398                         break; }
5399
5400                         case 2: {
5401                                 uint32_t _ptr_info2;
5402                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
5403                                 if (_ptr_info2) {
5404                                         NDR_PULL_ALLOC(ndr, r->info2);
5405                                 } else {
5406                                         r->info2 = NULL;
5407                                 }
5408                         break; }
5409
5410                         case 501: {
5411                                 uint32_t _ptr_info501;
5412                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info501));
5413                                 if (_ptr_info501) {
5414                                         NDR_PULL_ALLOC(ndr, r->info501);
5415                                 } else {
5416                                         r->info501 = NULL;
5417                                 }
5418                         break; }
5419
5420                         case 502: {
5421                                 uint32_t _ptr_info502;
5422                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info502));
5423                                 if (_ptr_info502) {
5424                                         NDR_PULL_ALLOC(ndr, r->info502);
5425                                 } else {
5426                                         r->info502 = NULL;
5427                                 }
5428                         break; }
5429
5430                         case 1004: {
5431                                 uint32_t _ptr_info1004;
5432                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1004));
5433                                 if (_ptr_info1004) {
5434                                         NDR_PULL_ALLOC(ndr, r->info1004);
5435                                 } else {
5436                                         r->info1004 = NULL;
5437                                 }
5438                         break; }
5439
5440                         case 1005: {
5441                                 uint32_t _ptr_info1005;
5442                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1005));
5443                                 if (_ptr_info1005) {
5444                                         NDR_PULL_ALLOC(ndr, r->info1005);
5445                                 } else {
5446                                         r->info1005 = NULL;
5447                                 }
5448                         break; }
5449
5450                         case 1006: {
5451                                 uint32_t _ptr_info1006;
5452                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1006));
5453                                 if (_ptr_info1006) {
5454                                         NDR_PULL_ALLOC(ndr, r->info1006);
5455                                 } else {
5456                                         r->info1006 = NULL;
5457                                 }
5458                         break; }
5459
5460                         case 1007: {
5461                                 uint32_t _ptr_info1007;
5462                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1007));
5463                                 if (_ptr_info1007) {
5464                                         NDR_PULL_ALLOC(ndr, r->info1007);
5465                                 } else {
5466                                         r->info1007 = NULL;
5467                                 }
5468                         break; }
5469
5470                         case 1501: {
5471                                 uint32_t _ptr_info1501;
5472                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1501));
5473                                 if (_ptr_info1501) {
5474                                         NDR_PULL_ALLOC(ndr, r->info1501);
5475                                 } else {
5476                                         r->info1501 = NULL;
5477                                 }
5478                         break; }
5479
5480                         default: {
5481                         break; }
5482
5483                 }
5484         }
5485         if (ndr_flags & NDR_BUFFERS) {
5486                 switch (level) {
5487                         case 0:
5488                                 if (r->info0) {
5489                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
5490                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
5491                                         NDR_CHECK(ndr_pull_srvsvc_NetShareInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
5492                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
5493                                 }
5494                         break;
5495
5496                         case 1:
5497                                 if (r->info1) {
5498                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5499                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
5500                                         NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
5501                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
5502                                 }
5503                         break;
5504
5505                         case 2:
5506                                 if (r->info2) {
5507                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
5508                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
5509                                         NDR_CHECK(ndr_pull_srvsvc_NetShareInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
5510                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
5511                                 }
5512                         break;
5513
5514                         case 501:
5515                                 if (r->info501) {
5516                                         _mem_save_info501_0 = NDR_PULL_GET_MEM_CTX(ndr);
5517                                         NDR_PULL_SET_MEM_CTX(ndr, r->info501, 0);
5518                                         NDR_CHECK(ndr_pull_srvsvc_NetShareInfo501(ndr, NDR_SCALARS|NDR_BUFFERS, r->info501));
5519                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info501_0, 0);
5520                                 }
5521                         break;
5522
5523                         case 502:
5524                                 if (r->info502) {
5525                                         _mem_save_info502_0 = NDR_PULL_GET_MEM_CTX(ndr);
5526                                         NDR_PULL_SET_MEM_CTX(ndr, r->info502, 0);
5527                                         NDR_CHECK(ndr_pull_srvsvc_NetShareInfo502(ndr, NDR_SCALARS|NDR_BUFFERS, r->info502));
5528                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info502_0, 0);
5529                                 }
5530                         break;
5531
5532                         case 1004:
5533                                 if (r->info1004) {
5534                                         _mem_save_info1004_0 = NDR_PULL_GET_MEM_CTX(ndr);
5535                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1004, 0);
5536                                         NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1004(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1004));
5537                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1004_0, 0);
5538                                 }
5539                         break;
5540
5541                         case 1005:
5542                                 if (r->info1005) {
5543                                         _mem_save_info1005_0 = NDR_PULL_GET_MEM_CTX(ndr);
5544                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1005, 0);
5545                                         NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1005(ndr, NDR_SCALARS, r->info1005));
5546                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1005_0, 0);
5547                                 }
5548                         break;
5549
5550                         case 1006:
5551                                 if (r->info1006) {
5552                                         _mem_save_info1006_0 = NDR_PULL_GET_MEM_CTX(ndr);
5553                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1006, 0);
5554                                         NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1006(ndr, NDR_SCALARS, r->info1006));
5555                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1006_0, 0);
5556                                 }
5557                         break;
5558
5559                         case 1007:
5560                                 if (r->info1007) {
5561                                         _mem_save_info1007_0 = NDR_PULL_GET_MEM_CTX(ndr);
5562                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1007, 0);
5563                                         NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1007(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1007));
5564                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1007_0, 0);
5565                                 }
5566                         break;
5567
5568                         case 1501:
5569                                 if (r->info1501) {
5570                                         _mem_save_info1501_0 = NDR_PULL_GET_MEM_CTX(ndr);
5571                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1501, 0);
5572                                         NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1501));
5573                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1501_0, 0);
5574                                 }
5575                         break;
5576
5577                         default:
5578                         break;
5579
5580                 }
5581         }
5582         return NDR_ERR_SUCCESS;
5583 }
5584
5585 _PUBLIC_ void ndr_print_srvsvc_NetShareInfo(struct ndr_print *ndr, const char *name, const union srvsvc_NetShareInfo *r)
5586 {
5587         int level;
5588         level = ndr_print_get_switch_value(ndr, r);
5589         ndr_print_union(ndr, name, level, "srvsvc_NetShareInfo");
5590         switch (level) {
5591                 case 0:
5592                         ndr_print_ptr(ndr, "info0", r->info0);
5593                         ndr->depth++;
5594                         if (r->info0) {
5595                                 ndr_print_srvsvc_NetShareInfo0(ndr, "info0", r->info0);
5596                         }
5597                         ndr->depth--;
5598                 break;
5599
5600                 case 1:
5601                         ndr_print_ptr(ndr, "info1", r->info1);
5602                         ndr->depth++;
5603                         if (r->info1) {
5604                                 ndr_print_srvsvc_NetShareInfo1(ndr, "info1", r->info1);
5605                         }
5606                         ndr->depth--;
5607                 break;
5608
5609                 case 2:
5610                         ndr_print_ptr(ndr, "info2", r->info2);
5611                         ndr->depth++;
5612                         if (r->info2) {
5613                                 ndr_print_srvsvc_NetShareInfo2(ndr, "info2", r->info2);
5614                         }
5615                         ndr->depth--;
5616                 break;
5617
5618                 case 501:
5619                         ndr_print_ptr(ndr, "info501", r->info501);
5620                         ndr->depth++;
5621                         if (r->info501) {
5622                                 ndr_print_srvsvc_NetShareInfo501(ndr, "info501", r->info501);
5623                         }
5624                         ndr->depth--;
5625                 break;
5626
5627                 case 502:
5628                         ndr_print_ptr(ndr, "info502", r->info502);
5629                         ndr->depth++;
5630                         if (r->info502) {
5631                                 ndr_print_srvsvc_NetShareInfo502(ndr, "info502", r->info502);
5632                         }
5633                         ndr->depth--;
5634                 break;
5635
5636                 case 1004:
5637                         ndr_print_ptr(ndr, "info1004", r->info1004);
5638                         ndr->depth++;
5639                         if (r->info1004) {
5640                                 ndr_print_srvsvc_NetShareInfo1004(ndr, "info1004", r->info1004);
5641                         }
5642                         ndr->depth--;
5643                 break;
5644
5645                 case 1005:
5646                         ndr_print_ptr(ndr, "info1005", r->info1005);
5647                         ndr->depth++;
5648                         if (r->info1005) {
5649                                 ndr_print_srvsvc_NetShareInfo1005(ndr, "info1005", r->info1005);
5650                         }
5651                         ndr->depth--;
5652                 break;
5653
5654                 case 1006:
5655                         ndr_print_ptr(ndr, "info1006", r->info1006);
5656                         ndr->depth++;
5657                         if (r->info1006) {
5658                                 ndr_print_srvsvc_NetShareInfo1006(ndr, "info1006", r->info1006);
5659                         }
5660                         ndr->depth--;
5661                 break;
5662
5663                 case 1007:
5664                         ndr_print_ptr(ndr, "info1007", r->info1007);
5665                         ndr->depth++;
5666                         if (r->info1007) {
5667                                 ndr_print_srvsvc_NetShareInfo1007(ndr, "info1007", r->info1007);
5668                         }
5669                         ndr->depth--;
5670                 break;
5671
5672                 case 1501:
5673                         ndr_print_ptr(ndr, "info1501", r->info1501);
5674                         ndr->depth++;
5675                         if (r->info1501) {
5676                                 ndr_print_sec_desc_buf(ndr, "info1501", r->info1501);
5677                         }
5678                         ndr->depth--;
5679                 break;
5680
5681                 default:
5682                 break;
5683
5684         }
5685 }
5686
5687 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetShareCtr *r)
5688 {
5689         if (ndr_flags & NDR_SCALARS) {
5690                 int level = ndr_push_get_switch_value(ndr, r);
5691                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5692                 switch (level) {
5693                         case 0: {
5694                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
5695                         break; }
5696
5697                         case 1: {
5698                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
5699                         break; }
5700
5701                         case 2: {
5702                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr2));
5703                         break; }
5704
5705                         case 501: {
5706                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr501));
5707                         break; }
5708
5709                         case 502: {
5710                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr502));
5711                         break; }
5712
5713                         case 1004: {
5714                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1004));
5715                         break; }
5716
5717                         case 1005: {
5718                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1005));
5719                         break; }
5720
5721                         case 1006: {
5722                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1006));
5723                         break; }
5724
5725                         case 1007: {
5726                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1007));
5727                         break; }
5728
5729                         case 1501: {
5730                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1501));
5731                         break; }
5732
5733                         default: {
5734                         break; }
5735
5736                 }
5737         }
5738         if (ndr_flags & NDR_BUFFERS) {
5739                 int level = ndr_push_get_switch_value(ndr, r);
5740                 switch (level) {
5741                         case 0:
5742                                 if (r->ctr0) {
5743                                         NDR_CHECK(ndr_push_srvsvc_NetShareCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
5744                                 }
5745                         break;
5746
5747                         case 1:
5748                                 if (r->ctr1) {
5749                                         NDR_CHECK(ndr_push_srvsvc_NetShareCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
5750                                 }
5751                         break;
5752
5753                         case 2:
5754                                 if (r->ctr2) {
5755                                         NDR_CHECK(ndr_push_srvsvc_NetShareCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
5756                                 }
5757                         break;
5758
5759                         case 501:
5760                                 if (r->ctr501) {
5761                                         NDR_CHECK(ndr_push_srvsvc_NetShareCtr501(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr501));
5762                                 }
5763                         break;
5764
5765                         case 502:
5766                                 if (r->ctr502) {
5767                                         NDR_CHECK(ndr_push_srvsvc_NetShareCtr502(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr502));
5768                                 }
5769                         break;
5770
5771                         case 1004:
5772                                 if (r->ctr1004) {
5773                                         NDR_CHECK(ndr_push_srvsvc_NetShareCtr1004(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1004));
5774                                 }
5775                         break;
5776
5777                         case 1005:
5778                                 if (r->ctr1005) {
5779                                         NDR_CHECK(ndr_push_srvsvc_NetShareCtr1005(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1005));
5780                                 }
5781                         break;
5782
5783                         case 1006:
5784                                 if (r->ctr1006) {
5785                                         NDR_CHECK(ndr_push_srvsvc_NetShareCtr1006(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1006));
5786                                 }
5787                         break;
5788
5789                         case 1007:
5790                                 if (r->ctr1007) {
5791                                         NDR_CHECK(ndr_push_srvsvc_NetShareCtr1007(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1007));
5792                                 }
5793                         break;
5794
5795                         case 1501:
5796                                 if (r->ctr1501) {
5797                                         NDR_CHECK(ndr_push_srvsvc_NetShareCtr1501(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1501));
5798                                 }
5799                         break;
5800
5801                         default:
5802                         break;
5803
5804                 }
5805         }
5806         return NDR_ERR_SUCCESS;
5807 }
5808
5809 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetShareCtr *r)
5810 {
5811         int level;
5812         uint32_t _level;
5813         TALLOC_CTX *_mem_save_ctr0_0;
5814         TALLOC_CTX *_mem_save_ctr1_0;
5815         TALLOC_CTX *_mem_save_ctr2_0;
5816         TALLOC_CTX *_mem_save_ctr501_0;
5817         TALLOC_CTX *_mem_save_ctr502_0;
5818         TALLOC_CTX *_mem_save_ctr1004_0;
5819         TALLOC_CTX *_mem_save_ctr1005_0;
5820         TALLOC_CTX *_mem_save_ctr1006_0;
5821         TALLOC_CTX *_mem_save_ctr1007_0;
5822         TALLOC_CTX *_mem_save_ctr1501_0;
5823         level = ndr_pull_get_switch_value(ndr, r);
5824         if (ndr_flags & NDR_SCALARS) {
5825                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5826                 if (_level != level) {
5827                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5828                 }
5829                 switch (level) {
5830                         case 0: {
5831                                 uint32_t _ptr_ctr0;
5832                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));
5833                                 if (_ptr_ctr0) {
5834                                         NDR_PULL_ALLOC(ndr, r->ctr0);
5835                                 } else {
5836                                         r->ctr0 = NULL;
5837                                 }
5838                         break; }
5839
5840                         case 1: {
5841                                 uint32_t _ptr_ctr1;
5842                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
5843                                 if (_ptr_ctr1) {
5844                                         NDR_PULL_ALLOC(ndr, r->ctr1);
5845                                 } else {
5846                                         r->ctr1 = NULL;
5847                                 }
5848                         break; }
5849
5850                         case 2: {
5851                                 uint32_t _ptr_ctr2;
5852                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr2));
5853                                 if (_ptr_ctr2) {
5854                                         NDR_PULL_ALLOC(ndr, r->ctr2);
5855                                 } else {
5856                                         r->ctr2 = NULL;
5857                                 }
5858                         break; }
5859
5860                         case 501: {
5861                                 uint32_t _ptr_ctr501;
5862                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr501));
5863                                 if (_ptr_ctr501) {
5864                                         NDR_PULL_ALLOC(ndr, r->ctr501);
5865                                 } else {
5866                                         r->ctr501 = NULL;
5867                                 }
5868                         break; }
5869
5870                         case 502: {
5871                                 uint32_t _ptr_ctr502;
5872                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr502));
5873                                 if (_ptr_ctr502) {
5874                                         NDR_PULL_ALLOC(ndr, r->ctr502);
5875                                 } else {
5876                                         r->ctr502 = NULL;
5877                                 }
5878                         break; }
5879
5880                         case 1004: {
5881                                 uint32_t _ptr_ctr1004;
5882                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1004));
5883                                 if (_ptr_ctr1004) {
5884                                         NDR_PULL_ALLOC(ndr, r->ctr1004);
5885                                 } else {
5886                                         r->ctr1004 = NULL;
5887                                 }
5888                         break; }
5889
5890                         case 1005: {
5891                                 uint32_t _ptr_ctr1005;
5892                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1005));
5893                                 if (_ptr_ctr1005) {
5894                                         NDR_PULL_ALLOC(ndr, r->ctr1005);
5895                                 } else {
5896                                         r->ctr1005 = NULL;
5897                                 }
5898                         break; }
5899
5900                         case 1006: {
5901                                 uint32_t _ptr_ctr1006;
5902                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1006));
5903                                 if (_ptr_ctr1006) {
5904                                         NDR_PULL_ALLOC(ndr, r->ctr1006);
5905                                 } else {
5906                                         r->ctr1006 = NULL;
5907                                 }
5908                         break; }
5909
5910                         case 1007: {
5911                                 uint32_t _ptr_ctr1007;
5912                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1007));
5913                                 if (_ptr_ctr1007) {
5914                                         NDR_PULL_ALLOC(ndr, r->ctr1007);
5915                                 } else {
5916                                         r->ctr1007 = NULL;
5917                                 }
5918                         break; }
5919
5920                         case 1501: {
5921                                 uint32_t _ptr_ctr1501;
5922                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1501));
5923                                 if (_ptr_ctr1501) {
5924                                         NDR_PULL_ALLOC(ndr, r->ctr1501);
5925                                 } else {
5926                                         r->ctr1501 = NULL;
5927                                 }
5928                         break; }
5929
5930                         default: {
5931                         break; }
5932
5933                 }
5934         }
5935         if (ndr_flags & NDR_BUFFERS) {
5936                 switch (level) {
5937                         case 0:
5938                                 if (r->ctr0) {
5939                                         _mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);
5940                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr0, 0);
5941                                         NDR_CHECK(ndr_pull_srvsvc_NetShareCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
5942                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);
5943                                 }
5944                         break;
5945
5946                         case 1:
5947                                 if (r->ctr1) {
5948                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5949                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
5950                                         NDR_CHECK(ndr_pull_srvsvc_NetShareCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
5951                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
5952                                 }
5953                         break;
5954
5955                         case 2:
5956                                 if (r->ctr2) {
5957                                         _mem_save_ctr2_0 = NDR_PULL_GET_MEM_CTX(ndr);
5958                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr2, 0);
5959                                         NDR_CHECK(ndr_pull_srvsvc_NetShareCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
5960                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr2_0, 0);
5961                                 }
5962                         break;
5963
5964                         case 501:
5965                                 if (r->ctr501) {
5966                                         _mem_save_ctr501_0 = NDR_PULL_GET_MEM_CTX(ndr);
5967                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr501, 0);
5968                                         NDR_CHECK(ndr_pull_srvsvc_NetShareCtr501(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr501));
5969                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr501_0, 0);
5970                                 }
5971                         break;
5972
5973                         case 502:
5974                                 if (r->ctr502) {
5975                                         _mem_save_ctr502_0 = NDR_PULL_GET_MEM_CTX(ndr);
5976                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr502, 0);
5977                                         NDR_CHECK(ndr_pull_srvsvc_NetShareCtr502(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr502));
5978                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr502_0, 0);
5979                                 }
5980                         break;
5981
5982                         case 1004:
5983                                 if (r->ctr1004) {
5984                                         _mem_save_ctr1004_0 = NDR_PULL_GET_MEM_CTX(ndr);
5985                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1004, 0);
5986                                         NDR_CHECK(ndr_pull_srvsvc_NetShareCtr1004(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1004));
5987                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1004_0, 0);
5988                                 }
5989                         break;
5990
5991                         case 1005:
5992                                 if (r->ctr1005) {
5993                                         _mem_save_ctr1005_0 = NDR_PULL_GET_MEM_CTX(ndr);
5994                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1005, 0);
5995                                         NDR_CHECK(ndr_pull_srvsvc_NetShareCtr1005(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1005));
5996                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1005_0, 0);
5997                                 }
5998                         break;
5999
6000                         case 1006:
6001                                 if (r->ctr1006) {
6002                                         _mem_save_ctr1006_0 = NDR_PULL_GET_MEM_CTX(ndr);
6003                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1006, 0);
6004                                         NDR_CHECK(ndr_pull_srvsvc_NetShareCtr1006(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1006));
6005                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1006_0, 0);
6006                                 }
6007                         break;
6008
6009                         case 1007:
6010                                 if (r->ctr1007) {
6011                                         _mem_save_ctr1007_0 = NDR_PULL_GET_MEM_CTX(ndr);
6012                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1007, 0);
6013                                         NDR_CHECK(ndr_pull_srvsvc_NetShareCtr1007(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1007));
6014                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1007_0, 0);
6015                                 }
6016                         break;
6017
6018                         case 1501:
6019                                 if (r->ctr1501) {
6020                                         _mem_save_ctr1501_0 = NDR_PULL_GET_MEM_CTX(ndr);
6021                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1501, 0);
6022                                         NDR_CHECK(ndr_pull_srvsvc_NetShareCtr1501(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1501));
6023                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1501_0, 0);
6024                                 }
6025                         break;
6026
6027                         default:
6028                         break;
6029
6030                 }
6031         }
6032         return NDR_ERR_SUCCESS;
6033 }
6034
6035 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr(struct ndr_print *ndr, const char *name, const union srvsvc_NetShareCtr *r)
6036 {
6037         int level;
6038         level = ndr_print_get_switch_value(ndr, r);
6039         ndr_print_union(ndr, name, level, "srvsvc_NetShareCtr");
6040         switch (level) {
6041                 case 0:
6042                         ndr_print_ptr(ndr, "ctr0", r->ctr0);
6043                         ndr->depth++;
6044                         if (r->ctr0) {
6045                                 ndr_print_srvsvc_NetShareCtr0(ndr, "ctr0", r->ctr0);
6046                         }
6047                         ndr->depth--;
6048                 break;
6049
6050                 case 1:
6051                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
6052                         ndr->depth++;
6053                         if (r->ctr1) {
6054                                 ndr_print_srvsvc_NetShareCtr1(ndr, "ctr1", r->ctr1);
6055                         }
6056                         ndr->depth--;
6057                 break;
6058
6059                 case 2:
6060                         ndr_print_ptr(ndr, "ctr2", r->ctr2);
6061                         ndr->depth++;
6062                         if (r->ctr2) {
6063                                 ndr_print_srvsvc_NetShareCtr2(ndr, "ctr2", r->ctr2);
6064                         }
6065                         ndr->depth--;
6066                 break;
6067
6068                 case 501:
6069                         ndr_print_ptr(ndr, "ctr501", r->ctr501);
6070                         ndr->depth++;
6071                         if (r->ctr501) {
6072                                 ndr_print_srvsvc_NetShareCtr501(ndr, "ctr501", r->ctr501);
6073                         }
6074                         ndr->depth--;
6075                 break;
6076
6077                 case 502:
6078                         ndr_print_ptr(ndr, "ctr502", r->ctr502);
6079                         ndr->depth++;
6080                         if (r->ctr502) {
6081                                 ndr_print_srvsvc_NetShareCtr502(ndr, "ctr502", r->ctr502);
6082                         }
6083                         ndr->depth--;
6084                 break;
6085
6086                 case 1004:
6087                         ndr_print_ptr(ndr, "ctr1004", r->ctr1004);
6088                         ndr->depth++;
6089                         if (r->ctr1004) {
6090                                 ndr_print_srvsvc_NetShareCtr1004(ndr, "ctr1004", r->ctr1004);
6091                         }
6092                         ndr->depth--;
6093                 break;
6094
6095                 case 1005:
6096                         ndr_print_ptr(ndr, "ctr1005", r->ctr1005);
6097                         ndr->depth++;
6098                         if (r->ctr1005) {
6099                                 ndr_print_srvsvc_NetShareCtr1005(ndr, "ctr1005", r->ctr1005);
6100                         }
6101                         ndr->depth--;
6102                 break;
6103
6104                 case 1006:
6105                         ndr_print_ptr(ndr, "ctr1006", r->ctr1006);
6106                         ndr->depth++;
6107                         if (r->ctr1006) {
6108                                 ndr_print_srvsvc_NetShareCtr1006(ndr, "ctr1006", r->ctr1006);
6109                         }
6110                         ndr->depth--;
6111                 break;
6112
6113                 case 1007:
6114                         ndr_print_ptr(ndr, "ctr1007", r->ctr1007);
6115                         ndr->depth++;
6116                         if (r->ctr1007) {
6117                                 ndr_print_srvsvc_NetShareCtr1007(ndr, "ctr1007", r->ctr1007);
6118                         }
6119                         ndr->depth--;
6120                 break;
6121
6122                 case 1501:
6123                         ndr_print_ptr(ndr, "ctr1501", r->ctr1501);
6124                         ndr->depth++;
6125                         if (r->ctr1501) {
6126                                 ndr_print_srvsvc_NetShareCtr1501(ndr, "ctr1501", r->ctr1501);
6127                         }
6128                         ndr->depth--;
6129                 break;
6130
6131                 default:
6132                 break;
6133
6134         }
6135 }
6136
6137 static enum ndr_err_code ndr_push_srvsvc_NetShareInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfoCtr *r)
6138 {
6139         if (ndr_flags & NDR_SCALARS) {
6140                 NDR_CHECK(ndr_push_align(ndr, 4));
6141                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
6142                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
6143                 NDR_CHECK(ndr_push_srvsvc_NetShareCtr(ndr, NDR_SCALARS, &r->ctr));
6144         }
6145         if (ndr_flags & NDR_BUFFERS) {
6146                 NDR_CHECK(ndr_push_srvsvc_NetShareCtr(ndr, NDR_BUFFERS, &r->ctr));
6147         }
6148         return NDR_ERR_SUCCESS;
6149 }
6150
6151 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfoCtr *r)
6152 {
6153         if (ndr_flags & NDR_SCALARS) {
6154                 NDR_CHECK(ndr_pull_align(ndr, 4));
6155                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
6156                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
6157                 NDR_CHECK(ndr_pull_srvsvc_NetShareCtr(ndr, NDR_SCALARS, &r->ctr));
6158         }
6159         if (ndr_flags & NDR_BUFFERS) {
6160                 NDR_CHECK(ndr_pull_srvsvc_NetShareCtr(ndr, NDR_BUFFERS, &r->ctr));
6161         }
6162         return NDR_ERR_SUCCESS;
6163 }
6164
6165 _PUBLIC_ void ndr_print_srvsvc_NetShareInfoCtr(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfoCtr *r)
6166 {
6167         ndr_print_struct(ndr, name, "srvsvc_NetShareInfoCtr");
6168         ndr->depth++;
6169         ndr_print_uint32(ndr, "level", r->level);
6170         ndr_print_set_switch_value(ndr, &r->ctr, r->level);
6171         ndr_print_srvsvc_NetShareCtr(ndr, "ctr", &r->ctr);
6172         ndr->depth--;
6173 }
6174
6175 _PUBLIC_ enum ndr_err_code ndr_push_srvsvc_PlatformId(struct ndr_push *ndr, int ndr_flags, enum srvsvc_PlatformId r)
6176 {
6177         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
6178         return NDR_ERR_SUCCESS;
6179 }
6180
6181 _PUBLIC_ enum ndr_err_code ndr_pull_srvsvc_PlatformId(struct ndr_pull *ndr, int ndr_flags, enum srvsvc_PlatformId *r)
6182 {
6183         uint32_t v;
6184         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
6185         *r = v;
6186         return NDR_ERR_SUCCESS;
6187 }
6188
6189 _PUBLIC_ void ndr_print_srvsvc_PlatformId(struct ndr_print *ndr, const char *name, enum srvsvc_PlatformId r)
6190 {
6191         const char *val = NULL;
6192
6193         switch (r) {
6194                 case PLATFORM_ID_DOS: val = "PLATFORM_ID_DOS"; break;
6195                 case PLATFORM_ID_OS2: val = "PLATFORM_ID_OS2"; break;
6196                 case PLATFORM_ID_NT: val = "PLATFORM_ID_NT"; break;
6197                 case PLATFORM_ID_OSF: val = "PLATFORM_ID_OSF"; break;
6198                 case PLATFORM_ID_VMS: val = "PLATFORM_ID_VMS"; break;
6199         }
6200         ndr_print_enum(ndr, name, "ENUM", val, r);
6201 }
6202
6203 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo100(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo100 *r)
6204 {
6205         if (ndr_flags & NDR_SCALARS) {
6206                 NDR_CHECK(ndr_push_align(ndr, 4));
6207                 NDR_CHECK(ndr_push_srvsvc_PlatformId(ndr, NDR_SCALARS, r->platform_id));
6208                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
6209         }
6210         if (ndr_flags & NDR_BUFFERS) {
6211                 if (r->server_name) {
6212                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
6213                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6214                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
6215                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6216                 }
6217         }
6218         return NDR_ERR_SUCCESS;
6219 }
6220
6221 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo100(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo100 *r)
6222 {
6223         uint32_t _ptr_server_name;
6224         TALLOC_CTX *_mem_save_server_name_0;
6225         if (ndr_flags & NDR_SCALARS) {
6226                 NDR_CHECK(ndr_pull_align(ndr, 4));
6227                 NDR_CHECK(ndr_pull_srvsvc_PlatformId(ndr, NDR_SCALARS, &r->platform_id));
6228                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6229                 if (_ptr_server_name) {
6230                         NDR_PULL_ALLOC(ndr, r->server_name);
6231                 } else {
6232                         r->server_name = NULL;
6233                 }
6234         }
6235         if (ndr_flags & NDR_BUFFERS) {
6236                 if (r->server_name) {
6237                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6238                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
6239                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
6240                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
6241                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
6242                                 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));
6243                         }
6244                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
6245                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
6246                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6247                 }
6248         }
6249         return NDR_ERR_SUCCESS;
6250 }
6251
6252 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo100(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo100 *r)
6253 {
6254         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo100");
6255         ndr->depth++;
6256         ndr_print_srvsvc_PlatformId(ndr, "platform_id", r->platform_id);
6257         ndr_print_ptr(ndr, "server_name", r->server_name);
6258         ndr->depth++;
6259         if (r->server_name) {
6260                 ndr_print_string(ndr, "server_name", r->server_name);
6261         }
6262         ndr->depth--;
6263         ndr->depth--;
6264 }
6265
6266 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo101(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo101 *r)
6267 {
6268         if (ndr_flags & NDR_SCALARS) {
6269                 NDR_CHECK(ndr_push_align(ndr, 4));
6270                 NDR_CHECK(ndr_push_srvsvc_PlatformId(ndr, NDR_SCALARS, r->platform_id));
6271                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
6272                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_major));
6273                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_minor));
6274                 NDR_CHECK(ndr_push_svcctl_ServerType(ndr, NDR_SCALARS, r->server_type));
6275                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6276         }
6277         if (ndr_flags & NDR_BUFFERS) {
6278                 if (r->server_name) {
6279                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
6280                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6281                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
6282                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6283                 }
6284                 if (r->comment) {
6285                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6286                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6287                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6288                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6289                 }
6290         }
6291         return NDR_ERR_SUCCESS;
6292 }
6293
6294 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo101(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo101 *r)
6295 {
6296         uint32_t _ptr_server_name;
6297         TALLOC_CTX *_mem_save_server_name_0;
6298         uint32_t _ptr_comment;
6299         TALLOC_CTX *_mem_save_comment_0;
6300         if (ndr_flags & NDR_SCALARS) {
6301                 NDR_CHECK(ndr_pull_align(ndr, 4));
6302                 NDR_CHECK(ndr_pull_srvsvc_PlatformId(ndr, NDR_SCALARS, &r->platform_id));
6303                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6304                 if (_ptr_server_name) {
6305                         NDR_PULL_ALLOC(ndr, r->server_name);
6306                 } else {
6307                         r->server_name = NULL;
6308                 }
6309                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_major));
6310                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_minor));
6311                 NDR_CHECK(ndr_pull_svcctl_ServerType(ndr, NDR_SCALARS, &r->server_type));
6312                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6313                 if (_ptr_comment) {
6314                         NDR_PULL_ALLOC(ndr, r->comment);
6315                 } else {
6316                         r->comment = NULL;
6317                 }
6318         }
6319         if (ndr_flags & NDR_BUFFERS) {
6320                 if (r->server_name) {
6321                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6322                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
6323                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
6324                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
6325                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
6326                                 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));
6327                         }
6328                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
6329                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
6330                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6331                 }
6332                 if (r->comment) {
6333                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6334                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6335                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6336                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6337                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6338                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
6339                         }
6340                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6341                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6342                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6343                 }
6344         }
6345         return NDR_ERR_SUCCESS;
6346 }
6347
6348 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo101(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo101 *r)
6349 {
6350         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo101");
6351         ndr->depth++;
6352         ndr_print_srvsvc_PlatformId(ndr, "platform_id", r->platform_id);
6353         ndr_print_ptr(ndr, "server_name", r->server_name);
6354         ndr->depth++;
6355         if (r->server_name) {
6356                 ndr_print_string(ndr, "server_name", r->server_name);
6357         }
6358         ndr->depth--;
6359         ndr_print_uint32(ndr, "version_major", r->version_major);
6360         ndr_print_uint32(ndr, "version_minor", r->version_minor);
6361         ndr_print_svcctl_ServerType(ndr, "server_type", r->server_type);
6362         ndr_print_ptr(ndr, "comment", r->comment);
6363         ndr->depth++;
6364         if (r->comment) {
6365                 ndr_print_string(ndr, "comment", r->comment);
6366         }
6367         ndr->depth--;
6368         ndr->depth--;
6369 }
6370
6371 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo102(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo102 *r)
6372 {
6373         if (ndr_flags & NDR_SCALARS) {
6374                 NDR_CHECK(ndr_push_align(ndr, 4));
6375                 NDR_CHECK(ndr_push_srvsvc_PlatformId(ndr, NDR_SCALARS, r->platform_id));
6376                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
6377                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_major));
6378                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_minor));
6379                 NDR_CHECK(ndr_push_svcctl_ServerType(ndr, NDR_SCALARS, r->server_type));
6380                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6381                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->users));
6382                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->disc));
6383                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->hidden));
6384                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->announce));
6385                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->anndelta));
6386                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->licenses));
6387                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->userpath));
6388         }
6389         if (ndr_flags & NDR_BUFFERS) {
6390                 if (r->server_name) {
6391                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
6392                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6393                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
6394                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6395                 }
6396                 if (r->comment) {
6397                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6398                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6399                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6400                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6401                 }
6402                 if (r->userpath) {
6403                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->userpath, CH_UTF16)));
6404                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6405                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->userpath, CH_UTF16)));
6406                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->userpath, ndr_charset_length(r->userpath, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6407                 }
6408         }
6409         return NDR_ERR_SUCCESS;
6410 }
6411
6412 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo102(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo102 *r)
6413 {
6414         uint32_t _ptr_server_name;
6415         TALLOC_CTX *_mem_save_server_name_0;
6416         uint32_t _ptr_comment;
6417         TALLOC_CTX *_mem_save_comment_0;
6418         uint32_t _ptr_userpath;
6419         TALLOC_CTX *_mem_save_userpath_0;
6420         if (ndr_flags & NDR_SCALARS) {
6421                 NDR_CHECK(ndr_pull_align(ndr, 4));
6422                 NDR_CHECK(ndr_pull_srvsvc_PlatformId(ndr, NDR_SCALARS, &r->platform_id));
6423                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6424                 if (_ptr_server_name) {
6425                         NDR_PULL_ALLOC(ndr, r->server_name);
6426                 } else {
6427                         r->server_name = NULL;
6428                 }
6429                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_major));
6430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_minor));
6431                 NDR_CHECK(ndr_pull_svcctl_ServerType(ndr, NDR_SCALARS, &r->server_type));
6432                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6433                 if (_ptr_comment) {
6434                         NDR_PULL_ALLOC(ndr, r->comment);
6435                 } else {
6436                         r->comment = NULL;
6437                 }
6438                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->users));
6439                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->disc));
6440                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->hidden));
6441                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->announce));
6442                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->anndelta));
6443                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->licenses));
6444                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_userpath));
6445                 if (_ptr_userpath) {
6446                         NDR_PULL_ALLOC(ndr, r->userpath);
6447                 } else {
6448                         r->userpath = NULL;
6449                 }
6450         }
6451         if (ndr_flags & NDR_BUFFERS) {
6452                 if (r->server_name) {
6453                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6454                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
6455                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
6456                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
6457                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
6458                                 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));
6459                         }
6460                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
6461                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
6462                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6463                 }
6464                 if (r->comment) {
6465                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6466                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6467                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6468                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6469                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6470                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
6471                         }
6472                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6473                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6474                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6475                 }
6476                 if (r->userpath) {
6477                         _mem_save_userpath_0 = NDR_PULL_GET_MEM_CTX(ndr);
6478                         NDR_PULL_SET_MEM_CTX(ndr, r->userpath, 0);
6479                         NDR_CHECK(ndr_pull_array_size(ndr, &r->userpath));
6480                         NDR_CHECK(ndr_pull_array_length(ndr, &r->userpath));
6481                         if (ndr_get_array_length(ndr, &r->userpath) > ndr_get_array_size(ndr, &r->userpath)) {
6482                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->userpath), ndr_get_array_length(ndr, &r->userpath));
6483                         }
6484                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->userpath), sizeof(uint16_t)));
6485                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->userpath, ndr_get_array_length(ndr, &r->userpath), sizeof(uint16_t), CH_UTF16));
6486                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userpath_0, 0);
6487                 }
6488         }
6489         return NDR_ERR_SUCCESS;
6490 }
6491
6492 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo102(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo102 *r)
6493 {
6494         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo102");
6495         ndr->depth++;
6496         ndr_print_srvsvc_PlatformId(ndr, "platform_id", r->platform_id);
6497         ndr_print_ptr(ndr, "server_name", r->server_name);
6498         ndr->depth++;
6499         if (r->server_name) {
6500                 ndr_print_string(ndr, "server_name", r->server_name);
6501         }
6502         ndr->depth--;
6503         ndr_print_uint32(ndr, "version_major", r->version_major);
6504         ndr_print_uint32(ndr, "version_minor", r->version_minor);
6505         ndr_print_svcctl_ServerType(ndr, "server_type", r->server_type);
6506         ndr_print_ptr(ndr, "comment", r->comment);
6507         ndr->depth++;
6508         if (r->comment) {
6509                 ndr_print_string(ndr, "comment", r->comment);
6510         }
6511         ndr->depth--;
6512         ndr_print_uint32(ndr, "users", r->users);
6513         ndr_print_uint32(ndr, "disc", r->disc);
6514         ndr_print_uint32(ndr, "hidden", r->hidden);
6515         ndr_print_uint32(ndr, "announce", r->announce);
6516         ndr_print_uint32(ndr, "anndelta", r->anndelta);
6517         ndr_print_uint32(ndr, "licenses", r->licenses);
6518         ndr_print_ptr(ndr, "userpath", r->userpath);
6519         ndr->depth++;
6520         if (r->userpath) {
6521                 ndr_print_string(ndr, "userpath", r->userpath);
6522         }
6523         ndr->depth--;
6524         ndr->depth--;
6525 }
6526
6527 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo402(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo402 *r)
6528 {
6529         if (ndr_flags & NDR_SCALARS) {
6530                 NDR_CHECK(ndr_push_align(ndr, 4));
6531                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ulist_mtime));
6532                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->glist_mtime));
6533                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alist_mtime));
6534                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->alerts));
6535                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->security));
6536                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numadmin));
6537                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lanmask));
6538                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guestaccount));
6539                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->chdevs));
6540                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->chdevqs));
6541                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->chdevjobs));
6542                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->connections));
6543                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->shares));
6544                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->openfiles));
6545                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessopen));
6546                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sesssvc));
6547                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessreqs));
6548                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->opensearch));
6549                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->activelocks));
6550                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sizereqbufs));
6551                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numbigbufs));
6552                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numfiletasks));
6553                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alertsched));
6554                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->erroralert));
6555                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->logonalert));
6556                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->accessalert));
6557                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->diskalert));
6558                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->netioalert));
6559                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxaudits));
6560                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->srvheuristics));
6561         }
6562         if (ndr_flags & NDR_BUFFERS) {
6563                 if (r->alerts) {
6564                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->alerts, CH_UTF16)));
6565                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6566                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->alerts, CH_UTF16)));
6567                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->alerts, ndr_charset_length(r->alerts, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6568                 }
6569                 if (r->guestaccount) {
6570                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guestaccount, CH_UTF16)));
6571                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6572                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guestaccount, CH_UTF16)));
6573                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guestaccount, ndr_charset_length(r->guestaccount, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6574                 }
6575                 if (r->srvheuristics) {
6576                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->srvheuristics, CH_UTF16)));
6577                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6578                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->srvheuristics, CH_UTF16)));
6579                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->srvheuristics, ndr_charset_length(r->srvheuristics, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6580                 }
6581         }
6582         return NDR_ERR_SUCCESS;
6583 }
6584
6585 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo402(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo402 *r)
6586 {
6587         uint32_t _ptr_alerts;
6588         TALLOC_CTX *_mem_save_alerts_0;
6589         uint32_t _ptr_guestaccount;
6590         TALLOC_CTX *_mem_save_guestaccount_0;
6591         uint32_t _ptr_srvheuristics;
6592         TALLOC_CTX *_mem_save_srvheuristics_0;
6593         if (ndr_flags & NDR_SCALARS) {
6594                 NDR_CHECK(ndr_pull_align(ndr, 4));
6595                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ulist_mtime));
6596                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->glist_mtime));
6597                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alist_mtime));
6598                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_alerts));
6599                 if (_ptr_alerts) {
6600                         NDR_PULL_ALLOC(ndr, r->alerts);
6601                 } else {
6602                         r->alerts = NULL;
6603                 }
6604                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->security));
6605                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numadmin));
6606                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lanmask));
6607                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guestaccount));
6608                 if (_ptr_guestaccount) {
6609                         NDR_PULL_ALLOC(ndr, r->guestaccount);
6610                 } else {
6611                         r->guestaccount = NULL;
6612                 }
6613                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->chdevs));
6614                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->chdevqs));
6615                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->chdevjobs));
6616                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->connections));
6617                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->shares));
6618                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->openfiles));
6619                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessopen));
6620                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sesssvc));
6621                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessreqs));
6622                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->opensearch));
6623                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->activelocks));
6624                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sizereqbufs));
6625                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numbigbufs));
6626                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numfiletasks));
6627                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alertsched));
6628                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->erroralert));
6629                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->logonalert));
6630                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->accessalert));
6631                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->diskalert));
6632                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->netioalert));
6633                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxaudits));
6634                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_srvheuristics));
6635                 if (_ptr_srvheuristics) {
6636                         NDR_PULL_ALLOC(ndr, r->srvheuristics);
6637                 } else {
6638                         r->srvheuristics = NULL;
6639                 }
6640         }
6641         if (ndr_flags & NDR_BUFFERS) {
6642                 if (r->alerts) {
6643                         _mem_save_alerts_0 = NDR_PULL_GET_MEM_CTX(ndr);
6644                         NDR_PULL_SET_MEM_CTX(ndr, r->alerts, 0);
6645                         NDR_CHECK(ndr_pull_array_size(ndr, &r->alerts));
6646                         NDR_CHECK(ndr_pull_array_length(ndr, &r->alerts));
6647                         if (ndr_get_array_length(ndr, &r->alerts) > ndr_get_array_size(ndr, &r->alerts)) {
6648                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->alerts), ndr_get_array_length(ndr, &r->alerts));
6649                         }
6650                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->alerts), sizeof(uint16_t)));
6651                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->alerts, ndr_get_array_length(ndr, &r->alerts), sizeof(uint16_t), CH_UTF16));
6652                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alerts_0, 0);
6653                 }
6654                 if (r->guestaccount) {
6655                         _mem_save_guestaccount_0 = NDR_PULL_GET_MEM_CTX(ndr);
6656                         NDR_PULL_SET_MEM_CTX(ndr, r->guestaccount, 0);
6657                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guestaccount));
6658                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guestaccount));
6659                         if (ndr_get_array_length(ndr, &r->guestaccount) > ndr_get_array_size(ndr, &r->guestaccount)) {
6660                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->guestaccount), ndr_get_array_length(ndr, &r->guestaccount));
6661                         }
6662                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guestaccount), sizeof(uint16_t)));
6663                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guestaccount, ndr_get_array_length(ndr, &r->guestaccount), sizeof(uint16_t), CH_UTF16));
6664                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guestaccount_0, 0);
6665                 }
6666                 if (r->srvheuristics) {
6667                         _mem_save_srvheuristics_0 = NDR_PULL_GET_MEM_CTX(ndr);
6668                         NDR_PULL_SET_MEM_CTX(ndr, r->srvheuristics, 0);
6669                         NDR_CHECK(ndr_pull_array_size(ndr, &r->srvheuristics));
6670                         NDR_CHECK(ndr_pull_array_length(ndr, &r->srvheuristics));
6671                         if (ndr_get_array_length(ndr, &r->srvheuristics) > ndr_get_array_size(ndr, &r->srvheuristics)) {
6672                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->srvheuristics), ndr_get_array_length(ndr, &r->srvheuristics));
6673                         }
6674                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->srvheuristics), sizeof(uint16_t)));
6675                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->srvheuristics, ndr_get_array_length(ndr, &r->srvheuristics), sizeof(uint16_t), CH_UTF16));
6676                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_srvheuristics_0, 0);
6677                 }
6678         }
6679         return NDR_ERR_SUCCESS;
6680 }
6681
6682 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo402(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo402 *r)
6683 {
6684         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo402");
6685         ndr->depth++;
6686         ndr_print_uint32(ndr, "ulist_mtime", r->ulist_mtime);
6687         ndr_print_uint32(ndr, "glist_mtime", r->glist_mtime);
6688         ndr_print_uint32(ndr, "alist_mtime", r->alist_mtime);
6689         ndr_print_ptr(ndr, "alerts", r->alerts);
6690         ndr->depth++;
6691         if (r->alerts) {
6692                 ndr_print_string(ndr, "alerts", r->alerts);
6693         }
6694         ndr->depth--;
6695         ndr_print_uint32(ndr, "security", r->security);
6696         ndr_print_uint32(ndr, "numadmin", r->numadmin);
6697         ndr_print_uint32(ndr, "lanmask", r->lanmask);
6698         ndr_print_ptr(ndr, "guestaccount", r->guestaccount);
6699         ndr->depth++;
6700         if (r->guestaccount) {
6701                 ndr_print_string(ndr, "guestaccount", r->guestaccount);
6702         }
6703         ndr->depth--;
6704         ndr_print_uint32(ndr, "chdevs", r->chdevs);
6705         ndr_print_uint32(ndr, "chdevqs", r->chdevqs);
6706         ndr_print_uint32(ndr, "chdevjobs", r->chdevjobs);
6707         ndr_print_uint32(ndr, "connections", r->connections);
6708         ndr_print_uint32(ndr, "shares", r->shares);
6709         ndr_print_uint32(ndr, "openfiles", r->openfiles);
6710         ndr_print_uint32(ndr, "sessopen", r->sessopen);
6711         ndr_print_uint32(ndr, "sesssvc", r->sesssvc);
6712         ndr_print_uint32(ndr, "sessreqs", r->sessreqs);
6713         ndr_print_uint32(ndr, "opensearch", r->opensearch);
6714         ndr_print_uint32(ndr, "activelocks", r->activelocks);
6715         ndr_print_uint32(ndr, "sizereqbufs", r->sizereqbufs);
6716         ndr_print_uint32(ndr, "numbigbufs", r->numbigbufs);
6717         ndr_print_uint32(ndr, "numfiletasks", r->numfiletasks);
6718         ndr_print_uint32(ndr, "alertsched", r->alertsched);
6719         ndr_print_uint32(ndr, "erroralert", r->erroralert);
6720         ndr_print_uint32(ndr, "logonalert", r->logonalert);
6721         ndr_print_uint32(ndr, "accessalert", r->accessalert);
6722         ndr_print_uint32(ndr, "diskalert", r->diskalert);
6723         ndr_print_uint32(ndr, "netioalert", r->netioalert);
6724         ndr_print_uint32(ndr, "maxaudits", r->maxaudits);
6725         ndr_print_ptr(ndr, "srvheuristics", r->srvheuristics);
6726         ndr->depth++;
6727         if (r->srvheuristics) {
6728                 ndr_print_string(ndr, "srvheuristics", r->srvheuristics);
6729         }
6730         ndr->depth--;
6731         ndr->depth--;
6732 }
6733
6734 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo403(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo403 *r)
6735 {
6736         if (ndr_flags & NDR_SCALARS) {
6737                 NDR_CHECK(ndr_push_align(ndr, 4));
6738                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ulist_mtime));
6739                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->glist_mtime));
6740                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alist_mtime));
6741                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->alerts));
6742                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->security));
6743                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numadmin));
6744                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lanmask));
6745                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guestaccount));
6746                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->chdevs));
6747                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->chdevqs));
6748                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->chdevjobs));
6749                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->connections));
6750                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->shares));
6751                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->openfiles));
6752                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessopen));
6753                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sesssvc));
6754                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessreqs));
6755                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->opensearch));
6756                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->activelocks));
6757                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sizereqbufs));
6758                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numbigbufs));
6759                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numfiletasks));
6760                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alertsched));
6761                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->eroralert));
6762                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->logonalert));
6763                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->accessalert));
6764                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->diskalert));
6765                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->netioalert));
6766                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxaudits));
6767                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->srvheuristics));
6768                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->auditedevents));
6769                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->auditprofile));
6770                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->autopath));
6771         }
6772         if (ndr_flags & NDR_BUFFERS) {
6773                 if (r->alerts) {
6774                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->alerts, CH_UTF16)));
6775                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6776                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->alerts, CH_UTF16)));
6777                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->alerts, ndr_charset_length(r->alerts, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6778                 }
6779                 if (r->guestaccount) {
6780                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guestaccount, CH_UTF16)));
6781                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6782                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guestaccount, CH_UTF16)));
6783                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guestaccount, ndr_charset_length(r->guestaccount, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6784                 }
6785                 if (r->srvheuristics) {
6786                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->srvheuristics, CH_UTF16)));
6787                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6788                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->srvheuristics, CH_UTF16)));
6789                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->srvheuristics, ndr_charset_length(r->srvheuristics, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6790                 }
6791                 if (r->autopath) {
6792                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->autopath, CH_UTF16)));
6793                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6794                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->autopath, CH_UTF16)));
6795                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->autopath, ndr_charset_length(r->autopath, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6796                 }
6797         }
6798         return NDR_ERR_SUCCESS;
6799 }
6800
6801 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo403(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo403 *r)
6802 {
6803         uint32_t _ptr_alerts;
6804         TALLOC_CTX *_mem_save_alerts_0;
6805         uint32_t _ptr_guestaccount;
6806         TALLOC_CTX *_mem_save_guestaccount_0;
6807         uint32_t _ptr_srvheuristics;
6808         TALLOC_CTX *_mem_save_srvheuristics_0;
6809         uint32_t _ptr_autopath;
6810         TALLOC_CTX *_mem_save_autopath_0;
6811         if (ndr_flags & NDR_SCALARS) {
6812                 NDR_CHECK(ndr_pull_align(ndr, 4));
6813                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ulist_mtime));
6814                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->glist_mtime));
6815                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alist_mtime));
6816                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_alerts));
6817                 if (_ptr_alerts) {
6818                         NDR_PULL_ALLOC(ndr, r->alerts);
6819                 } else {
6820                         r->alerts = NULL;
6821                 }
6822                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->security));
6823                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numadmin));
6824                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lanmask));
6825                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guestaccount));
6826                 if (_ptr_guestaccount) {
6827                         NDR_PULL_ALLOC(ndr, r->guestaccount);
6828                 } else {
6829                         r->guestaccount = NULL;
6830                 }
6831                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->chdevs));
6832                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->chdevqs));
6833                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->chdevjobs));
6834                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->connections));
6835                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->shares));
6836                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->openfiles));
6837                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessopen));
6838                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sesssvc));
6839                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessreqs));
6840                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->opensearch));
6841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->activelocks));
6842                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sizereqbufs));
6843                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numbigbufs));
6844                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numfiletasks));
6845                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alertsched));
6846                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->eroralert));
6847                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->logonalert));
6848                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->accessalert));
6849                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->diskalert));
6850                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->netioalert));
6851                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxaudits));
6852                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_srvheuristics));
6853                 if (_ptr_srvheuristics) {
6854                         NDR_PULL_ALLOC(ndr, r->srvheuristics);
6855                 } else {
6856                         r->srvheuristics = NULL;
6857                 }
6858                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->auditedevents));
6859                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->auditprofile));
6860                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_autopath));
6861                 if (_ptr_autopath) {
6862                         NDR_PULL_ALLOC(ndr, r->autopath);
6863                 } else {
6864                         r->autopath = NULL;
6865                 }
6866         }
6867         if (ndr_flags & NDR_BUFFERS) {
6868                 if (r->alerts) {
6869                         _mem_save_alerts_0 = NDR_PULL_GET_MEM_CTX(ndr);
6870                         NDR_PULL_SET_MEM_CTX(ndr, r->alerts, 0);
6871                         NDR_CHECK(ndr_pull_array_size(ndr, &r->alerts));
6872                         NDR_CHECK(ndr_pull_array_length(ndr, &r->alerts));
6873                         if (ndr_get_array_length(ndr, &r->alerts) > ndr_get_array_size(ndr, &r->alerts)) {
6874                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->alerts), ndr_get_array_length(ndr, &r->alerts));
6875                         }
6876                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->alerts), sizeof(uint16_t)));
6877                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->alerts, ndr_get_array_length(ndr, &r->alerts), sizeof(uint16_t), CH_UTF16));
6878                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alerts_0, 0);
6879                 }
6880                 if (r->guestaccount) {
6881                         _mem_save_guestaccount_0 = NDR_PULL_GET_MEM_CTX(ndr);
6882                         NDR_PULL_SET_MEM_CTX(ndr, r->guestaccount, 0);
6883                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guestaccount));
6884                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guestaccount));
6885                         if (ndr_get_array_length(ndr, &r->guestaccount) > ndr_get_array_size(ndr, &r->guestaccount)) {
6886                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->guestaccount), ndr_get_array_length(ndr, &r->guestaccount));
6887                         }
6888                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guestaccount), sizeof(uint16_t)));
6889                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guestaccount, ndr_get_array_length(ndr, &r->guestaccount), sizeof(uint16_t), CH_UTF16));
6890                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guestaccount_0, 0);
6891                 }
6892                 if (r->srvheuristics) {
6893                         _mem_save_srvheuristics_0 = NDR_PULL_GET_MEM_CTX(ndr);
6894                         NDR_PULL_SET_MEM_CTX(ndr, r->srvheuristics, 0);
6895                         NDR_CHECK(ndr_pull_array_size(ndr, &r->srvheuristics));
6896                         NDR_CHECK(ndr_pull_array_length(ndr, &r->srvheuristics));
6897                         if (ndr_get_array_length(ndr, &r->srvheuristics) > ndr_get_array_size(ndr, &r->srvheuristics)) {
6898                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->srvheuristics), ndr_get_array_length(ndr, &r->srvheuristics));
6899                         }
6900                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->srvheuristics), sizeof(uint16_t)));
6901                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->srvheuristics, ndr_get_array_length(ndr, &r->srvheuristics), sizeof(uint16_t), CH_UTF16));
6902                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_srvheuristics_0, 0);
6903                 }
6904                 if (r->autopath) {
6905                         _mem_save_autopath_0 = NDR_PULL_GET_MEM_CTX(ndr);
6906                         NDR_PULL_SET_MEM_CTX(ndr, r->autopath, 0);
6907                         NDR_CHECK(ndr_pull_array_size(ndr, &r->autopath));
6908                         NDR_CHECK(ndr_pull_array_length(ndr, &r->autopath));
6909                         if (ndr_get_array_length(ndr, &r->autopath) > ndr_get_array_size(ndr, &r->autopath)) {
6910                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->autopath), ndr_get_array_length(ndr, &r->autopath));
6911                         }
6912                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->autopath), sizeof(uint16_t)));
6913                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->autopath, ndr_get_array_length(ndr, &r->autopath), sizeof(uint16_t), CH_UTF16));
6914                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_autopath_0, 0);
6915                 }
6916         }
6917         return NDR_ERR_SUCCESS;
6918 }
6919
6920 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo403(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo403 *r)
6921 {
6922         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo403");
6923         ndr->depth++;
6924         ndr_print_uint32(ndr, "ulist_mtime", r->ulist_mtime);
6925         ndr_print_uint32(ndr, "glist_mtime", r->glist_mtime);
6926         ndr_print_uint32(ndr, "alist_mtime", r->alist_mtime);
6927         ndr_print_ptr(ndr, "alerts", r->alerts);
6928         ndr->depth++;
6929         if (r->alerts) {
6930                 ndr_print_string(ndr, "alerts", r->alerts);
6931         }
6932         ndr->depth--;
6933         ndr_print_uint32(ndr, "security", r->security);
6934         ndr_print_uint32(ndr, "numadmin", r->numadmin);
6935         ndr_print_uint32(ndr, "lanmask", r->lanmask);
6936         ndr_print_ptr(ndr, "guestaccount", r->guestaccount);
6937         ndr->depth++;
6938         if (r->guestaccount) {
6939                 ndr_print_string(ndr, "guestaccount", r->guestaccount);
6940         }
6941         ndr->depth--;
6942         ndr_print_uint32(ndr, "chdevs", r->chdevs);
6943         ndr_print_uint32(ndr, "chdevqs", r->chdevqs);
6944         ndr_print_uint32(ndr, "chdevjobs", r->chdevjobs);
6945         ndr_print_uint32(ndr, "connections", r->connections);
6946         ndr_print_uint32(ndr, "shares", r->shares);
6947         ndr_print_uint32(ndr, "openfiles", r->openfiles);
6948         ndr_print_uint32(ndr, "sessopen", r->sessopen);
6949         ndr_print_uint32(ndr, "sesssvc", r->sesssvc);
6950         ndr_print_uint32(ndr, "sessreqs", r->sessreqs);
6951         ndr_print_uint32(ndr, "opensearch", r->opensearch);
6952         ndr_print_uint32(ndr, "activelocks", r->activelocks);
6953         ndr_print_uint32(ndr, "sizereqbufs", r->sizereqbufs);
6954         ndr_print_uint32(ndr, "numbigbufs", r->numbigbufs);
6955         ndr_print_uint32(ndr, "numfiletasks", r->numfiletasks);
6956         ndr_print_uint32(ndr, "alertsched", r->alertsched);
6957         ndr_print_uint32(ndr, "eroralert", r->eroralert);
6958         ndr_print_uint32(ndr, "logonalert", r->logonalert);
6959         ndr_print_uint32(ndr, "accessalert", r->accessalert);
6960         ndr_print_uint32(ndr, "diskalert", r->diskalert);
6961         ndr_print_uint32(ndr, "netioalert", r->netioalert);
6962         ndr_print_uint32(ndr, "maxaudits", r->maxaudits);
6963         ndr_print_ptr(ndr, "srvheuristics", r->srvheuristics);
6964         ndr->depth++;
6965         if (r->srvheuristics) {
6966                 ndr_print_string(ndr, "srvheuristics", r->srvheuristics);
6967         }
6968         ndr->depth--;
6969         ndr_print_uint32(ndr, "auditedevents", r->auditedevents);
6970         ndr_print_uint32(ndr, "auditprofile", r->auditprofile);
6971         ndr_print_ptr(ndr, "autopath", r->autopath);
6972         ndr->depth++;
6973         if (r->autopath) {
6974                 ndr_print_string(ndr, "autopath", r->autopath);
6975         }
6976         ndr->depth--;
6977         ndr->depth--;
6978 }
6979
6980 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo502(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo502 *r)
6981 {
6982         if (ndr_flags & NDR_SCALARS) {
6983                 NDR_CHECK(ndr_push_align(ndr, 4));
6984                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessopen));
6985                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sesssvc));
6986                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->opensearch));
6987                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sizereqbufs));
6988                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initworkitems));
6989                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxworkitems));
6990                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rawworkitems));
6991                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->irpstacksize));
6992                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxrawbuflen));
6993                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessusers));
6994                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessconns));
6995                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxpagedmemoryusage));
6996                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxnonpagedmemoryusage));
6997                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablesoftcompat));
6998                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableforcedlogoff));
6999                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->timesource));
7000                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->acceptdownlevelapis));
7001                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lmannounce));
7002         }
7003         if (ndr_flags & NDR_BUFFERS) {
7004         }
7005         return NDR_ERR_SUCCESS;
7006 }
7007
7008 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo502(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo502 *r)
7009 {
7010         if (ndr_flags & NDR_SCALARS) {
7011                 NDR_CHECK(ndr_pull_align(ndr, 4));
7012                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessopen));
7013                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sesssvc));
7014                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->opensearch));
7015                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sizereqbufs));
7016                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initworkitems));
7017                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxworkitems));
7018                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rawworkitems));
7019                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->irpstacksize));
7020                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxrawbuflen));
7021                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessusers));
7022                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessconns));
7023                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxpagedmemoryusage));
7024                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxnonpagedmemoryusage));
7025                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablesoftcompat));
7026                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableforcedlogoff));
7027                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->timesource));
7028                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->acceptdownlevelapis));
7029                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lmannounce));
7030         }
7031         if (ndr_flags & NDR_BUFFERS) {
7032         }
7033         return NDR_ERR_SUCCESS;
7034 }
7035
7036 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo502(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo502 *r)
7037 {
7038         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo502");
7039         ndr->depth++;
7040         ndr_print_uint32(ndr, "sessopen", r->sessopen);
7041         ndr_print_uint32(ndr, "sesssvc", r->sesssvc);
7042         ndr_print_uint32(ndr, "opensearch", r->opensearch);
7043         ndr_print_uint32(ndr, "sizereqbufs", r->sizereqbufs);
7044         ndr_print_uint32(ndr, "initworkitems", r->initworkitems);
7045         ndr_print_uint32(ndr, "maxworkitems", r->maxworkitems);
7046         ndr_print_uint32(ndr, "rawworkitems", r->rawworkitems);
7047         ndr_print_uint32(ndr, "irpstacksize", r->irpstacksize);
7048         ndr_print_uint32(ndr, "maxrawbuflen", r->maxrawbuflen);
7049         ndr_print_uint32(ndr, "sessusers", r->sessusers);
7050         ndr_print_uint32(ndr, "sessconns", r->sessconns);
7051         ndr_print_uint32(ndr, "maxpagedmemoryusage", r->maxpagedmemoryusage);
7052         ndr_print_uint32(ndr, "maxnonpagedmemoryusage", r->maxnonpagedmemoryusage);
7053         ndr_print_uint32(ndr, "enablesoftcompat", r->enablesoftcompat);
7054         ndr_print_uint32(ndr, "enableforcedlogoff", r->enableforcedlogoff);
7055         ndr_print_uint32(ndr, "timesource", r->timesource);
7056         ndr_print_uint32(ndr, "acceptdownlevelapis", r->acceptdownlevelapis);
7057         ndr_print_uint32(ndr, "lmannounce", r->lmannounce);
7058         ndr->depth--;
7059 }
7060
7061 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo503(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo503 *r)
7062 {
7063         if (ndr_flags & NDR_SCALARS) {
7064                 NDR_CHECK(ndr_push_align(ndr, 4));
7065                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessopen));
7066                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sesssvc));
7067                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->opensearch));
7068                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sizereqbufs));
7069                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initworkitems));
7070                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxworkitems));
7071                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rawworkitems));
7072                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->irpstacksize));
7073                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxrawbuflen));
7074                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessusers));
7075                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessconns));
7076                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxpagedmemoryusage));
7077                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxnonpagedmemoryusage));
7078                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablesoftcompat));
7079                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableforcedlogoff));
7080                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->timesource));
7081                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->acceptdownlevelapis));
7082                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lmannounce));
7083                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
7084                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxcopyreadlen));
7085                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxcopywritelen));
7086                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minkeepsearch));
7087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxkeepsearch));
7088                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minkeepcomplsearch));
7089                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxkeepcomplsearch));
7090                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->threadcountadd));
7091                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numlockthreads));
7092                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->scavtimeout));
7093                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minrcvqueue));
7094                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minfreeworkitems));
7095                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->xactmemsize));
7096                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->threadpriority));
7097                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxmpxct));
7098                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->oplockbreakwait));
7099                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->oplockbreakresponsewait));
7100                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableoplocks));
7101                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableoplockforceclose));
7102                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablefcbopens));
7103                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableraw));
7104                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablesharednetdrives));
7105                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minfreeconnections));
7106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxfreeconnections));
7107         }
7108         if (ndr_flags & NDR_BUFFERS) {
7109                 if (r->domain) {
7110                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
7111                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7112                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
7113                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain, ndr_charset_length(r->domain, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7114                 }
7115         }
7116         return NDR_ERR_SUCCESS;
7117 }
7118
7119 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo503(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo503 *r)
7120 {
7121         uint32_t _ptr_domain;
7122         TALLOC_CTX *_mem_save_domain_0;
7123         if (ndr_flags & NDR_SCALARS) {
7124                 NDR_CHECK(ndr_pull_align(ndr, 4));
7125                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessopen));
7126                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sesssvc));
7127                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->opensearch));
7128                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sizereqbufs));
7129                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initworkitems));
7130                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxworkitems));
7131                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rawworkitems));
7132                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->irpstacksize));
7133                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxrawbuflen));
7134                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessusers));
7135                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessconns));
7136                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxpagedmemoryusage));
7137                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxnonpagedmemoryusage));
7138                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablesoftcompat));
7139                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableforcedlogoff));
7140                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->timesource));
7141                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->acceptdownlevelapis));
7142                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lmannounce));
7143                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
7144                 if (_ptr_domain) {
7145                         NDR_PULL_ALLOC(ndr, r->domain);
7146                 } else {
7147                         r->domain = NULL;
7148                 }
7149                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxcopyreadlen));
7150                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxcopywritelen));
7151                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minkeepsearch));
7152                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxkeepsearch));
7153                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minkeepcomplsearch));
7154                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxkeepcomplsearch));
7155                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->threadcountadd));
7156                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numlockthreads));
7157                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->scavtimeout));
7158                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minrcvqueue));
7159                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minfreeworkitems));
7160                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->xactmemsize));
7161                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->threadpriority));
7162                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxmpxct));
7163                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->oplockbreakwait));
7164                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->oplockbreakresponsewait));
7165                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableoplocks));
7166                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableoplockforceclose));
7167                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablefcbopens));
7168                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableraw));
7169                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablesharednetdrives));
7170                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minfreeconnections));
7171                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxfreeconnections));
7172         }
7173         if (ndr_flags & NDR_BUFFERS) {
7174                 if (r->domain) {
7175                         _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
7176                         NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);
7177                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain));
7178                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain));
7179                         if (ndr_get_array_length(ndr, &r->domain) > ndr_get_array_size(ndr, &r->domain)) {
7180                                 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), ndr_get_array_length(ndr, &r->domain));
7181                         }
7182                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t)));
7183                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t), CH_UTF16));
7184                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);
7185                 }
7186         }
7187         return NDR_ERR_SUCCESS;
7188 }
7189
7190 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo503(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo503 *r)
7191 {
7192         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo503");
7193         ndr->depth++;
7194         ndr_print_uint32(ndr, "sessopen", r->sessopen);
7195         ndr_print_uint32(ndr, "sesssvc", r->sesssvc);
7196         ndr_print_uint32(ndr, "opensearch", r->opensearch);
7197         ndr_print_uint32(ndr, "sizereqbufs", r->sizereqbufs);
7198         ndr_print_uint32(ndr, "initworkitems", r->initworkitems);
7199         ndr_print_uint32(ndr, "maxworkitems", r->maxworkitems);
7200         ndr_print_uint32(ndr, "rawworkitems", r->rawworkitems);
7201         ndr_print_uint32(ndr, "irpstacksize", r->irpstacksize);
7202         ndr_print_uint32(ndr, "maxrawbuflen", r->maxrawbuflen);
7203         ndr_print_uint32(ndr, "sessusers", r->sessusers);
7204         ndr_print_uint32(ndr, "sessconns", r->sessconns);
7205         ndr_print_uint32(ndr, "maxpagedmemoryusage", r->maxpagedmemoryusage);
7206         ndr_print_uint32(ndr, "maxnonpagedmemoryusage", r->maxnonpagedmemoryusage);
7207         ndr_print_uint32(ndr, "enablesoftcompat", r->enablesoftcompat);
7208         ndr_print_uint32(ndr, "enableforcedlogoff", r->enableforcedlogoff);
7209         ndr_print_uint32(ndr, "timesource", r->timesource);
7210         ndr_print_uint32(ndr, "acceptdownlevelapis", r->acceptdownlevelapis);
7211         ndr_print_uint32(ndr, "lmannounce", r->lmannounce);
7212         ndr_print_ptr(ndr, "domain", r->domain);
7213         ndr->depth++;
7214         if (r->domain) {
7215                 ndr_print_string(ndr, "domain", r->domain);
7216         }
7217         ndr->depth--;
7218         ndr_print_uint32(ndr, "maxcopyreadlen", r->maxcopyreadlen);
7219         ndr_print_uint32(ndr, "maxcopywritelen", r->maxcopywritelen);
7220         ndr_print_uint32(ndr, "minkeepsearch", r->minkeepsearch);
7221         ndr_print_uint32(ndr, "maxkeepsearch", r->maxkeepsearch);
7222         ndr_print_uint32(ndr, "minkeepcomplsearch", r->minkeepcomplsearch);
7223         ndr_print_uint32(ndr, "maxkeepcomplsearch", r->maxkeepcomplsearch);
7224         ndr_print_uint32(ndr, "threadcountadd", r->threadcountadd);
7225         ndr_print_uint32(ndr, "numlockthreads", r->numlockthreads);
7226         ndr_print_uint32(ndr, "scavtimeout", r->scavtimeout);
7227         ndr_print_uint32(ndr, "minrcvqueue", r->minrcvqueue);
7228         ndr_print_uint32(ndr, "minfreeworkitems", r->minfreeworkitems);
7229         ndr_print_uint32(ndr, "xactmemsize", r->xactmemsize);
7230         ndr_print_uint32(ndr, "threadpriority", r->threadpriority);
7231         ndr_print_uint32(ndr, "maxmpxct", r->maxmpxct);
7232         ndr_print_uint32(ndr, "oplockbreakwait", r->oplockbreakwait);
7233         ndr_print_uint32(ndr, "oplockbreakresponsewait", r->oplockbreakresponsewait);
7234         ndr_print_uint32(ndr, "enableoplocks", r->enableoplocks);
7235         ndr_print_uint32(ndr, "enableoplockforceclose", r->enableoplockforceclose);
7236         ndr_print_uint32(ndr, "enablefcbopens", r->enablefcbopens);
7237         ndr_print_uint32(ndr, "enableraw", r->enableraw);
7238         ndr_print_uint32(ndr, "enablesharednetdrives", r->enablesharednetdrives);
7239         ndr_print_uint32(ndr, "minfreeconnections", r->minfreeconnections);
7240         ndr_print_uint32(ndr, "maxfreeconnections", r->maxfreeconnections);
7241         ndr->depth--;
7242 }
7243
7244 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo599(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo599 *r)
7245 {
7246         if (ndr_flags & NDR_SCALARS) {
7247                 NDR_CHECK(ndr_push_align(ndr, 4));
7248                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessopen));
7249                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sesssvc));
7250                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->opensearch));
7251                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sizereqbufs));
7252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initworkitems));
7253                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxworkitems));
7254                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rawworkitems));
7255                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->irpstacksize));
7256                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxrawbuflen));
7257                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessusers));
7258                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessconns));
7259                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxpagedmemoryusage));
7260                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxnonpagedmemoryusage));
7261                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablesoftcompat));
7262                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableforcedlogoff));
7263                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->timesource));
7264                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->acceptdownlevelapis));
7265                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lmannounce));
7266                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
7267                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxcopyreadlen));
7268                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxcopywritelen));
7269                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minkeepsearch));
7270                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minkeepcomplsearch));
7271                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxkeepcomplsearch));
7272                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->threadcountadd));
7273                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numlockthreads));
7274                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->scavtimeout));
7275                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minrcvqueue));
7276                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minfreeworkitems));
7277                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->xactmemsize));
7278                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->threadpriority));
7279                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxmpxct));
7280                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->oplockbreakwait));
7281                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->oplockbreakresponsewait));
7282                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableoplocks));
7283                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableoplockforceclose));
7284                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablefcbopens));
7285                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableraw));
7286                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablesharednetdrives));
7287                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minfreeconnections));
7288                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxfreeconnections));
7289                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initsesstable));
7290                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initconntable));
7291                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initfiletable));
7292                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initsearchtable));
7293                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alertsched));
7294                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->errortreshold));
7295                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->networkerrortreshold));
7296                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->diskspacetreshold));
7297                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
7298                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxlinkdelay));
7299                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minlinkthroughput));
7300                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->linkinfovalidtime));
7301                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->scavqosinfoupdatetime));
7302                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxworkitemidletime));
7303         }
7304         if (ndr_flags & NDR_BUFFERS) {
7305                 if (r->domain) {
7306                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
7307                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7308                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
7309                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain, ndr_charset_length(r->domain, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7310                 }
7311         }
7312         return NDR_ERR_SUCCESS;
7313 }
7314
7315 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo599(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo599 *r)
7316 {
7317         uint32_t _ptr_domain;
7318         TALLOC_CTX *_mem_save_domain_0;
7319         if (ndr_flags & NDR_SCALARS) {
7320                 NDR_CHECK(ndr_pull_align(ndr, 4));
7321                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessopen));
7322                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sesssvc));
7323                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->opensearch));
7324                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sizereqbufs));
7325                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initworkitems));
7326                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxworkitems));
7327                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rawworkitems));
7328                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->irpstacksize));
7329                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxrawbuflen));
7330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessusers));
7331                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessconns));
7332                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxpagedmemoryusage));
7333                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxnonpagedmemoryusage));
7334                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablesoftcompat));
7335                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableforcedlogoff));
7336                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->timesource));
7337                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->acceptdownlevelapis));
7338                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lmannounce));
7339                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
7340                 if (_ptr_domain) {
7341                         NDR_PULL_ALLOC(ndr, r->domain);
7342                 } else {
7343                         r->domain = NULL;
7344                 }
7345                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxcopyreadlen));
7346                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxcopywritelen));
7347                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minkeepsearch));
7348                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minkeepcomplsearch));
7349                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxkeepcomplsearch));
7350                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->threadcountadd));
7351                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numlockthreads));
7352                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->scavtimeout));
7353                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minrcvqueue));
7354                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minfreeworkitems));
7355                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->xactmemsize));
7356                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->threadpriority));
7357                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxmpxct));
7358                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->oplockbreakwait));
7359                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->oplockbreakresponsewait));
7360                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableoplocks));
7361                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableoplockforceclose));
7362                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablefcbopens));
7363                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableraw));
7364                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablesharednetdrives));
7365                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minfreeconnections));
7366                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxfreeconnections));
7367                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initsesstable));
7368                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initconntable));
7369                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initfiletable));
7370                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initsearchtable));
7371                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alertsched));
7372                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->errortreshold));
7373                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->networkerrortreshold));
7374                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->diskspacetreshold));
7375                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
7376                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxlinkdelay));
7377                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minlinkthroughput));
7378                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->linkinfovalidtime));
7379                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->scavqosinfoupdatetime));
7380                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxworkitemidletime));
7381         }
7382         if (ndr_flags & NDR_BUFFERS) {
7383                 if (r->domain) {
7384                         _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
7385                         NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);
7386                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain));
7387                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain));
7388                         if (ndr_get_array_length(ndr, &r->domain) > ndr_get_array_size(ndr, &r->domain)) {
7389                                 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), ndr_get_array_length(ndr, &r->domain));
7390                         }
7391                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t)));
7392                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t), CH_UTF16));
7393                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);
7394                 }
7395         }
7396         return NDR_ERR_SUCCESS;
7397 }
7398
7399 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo599(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo599 *r)
7400 {
7401         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo599");
7402         ndr->depth++;
7403         ndr_print_uint32(ndr, "sessopen", r->sessopen);
7404         ndr_print_uint32(ndr, "sesssvc", r->sesssvc);
7405         ndr_print_uint32(ndr, "opensearch", r->opensearch);
7406         ndr_print_uint32(ndr, "sizereqbufs", r->sizereqbufs);
7407         ndr_print_uint32(ndr, "initworkitems", r->initworkitems);
7408         ndr_print_uint32(ndr, "maxworkitems", r->maxworkitems);
7409         ndr_print_uint32(ndr, "rawworkitems", r->rawworkitems);
7410         ndr_print_uint32(ndr, "irpstacksize", r->irpstacksize);
7411         ndr_print_uint32(ndr, "maxrawbuflen", r->maxrawbuflen);
7412         ndr_print_uint32(ndr, "sessusers", r->sessusers);
7413         ndr_print_uint32(ndr, "sessconns", r->sessconns);
7414         ndr_print_uint32(ndr, "maxpagedmemoryusage", r->maxpagedmemoryusage);
7415         ndr_print_uint32(ndr, "maxnonpagedmemoryusage", r->maxnonpagedmemoryusage);
7416         ndr_print_uint32(ndr, "enablesoftcompat", r->enablesoftcompat);
7417         ndr_print_uint32(ndr, "enableforcedlogoff", r->enableforcedlogoff);
7418         ndr_print_uint32(ndr, "timesource", r->timesource);
7419         ndr_print_uint32(ndr, "acceptdownlevelapis", r->acceptdownlevelapis);
7420         ndr_print_uint32(ndr, "lmannounce", r->lmannounce);
7421         ndr_print_ptr(ndr, "domain", r->domain);
7422         ndr->depth++;
7423         if (r->domain) {
7424                 ndr_print_string(ndr, "domain", r->domain);
7425         }
7426         ndr->depth--;
7427         ndr_print_uint32(ndr, "maxcopyreadlen", r->maxcopyreadlen);
7428         ndr_print_uint32(ndr, "maxcopywritelen", r->maxcopywritelen);
7429         ndr_print_uint32(ndr, "minkeepsearch", r->minkeepsearch);
7430         ndr_print_uint32(ndr, "minkeepcomplsearch", r->minkeepcomplsearch);
7431         ndr_print_uint32(ndr, "maxkeepcomplsearch", r->maxkeepcomplsearch);
7432         ndr_print_uint32(ndr, "threadcountadd", r->threadcountadd);
7433         ndr_print_uint32(ndr, "numlockthreads", r->numlockthreads);
7434         ndr_print_uint32(ndr, "scavtimeout", r->scavtimeout);
7435         ndr_print_uint32(ndr, "minrcvqueue", r->minrcvqueue);
7436         ndr_print_uint32(ndr, "minfreeworkitems", r->minfreeworkitems);
7437         ndr_print_uint32(ndr, "xactmemsize", r->xactmemsize);
7438         ndr_print_uint32(ndr, "threadpriority", r->threadpriority);
7439         ndr_print_uint32(ndr, "maxmpxct", r->maxmpxct);
7440         ndr_print_uint32(ndr, "oplockbreakwait", r->oplockbreakwait);
7441         ndr_print_uint32(ndr, "oplockbreakresponsewait", r->oplockbreakresponsewait);
7442         ndr_print_uint32(ndr, "enableoplocks", r->enableoplocks);
7443         ndr_print_uint32(ndr, "enableoplockforceclose", r->enableoplockforceclose);
7444         ndr_print_uint32(ndr, "enablefcbopens", r->enablefcbopens);
7445         ndr_print_uint32(ndr, "enableraw", r->enableraw);
7446         ndr_print_uint32(ndr, "enablesharednetdrives", r->enablesharednetdrives);
7447         ndr_print_uint32(ndr, "minfreeconnections", r->minfreeconnections);
7448         ndr_print_uint32(ndr, "maxfreeconnections", r->maxfreeconnections);
7449         ndr_print_uint32(ndr, "initsesstable", r->initsesstable);
7450         ndr_print_uint32(ndr, "initconntable", r->initconntable);
7451         ndr_print_uint32(ndr, "initfiletable", r->initfiletable);
7452         ndr_print_uint32(ndr, "initsearchtable", r->initsearchtable);
7453         ndr_print_uint32(ndr, "alertsched", r->alertsched);
7454         ndr_print_uint32(ndr, "errortreshold", r->errortreshold);
7455         ndr_print_uint32(ndr, "networkerrortreshold", r->networkerrortreshold);
7456         ndr_print_uint32(ndr, "diskspacetreshold", r->diskspacetreshold);
7457         ndr_print_uint32(ndr, "reserved", r->reserved);
7458         ndr_print_uint32(ndr, "maxlinkdelay", r->maxlinkdelay);
7459         ndr_print_uint32(ndr, "minlinkthroughput", r->minlinkthroughput);
7460         ndr_print_uint32(ndr, "linkinfovalidtime", r->linkinfovalidtime);
7461         ndr_print_uint32(ndr, "scavqosinfoupdatetime", r->scavqosinfoupdatetime);
7462         ndr_print_uint32(ndr, "maxworkitemidletime", r->maxworkitemidletime);
7463         ndr->depth--;
7464 }
7465
7466 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1005(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1005 *r)
7467 {
7468         if (ndr_flags & NDR_SCALARS) {
7469                 NDR_CHECK(ndr_push_align(ndr, 4));
7470                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
7471         }
7472         if (ndr_flags & NDR_BUFFERS) {
7473                 if (r->comment) {
7474                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
7475                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7476                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
7477                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7478                 }
7479         }
7480         return NDR_ERR_SUCCESS;
7481 }
7482
7483 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1005(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1005 *r)
7484 {
7485         uint32_t _ptr_comment;
7486         TALLOC_CTX *_mem_save_comment_0;
7487         if (ndr_flags & NDR_SCALARS) {
7488                 NDR_CHECK(ndr_pull_align(ndr, 4));
7489                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
7490                 if (_ptr_comment) {
7491                         NDR_PULL_ALLOC(ndr, r->comment);
7492                 } else {
7493                         r->comment = NULL;
7494                 }
7495         }
7496         if (ndr_flags & NDR_BUFFERS) {
7497                 if (r->comment) {
7498                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
7499                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
7500                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
7501                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
7502                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
7503                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
7504                         }
7505                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
7506                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
7507                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
7508                 }
7509         }
7510         return NDR_ERR_SUCCESS;
7511 }
7512
7513 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1005(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1005 *r)
7514 {
7515         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1005");
7516         ndr->depth++;
7517         ndr_print_ptr(ndr, "comment", r->comment);
7518         ndr->depth++;
7519         if (r->comment) {
7520                 ndr_print_string(ndr, "comment", r->comment);
7521         }
7522         ndr->depth--;
7523         ndr->depth--;
7524 }
7525
7526 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1010(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1010 *r)
7527 {
7528         if (ndr_flags & NDR_SCALARS) {
7529                 NDR_CHECK(ndr_push_align(ndr, 4));
7530                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->disc));
7531         }
7532         if (ndr_flags & NDR_BUFFERS) {
7533         }
7534         return NDR_ERR_SUCCESS;
7535 }
7536
7537 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1010(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1010 *r)
7538 {
7539         if (ndr_flags & NDR_SCALARS) {
7540                 NDR_CHECK(ndr_pull_align(ndr, 4));
7541                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->disc));
7542         }
7543         if (ndr_flags & NDR_BUFFERS) {
7544         }
7545         return NDR_ERR_SUCCESS;
7546 }
7547
7548 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1010(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1010 *r)
7549 {
7550         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1010");
7551         ndr->depth++;
7552         ndr_print_uint32(ndr, "disc", r->disc);
7553         ndr->depth--;
7554 }
7555
7556 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1016(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1016 *r)
7557 {
7558         if (ndr_flags & NDR_SCALARS) {
7559                 NDR_CHECK(ndr_push_align(ndr, 4));
7560                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->hidden));
7561         }
7562         if (ndr_flags & NDR_BUFFERS) {
7563         }
7564         return NDR_ERR_SUCCESS;
7565 }
7566
7567 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1016(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1016 *r)
7568 {
7569         if (ndr_flags & NDR_SCALARS) {
7570                 NDR_CHECK(ndr_pull_align(ndr, 4));
7571                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->hidden));
7572         }
7573         if (ndr_flags & NDR_BUFFERS) {
7574         }
7575         return NDR_ERR_SUCCESS;
7576 }
7577
7578 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1016(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1016 *r)
7579 {
7580         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1016");
7581         ndr->depth++;
7582         ndr_print_uint32(ndr, "hidden", r->hidden);
7583         ndr->depth--;
7584 }
7585
7586 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1017(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1017 *r)
7587 {
7588         if (ndr_flags & NDR_SCALARS) {
7589                 NDR_CHECK(ndr_push_align(ndr, 4));
7590                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->announce));
7591         }
7592         if (ndr_flags & NDR_BUFFERS) {
7593         }
7594         return NDR_ERR_SUCCESS;
7595 }
7596
7597 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1017(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1017 *r)
7598 {
7599         if (ndr_flags & NDR_SCALARS) {
7600                 NDR_CHECK(ndr_pull_align(ndr, 4));
7601                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->announce));
7602         }
7603         if (ndr_flags & NDR_BUFFERS) {
7604         }
7605         return NDR_ERR_SUCCESS;
7606 }
7607
7608 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1017(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1017 *r)
7609 {
7610         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1017");
7611         ndr->depth++;
7612         ndr_print_uint32(ndr, "announce", r->announce);
7613         ndr->depth--;
7614 }
7615
7616 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1018(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1018 *r)
7617 {
7618         if (ndr_flags & NDR_SCALARS) {
7619                 NDR_CHECK(ndr_push_align(ndr, 4));
7620                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->anndelta));
7621         }
7622         if (ndr_flags & NDR_BUFFERS) {
7623         }
7624         return NDR_ERR_SUCCESS;
7625 }
7626
7627 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1018(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1018 *r)
7628 {
7629         if (ndr_flags & NDR_SCALARS) {
7630                 NDR_CHECK(ndr_pull_align(ndr, 4));
7631                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->anndelta));
7632         }
7633         if (ndr_flags & NDR_BUFFERS) {
7634         }
7635         return NDR_ERR_SUCCESS;
7636 }
7637
7638 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1018(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1018 *r)
7639 {
7640         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1018");
7641         ndr->depth++;
7642         ndr_print_uint32(ndr, "anndelta", r->anndelta);
7643         ndr->depth--;
7644 }
7645
7646 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1107(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1107 *r)
7647 {
7648         if (ndr_flags & NDR_SCALARS) {
7649                 NDR_CHECK(ndr_push_align(ndr, 4));
7650                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->users));
7651         }
7652         if (ndr_flags & NDR_BUFFERS) {
7653         }
7654         return NDR_ERR_SUCCESS;
7655 }
7656
7657 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1107(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1107 *r)
7658 {
7659         if (ndr_flags & NDR_SCALARS) {
7660                 NDR_CHECK(ndr_pull_align(ndr, 4));
7661                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->users));
7662         }
7663         if (ndr_flags & NDR_BUFFERS) {
7664         }
7665         return NDR_ERR_SUCCESS;
7666 }
7667
7668 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1107(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1107 *r)
7669 {
7670         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1107");
7671         ndr->depth++;
7672         ndr_print_uint32(ndr, "users", r->users);
7673         ndr->depth--;
7674 }
7675
7676 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1501(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1501 *r)
7677 {
7678         if (ndr_flags & NDR_SCALARS) {
7679                 NDR_CHECK(ndr_push_align(ndr, 4));
7680                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessopens));
7681         }
7682         if (ndr_flags & NDR_BUFFERS) {
7683         }
7684         return NDR_ERR_SUCCESS;
7685 }
7686
7687 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1501(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1501 *r)
7688 {
7689         if (ndr_flags & NDR_SCALARS) {
7690                 NDR_CHECK(ndr_pull_align(ndr, 4));
7691                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessopens));
7692         }
7693         if (ndr_flags & NDR_BUFFERS) {
7694         }
7695         return NDR_ERR_SUCCESS;
7696 }
7697
7698 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1501(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1501 *r)
7699 {
7700         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1501");
7701         ndr->depth++;
7702         ndr_print_uint32(ndr, "sessopens", r->sessopens);
7703         ndr->depth--;
7704 }
7705
7706 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1502(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1502 *r)
7707 {
7708         if (ndr_flags & NDR_SCALARS) {
7709                 NDR_CHECK(ndr_push_align(ndr, 4));
7710                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessvcs));
7711         }
7712         if (ndr_flags & NDR_BUFFERS) {
7713         }
7714         return NDR_ERR_SUCCESS;
7715 }
7716
7717 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1502(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1502 *r)
7718 {
7719         if (ndr_flags & NDR_SCALARS) {
7720                 NDR_CHECK(ndr_pull_align(ndr, 4));
7721                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessvcs));
7722         }
7723         if (ndr_flags & NDR_BUFFERS) {
7724         }
7725         return NDR_ERR_SUCCESS;
7726 }
7727
7728 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1502(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1502 *r)
7729 {
7730         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1502");
7731         ndr->depth++;
7732         ndr_print_uint32(ndr, "sessvcs", r->sessvcs);
7733         ndr->depth--;
7734 }
7735
7736 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1503(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1503 *r)
7737 {
7738         if (ndr_flags & NDR_SCALARS) {
7739                 NDR_CHECK(ndr_push_align(ndr, 4));
7740                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->opensearch));
7741         }
7742         if (ndr_flags & NDR_BUFFERS) {
7743         }
7744         return NDR_ERR_SUCCESS;
7745 }
7746
7747 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1503(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1503 *r)
7748 {
7749         if (ndr_flags & NDR_SCALARS) {
7750                 NDR_CHECK(ndr_pull_align(ndr, 4));
7751                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->opensearch));
7752         }
7753         if (ndr_flags & NDR_BUFFERS) {
7754         }
7755         return NDR_ERR_SUCCESS;
7756 }
7757
7758 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1503(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1503 *r)
7759 {
7760         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1503");
7761         ndr->depth++;
7762         ndr_print_uint32(ndr, "opensearch", r->opensearch);
7763         ndr->depth--;
7764 }
7765
7766 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1506(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1506 *r)
7767 {
7768         if (ndr_flags & NDR_SCALARS) {
7769                 NDR_CHECK(ndr_push_align(ndr, 4));
7770                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxworkitems));
7771         }
7772         if (ndr_flags & NDR_BUFFERS) {
7773         }
7774         return NDR_ERR_SUCCESS;
7775 }
7776
7777 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1506(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1506 *r)
7778 {
7779         if (ndr_flags & NDR_SCALARS) {
7780                 NDR_CHECK(ndr_pull_align(ndr, 4));
7781                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxworkitems));
7782         }
7783         if (ndr_flags & NDR_BUFFERS) {
7784         }
7785         return NDR_ERR_SUCCESS;
7786 }
7787
7788 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1506(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1506 *r)
7789 {
7790         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1506");
7791         ndr->depth++;
7792         ndr_print_uint32(ndr, "maxworkitems", r->maxworkitems);
7793         ndr->depth--;
7794 }
7795
7796 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1509(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1509 *r)
7797 {
7798         if (ndr_flags & NDR_SCALARS) {
7799                 NDR_CHECK(ndr_push_align(ndr, 4));
7800                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxrawbuflen));
7801         }
7802         if (ndr_flags & NDR_BUFFERS) {
7803         }
7804         return NDR_ERR_SUCCESS;
7805 }
7806
7807 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1509(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1509 *r)
7808 {
7809         if (ndr_flags & NDR_SCALARS) {
7810                 NDR_CHECK(ndr_pull_align(ndr, 4));
7811                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxrawbuflen));
7812         }
7813         if (ndr_flags & NDR_BUFFERS) {
7814         }
7815         return NDR_ERR_SUCCESS;
7816 }
7817
7818 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1509(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1509 *r)
7819 {
7820         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1509");
7821         ndr->depth++;
7822         ndr_print_uint32(ndr, "maxrawbuflen", r->maxrawbuflen);
7823         ndr->depth--;
7824 }
7825
7826 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1510(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1510 *r)
7827 {
7828         if (ndr_flags & NDR_SCALARS) {
7829                 NDR_CHECK(ndr_push_align(ndr, 4));
7830                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessusers));
7831         }
7832         if (ndr_flags & NDR_BUFFERS) {
7833         }
7834         return NDR_ERR_SUCCESS;
7835 }
7836
7837 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1510(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1510 *r)
7838 {
7839         if (ndr_flags & NDR_SCALARS) {
7840                 NDR_CHECK(ndr_pull_align(ndr, 4));
7841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessusers));
7842         }
7843         if (ndr_flags & NDR_BUFFERS) {
7844         }
7845         return NDR_ERR_SUCCESS;
7846 }
7847
7848 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1510(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1510 *r)
7849 {
7850         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1510");
7851         ndr->depth++;
7852         ndr_print_uint32(ndr, "sessusers", r->sessusers);
7853         ndr->depth--;
7854 }
7855
7856 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1511(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1511 *r)
7857 {
7858         if (ndr_flags & NDR_SCALARS) {
7859                 NDR_CHECK(ndr_push_align(ndr, 4));
7860                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sesscons));
7861         }
7862         if (ndr_flags & NDR_BUFFERS) {
7863         }
7864         return NDR_ERR_SUCCESS;
7865 }
7866
7867 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1511(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1511 *r)
7868 {
7869         if (ndr_flags & NDR_SCALARS) {
7870                 NDR_CHECK(ndr_pull_align(ndr, 4));
7871                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sesscons));
7872         }
7873         if (ndr_flags & NDR_BUFFERS) {
7874         }
7875         return NDR_ERR_SUCCESS;
7876 }
7877
7878 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1511(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1511 *r)
7879 {
7880         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1511");
7881         ndr->depth++;
7882         ndr_print_uint32(ndr, "sesscons", r->sesscons);
7883         ndr->depth--;
7884 }
7885
7886 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1512(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1512 *r)
7887 {
7888         if (ndr_flags & NDR_SCALARS) {
7889                 NDR_CHECK(ndr_push_align(ndr, 4));
7890                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxnonpagedmemoryusage));
7891         }
7892         if (ndr_flags & NDR_BUFFERS) {
7893         }
7894         return NDR_ERR_SUCCESS;
7895 }
7896
7897 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1512(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1512 *r)
7898 {
7899         if (ndr_flags & NDR_SCALARS) {
7900                 NDR_CHECK(ndr_pull_align(ndr, 4));
7901                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxnonpagedmemoryusage));
7902         }
7903         if (ndr_flags & NDR_BUFFERS) {
7904         }
7905         return NDR_ERR_SUCCESS;
7906 }
7907
7908 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1512(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1512 *r)
7909 {
7910         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1512");
7911         ndr->depth++;
7912         ndr_print_uint32(ndr, "maxnonpagedmemoryusage", r->maxnonpagedmemoryusage);
7913         ndr->depth--;
7914 }
7915
7916 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1513(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1513 *r)
7917 {
7918         if (ndr_flags & NDR_SCALARS) {
7919                 NDR_CHECK(ndr_push_align(ndr, 4));
7920                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxpagedmemoryusage));
7921         }
7922         if (ndr_flags & NDR_BUFFERS) {
7923         }
7924         return NDR_ERR_SUCCESS;
7925 }
7926
7927 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1513(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1513 *r)
7928 {
7929         if (ndr_flags & NDR_SCALARS) {
7930                 NDR_CHECK(ndr_pull_align(ndr, 4));
7931                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxpagedmemoryusage));
7932         }
7933         if (ndr_flags & NDR_BUFFERS) {
7934         }
7935         return NDR_ERR_SUCCESS;
7936 }
7937
7938 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1513(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1513 *r)
7939 {
7940         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1513");
7941         ndr->depth++;
7942         ndr_print_uint32(ndr, "maxpagedmemoryusage", r->maxpagedmemoryusage);
7943         ndr->depth--;
7944 }
7945
7946 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1514(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1514 *r)
7947 {
7948         if (ndr_flags & NDR_SCALARS) {
7949                 NDR_CHECK(ndr_push_align(ndr, 4));
7950                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablesoftcompat));
7951         }
7952         if (ndr_flags & NDR_BUFFERS) {
7953         }
7954         return NDR_ERR_SUCCESS;
7955 }
7956
7957 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1514(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1514 *r)
7958 {
7959         if (ndr_flags & NDR_SCALARS) {
7960                 NDR_CHECK(ndr_pull_align(ndr, 4));
7961                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablesoftcompat));
7962         }
7963         if (ndr_flags & NDR_BUFFERS) {
7964         }
7965         return NDR_ERR_SUCCESS;
7966 }
7967
7968 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1514(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1514 *r)
7969 {
7970         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1514");
7971         ndr->depth++;
7972         ndr_print_uint32(ndr, "enablesoftcompat", r->enablesoftcompat);
7973         ndr->depth--;
7974 }
7975
7976 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1515(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1515 *r)
7977 {
7978         if (ndr_flags & NDR_SCALARS) {
7979                 NDR_CHECK(ndr_push_align(ndr, 4));
7980                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableforcedlogoff));
7981         }
7982         if (ndr_flags & NDR_BUFFERS) {
7983         }
7984         return NDR_ERR_SUCCESS;
7985 }
7986
7987 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1515(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1515 *r)
7988 {
7989         if (ndr_flags & NDR_SCALARS) {
7990                 NDR_CHECK(ndr_pull_align(ndr, 4));
7991                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableforcedlogoff));
7992         }
7993         if (ndr_flags & NDR_BUFFERS) {
7994         }
7995         return NDR_ERR_SUCCESS;
7996 }
7997
7998 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1515(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1515 *r)
7999 {
8000         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1515");
8001         ndr->depth++;
8002         ndr_print_uint32(ndr, "enableforcedlogoff", r->enableforcedlogoff);
8003         ndr->depth--;
8004 }
8005
8006 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1516(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1516 *r)
8007 {
8008         if (ndr_flags & NDR_SCALARS) {
8009                 NDR_CHECK(ndr_push_align(ndr, 4));
8010                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->timesource));
8011         }
8012         if (ndr_flags & NDR_BUFFERS) {
8013         }
8014         return NDR_ERR_SUCCESS;
8015 }
8016
8017 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1516(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1516 *r)
8018 {
8019         if (ndr_flags & NDR_SCALARS) {
8020                 NDR_CHECK(ndr_pull_align(ndr, 4));
8021                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->timesource));
8022         }
8023         if (ndr_flags & NDR_BUFFERS) {
8024         }
8025         return NDR_ERR_SUCCESS;
8026 }
8027
8028 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1516(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1516 *r)
8029 {
8030         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1516");
8031         ndr->depth++;
8032         ndr_print_uint32(ndr, "timesource", r->timesource);
8033         ndr->depth--;
8034 }
8035
8036 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1518(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1518 *r)
8037 {
8038         if (ndr_flags & NDR_SCALARS) {
8039                 NDR_CHECK(ndr_push_align(ndr, 4));
8040                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lmannounce));
8041         }
8042         if (ndr_flags & NDR_BUFFERS) {
8043         }
8044         return NDR_ERR_SUCCESS;
8045 }
8046
8047 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1518(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1518 *r)
8048 {
8049         if (ndr_flags & NDR_SCALARS) {
8050                 NDR_CHECK(ndr_pull_align(ndr, 4));
8051                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lmannounce));
8052         }
8053         if (ndr_flags & NDR_BUFFERS) {
8054         }
8055         return NDR_ERR_SUCCESS;
8056 }
8057
8058 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1518(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1518 *r)
8059 {
8060         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1518");
8061         ndr->depth++;
8062         ndr_print_uint32(ndr, "lmannounce", r->lmannounce);
8063         ndr->depth--;
8064 }
8065
8066 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1520(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1520 *r)
8067 {
8068         if (ndr_flags & NDR_SCALARS) {
8069                 NDR_CHECK(ndr_push_align(ndr, 4));
8070                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxcopyreadlen));
8071         }
8072         if (ndr_flags & NDR_BUFFERS) {
8073         }
8074         return NDR_ERR_SUCCESS;
8075 }
8076
8077 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1520(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1520 *r)
8078 {
8079         if (ndr_flags & NDR_SCALARS) {
8080                 NDR_CHECK(ndr_pull_align(ndr, 4));
8081                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxcopyreadlen));
8082         }
8083         if (ndr_flags & NDR_BUFFERS) {
8084         }
8085         return NDR_ERR_SUCCESS;
8086 }
8087
8088 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1520(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1520 *r)
8089 {
8090         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1520");
8091         ndr->depth++;
8092         ndr_print_uint32(ndr, "maxcopyreadlen", r->maxcopyreadlen);
8093         ndr->depth--;
8094 }
8095
8096 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1521(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1521 *r)
8097 {
8098         if (ndr_flags & NDR_SCALARS) {
8099                 NDR_CHECK(ndr_push_align(ndr, 4));
8100                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxcopywritelen));
8101         }
8102         if (ndr_flags & NDR_BUFFERS) {
8103         }
8104         return NDR_ERR_SUCCESS;
8105 }
8106
8107 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1521(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1521 *r)
8108 {
8109         if (ndr_flags & NDR_SCALARS) {
8110                 NDR_CHECK(ndr_pull_align(ndr, 4));
8111                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxcopywritelen));
8112         }
8113         if (ndr_flags & NDR_BUFFERS) {
8114         }
8115         return NDR_ERR_SUCCESS;
8116 }
8117
8118 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1521(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1521 *r)
8119 {
8120         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1521");
8121         ndr->depth++;
8122         ndr_print_uint32(ndr, "maxcopywritelen", r->maxcopywritelen);
8123         ndr->depth--;
8124 }
8125
8126 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1522(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1522 *r)
8127 {
8128         if (ndr_flags & NDR_SCALARS) {
8129                 NDR_CHECK(ndr_push_align(ndr, 4));
8130                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minkeepsearch));
8131         }
8132         if (ndr_flags & NDR_BUFFERS) {
8133         }
8134         return NDR_ERR_SUCCESS;
8135 }
8136
8137 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1522(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1522 *r)
8138 {
8139         if (ndr_flags & NDR_SCALARS) {
8140                 NDR_CHECK(ndr_pull_align(ndr, 4));
8141                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minkeepsearch));
8142         }
8143         if (ndr_flags & NDR_BUFFERS) {
8144         }
8145         return NDR_ERR_SUCCESS;
8146 }
8147
8148 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1522(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1522 *r)
8149 {
8150         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1522");
8151         ndr->depth++;
8152         ndr_print_uint32(ndr, "minkeepsearch", r->minkeepsearch);
8153         ndr->depth--;
8154 }
8155
8156 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1523(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1523 *r)
8157 {
8158         if (ndr_flags & NDR_SCALARS) {
8159                 NDR_CHECK(ndr_push_align(ndr, 4));
8160                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxkeepsearch));
8161         }
8162         if (ndr_flags & NDR_BUFFERS) {
8163         }
8164         return NDR_ERR_SUCCESS;
8165 }
8166
8167 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1523(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1523 *r)
8168 {
8169         if (ndr_flags & NDR_SCALARS) {
8170                 NDR_CHECK(ndr_pull_align(ndr, 4));
8171                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxkeepsearch));
8172         }
8173         if (ndr_flags & NDR_BUFFERS) {
8174         }
8175         return NDR_ERR_SUCCESS;
8176 }
8177
8178 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1523(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1523 *r)
8179 {
8180         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1523");
8181         ndr->depth++;
8182         ndr_print_uint32(ndr, "maxkeepsearch", r->maxkeepsearch);
8183         ndr->depth--;
8184 }
8185
8186 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1524(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1524 *r)
8187 {
8188         if (ndr_flags & NDR_SCALARS) {
8189                 NDR_CHECK(ndr_push_align(ndr, 4));
8190                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minkeepcomplsearch));
8191         }
8192         if (ndr_flags & NDR_BUFFERS) {
8193         }
8194         return NDR_ERR_SUCCESS;
8195 }
8196
8197 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1524(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1524 *r)
8198 {
8199         if (ndr_flags & NDR_SCALARS) {
8200                 NDR_CHECK(ndr_pull_align(ndr, 4));
8201                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minkeepcomplsearch));
8202         }
8203         if (ndr_flags & NDR_BUFFERS) {
8204         }
8205         return NDR_ERR_SUCCESS;
8206 }
8207
8208 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1524(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1524 *r)
8209 {
8210         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1524");
8211         ndr->depth++;
8212         ndr_print_uint32(ndr, "minkeepcomplsearch", r->minkeepcomplsearch);
8213         ndr->depth--;
8214 }
8215
8216 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1525(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1525 *r)
8217 {
8218         if (ndr_flags & NDR_SCALARS) {
8219                 NDR_CHECK(ndr_push_align(ndr, 4));
8220                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxkeepcomplsearch));
8221         }
8222         if (ndr_flags & NDR_BUFFERS) {
8223         }
8224         return NDR_ERR_SUCCESS;
8225 }
8226
8227 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1525(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1525 *r)
8228 {
8229         if (ndr_flags & NDR_SCALARS) {
8230                 NDR_CHECK(ndr_pull_align(ndr, 4));
8231                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxkeepcomplsearch));
8232         }
8233         if (ndr_flags & NDR_BUFFERS) {
8234         }
8235         return NDR_ERR_SUCCESS;
8236 }
8237
8238 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1525(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1525 *r)
8239 {
8240         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1525");
8241         ndr->depth++;
8242         ndr_print_uint32(ndr, "maxkeepcomplsearch", r->maxkeepcomplsearch);
8243         ndr->depth--;
8244 }
8245
8246 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1528(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1528 *r)
8247 {
8248         if (ndr_flags & NDR_SCALARS) {
8249                 NDR_CHECK(ndr_push_align(ndr, 4));
8250                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->scavtimeout));
8251         }
8252         if (ndr_flags & NDR_BUFFERS) {
8253         }
8254         return NDR_ERR_SUCCESS;
8255 }
8256
8257 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1528(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1528 *r)
8258 {
8259         if (ndr_flags & NDR_SCALARS) {
8260                 NDR_CHECK(ndr_pull_align(ndr, 4));
8261                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->scavtimeout));
8262         }
8263         if (ndr_flags & NDR_BUFFERS) {
8264         }
8265         return NDR_ERR_SUCCESS;
8266 }
8267
8268 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1528(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1528 *r)
8269 {
8270         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1528");
8271         ndr->depth++;
8272         ndr_print_uint32(ndr, "scavtimeout", r->scavtimeout);
8273         ndr->depth--;
8274 }
8275
8276 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1529(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1529 *r)
8277 {
8278         if (ndr_flags & NDR_SCALARS) {
8279                 NDR_CHECK(ndr_push_align(ndr, 4));
8280                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minrcvqueue));
8281         }
8282         if (ndr_flags & NDR_BUFFERS) {
8283         }
8284         return NDR_ERR_SUCCESS;
8285 }
8286
8287 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1529(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1529 *r)
8288 {
8289         if (ndr_flags & NDR_SCALARS) {
8290                 NDR_CHECK(ndr_pull_align(ndr, 4));
8291                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minrcvqueue));
8292         }
8293         if (ndr_flags & NDR_BUFFERS) {
8294         }
8295         return NDR_ERR_SUCCESS;
8296 }
8297
8298 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1529(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1529 *r)
8299 {
8300         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1529");
8301         ndr->depth++;
8302         ndr_print_uint32(ndr, "minrcvqueue", r->minrcvqueue);
8303         ndr->depth--;
8304 }
8305
8306 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1530(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1530 *r)
8307 {
8308         if (ndr_flags & NDR_SCALARS) {
8309                 NDR_CHECK(ndr_push_align(ndr, 4));
8310                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minfreeworkitems));
8311         }
8312         if (ndr_flags & NDR_BUFFERS) {
8313         }
8314         return NDR_ERR_SUCCESS;
8315 }
8316
8317 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1530(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1530 *r)
8318 {
8319         if (ndr_flags & NDR_SCALARS) {
8320                 NDR_CHECK(ndr_pull_align(ndr, 4));
8321                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minfreeworkitems));
8322         }
8323         if (ndr_flags & NDR_BUFFERS) {
8324         }
8325         return NDR_ERR_SUCCESS;
8326 }
8327
8328 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1530(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1530 *r)
8329 {
8330         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1530");
8331         ndr->depth++;
8332         ndr_print_uint32(ndr, "minfreeworkitems", r->minfreeworkitems);
8333         ndr->depth--;
8334 }
8335
8336 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1533(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1533 *r)
8337 {
8338         if (ndr_flags & NDR_SCALARS) {
8339                 NDR_CHECK(ndr_push_align(ndr, 4));
8340                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxmpxct));
8341         }
8342         if (ndr_flags & NDR_BUFFERS) {
8343         }
8344         return NDR_ERR_SUCCESS;
8345 }
8346
8347 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1533(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1533 *r)
8348 {
8349         if (ndr_flags & NDR_SCALARS) {
8350                 NDR_CHECK(ndr_pull_align(ndr, 4));
8351                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxmpxct));
8352         }
8353         if (ndr_flags & NDR_BUFFERS) {
8354         }
8355         return NDR_ERR_SUCCESS;
8356 }
8357
8358 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1533(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1533 *r)
8359 {
8360         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1533");
8361         ndr->depth++;
8362         ndr_print_uint32(ndr, "maxmpxct", r->maxmpxct);
8363         ndr->depth--;
8364 }
8365
8366 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1534(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1534 *r)
8367 {
8368         if (ndr_flags & NDR_SCALARS) {
8369                 NDR_CHECK(ndr_push_align(ndr, 4));
8370                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->oplockbreakwait));
8371         }
8372         if (ndr_flags & NDR_BUFFERS) {
8373         }
8374         return NDR_ERR_SUCCESS;
8375 }
8376
8377 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1534(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1534 *r)
8378 {
8379         if (ndr_flags & NDR_SCALARS) {
8380                 NDR_CHECK(ndr_pull_align(ndr, 4));
8381                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->oplockbreakwait));
8382         }
8383         if (ndr_flags & NDR_BUFFERS) {
8384         }
8385         return NDR_ERR_SUCCESS;
8386 }
8387
8388 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1534(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1534 *r)
8389 {
8390         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1534");
8391         ndr->depth++;
8392         ndr_print_uint32(ndr, "oplockbreakwait", r->oplockbreakwait);
8393         ndr->depth--;
8394 }
8395
8396 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1535(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1535 *r)
8397 {
8398         if (ndr_flags & NDR_SCALARS) {
8399                 NDR_CHECK(ndr_push_align(ndr, 4));
8400                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->oplockbreakresponsewait));
8401         }
8402         if (ndr_flags & NDR_BUFFERS) {
8403         }
8404         return NDR_ERR_SUCCESS;
8405 }
8406
8407 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1535(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1535 *r)
8408 {
8409         if (ndr_flags & NDR_SCALARS) {
8410                 NDR_CHECK(ndr_pull_align(ndr, 4));
8411                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->oplockbreakresponsewait));
8412         }
8413         if (ndr_flags & NDR_BUFFERS) {
8414         }
8415         return NDR_ERR_SUCCESS;
8416 }
8417
8418 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1535(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1535 *r)
8419 {
8420         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1535");
8421         ndr->depth++;
8422         ndr_print_uint32(ndr, "oplockbreakresponsewait", r->oplockbreakresponsewait);
8423         ndr->depth--;
8424 }
8425
8426 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1536(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1536 *r)
8427 {
8428         if (ndr_flags & NDR_SCALARS) {
8429                 NDR_CHECK(ndr_push_align(ndr, 4));
8430                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableoplocks));
8431         }
8432         if (ndr_flags & NDR_BUFFERS) {
8433         }
8434         return NDR_ERR_SUCCESS;
8435 }
8436
8437 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1536(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1536 *r)
8438 {
8439         if (ndr_flags & NDR_SCALARS) {
8440                 NDR_CHECK(ndr_pull_align(ndr, 4));
8441                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableoplocks));
8442         }
8443         if (ndr_flags & NDR_BUFFERS) {
8444         }
8445         return NDR_ERR_SUCCESS;
8446 }
8447
8448 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1536(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1536 *r)
8449 {
8450         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1536");
8451         ndr->depth++;
8452         ndr_print_uint32(ndr, "enableoplocks", r->enableoplocks);
8453         ndr->depth--;
8454 }
8455
8456 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1537(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1537 *r)
8457 {
8458         if (ndr_flags & NDR_SCALARS) {
8459                 NDR_CHECK(ndr_push_align(ndr, 4));
8460                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableoplockforceclose));
8461         }
8462         if (ndr_flags & NDR_BUFFERS) {
8463         }
8464         return NDR_ERR_SUCCESS;
8465 }
8466
8467 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1537(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1537 *r)
8468 {
8469         if (ndr_flags & NDR_SCALARS) {
8470                 NDR_CHECK(ndr_pull_align(ndr, 4));
8471                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableoplockforceclose));
8472         }
8473         if (ndr_flags & NDR_BUFFERS) {
8474         }
8475         return NDR_ERR_SUCCESS;
8476 }
8477
8478 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1537(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1537 *r)
8479 {
8480         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1537");
8481         ndr->depth++;
8482         ndr_print_uint32(ndr, "enableoplockforceclose", r->enableoplockforceclose);
8483         ndr->depth--;
8484 }
8485
8486 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1538(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1538 *r)
8487 {
8488         if (ndr_flags & NDR_SCALARS) {
8489                 NDR_CHECK(ndr_push_align(ndr, 4));
8490                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablefcbopens));
8491         }
8492         if (ndr_flags & NDR_BUFFERS) {
8493         }
8494         return NDR_ERR_SUCCESS;
8495 }
8496
8497 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1538(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1538 *r)
8498 {
8499         if (ndr_flags & NDR_SCALARS) {
8500                 NDR_CHECK(ndr_pull_align(ndr, 4));
8501                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablefcbopens));
8502         }
8503         if (ndr_flags & NDR_BUFFERS) {
8504         }
8505         return NDR_ERR_SUCCESS;
8506 }
8507
8508 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1538(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1538 *r)
8509 {
8510         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1538");
8511         ndr->depth++;
8512         ndr_print_uint32(ndr, "enablefcbopens", r->enablefcbopens);
8513         ndr->depth--;
8514 }
8515
8516 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1539(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1539 *r)
8517 {
8518         if (ndr_flags & NDR_SCALARS) {
8519                 NDR_CHECK(ndr_push_align(ndr, 4));
8520                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableraw));
8521         }
8522         if (ndr_flags & NDR_BUFFERS) {
8523         }
8524         return NDR_ERR_SUCCESS;
8525 }
8526
8527 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1539(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1539 *r)
8528 {
8529         if (ndr_flags & NDR_SCALARS) {
8530                 NDR_CHECK(ndr_pull_align(ndr, 4));
8531                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableraw));
8532         }
8533         if (ndr_flags & NDR_BUFFERS) {
8534         }
8535         return NDR_ERR_SUCCESS;
8536 }
8537
8538 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1539(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1539 *r)
8539 {
8540         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1539");
8541         ndr->depth++;
8542         ndr_print_uint32(ndr, "enableraw", r->enableraw);
8543         ndr->depth--;
8544 }
8545
8546 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1540(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1540 *r)
8547 {
8548         if (ndr_flags & NDR_SCALARS) {
8549                 NDR_CHECK(ndr_push_align(ndr, 4));
8550                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablesharednetdrives));
8551         }
8552         if (ndr_flags & NDR_BUFFERS) {
8553         }
8554         return NDR_ERR_SUCCESS;
8555 }
8556
8557 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1540(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1540 *r)
8558 {
8559         if (ndr_flags & NDR_SCALARS) {
8560                 NDR_CHECK(ndr_pull_align(ndr, 4));
8561                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablesharednetdrives));
8562         }
8563         if (ndr_flags & NDR_BUFFERS) {
8564         }
8565         return NDR_ERR_SUCCESS;
8566 }
8567
8568 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1540(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1540 *r)
8569 {
8570         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1540");
8571         ndr->depth++;
8572         ndr_print_uint32(ndr, "enablesharednetdrives", r->enablesharednetdrives);
8573         ndr->depth--;
8574 }
8575
8576 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1541(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1541 *r)
8577 {
8578         if (ndr_flags & NDR_SCALARS) {
8579                 NDR_CHECK(ndr_push_align(ndr, 4));
8580                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minfreeconnections));
8581         }
8582         if (ndr_flags & NDR_BUFFERS) {
8583         }
8584         return NDR_ERR_SUCCESS;
8585 }
8586
8587 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1541(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1541 *r)
8588 {
8589         if (ndr_flags & NDR_SCALARS) {
8590                 NDR_CHECK(ndr_pull_align(ndr, 4));
8591                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minfreeconnections));
8592         }
8593         if (ndr_flags & NDR_BUFFERS) {
8594         }
8595         return NDR_ERR_SUCCESS;
8596 }
8597
8598 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1541(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1541 *r)
8599 {
8600         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1541");
8601         ndr->depth++;
8602         ndr_print_uint32(ndr, "minfreeconnections", r->minfreeconnections);
8603         ndr->depth--;
8604 }
8605
8606 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1542(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1542 *r)
8607 {
8608         if (ndr_flags & NDR_SCALARS) {
8609                 NDR_CHECK(ndr_push_align(ndr, 4));
8610                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxfreeconnections));
8611         }
8612         if (ndr_flags & NDR_BUFFERS) {
8613         }
8614         return NDR_ERR_SUCCESS;
8615 }
8616
8617 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1542(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1542 *r)
8618 {
8619         if (ndr_flags & NDR_SCALARS) {
8620                 NDR_CHECK(ndr_pull_align(ndr, 4));
8621                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxfreeconnections));
8622         }
8623         if (ndr_flags & NDR_BUFFERS) {
8624         }
8625         return NDR_ERR_SUCCESS;
8626 }
8627
8628 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1542(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1542 *r)
8629 {
8630         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1542");
8631         ndr->depth++;
8632         ndr_print_uint32(ndr, "maxfreeconnections", r->maxfreeconnections);
8633         ndr->depth--;
8634 }
8635
8636 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1543(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1543 *r)
8637 {
8638         if (ndr_flags & NDR_SCALARS) {
8639                 NDR_CHECK(ndr_push_align(ndr, 4));
8640                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initsesstable));
8641         }
8642         if (ndr_flags & NDR_BUFFERS) {
8643         }
8644         return NDR_ERR_SUCCESS;
8645 }
8646
8647 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1543(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1543 *r)
8648 {
8649         if (ndr_flags & NDR_SCALARS) {
8650                 NDR_CHECK(ndr_pull_align(ndr, 4));
8651                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initsesstable));
8652         }
8653         if (ndr_flags & NDR_BUFFERS) {
8654         }
8655         return NDR_ERR_SUCCESS;
8656 }
8657
8658 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1543(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1543 *r)
8659 {
8660         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1543");
8661         ndr->depth++;
8662         ndr_print_uint32(ndr, "initsesstable", r->initsesstable);
8663         ndr->depth--;
8664 }
8665
8666 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1544(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1544 *r)
8667 {
8668         if (ndr_flags & NDR_SCALARS) {
8669                 NDR_CHECK(ndr_push_align(ndr, 4));
8670                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initconntable));
8671         }
8672         if (ndr_flags & NDR_BUFFERS) {
8673         }
8674         return NDR_ERR_SUCCESS;
8675 }
8676
8677 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1544(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1544 *r)
8678 {
8679         if (ndr_flags & NDR_SCALARS) {
8680                 NDR_CHECK(ndr_pull_align(ndr, 4));
8681                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initconntable));
8682         }
8683         if (ndr_flags & NDR_BUFFERS) {
8684         }
8685         return NDR_ERR_SUCCESS;
8686 }
8687
8688 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1544(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1544 *r)
8689 {
8690         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1544");
8691         ndr->depth++;
8692         ndr_print_uint32(ndr, "initconntable", r->initconntable);
8693         ndr->depth--;
8694 }
8695
8696 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1545(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1545 *r)
8697 {
8698         if (ndr_flags & NDR_SCALARS) {
8699                 NDR_CHECK(ndr_push_align(ndr, 4));
8700                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initfiletable));
8701         }
8702         if (ndr_flags & NDR_BUFFERS) {
8703         }
8704         return NDR_ERR_SUCCESS;
8705 }
8706
8707 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1545(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1545 *r)
8708 {
8709         if (ndr_flags & NDR_SCALARS) {
8710                 NDR_CHECK(ndr_pull_align(ndr, 4));
8711                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initfiletable));
8712         }
8713         if (ndr_flags & NDR_BUFFERS) {
8714         }
8715         return NDR_ERR_SUCCESS;
8716 }
8717
8718 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1545(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1545 *r)
8719 {
8720         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1545");
8721         ndr->depth++;
8722         ndr_print_uint32(ndr, "initfiletable", r->initfiletable);
8723         ndr->depth--;
8724 }
8725
8726 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1546(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1546 *r)
8727 {
8728         if (ndr_flags & NDR_SCALARS) {
8729                 NDR_CHECK(ndr_push_align(ndr, 4));
8730                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initsearchtable));
8731         }
8732         if (ndr_flags & NDR_BUFFERS) {
8733         }
8734         return NDR_ERR_SUCCESS;
8735 }
8736
8737 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1546(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1546 *r)
8738 {
8739         if (ndr_flags & NDR_SCALARS) {
8740                 NDR_CHECK(ndr_pull_align(ndr, 4));
8741                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initsearchtable));
8742         }
8743         if (ndr_flags & NDR_BUFFERS) {
8744         }
8745         return NDR_ERR_SUCCESS;
8746 }
8747
8748 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1546(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1546 *r)
8749 {
8750         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1546");
8751         ndr->depth++;
8752         ndr_print_uint32(ndr, "initsearchtable", r->initsearchtable);
8753         ndr->depth--;
8754 }
8755
8756 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1547(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1547 *r)
8757 {
8758         if (ndr_flags & NDR_SCALARS) {
8759                 NDR_CHECK(ndr_push_align(ndr, 4));
8760                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alertsched));
8761         }
8762         if (ndr_flags & NDR_BUFFERS) {
8763         }
8764         return NDR_ERR_SUCCESS;
8765 }
8766
8767 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1547(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1547 *r)
8768 {
8769         if (ndr_flags & NDR_SCALARS) {
8770                 NDR_CHECK(ndr_pull_align(ndr, 4));
8771                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alertsched));
8772         }
8773         if (ndr_flags & NDR_BUFFERS) {
8774         }
8775         return NDR_ERR_SUCCESS;
8776 }
8777
8778 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1547(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1547 *r)
8779 {
8780         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1547");
8781         ndr->depth++;
8782         ndr_print_uint32(ndr, "alertsched", r->alertsched);
8783         ndr->depth--;
8784 }
8785
8786 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1548(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1548 *r)
8787 {
8788         if (ndr_flags & NDR_SCALARS) {
8789                 NDR_CHECK(ndr_push_align(ndr, 4));
8790                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->errortreshold));
8791         }
8792         if (ndr_flags & NDR_BUFFERS) {
8793         }
8794         return NDR_ERR_SUCCESS;
8795 }
8796
8797 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1548(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1548 *r)
8798 {
8799         if (ndr_flags & NDR_SCALARS) {
8800                 NDR_CHECK(ndr_pull_align(ndr, 4));
8801                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->errortreshold));
8802         }
8803         if (ndr_flags & NDR_BUFFERS) {
8804         }
8805         return NDR_ERR_SUCCESS;
8806 }
8807
8808 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1548(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1548 *r)
8809 {
8810         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1548");
8811         ndr->depth++;
8812         ndr_print_uint32(ndr, "errortreshold", r->errortreshold);
8813         ndr->depth--;
8814 }
8815
8816 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1549(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1549 *r)
8817 {
8818         if (ndr_flags & NDR_SCALARS) {
8819                 NDR_CHECK(ndr_push_align(ndr, 4));
8820                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->networkerrortreshold));
8821         }
8822         if (ndr_flags & NDR_BUFFERS) {
8823         }
8824         return NDR_ERR_SUCCESS;
8825 }
8826
8827 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1549(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1549 *r)
8828 {
8829         if (ndr_flags & NDR_SCALARS) {
8830                 NDR_CHECK(ndr_pull_align(ndr, 4));
8831                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->networkerrortreshold));
8832         }
8833         if (ndr_flags & NDR_BUFFERS) {
8834         }
8835         return NDR_ERR_SUCCESS;
8836 }
8837
8838 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1549(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1549 *r)
8839 {
8840         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1549");
8841         ndr->depth++;
8842         ndr_print_uint32(ndr, "networkerrortreshold", r->networkerrortreshold);
8843         ndr->depth--;
8844 }
8845
8846 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1550(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1550 *r)
8847 {
8848         if (ndr_flags & NDR_SCALARS) {
8849                 NDR_CHECK(ndr_push_align(ndr, 4));
8850                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->diskspacetreshold));
8851         }
8852         if (ndr_flags & NDR_BUFFERS) {
8853         }
8854         return NDR_ERR_SUCCESS;
8855 }
8856
8857 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1550(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1550 *r)
8858 {
8859         if (ndr_flags & NDR_SCALARS) {
8860                 NDR_CHECK(ndr_pull_align(ndr, 4));
8861                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->diskspacetreshold));
8862         }
8863         if (ndr_flags & NDR_BUFFERS) {
8864         }
8865         return NDR_ERR_SUCCESS;
8866 }
8867
8868 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1550(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1550 *r)
8869 {
8870         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1550");
8871         ndr->depth++;
8872         ndr_print_uint32(ndr, "diskspacetreshold", r->diskspacetreshold);
8873         ndr->depth--;
8874 }
8875
8876 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1552(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1552 *r)
8877 {
8878         if (ndr_flags & NDR_SCALARS) {
8879                 NDR_CHECK(ndr_push_align(ndr, 4));
8880                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxlinkdelay));
8881         }
8882         if (ndr_flags & NDR_BUFFERS) {
8883         }
8884         return NDR_ERR_SUCCESS;
8885 }
8886
8887 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1552(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1552 *r)
8888 {
8889         if (ndr_flags & NDR_SCALARS) {
8890                 NDR_CHECK(ndr_pull_align(ndr, 4));
8891                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxlinkdelay));
8892         }
8893         if (ndr_flags & NDR_BUFFERS) {
8894         }
8895         return NDR_ERR_SUCCESS;
8896 }
8897
8898 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1552(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1552 *r)
8899 {
8900         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1552");
8901         ndr->depth++;
8902         ndr_print_uint32(ndr, "maxlinkdelay", r->maxlinkdelay);
8903         ndr->depth--;
8904 }
8905
8906 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1553(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1553 *r)
8907 {
8908         if (ndr_flags & NDR_SCALARS) {
8909                 NDR_CHECK(ndr_push_align(ndr, 4));
8910                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minlinkthroughput));
8911         }
8912         if (ndr_flags & NDR_BUFFERS) {
8913         }
8914         return NDR_ERR_SUCCESS;
8915 }
8916
8917 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1553(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1553 *r)
8918 {
8919         if (ndr_flags & NDR_SCALARS) {
8920                 NDR_CHECK(ndr_pull_align(ndr, 4));
8921                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minlinkthroughput));
8922         }
8923         if (ndr_flags & NDR_BUFFERS) {
8924         }
8925         return NDR_ERR_SUCCESS;
8926 }
8927
8928 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1553(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1553 *r)
8929 {
8930         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1553");
8931         ndr->depth++;
8932         ndr_print_uint32(ndr, "minlinkthroughput", r->minlinkthroughput);
8933         ndr->depth--;
8934 }
8935
8936 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1554(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1554 *r)
8937 {
8938         if (ndr_flags & NDR_SCALARS) {
8939                 NDR_CHECK(ndr_push_align(ndr, 4));
8940                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->linkinfovalidtime));
8941         }
8942         if (ndr_flags & NDR_BUFFERS) {
8943         }
8944         return NDR_ERR_SUCCESS;
8945 }
8946
8947 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1554(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1554 *r)
8948 {
8949         if (ndr_flags & NDR_SCALARS) {
8950                 NDR_CHECK(ndr_pull_align(ndr, 4));
8951                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->linkinfovalidtime));
8952         }
8953         if (ndr_flags & NDR_BUFFERS) {
8954         }
8955         return NDR_ERR_SUCCESS;
8956 }
8957
8958 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1554(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1554 *r)
8959 {
8960         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1554");
8961         ndr->depth++;
8962         ndr_print_uint32(ndr, "linkinfovalidtime", r->linkinfovalidtime);
8963         ndr->depth--;
8964 }
8965
8966 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1555(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1555 *r)
8967 {
8968         if (ndr_flags & NDR_SCALARS) {
8969                 NDR_CHECK(ndr_push_align(ndr, 4));
8970                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->scavqosinfoupdatetime));
8971         }
8972         if (ndr_flags & NDR_BUFFERS) {
8973         }
8974         return NDR_ERR_SUCCESS;
8975 }
8976
8977 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1555(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1555 *r)
8978 {
8979         if (ndr_flags & NDR_SCALARS) {
8980                 NDR_CHECK(ndr_pull_align(ndr, 4));
8981                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->scavqosinfoupdatetime));
8982         }
8983         if (ndr_flags & NDR_BUFFERS) {
8984         }
8985         return NDR_ERR_SUCCESS;
8986 }
8987
8988 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1555(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1555 *r)
8989 {
8990         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1555");
8991         ndr->depth++;
8992         ndr_print_uint32(ndr, "scavqosinfoupdatetime", r->scavqosinfoupdatetime);
8993         ndr->depth--;
8994 }
8995
8996 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1556(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1556 *r)
8997 {
8998         if (ndr_flags & NDR_SCALARS) {
8999                 NDR_CHECK(ndr_push_align(ndr, 4));
9000                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxworkitemidletime));
9001         }
9002         if (ndr_flags & NDR_BUFFERS) {
9003         }
9004         return NDR_ERR_SUCCESS;
9005 }
9006
9007 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1556(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1556 *r)
9008 {
9009         if (ndr_flags & NDR_SCALARS) {
9010                 NDR_CHECK(ndr_pull_align(ndr, 4));
9011                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxworkitemidletime));
9012         }
9013         if (ndr_flags & NDR_BUFFERS) {
9014         }
9015         return NDR_ERR_SUCCESS;
9016 }
9017
9018 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1556(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1556 *r)
9019 {
9020         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1556");
9021         ndr->depth++;
9022         ndr_print_uint32(ndr, "maxworkitemidletime", r->maxworkitemidletime);
9023         ndr->depth--;
9024 }
9025
9026 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetSrvInfo *r)
9027 {
9028         if (ndr_flags & NDR_SCALARS) {
9029                 int level = ndr_push_get_switch_value(ndr, r);
9030                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
9031                 switch (level) {
9032                         case 100: {
9033                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info100));
9034                         break; }
9035
9036                         case 101: {
9037                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info101));
9038                         break; }
9039
9040                         case 102: {
9041                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info102));
9042                         break; }
9043
9044                         case 402: {
9045                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info402));
9046                         break; }
9047
9048                         case 403: {
9049                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info403));
9050                         break; }
9051
9052                         case 502: {
9053                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info502));
9054                         break; }
9055
9056                         case 503: {
9057                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info503));
9058                         break; }
9059
9060                         case 599: {
9061                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info599));
9062                         break; }
9063
9064                         case 1005: {
9065                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1005));
9066                         break; }
9067
9068                         case 1010: {
9069                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1010));
9070                         break; }
9071
9072                         case 1016: {
9073                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1016));
9074                         break; }
9075
9076                         case 1017: {
9077                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1017));
9078                         break; }
9079
9080                         case 1018: {
9081                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1018));
9082                         break; }
9083
9084                         case 1107: {
9085                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1107));
9086                         break; }
9087
9088                         case 1501: {
9089                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1501));
9090                         break; }
9091
9092                         case 1502: {
9093                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1502));
9094                         break; }
9095
9096                         case 1503: {
9097                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1503));
9098                         break; }
9099
9100                         case 1506: {
9101                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1506));
9102                         break; }
9103
9104                         case 1509: {
9105                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1509));
9106                         break; }
9107
9108                         case 1510: {
9109                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1510));
9110                         break; }
9111
9112                         case 1511: {
9113                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1511));
9114                         break; }
9115
9116                         case 1512: {
9117                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1512));
9118                         break; }
9119
9120                         case 1513: {
9121                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1513));
9122                         break; }
9123
9124                         case 1514: {
9125                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1514));
9126                         break; }
9127
9128                         case 1515: {
9129                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1515));
9130                         break; }
9131
9132                         case 1516: {
9133                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1516));
9134                         break; }
9135
9136                         case 1518: {
9137                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1518));
9138                         break; }
9139
9140                         case 1520: {
9141                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1520));
9142                         break; }
9143
9144                         case 1521: {
9145                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1521));
9146                         break; }
9147
9148                         case 1522: {
9149                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1522));
9150                         break; }
9151
9152                         case 1523: {
9153                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1523));
9154                         break; }
9155
9156                         case 1524: {
9157                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1524));
9158                         break; }
9159
9160                         case 1525: {
9161                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1525));
9162                         break; }
9163
9164                         case 1528: {
9165                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1528));
9166                         break; }
9167
9168                         case 1529: {
9169                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1529));
9170                         break; }
9171
9172                         case 1530: {
9173                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1530));
9174                         break; }
9175
9176                         case 1533: {
9177                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1533));
9178                         break; }
9179
9180                         case 1534: {
9181                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1534));
9182                         break; }
9183
9184                         case 1535: {
9185                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1535));
9186                         break; }
9187
9188                         case 1536: {
9189                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1536));
9190                         break; }
9191
9192                         case 1537: {
9193                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1537));
9194                         break; }
9195
9196                         case 1538: {
9197                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1538));
9198                         break; }
9199
9200                         case 1539: {
9201                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1539));
9202                         break; }
9203
9204                         case 1540: {
9205                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1540));
9206                         break; }
9207
9208                         case 1541: {
9209                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1541));
9210                         break; }
9211
9212                         case 1542: {
9213                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1542));
9214                         break; }
9215
9216                         case 1543: {
9217                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1543));
9218                         break; }
9219
9220                         case 1544: {
9221                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1544));
9222                         break; }
9223
9224                         case 1545: {
9225                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1545));
9226                         break; }
9227
9228                         case 1546: {
9229                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1546));
9230                         break; }
9231
9232                         case 1547: {
9233                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1547));
9234                         break; }
9235
9236                         case 1548: {
9237                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1548));
9238                         break; }
9239
9240                         case 1549: {
9241                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1549));
9242                         break; }
9243
9244                         case 1550: {
9245                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1550));
9246                         break; }
9247
9248                         case 1552: {
9249                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1552));
9250                         break; }
9251
9252                         case 1553: {
9253                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1553));
9254                         break; }
9255
9256                         case 1554: {
9257                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1554));
9258                         break; }
9259
9260                         case 1555: {
9261                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1555));
9262                         break; }
9263
9264                         case 1556: {
9265                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1556));
9266                         break; }
9267
9268                         default: {
9269                         break; }
9270
9271                 }
9272         }
9273         if (ndr_flags & NDR_BUFFERS) {
9274                 int level = ndr_push_get_switch_value(ndr, r);
9275                 switch (level) {
9276                         case 100:
9277                                 if (r->info100) {
9278                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo100(ndr, NDR_SCALARS|NDR_BUFFERS, r->info100));
9279                                 }
9280                         break;
9281
9282                         case 101:
9283                                 if (r->info101) {
9284                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info101));
9285                                 }
9286                         break;
9287
9288                         case 102:
9289                                 if (r->info102) {
9290                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo102(ndr, NDR_SCALARS|NDR_BUFFERS, r->info102));
9291                                 }
9292                         break;
9293
9294                         case 402:
9295                                 if (r->info402) {
9296                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo402(ndr, NDR_SCALARS|NDR_BUFFERS, r->info402));
9297                                 }
9298                         break;
9299
9300                         case 403:
9301                                 if (r->info403) {
9302                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo403(ndr, NDR_SCALARS|NDR_BUFFERS, r->info403));
9303                                 }
9304                         break;
9305
9306                         case 502:
9307                                 if (r->info502) {
9308                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo502(ndr, NDR_SCALARS, r->info502));
9309                                 }
9310                         break;
9311
9312                         case 503:
9313                                 if (r->info503) {
9314                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo503(ndr, NDR_SCALARS|NDR_BUFFERS, r->info503));
9315                                 }
9316                         break;
9317
9318                         case 599:
9319                                 if (r->info599) {
9320                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo599(ndr, NDR_SCALARS|NDR_BUFFERS, r->info599));
9321                                 }
9322                         break;
9323
9324                         case 1005:
9325                                 if (r->info1005) {
9326                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1005(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1005));
9327                                 }
9328                         break;
9329
9330                         case 1010:
9331                                 if (r->info1010) {
9332                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1010(ndr, NDR_SCALARS, r->info1010));
9333                                 }
9334                         break;
9335
9336                         case 1016:
9337                                 if (r->info1016) {
9338                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1016(ndr, NDR_SCALARS, r->info1016));
9339                                 }
9340                         break;
9341
9342                         case 1017:
9343                                 if (r->info1017) {
9344                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1017(ndr, NDR_SCALARS, r->info1017));
9345                                 }
9346                         break;
9347
9348                         case 1018:
9349                                 if (r->info1018) {
9350                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1018(ndr, NDR_SCALARS, r->info1018));
9351                                 }
9352                         break;
9353
9354                         case 1107:
9355                                 if (r->info1107) {
9356                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1107(ndr, NDR_SCALARS, r->info1107));
9357                                 }
9358                         break;
9359
9360                         case 1501:
9361                                 if (r->info1501) {
9362                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1501(ndr, NDR_SCALARS, r->info1501));
9363                                 }
9364                         break;
9365
9366                         case 1502:
9367                                 if (r->info1502) {
9368                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1502(ndr, NDR_SCALARS, r->info1502));
9369                                 }
9370                         break;
9371
9372                         case 1503:
9373                                 if (r->info1503) {
9374                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1503(ndr, NDR_SCALARS, r->info1503));
9375                                 }
9376                         break;
9377
9378                         case 1506:
9379                                 if (r->info1506) {
9380                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1506(ndr, NDR_SCALARS, r->info1506));
9381                                 }
9382                         break;
9383
9384                         case 1509:
9385                                 if (r->info1509) {
9386                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1509(ndr, NDR_SCALARS, r->info1509));
9387                                 }
9388                         break;
9389
9390                         case 1510:
9391                                 if (r->info1510) {
9392                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1510(ndr, NDR_SCALARS, r->info1510));
9393                                 }
9394                         break;
9395
9396                         case 1511:
9397                                 if (r->info1511) {
9398                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1511(ndr, NDR_SCALARS, r->info1511));
9399                                 }
9400                         break;
9401
9402                         case 1512:
9403                                 if (r->info1512) {
9404                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1512(ndr, NDR_SCALARS, r->info1512));
9405                                 }
9406                         break;
9407
9408                         case 1513:
9409                                 if (r->info1513) {
9410                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1513(ndr, NDR_SCALARS, r->info1513));
9411                                 }
9412                         break;
9413
9414                         case 1514:
9415                                 if (r->info1514) {
9416                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1514(ndr, NDR_SCALARS, r->info1514));
9417                                 }
9418                         break;
9419
9420                         case 1515:
9421                                 if (r->info1515) {
9422                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1515(ndr, NDR_SCALARS, r->info1515));
9423                                 }
9424                         break;
9425
9426                         case 1516:
9427                                 if (r->info1516) {
9428                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1516(ndr, NDR_SCALARS, r->info1516));
9429                                 }
9430                         break;
9431
9432                         case 1518:
9433                                 if (r->info1518) {
9434                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1518(ndr, NDR_SCALARS, r->info1518));
9435                                 }
9436                         break;
9437
9438                         case 1520:
9439                                 if (r->info1520) {
9440                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1520(ndr, NDR_SCALARS, r->info1520));
9441                                 }
9442                         break;
9443
9444                         case 1521:
9445                                 if (r->info1521) {
9446                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1521(ndr, NDR_SCALARS, r->info1521));
9447                                 }
9448                         break;
9449
9450                         case 1522:
9451                                 if (r->info1522) {
9452                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1522(ndr, NDR_SCALARS, r->info1522));
9453                                 }
9454                         break;
9455
9456                         case 1523:
9457                                 if (r->info1523) {
9458                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1523(ndr, NDR_SCALARS, r->info1523));
9459                                 }
9460                         break;
9461
9462                         case 1524:
9463                                 if (r->info1524) {
9464                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1524(ndr, NDR_SCALARS, r->info1524));
9465                                 }
9466                         break;
9467
9468                         case 1525:
9469                                 if (r->info1525) {
9470                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1525(ndr, NDR_SCALARS, r->info1525));
9471                                 }
9472                         break;
9473
9474                         case 1528:
9475                                 if (r->info1528) {
9476                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1528(ndr, NDR_SCALARS, r->info1528));
9477                                 }
9478                         break;
9479
9480                         case 1529:
9481                                 if (r->info1529) {
9482                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1529(ndr, NDR_SCALARS, r->info1529));
9483                                 }
9484                         break;
9485
9486                         case 1530:
9487                                 if (r->info1530) {
9488                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1530(ndr, NDR_SCALARS, r->info1530));
9489                                 }
9490                         break;
9491
9492                         case 1533:
9493                                 if (r->info1533) {
9494                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1533(ndr, NDR_SCALARS, r->info1533));
9495                                 }
9496                         break;
9497
9498                         case 1534:
9499                                 if (r->info1534) {
9500                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1534(ndr, NDR_SCALARS, r->info1534));
9501                                 }
9502                         break;
9503
9504                         case 1535:
9505                                 if (r->info1535) {
9506                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1535(ndr, NDR_SCALARS, r->info1535));
9507                                 }
9508                         break;
9509
9510                         case 1536:
9511                                 if (r->info1536) {
9512                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1536(ndr, NDR_SCALARS, r->info1536));
9513                                 }
9514                         break;
9515
9516                         case 1537:
9517                                 if (r->info1537) {
9518                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1537(ndr, NDR_SCALARS, r->info1537));
9519                                 }
9520                         break;
9521
9522                         case 1538:
9523                                 if (r->info1538) {
9524                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1538(ndr, NDR_SCALARS, r->info1538));
9525                                 }
9526                         break;
9527
9528                         case 1539:
9529                                 if (r->info1539) {
9530                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1539(ndr, NDR_SCALARS, r->info1539));
9531                                 }
9532                         break;
9533
9534                         case 1540:
9535                                 if (r->info1540) {
9536                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1540(ndr, NDR_SCALARS, r->info1540));
9537                                 }
9538                         break;
9539
9540                         case 1541:
9541                                 if (r->info1541) {
9542                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1541(ndr, NDR_SCALARS, r->info1541));
9543                                 }
9544                         break;
9545
9546                         case 1542:
9547                                 if (r->info1542) {
9548                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1542(ndr, NDR_SCALARS, r->info1542));
9549                                 }
9550                         break;
9551
9552                         case 1543:
9553                                 if (r->info1543) {
9554                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1543(ndr, NDR_SCALARS, r->info1543));
9555                                 }
9556                         break;
9557
9558                         case 1544:
9559                                 if (r->info1544) {
9560                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1544(ndr, NDR_SCALARS, r->info1544));
9561                                 }
9562                         break;
9563
9564                         case 1545:
9565                                 if (r->info1545) {
9566                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1545(ndr, NDR_SCALARS, r->info1545));
9567                                 }
9568                         break;
9569
9570                         case 1546:
9571                                 if (r->info1546) {
9572                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1546(ndr, NDR_SCALARS, r->info1546));
9573                                 }
9574                         break;
9575
9576                         case 1547:
9577                                 if (r->info1547) {
9578                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1547(ndr, NDR_SCALARS, r->info1547));
9579                                 }
9580                         break;
9581
9582                         case 1548:
9583                                 if (r->info1548) {
9584                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1548(ndr, NDR_SCALARS, r->info1548));
9585                                 }
9586                         break;
9587
9588                         case 1549:
9589                                 if (r->info1549) {
9590                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1549(ndr, NDR_SCALARS, r->info1549));
9591                                 }
9592                         break;
9593
9594                         case 1550:
9595                                 if (r->info1550) {
9596                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1550(ndr, NDR_SCALARS, r->info1550));
9597                                 }
9598                         break;
9599
9600                         case 1552:
9601                                 if (r->info1552) {
9602                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1552(ndr, NDR_SCALARS, r->info1552));
9603                                 }
9604                         break;
9605
9606                         case 1553:
9607                                 if (r->info1553) {
9608                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1553(ndr, NDR_SCALARS, r->info1553));
9609                                 }
9610                         break;
9611
9612                         case 1554:
9613                                 if (r->info1554) {
9614                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1554(ndr, NDR_SCALARS, r->info1554));
9615                                 }
9616                         break;
9617
9618                         case 1555:
9619                                 if (r->info1555) {
9620                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1555(ndr, NDR_SCALARS, r->info1555));
9621                                 }
9622                         break;
9623
9624                         case 1556:
9625                                 if (r->info1556) {
9626                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1556(ndr, NDR_SCALARS, r->info1556));
9627                                 }
9628                         break;
9629
9630                         default:
9631                         break;
9632
9633                 }
9634         }
9635         return NDR_ERR_SUCCESS;
9636 }
9637
9638 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetSrvInfo *r)
9639 {
9640         int level;
9641         uint32_t _level;
9642         TALLOC_CTX *_mem_save_info100_0;
9643         TALLOC_CTX *_mem_save_info101_0;
9644         TALLOC_CTX *_mem_save_info102_0;
9645         TALLOC_CTX *_mem_save_info402_0;
9646         TALLOC_CTX *_mem_save_info403_0;
9647         TALLOC_CTX *_mem_save_info502_0;
9648         TALLOC_CTX *_mem_save_info503_0;
9649         TALLOC_CTX *_mem_save_info599_0;
9650         TALLOC_CTX *_mem_save_info1005_0;
9651         TALLOC_CTX *_mem_save_info1010_0;
9652         TALLOC_CTX *_mem_save_info1016_0;
9653         TALLOC_CTX *_mem_save_info1017_0;
9654         TALLOC_CTX *_mem_save_info1018_0;
9655         TALLOC_CTX *_mem_save_info1107_0;
9656         TALLOC_CTX *_mem_save_info1501_0;
9657         TALLOC_CTX *_mem_save_info1502_0;
9658         TALLOC_CTX *_mem_save_info1503_0;
9659         TALLOC_CTX *_mem_save_info1506_0;
9660         TALLOC_CTX *_mem_save_info1509_0;
9661         TALLOC_CTX *_mem_save_info1510_0;
9662         TALLOC_CTX *_mem_save_info1511_0;
9663         TALLOC_CTX *_mem_save_info1512_0;
9664         TALLOC_CTX *_mem_save_info1513_0;
9665         TALLOC_CTX *_mem_save_info1514_0;
9666         TALLOC_CTX *_mem_save_info1515_0;
9667         TALLOC_CTX *_mem_save_info1516_0;
9668         TALLOC_CTX *_mem_save_info1518_0;
9669         TALLOC_CTX *_mem_save_info1520_0;
9670         TALLOC_CTX *_mem_save_info1521_0;
9671         TALLOC_CTX *_mem_save_info1522_0;
9672         TALLOC_CTX *_mem_save_info1523_0;
9673         TALLOC_CTX *_mem_save_info1524_0;
9674         TALLOC_CTX *_mem_save_info1525_0;
9675         TALLOC_CTX *_mem_save_info1528_0;
9676         TALLOC_CTX *_mem_save_info1529_0;
9677         TALLOC_CTX *_mem_save_info1530_0;
9678         TALLOC_CTX *_mem_save_info1533_0;
9679         TALLOC_CTX *_mem_save_info1534_0;
9680         TALLOC_CTX *_mem_save_info1535_0;
9681         TALLOC_CTX *_mem_save_info1536_0;
9682         TALLOC_CTX *_mem_save_info1537_0;
9683         TALLOC_CTX *_mem_save_info1538_0;
9684         TALLOC_CTX *_mem_save_info1539_0;
9685         TALLOC_CTX *_mem_save_info1540_0;
9686         TALLOC_CTX *_mem_save_info1541_0;
9687         TALLOC_CTX *_mem_save_info1542_0;
9688         TALLOC_CTX *_mem_save_info1543_0;
9689         TALLOC_CTX *_mem_save_info1544_0;
9690         TALLOC_CTX *_mem_save_info1545_0;
9691         TALLOC_CTX *_mem_save_info1546_0;
9692         TALLOC_CTX *_mem_save_info1547_0;
9693         TALLOC_CTX *_mem_save_info1548_0;
9694         TALLOC_CTX *_mem_save_info1549_0;
9695         TALLOC_CTX *_mem_save_info1550_0;
9696         TALLOC_CTX *_mem_save_info1552_0;
9697         TALLOC_CTX *_mem_save_info1553_0;
9698         TALLOC_CTX *_mem_save_info1554_0;
9699         TALLOC_CTX *_mem_save_info1555_0;
9700         TALLOC_CTX *_mem_save_info1556_0;
9701         level = ndr_pull_get_switch_value(ndr, r);
9702         if (ndr_flags & NDR_SCALARS) {
9703                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9704                 if (_level != level) {
9705                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
9706                 }
9707                 switch (level) {
9708                         case 100: {
9709                                 uint32_t _ptr_info100;
9710                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info100));
9711                                 if (_ptr_info100) {
9712                                         NDR_PULL_ALLOC(ndr, r->info100);
9713                                 } else {
9714                                         r->info100 = NULL;
9715                                 }
9716                         break; }
9717
9718                         case 101: {
9719                                 uint32_t _ptr_info101;
9720                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info101));
9721                                 if (_ptr_info101) {
9722                                         NDR_PULL_ALLOC(ndr, r->info101);
9723                                 } else {
9724                                         r->info101 = NULL;
9725                                 }
9726                         break; }
9727
9728                         case 102: {
9729                                 uint32_t _ptr_info102;
9730                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info102));
9731                                 if (_ptr_info102) {
9732                                         NDR_PULL_ALLOC(ndr, r->info102);
9733                                 } else {
9734                                         r->info102 = NULL;
9735                                 }
9736                         break; }
9737
9738                         case 402: {
9739                                 uint32_t _ptr_info402;
9740                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info402));
9741                                 if (_ptr_info402) {
9742                                         NDR_PULL_ALLOC(ndr, r->info402);
9743                                 } else {
9744                                         r->info402 = NULL;
9745                                 }
9746                         break; }
9747
9748                         case 403: {
9749                                 uint32_t _ptr_info403;
9750                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info403));
9751                                 if (_ptr_info403) {
9752                                         NDR_PULL_ALLOC(ndr, r->info403);
9753                                 } else {
9754                                         r->info403 = NULL;
9755                                 }
9756                         break; }
9757
9758                         case 502: {
9759                                 uint32_t _ptr_info502;
9760                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info502));
9761                                 if (_ptr_info502) {
9762                                         NDR_PULL_ALLOC(ndr, r->info502);
9763                                 } else {
9764                                         r->info502 = NULL;
9765                                 }
9766                         break; }
9767
9768                         case 503: {
9769                                 uint32_t _ptr_info503;
9770                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info503));
9771                                 if (_ptr_info503) {
9772                                         NDR_PULL_ALLOC(ndr, r->info503);
9773                                 } else {
9774                                         r->info503 = NULL;
9775                                 }
9776                         break; }
9777
9778                         case 599: {
9779                                 uint32_t _ptr_info599;
9780                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info599));
9781                                 if (_ptr_info599) {
9782                                         NDR_PULL_ALLOC(ndr, r->info599);
9783                                 } else {
9784                                         r->info599 = NULL;
9785                                 }
9786                         break; }
9787
9788                         case 1005: {
9789                                 uint32_t _ptr_info1005;
9790                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1005));
9791                                 if (_ptr_info1005) {
9792                                         NDR_PULL_ALLOC(ndr, r->info1005);
9793                                 } else {
9794                                         r->info1005 = NULL;
9795                                 }
9796                         break; }
9797
9798                         case 1010: {
9799                                 uint32_t _ptr_info1010;
9800                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1010));
9801                                 if (_ptr_info1010) {
9802                                         NDR_PULL_ALLOC(ndr, r->info1010);
9803                                 } else {
9804                                         r->info1010 = NULL;
9805                                 }
9806                         break; }
9807
9808                         case 1016: {
9809                                 uint32_t _ptr_info1016;
9810                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1016));
9811                                 if (_ptr_info1016) {
9812                                         NDR_PULL_ALLOC(ndr, r->info1016);
9813                                 } else {
9814                                         r->info1016 = NULL;
9815                                 }
9816                         break; }
9817
9818                         case 1017: {
9819                                 uint32_t _ptr_info1017;
9820                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1017));
9821                                 if (_ptr_info1017) {
9822                                         NDR_PULL_ALLOC(ndr, r->info1017);
9823                                 } else {
9824                                         r->info1017 = NULL;
9825                                 }
9826                         break; }
9827
9828                         case 1018: {
9829                                 uint32_t _ptr_info1018;
9830                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1018));
9831                                 if (_ptr_info1018) {
9832                                         NDR_PULL_ALLOC(ndr, r->info1018);
9833                                 } else {
9834                                         r->info1018 = NULL;
9835                                 }
9836                         break; }
9837
9838                         case 1107: {
9839                                 uint32_t _ptr_info1107;
9840                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1107));
9841                                 if (_ptr_info1107) {
9842                                         NDR_PULL_ALLOC(ndr, r->info1107);
9843                                 } else {
9844                                         r->info1107 = NULL;
9845                                 }
9846                         break; }
9847
9848                         case 1501: {
9849                                 uint32_t _ptr_info1501;
9850                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1501));
9851                                 if (_ptr_info1501) {
9852                                         NDR_PULL_ALLOC(ndr, r->info1501);
9853                                 } else {
9854                                         r->info1501 = NULL;
9855                                 }
9856                         break; }
9857
9858                         case 1502: {
9859                                 uint32_t _ptr_info1502;
9860                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1502));
9861                                 if (_ptr_info1502) {
9862                                         NDR_PULL_ALLOC(ndr, r->info1502);
9863                                 } else {
9864                                         r->info1502 = NULL;
9865                                 }
9866                         break; }
9867
9868                         case 1503: {
9869                                 uint32_t _ptr_info1503;
9870                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1503));
9871                                 if (_ptr_info1503) {
9872                                         NDR_PULL_ALLOC(ndr, r->info1503);
9873                                 } else {
9874                                         r->info1503 = NULL;
9875                                 }
9876                         break; }
9877
9878                         case 1506: {
9879                                 uint32_t _ptr_info1506;
9880                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1506));
9881                                 if (_ptr_info1506) {
9882                                         NDR_PULL_ALLOC(ndr, r->info1506);
9883                                 } else {
9884                                         r->info1506 = NULL;
9885                                 }
9886                         break; }
9887
9888                         case 1509: {
9889                                 uint32_t _ptr_info1509;
9890                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1509));
9891                                 if (_ptr_info1509) {
9892                                         NDR_PULL_ALLOC(ndr, r->info1509);
9893                                 } else {
9894                                         r->info1509 = NULL;
9895                                 }
9896                         break; }
9897
9898                         case 1510: {
9899                                 uint32_t _ptr_info1510;
9900                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1510));
9901                                 if (_ptr_info1510) {
9902                                         NDR_PULL_ALLOC(ndr, r->info1510);
9903                                 } else {
9904                                         r->info1510 = NULL;
9905                                 }
9906                         break; }
9907
9908                         case 1511: {
9909                                 uint32_t _ptr_info1511;
9910                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1511));
9911                                 if (_ptr_info1511) {
9912                                         NDR_PULL_ALLOC(ndr, r->info1511);
9913                                 } else {
9914                                         r->info1511 = NULL;
9915                                 }
9916                         break; }
9917
9918                         case 1512: {
9919                                 uint32_t _ptr_info1512;
9920                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1512));
9921                                 if (_ptr_info1512) {
9922                                         NDR_PULL_ALLOC(ndr, r->info1512);
9923                                 } else {
9924                                         r->info1512 = NULL;
9925                                 }
9926                         break; }
9927
9928                         case 1513: {
9929                                 uint32_t _ptr_info1513;
9930                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1513));
9931                                 if (_ptr_info1513) {
9932                                         NDR_PULL_ALLOC(ndr, r->info1513);
9933                                 } else {
9934                                         r->info1513 = NULL;
9935                                 }
9936                         break; }
9937
9938                         case 1514: {
9939                                 uint32_t _ptr_info1514;
9940                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1514));
9941                                 if (_ptr_info1514) {
9942                                         NDR_PULL_ALLOC(ndr, r->info1514);
9943                                 } else {
9944                                         r->info1514 = NULL;
9945                                 }
9946                         break; }
9947
9948                         case 1515: {
9949                                 uint32_t _ptr_info1515;
9950                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1515));
9951                                 if (_ptr_info1515) {
9952                                         NDR_PULL_ALLOC(ndr, r->info1515);
9953                                 } else {
9954                                         r->info1515 = NULL;
9955                                 }
9956                         break; }
9957
9958                         case 1516: {
9959                                 uint32_t _ptr_info1516;
9960                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1516));
9961                                 if (_ptr_info1516) {
9962                                         NDR_PULL_ALLOC(ndr, r->info1516);
9963                                 } else {
9964                                         r->info1516 = NULL;
9965                                 }
9966                         break; }
9967
9968                         case 1518: {
9969                                 uint32_t _ptr_info1518;
9970                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1518));
9971                                 if (_ptr_info1518) {
9972                                         NDR_PULL_ALLOC(ndr, r->info1518);
9973                                 } else {
9974                                         r->info1518 = NULL;
9975                                 }
9976                         break; }
9977
9978                         case 1520: {
9979                                 uint32_t _ptr_info1520;
9980                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1520));
9981                                 if (_ptr_info1520) {
9982                                         NDR_PULL_ALLOC(ndr, r->info1520);
9983                                 } else {
9984                                         r->info1520 = NULL;
9985                                 }
9986                         break; }
9987
9988                         case 1521: {
9989                                 uint32_t _ptr_info1521;
9990                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1521));
9991                                 if (_ptr_info1521) {
9992                                         NDR_PULL_ALLOC(ndr, r->info1521);
9993                                 } else {
9994                                         r->info1521 = NULL;
9995                                 }
9996                         break; }
9997
9998                         case 1522: {
9999                                 uint32_t _ptr_info1522;
10000                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1522));
10001                                 if (_ptr_info1522) {
10002                                         NDR_PULL_ALLOC(ndr, r->info1522);
10003                                 } else {
10004                                         r->info1522 = NULL;
10005                                 }
10006                         break; }
10007
10008                         case 1523: {
10009                                 uint32_t _ptr_info1523;
10010                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1523));
10011                                 if (_ptr_info1523) {
10012                                         NDR_PULL_ALLOC(ndr, r->info1523);
10013                                 } else {
10014                                         r->info1523 = NULL;
10015                                 }
10016                         break; }
10017
10018                         case 1524: {
10019                                 uint32_t _ptr_info1524;
10020                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1524));
10021                                 if (_ptr_info1524) {
10022                                         NDR_PULL_ALLOC(ndr, r->info1524);
10023                                 } else {
10024                                         r->info1524 = NULL;
10025                                 }
10026                         break; }
10027
10028                         case 1525: {
10029                                 uint32_t _ptr_info1525;
10030                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1525));
10031                                 if (_ptr_info1525) {
10032                                         NDR_PULL_ALLOC(ndr, r->info1525);
10033                                 } else {
10034                                         r->info1525 = NULL;
10035                                 }
10036                         break; }
10037
10038                         case 1528: {
10039                                 uint32_t _ptr_info1528;
10040                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1528));
10041                                 if (_ptr_info1528) {
10042                                         NDR_PULL_ALLOC(ndr, r->info1528);
10043                                 } else {
10044                                         r->info1528 = NULL;
10045                                 }
10046                         break; }
10047
10048                         case 1529: {
10049                                 uint32_t _ptr_info1529;
10050                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1529));
10051                                 if (_ptr_info1529) {
10052                                         NDR_PULL_ALLOC(ndr, r->info1529);
10053                                 } else {
10054                                         r->info1529 = NULL;
10055                                 }
10056                         break; }
10057
10058                         case 1530: {
10059                                 uint32_t _ptr_info1530;
10060                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1530));
10061                                 if (_ptr_info1530) {
10062                                         NDR_PULL_ALLOC(ndr, r->info1530);
10063                                 } else {
10064                                         r->info1530 = NULL;
10065                                 }
10066                         break; }
10067
10068                         case 1533: {
10069                                 uint32_t _ptr_info1533;
10070                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1533));
10071                                 if (_ptr_info1533) {
10072                                         NDR_PULL_ALLOC(ndr, r->info1533);
10073                                 } else {
10074                                         r->info1533 = NULL;
10075                                 }
10076                         break; }
10077
10078                         case 1534: {
10079                                 uint32_t _ptr_info1534;
10080                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1534));
10081                                 if (_ptr_info1534) {
10082                                         NDR_PULL_ALLOC(ndr, r->info1534);
10083                                 } else {
10084                                         r->info1534 = NULL;
10085                                 }
10086                         break; }
10087
10088                         case 1535: {
10089                                 uint32_t _ptr_info1535;
10090                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1535));
10091                                 if (_ptr_info1535) {
10092                                         NDR_PULL_ALLOC(ndr, r->info1535);
10093                                 } else {
10094                                         r->info1535 = NULL;
10095                                 }
10096                         break; }
10097
10098                         case 1536: {
10099                                 uint32_t _ptr_info1536;
10100                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1536));
10101                                 if (_ptr_info1536) {
10102                                         NDR_PULL_ALLOC(ndr, r->info1536);
10103                                 } else {
10104                                         r->info1536 = NULL;
10105                                 }
10106                         break; }
10107
10108                         case 1537: {
10109                                 uint32_t _ptr_info1537;
10110                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1537));
10111                                 if (_ptr_info1537) {
10112                                         NDR_PULL_ALLOC(ndr, r->info1537);
10113                                 } else {
10114                                         r->info1537 = NULL;
10115                                 }
10116                         break; }
10117
10118                         case 1538: {
10119                                 uint32_t _ptr_info1538;
10120                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1538));
10121                                 if (_ptr_info1538) {
10122                                         NDR_PULL_ALLOC(ndr, r->info1538);
10123                                 } else {
10124                                         r->info1538 = NULL;
10125                                 }
10126                         break; }
10127
10128                         case 1539: {
10129                                 uint32_t _ptr_info1539;
10130                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1539));
10131                                 if (_ptr_info1539) {
10132                                         NDR_PULL_ALLOC(ndr, r->info1539);
10133                                 } else {
10134                                         r->info1539 = NULL;
10135                                 }
10136                         break; }
10137
10138                         case 1540: {
10139                                 uint32_t _ptr_info1540;
10140                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1540));
10141                                 if (_ptr_info1540) {
10142                                         NDR_PULL_ALLOC(ndr, r->info1540);
10143                                 } else {
10144                                         r->info1540 = NULL;
10145                                 }
10146                         break; }
10147
10148                         case 1541: {
10149                                 uint32_t _ptr_info1541;
10150                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1541));
10151                                 if (_ptr_info1541) {
10152                                         NDR_PULL_ALLOC(ndr, r->info1541);
10153                                 } else {
10154                                         r->info1541 = NULL;
10155                                 }
10156                         break; }
10157
10158                         case 1542: {
10159                                 uint32_t _ptr_info1542;
10160                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1542));
10161                                 if (_ptr_info1542) {
10162                                         NDR_PULL_ALLOC(ndr, r->info1542);
10163                                 } else {
10164                                         r->info1542 = NULL;
10165                                 }
10166                         break; }
10167
10168                         case 1543: {
10169                                 uint32_t _ptr_info1543;
10170                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1543));
10171                                 if (_ptr_info1543) {
10172                                         NDR_PULL_ALLOC(ndr, r->info1543);
10173                                 } else {
10174                                         r->info1543 = NULL;
10175                                 }
10176                         break; }
10177
10178                         case 1544: {
10179                                 uint32_t _ptr_info1544;
10180                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1544));
10181                                 if (_ptr_info1544) {
10182                                         NDR_PULL_ALLOC(ndr, r->info1544);
10183                                 } else {
10184                                         r->info1544 = NULL;
10185                                 }
10186                         break; }
10187
10188                         case 1545: {
10189                                 uint32_t _ptr_info1545;
10190                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1545));
10191                                 if (_ptr_info1545) {
10192                                         NDR_PULL_ALLOC(ndr, r->info1545);
10193                                 } else {
10194                                         r->info1545 = NULL;
10195                                 }
10196                         break; }
10197
10198                         case 1546: {
10199                                 uint32_t _ptr_info1546;
10200                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1546));
10201                                 if (_ptr_info1546) {
10202                                         NDR_PULL_ALLOC(ndr, r->info1546);
10203                                 } else {
10204                                         r->info1546 = NULL;
10205                                 }
10206                         break; }
10207
10208                         case 1547: {
10209                                 uint32_t _ptr_info1547;
10210                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1547));
10211                                 if (_ptr_info1547) {
10212                                         NDR_PULL_ALLOC(ndr, r->info1547);
10213                                 } else {
10214                                         r->info1547 = NULL;
10215                                 }
10216                         break; }
10217
10218                         case 1548: {
10219                                 uint32_t _ptr_info1548;
10220                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1548));
10221                                 if (_ptr_info1548) {
10222                                         NDR_PULL_ALLOC(ndr, r->info1548);
10223                                 } else {
10224                                         r->info1548 = NULL;
10225                                 }
10226                         break; }
10227
10228                         case 1549: {
10229                                 uint32_t _ptr_info1549;
10230                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1549));
10231                                 if (_ptr_info1549) {
10232                                         NDR_PULL_ALLOC(ndr, r->info1549);
10233                                 } else {
10234                                         r->info1549 = NULL;
10235                                 }
10236                         break; }
10237
10238                         case 1550: {
10239                                 uint32_t _ptr_info1550;
10240                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1550));
10241                                 if (_ptr_info1550) {
10242                                         NDR_PULL_ALLOC(ndr, r->info1550);
10243                                 } else {
10244                                         r->info1550 = NULL;
10245                                 }
10246                         break; }
10247
10248                         case 1552: {
10249                                 uint32_t _ptr_info1552;
10250                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1552));
10251                                 if (_ptr_info1552) {
10252                                         NDR_PULL_ALLOC(ndr, r->info1552);
10253                                 } else {
10254                                         r->info1552 = NULL;
10255                                 }
10256                         break; }
10257
10258                         case 1553: {
10259                                 uint32_t _ptr_info1553;
10260                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1553));
10261                                 if (_ptr_info1553) {
10262                                         NDR_PULL_ALLOC(ndr, r->info1553);
10263                                 } else {
10264                                         r->info1553 = NULL;
10265                                 }
10266                         break; }
10267
10268                         case 1554: {
10269                                 uint32_t _ptr_info1554;
10270                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1554));
10271                                 if (_ptr_info1554) {
10272                                         NDR_PULL_ALLOC(ndr, r->info1554);
10273                                 } else {
10274                                         r->info1554 = NULL;
10275                                 }
10276                         break; }
10277
10278                         case 1555: {
10279                                 uint32_t _ptr_info1555;
10280                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1555));
10281                                 if (_ptr_info1555) {
10282                                         NDR_PULL_ALLOC(ndr, r->info1555);
10283                                 } else {
10284                                         r->info1555 = NULL;
10285                                 }
10286                         break; }
10287
10288                         case 1556: {
10289                                 uint32_t _ptr_info1556;
10290                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1556));
10291                                 if (_ptr_info1556) {
10292                                         NDR_PULL_ALLOC(ndr, r->info1556);
10293                                 } else {
10294                                         r->info1556 = NULL;
10295                                 }
10296                         break; }
10297
10298                         default: {
10299                         break; }
10300
10301                 }
10302         }
10303         if (ndr_flags & NDR_BUFFERS) {
10304                 switch (level) {
10305                         case 100:
10306                                 if (r->info100) {
10307                                         _mem_save_info100_0 = NDR_PULL_GET_MEM_CTX(ndr);
10308                                         NDR_PULL_SET_MEM_CTX(ndr, r->info100, 0);
10309                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo100(ndr, NDR_SCALARS|NDR_BUFFERS, r->info100));
10310                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info100_0, 0);
10311                                 }
10312                         break;
10313
10314                         case 101:
10315                                 if (r->info101) {
10316                                         _mem_save_info101_0 = NDR_PULL_GET_MEM_CTX(ndr);
10317                                         NDR_PULL_SET_MEM_CTX(ndr, r->info101, 0);
10318                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info101));
10319                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info101_0, 0);
10320                                 }
10321                         break;
10322
10323                         case 102:
10324                                 if (r->info102) {
10325                                         _mem_save_info102_0 = NDR_PULL_GET_MEM_CTX(ndr);
10326                                         NDR_PULL_SET_MEM_CTX(ndr, r->info102, 0);
10327                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo102(ndr, NDR_SCALARS|NDR_BUFFERS, r->info102));
10328                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info102_0, 0);
10329                                 }
10330                         break;
10331
10332                         case 402:
10333                                 if (r->info402) {
10334                                         _mem_save_info402_0 = NDR_PULL_GET_MEM_CTX(ndr);
10335                                         NDR_PULL_SET_MEM_CTX(ndr, r->info402, 0);
10336                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo402(ndr, NDR_SCALARS|NDR_BUFFERS, r->info402));
10337                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info402_0, 0);
10338                                 }
10339                         break;
10340
10341                         case 403:
10342                                 if (r->info403) {
10343                                         _mem_save_info403_0 = NDR_PULL_GET_MEM_CTX(ndr);
10344                                         NDR_PULL_SET_MEM_CTX(ndr, r->info403, 0);
10345                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo403(ndr, NDR_SCALARS|NDR_BUFFERS, r->info403));
10346                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info403_0, 0);
10347                                 }
10348                         break;
10349
10350                         case 502:
10351                                 if (r->info502) {
10352                                         _mem_save_info502_0 = NDR_PULL_GET_MEM_CTX(ndr);
10353                                         NDR_PULL_SET_MEM_CTX(ndr, r->info502, 0);
10354                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo502(ndr, NDR_SCALARS, r->info502));
10355                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info502_0, 0);
10356                                 }
10357                         break;
10358
10359                         case 503:
10360                                 if (r->info503) {
10361                                         _mem_save_info503_0 = NDR_PULL_GET_MEM_CTX(ndr);
10362                                         NDR_PULL_SET_MEM_CTX(ndr, r->info503, 0);
10363                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo503(ndr, NDR_SCALARS|NDR_BUFFERS, r->info503));
10364                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info503_0, 0);
10365                                 }
10366                         break;
10367
10368                         case 599:
10369                                 if (r->info599) {
10370                                         _mem_save_info599_0 = NDR_PULL_GET_MEM_CTX(ndr);
10371                                         NDR_PULL_SET_MEM_CTX(ndr, r->info599, 0);
10372                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo599(ndr, NDR_SCALARS|NDR_BUFFERS, r->info599));
10373                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info599_0, 0);
10374                                 }
10375                         break;
10376
10377                         case 1005:
10378                                 if (r->info1005) {
10379                                         _mem_save_info1005_0 = NDR_PULL_GET_MEM_CTX(ndr);
10380                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1005, 0);
10381                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1005(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1005));
10382                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1005_0, 0);
10383                                 }
10384                         break;
10385
10386                         case 1010:
10387                                 if (r->info1010) {
10388                                         _mem_save_info1010_0 = NDR_PULL_GET_MEM_CTX(ndr);
10389                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1010, 0);
10390                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1010(ndr, NDR_SCALARS, r->info1010));
10391                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1010_0, 0);
10392                                 }
10393                         break;
10394
10395                         case 1016:
10396                                 if (r->info1016) {
10397                                         _mem_save_info1016_0 = NDR_PULL_GET_MEM_CTX(ndr);
10398                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1016, 0);
10399                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1016(ndr, NDR_SCALARS, r->info1016));
10400                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1016_0, 0);
10401                                 }
10402                         break;
10403
10404                         case 1017:
10405                                 if (r->info1017) {
10406                                         _mem_save_info1017_0 = NDR_PULL_GET_MEM_CTX(ndr);
10407                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1017, 0);
10408                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1017(ndr, NDR_SCALARS, r->info1017));
10409                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1017_0, 0);
10410                                 }
10411                         break;
10412
10413                         case 1018:
10414                                 if (r->info1018) {
10415                                         _mem_save_info1018_0 = NDR_PULL_GET_MEM_CTX(ndr);
10416                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1018, 0);
10417                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1018(ndr, NDR_SCALARS, r->info1018));
10418                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1018_0, 0);
10419                                 }
10420                         break;
10421
10422                         case 1107:
10423                                 if (r->info1107) {
10424                                         _mem_save_info1107_0 = NDR_PULL_GET_MEM_CTX(ndr);
10425                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1107, 0);
10426                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1107(ndr, NDR_SCALARS, r->info1107));
10427                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1107_0, 0);
10428                                 }
10429                         break;
10430
10431                         case 1501:
10432                                 if (r->info1501) {
10433                                         _mem_save_info1501_0 = NDR_PULL_GET_MEM_CTX(ndr);
10434                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1501, 0);
10435                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1501(ndr, NDR_SCALARS, r->info1501));
10436                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1501_0, 0);
10437                                 }
10438                         break;
10439
10440                         case 1502:
10441                                 if (r->info1502) {
10442                                         _mem_save_info1502_0 = NDR_PULL_GET_MEM_CTX(ndr);
10443                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1502, 0);
10444                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1502(ndr, NDR_SCALARS, r->info1502));
10445                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1502_0, 0);
10446                                 }
10447                         break;
10448
10449                         case 1503:
10450                                 if (r->info1503) {
10451                                         _mem_save_info1503_0 = NDR_PULL_GET_MEM_CTX(ndr);
10452                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1503, 0);
10453                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1503(ndr, NDR_SCALARS, r->info1503));
10454                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1503_0, 0);
10455                                 }
10456                         break;
10457
10458                         case 1506:
10459                                 if (r->info1506) {
10460                                         _mem_save_info1506_0 = NDR_PULL_GET_MEM_CTX(ndr);
10461                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1506, 0);
10462                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1506(ndr, NDR_SCALARS, r->info1506));
10463                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1506_0, 0);
10464                                 }
10465                         break;
10466
10467                         case 1509:
10468                                 if (r->info1509) {
10469                                         _mem_save_info1509_0 = NDR_PULL_GET_MEM_CTX(ndr);
10470                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1509, 0);
10471                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1509(ndr, NDR_SCALARS, r->info1509));
10472                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1509_0, 0);
10473                                 }
10474                         break;
10475
10476                         case 1510:
10477                                 if (r->info1510) {
10478                                         _mem_save_info1510_0 = NDR_PULL_GET_MEM_CTX(ndr);
10479                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1510, 0);
10480                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1510(ndr, NDR_SCALARS, r->info1510));
10481                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1510_0, 0);
10482                                 }
10483                         break;
10484
10485                         case 1511:
10486                                 if (r->info1511) {
10487                                         _mem_save_info1511_0 = NDR_PULL_GET_MEM_CTX(ndr);
10488                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1511, 0);
10489                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1511(ndr, NDR_SCALARS, r->info1511));
10490                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1511_0, 0);
10491                                 }
10492                         break;
10493
10494                         case 1512:
10495                                 if (r->info1512) {
10496                                         _mem_save_info1512_0 = NDR_PULL_GET_MEM_CTX(ndr);
10497                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1512, 0);
10498                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1512(ndr, NDR_SCALARS, r->info1512));
10499                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1512_0, 0);
10500                                 }
10501                         break;
10502
10503                         case 1513:
10504                                 if (r->info1513) {
10505                                         _mem_save_info1513_0 = NDR_PULL_GET_MEM_CTX(ndr);
10506                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1513, 0);
10507                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1513(ndr, NDR_SCALARS, r->info1513));
10508                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1513_0, 0);
10509                                 }
10510                         break;
10511
10512                         case 1514:
10513                                 if (r->info1514) {
10514                                         _mem_save_info1514_0 = NDR_PULL_GET_MEM_CTX(ndr);
10515                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1514, 0);
10516                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1514(ndr, NDR_SCALARS, r->info1514));
10517                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1514_0, 0);
10518                                 }
10519                         break;
10520
10521                         case 1515:
10522                                 if (r->info1515) {
10523                                         _mem_save_info1515_0 = NDR_PULL_GET_MEM_CTX(ndr);
10524                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1515, 0);
10525                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1515(ndr, NDR_SCALARS, r->info1515));
10526                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1515_0, 0);
10527                                 }
10528                         break;
10529
10530                         case 1516:
10531                                 if (r->info1516) {
10532                                         _mem_save_info1516_0 = NDR_PULL_GET_MEM_CTX(ndr);
10533                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1516, 0);
10534                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1516(ndr, NDR_SCALARS, r->info1516));
10535                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1516_0, 0);
10536                                 }
10537                         break;
10538
10539                         case 1518:
10540                                 if (r->info1518) {
10541                                         _mem_save_info1518_0 = NDR_PULL_GET_MEM_CTX(ndr);
10542                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1518, 0);
10543                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1518(ndr, NDR_SCALARS, r->info1518));
10544                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1518_0, 0);
10545                                 }
10546                         break;
10547
10548                         case 1520:
10549                                 if (r->info1520) {
10550                                         _mem_save_info1520_0 = NDR_PULL_GET_MEM_CTX(ndr);
10551                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1520, 0);
10552                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1520(ndr, NDR_SCALARS, r->info1520));
10553                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1520_0, 0);
10554                                 }
10555                         break;
10556
10557                         case 1521:
10558                                 if (r->info1521) {
10559                                         _mem_save_info1521_0 = NDR_PULL_GET_MEM_CTX(ndr);
10560                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1521, 0);
10561                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1521(ndr, NDR_SCALARS, r->info1521));
10562                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1521_0, 0);
10563                                 }
10564                         break;
10565
10566                         case 1522:
10567                                 if (r->info1522) {
10568                                         _mem_save_info1522_0 = NDR_PULL_GET_MEM_CTX(ndr);
10569                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1522, 0);
10570                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1522(ndr, NDR_SCALARS, r->info1522));
10571                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1522_0, 0);
10572                                 }
10573                         break;
10574
10575                         case 1523:
10576                                 if (r->info1523) {
10577                                         _mem_save_info1523_0 = NDR_PULL_GET_MEM_CTX(ndr);
10578                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1523, 0);
10579                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1523(ndr, NDR_SCALARS, r->info1523));
10580                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1523_0, 0);
10581                                 }
10582                         break;
10583
10584                         case 1524:
10585                                 if (r->info1524) {
10586                                         _mem_save_info1524_0 = NDR_PULL_GET_MEM_CTX(ndr);
10587                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1524, 0);
10588                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1524(ndr, NDR_SCALARS, r->info1524));
10589                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1524_0, 0);
10590                                 }
10591                         break;
10592
10593                         case 1525:
10594                                 if (r->info1525) {
10595                                         _mem_save_info1525_0 = NDR_PULL_GET_MEM_CTX(ndr);
10596                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1525, 0);
10597                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1525(ndr, NDR_SCALARS, r->info1525));
10598                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1525_0, 0);
10599                                 }
10600                         break;
10601
10602                         case 1528:
10603                                 if (r->info1528) {
10604                                         _mem_save_info1528_0 = NDR_PULL_GET_MEM_CTX(ndr);
10605                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1528, 0);
10606                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1528(ndr, NDR_SCALARS, r->info1528));
10607                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1528_0, 0);
10608                                 }
10609                         break;
10610
10611                         case 1529:
10612                                 if (r->info1529) {
10613                                         _mem_save_info1529_0 = NDR_PULL_GET_MEM_CTX(ndr);
10614                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1529, 0);
10615                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1529(ndr, NDR_SCALARS, r->info1529));
10616                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1529_0, 0);
10617                                 }
10618                         break;
10619
10620                         case 1530:
10621                                 if (r->info1530) {
10622                                         _mem_save_info1530_0 = NDR_PULL_GET_MEM_CTX(ndr);
10623                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1530, 0);
10624                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1530(ndr, NDR_SCALARS, r->info1530));
10625                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1530_0, 0);
10626                                 }
10627                         break;
10628
10629                         case 1533:
10630                                 if (r->info1533) {
10631                                         _mem_save_info1533_0 = NDR_PULL_GET_MEM_CTX(ndr);
10632                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1533, 0);
10633                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1533(ndr, NDR_SCALARS, r->info1533));
10634                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1533_0, 0);
10635                                 }
10636                         break;
10637
10638                         case 1534:
10639                                 if (r->info1534) {
10640                                         _mem_save_info1534_0 = NDR_PULL_GET_MEM_CTX(ndr);
10641                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1534, 0);
10642                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1534(ndr, NDR_SCALARS, r->info1534));
10643                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1534_0, 0);
10644                                 }
10645                         break;
10646
10647                         case 1535:
10648                                 if (r->info1535) {
10649                                         _mem_save_info1535_0 = NDR_PULL_GET_MEM_CTX(ndr);
10650                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1535, 0);
10651                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1535(ndr, NDR_SCALARS, r->info1535));
10652                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1535_0, 0);
10653                                 }
10654                         break;
10655
10656                         case 1536:
10657                                 if (r->info1536) {
10658                                         _mem_save_info1536_0 = NDR_PULL_GET_MEM_CTX(ndr);
10659                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1536, 0);
10660                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1536(ndr, NDR_SCALARS, r->info1536));
10661                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1536_0, 0);
10662                                 }
10663                         break;
10664
10665                         case 1537:
10666                                 if (r->info1537) {
10667                                         _mem_save_info1537_0 = NDR_PULL_GET_MEM_CTX(ndr);
10668                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1537, 0);
10669                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1537(ndr, NDR_SCALARS, r->info1537));
10670                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1537_0, 0);
10671                                 }
10672                         break;
10673
10674                         case 1538:
10675                                 if (r->info1538) {
10676                                         _mem_save_info1538_0 = NDR_PULL_GET_MEM_CTX(ndr);
10677                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1538, 0);
10678                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1538(ndr, NDR_SCALARS, r->info1538));
10679                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1538_0, 0);
10680                                 }
10681                         break;
10682
10683                         case 1539:
10684                                 if (r->info1539) {
10685                                         _mem_save_info1539_0 = NDR_PULL_GET_MEM_CTX(ndr);
10686                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1539, 0);
10687                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1539(ndr, NDR_SCALARS, r->info1539));
10688                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1539_0, 0);
10689                                 }
10690                         break;
10691
10692                         case 1540:
10693                                 if (r->info1540) {
10694                                         _mem_save_info1540_0 = NDR_PULL_GET_MEM_CTX(ndr);
10695                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1540, 0);
10696                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1540(ndr, NDR_SCALARS, r->info1540));
10697                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1540_0, 0);
10698                                 }
10699                         break;
10700
10701                         case 1541:
10702                                 if (r->info1541) {
10703                                         _mem_save_info1541_0 = NDR_PULL_GET_MEM_CTX(ndr);
10704                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1541, 0);
10705                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1541(ndr, NDR_SCALARS, r->info1541));
10706                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1541_0, 0);
10707                                 }
10708                         break;
10709
10710                         case 1542:
10711                                 if (r->info1542) {
10712                                         _mem_save_info1542_0 = NDR_PULL_GET_MEM_CTX(ndr);
10713                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1542, 0);
10714                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1542(ndr, NDR_SCALARS, r->info1542));
10715                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1542_0, 0);
10716                                 }
10717                         break;
10718
10719                         case 1543:
10720                                 if (r->info1543) {
10721                                         _mem_save_info1543_0 = NDR_PULL_GET_MEM_CTX(ndr);
10722                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1543, 0);
10723                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1543(ndr, NDR_SCALARS, r->info1543));
10724                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1543_0, 0);
10725                                 }
10726                         break;
10727
10728                         case 1544:
10729                                 if (r->info1544) {
10730                                         _mem_save_info1544_0 = NDR_PULL_GET_MEM_CTX(ndr);
10731                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1544, 0);
10732                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1544(ndr, NDR_SCALARS, r->info1544));
10733                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1544_0, 0);
10734                                 }
10735                         break;
10736
10737                         case 1545:
10738                                 if (r->info1545) {
10739                                         _mem_save_info1545_0 = NDR_PULL_GET_MEM_CTX(ndr);
10740                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1545, 0);
10741                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1545(ndr, NDR_SCALARS, r->info1545));
10742                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1545_0, 0);
10743                                 }
10744                         break;
10745
10746                         case 1546:
10747                                 if (r->info1546) {
10748                                         _mem_save_info1546_0 = NDR_PULL_GET_MEM_CTX(ndr);
10749                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1546, 0);
10750                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1546(ndr, NDR_SCALARS, r->info1546));
10751                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1546_0, 0);
10752                                 }
10753                         break;
10754
10755                         case 1547:
10756                                 if (r->info1547) {
10757                                         _mem_save_info1547_0 = NDR_PULL_GET_MEM_CTX(ndr);
10758                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1547, 0);
10759                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1547(ndr, NDR_SCALARS, r->info1547));
10760                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1547_0, 0);
10761                                 }
10762                         break;
10763
10764                         case 1548:
10765                                 if (r->info1548) {
10766                                         _mem_save_info1548_0 = NDR_PULL_GET_MEM_CTX(ndr);
10767                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1548, 0);
10768                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1548(ndr, NDR_SCALARS, r->info1548));
10769                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1548_0, 0);
10770                                 }
10771                         break;
10772
10773                         case 1549:
10774                                 if (r->info1549) {
10775                                         _mem_save_info1549_0 = NDR_PULL_GET_MEM_CTX(ndr);
10776                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1549, 0);
10777                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1549(ndr, NDR_SCALARS, r->info1549));
10778                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1549_0, 0);
10779                                 }
10780                         break;
10781
10782                         case 1550:
10783                                 if (r->info1550) {
10784                                         _mem_save_info1550_0 = NDR_PULL_GET_MEM_CTX(ndr);
10785                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1550, 0);
10786                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1550(ndr, NDR_SCALARS, r->info1550));
10787                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1550_0, 0);
10788                                 }
10789                         break;
10790
10791                         case 1552:
10792                                 if (r->info1552) {
10793                                         _mem_save_info1552_0 = NDR_PULL_GET_MEM_CTX(ndr);
10794                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1552, 0);
10795                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1552(ndr, NDR_SCALARS, r->info1552));
10796                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1552_0, 0);
10797                                 }
10798                         break;
10799
10800                         case 1553:
10801                                 if (r->info1553) {
10802                                         _mem_save_info1553_0 = NDR_PULL_GET_MEM_CTX(ndr);
10803                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1553, 0);
10804                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1553(ndr, NDR_SCALARS, r->info1553));
10805                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1553_0, 0);
10806                                 }
10807                         break;
10808
10809                         case 1554:
10810                                 if (r->info1554) {
10811                                         _mem_save_info1554_0 = NDR_PULL_GET_MEM_CTX(ndr);
10812                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1554, 0);
10813                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1554(ndr, NDR_SCALARS, r->info1554));
10814                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1554_0, 0);
10815                                 }
10816                         break;
10817
10818                         case 1555:
10819                                 if (r->info1555) {
10820                                         _mem_save_info1555_0 = NDR_PULL_GET_MEM_CTX(ndr);
10821                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1555, 0);
10822                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1555(ndr, NDR_SCALARS, r->info1555));
10823                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1555_0, 0);
10824                                 }
10825                         break;
10826
10827                         case 1556:
10828                                 if (r->info1556) {
10829                                         _mem_save_info1556_0 = NDR_PULL_GET_MEM_CTX(ndr);
10830                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1556, 0);
10831                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1556(ndr, NDR_SCALARS, r->info1556));
10832                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1556_0, 0);
10833                                 }
10834                         break;
10835
10836                         default:
10837                         break;
10838
10839                 }
10840         }
10841         return NDR_ERR_SUCCESS;
10842 }
10843
10844 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo(struct ndr_print *ndr, const char *name, const union srvsvc_NetSrvInfo *r)
10845 {
10846         int level;
10847         level = ndr_print_get_switch_value(ndr, r);
10848         ndr_print_union(ndr, name, level, "srvsvc_NetSrvInfo");
10849         switch (level) {
10850                 case 100:
10851                         ndr_print_ptr(ndr, "info100", r->info100);
10852                         ndr->depth++;
10853                         if (r->info100) {
10854                                 ndr_print_srvsvc_NetSrvInfo100(ndr, "info100", r->info100);
10855                         }
10856                         ndr->depth--;
10857                 break;
10858
10859                 case 101:
10860                         ndr_print_ptr(ndr, "info101", r->info101);
10861                         ndr->depth++;
10862                         if (r->info101) {
10863                                 ndr_print_srvsvc_NetSrvInfo101(ndr, "info101", r->info101);
10864                         }
10865                         ndr->depth--;
10866                 break;
10867
10868                 case 102:
10869                         ndr_print_ptr(ndr, "info102", r->info102);
10870                         ndr->depth++;
10871                         if (r->info102) {
10872                                 ndr_print_srvsvc_NetSrvInfo102(ndr, "info102", r->info102);
10873                         }
10874                         ndr->depth--;
10875                 break;
10876
10877                 case 402:
10878                         ndr_print_ptr(ndr, "info402", r->info402);
10879                         ndr->depth++;
10880                         if (r->info402) {
10881                                 ndr_print_srvsvc_NetSrvInfo402(ndr, "info402", r->info402);
10882                         }
10883                         ndr->depth--;
10884                 break;
10885
10886                 case 403:
10887                         ndr_print_ptr(ndr, "info403", r->info403);
10888                         ndr->depth++;
10889                         if (r->info403) {
10890                                 ndr_print_srvsvc_NetSrvInfo403(ndr, "info403", r->info403);
10891                         }
10892                         ndr->depth--;
10893                 break;
10894
10895                 case 502:
10896                         ndr_print_ptr(ndr, "info502", r->info502);
10897                         ndr->depth++;
10898                         if (r->info502) {
10899                                 ndr_print_srvsvc_NetSrvInfo502(ndr, "info502", r->info502);
10900                         }
10901                         ndr->depth--;
10902                 break;
10903
10904                 case 503:
10905                         ndr_print_ptr(ndr, "info503", r->info503);
10906                         ndr->depth++;
10907                         if (r->info503) {
10908                                 ndr_print_srvsvc_NetSrvInfo503(ndr, "info503", r->info503);
10909                         }
10910                         ndr->depth--;
10911                 break;
10912
10913                 case 599:
10914                         ndr_print_ptr(ndr, "info599", r->info599);
10915                         ndr->depth++;
10916                         if (r->info599) {
10917                                 ndr_print_srvsvc_NetSrvInfo599(ndr, "info599", r->info599);
10918                         }
10919                         ndr->depth--;
10920                 break;
10921
10922                 case 1005:
10923                         ndr_print_ptr(ndr, "info1005", r->info1005);
10924                         ndr->depth++;
10925                         if (r->info1005) {
10926                                 ndr_print_srvsvc_NetSrvInfo1005(ndr, "info1005", r->info1005);
10927                         }
10928                         ndr->depth--;
10929                 break;
10930
10931                 case 1010:
10932                         ndr_print_ptr(ndr, "info1010", r->info1010);
10933                         ndr->depth++;
10934                         if (r->info1010) {
10935                                 ndr_print_srvsvc_NetSrvInfo1010(ndr, "info1010", r->info1010);
10936                         }
10937                         ndr->depth--;
10938                 break;
10939
10940                 case 1016:
10941                         ndr_print_ptr(ndr, "info1016", r->info1016);
10942                         ndr->depth++;
10943                         if (r->info1016) {
10944                                 ndr_print_srvsvc_NetSrvInfo1016(ndr, "info1016", r->info1016);
10945                         }
10946                         ndr->depth--;
10947                 break;
10948
10949                 case 1017:
10950                         ndr_print_ptr(ndr, "info1017", r->info1017);
10951                         ndr->depth++;
10952                         if (r->info1017) {
10953                                 ndr_print_srvsvc_NetSrvInfo1017(ndr, "info1017", r->info1017);
10954                         }
10955                         ndr->depth--;
10956                 break;
10957
10958                 case 1018:
10959                         ndr_print_ptr(ndr, "info1018", r->info1018);
10960                         ndr->depth++;
10961                         if (r->info1018) {
10962                                 ndr_print_srvsvc_NetSrvInfo1018(ndr, "info1018", r->info1018);
10963                         }
10964                         ndr->depth--;
10965                 break;
10966
10967                 case 1107:
10968                         ndr_print_ptr(ndr, "info1107", r->info1107);
10969                         ndr->depth++;
10970                         if (r->info1107) {
10971                                 ndr_print_srvsvc_NetSrvInfo1107(ndr, "info1107", r->info1107);
10972                         }
10973                         ndr->depth--;
10974                 break;
10975
10976                 case 1501:
10977                         ndr_print_ptr(ndr, "info1501", r->info1501);
10978                         ndr->depth++;
10979                         if (r->info1501) {
10980                                 ndr_print_srvsvc_NetSrvInfo1501(ndr, "info1501", r->info1501);
10981                         }
10982                         ndr->depth--;
10983                 break;
10984
10985                 case 1502:
10986                         ndr_print_ptr(ndr, "info1502", r->info1502);
10987                         ndr->depth++;
10988                         if (r->info1502) {
10989                                 ndr_print_srvsvc_NetSrvInfo1502(ndr, "info1502", r->info1502);
10990                         }
10991                         ndr->depth--;
10992                 break;
10993
10994                 case 1503:
10995                         ndr_print_ptr(ndr, "info1503", r->info1503);
10996                         ndr->depth++;
10997                         if (r->info1503) {
10998                                 ndr_print_srvsvc_NetSrvInfo1503(ndr, "info1503", r->info1503);
10999                         }
11000                         ndr->depth--;
11001                 break;
11002
11003                 case 1506:
11004                         ndr_print_ptr(ndr, "info1506", r->info1506);
11005                         ndr->depth++;
11006                         if (r->info1506) {
11007                                 ndr_print_srvsvc_NetSrvInfo1506(ndr, "info1506", r->info1506);
11008                         }
11009                         ndr->depth--;
11010                 break;
11011
11012                 case 1509:
11013                         ndr_print_ptr(ndr, "info1509", r->info1509);
11014                         ndr->depth++;
11015                         if (r->info1509) {
11016                                 ndr_print_srvsvc_NetSrvInfo1509(ndr, "info1509", r->info1509);
11017                         }
11018                         ndr->depth--;
11019                 break;
11020
11021                 case 1510:
11022                         ndr_print_ptr(ndr, "info1510", r->info1510);
11023                         ndr->depth++;
11024                         if (r->info1510) {
11025                                 ndr_print_srvsvc_NetSrvInfo1510(ndr, "info1510", r->info1510);
11026                         }
11027                         ndr->depth--;
11028                 break;
11029
11030                 case 1511:
11031                         ndr_print_ptr(ndr, "info1511", r->info1511);
11032                         ndr->depth++;
11033                         if (r->info1511) {
11034                                 ndr_print_srvsvc_NetSrvInfo1511(ndr, "info1511", r->info1511);
11035                         }
11036                         ndr->depth--;
11037                 break;
11038
11039                 case 1512:
11040                         ndr_print_ptr(ndr, "info1512", r->info1512);
11041                         ndr->depth++;
11042                         if (r->info1512) {
11043                                 ndr_print_srvsvc_NetSrvInfo1512(ndr, "info1512", r->info1512);
11044                         }
11045                         ndr->depth--;
11046                 break;
11047
11048                 case 1513:
11049                         ndr_print_ptr(ndr, "info1513", r->info1513);
11050                         ndr->depth++;
11051                         if (r->info1513) {
11052                                 ndr_print_srvsvc_NetSrvInfo1513(ndr, "info1513", r->info1513);
11053                         }
11054                         ndr->depth--;
11055                 break;
11056
11057                 case 1514:
11058                         ndr_print_ptr(ndr, "info1514", r->info1514);
11059                         ndr->depth++;
11060                         if (r->info1514) {
11061                                 ndr_print_srvsvc_NetSrvInfo1514(ndr, "info1514", r->info1514);
11062                         }
11063                         ndr->depth--;
11064                 break;
11065
11066                 case 1515:
11067                         ndr_print_ptr(ndr, "info1515", r->info1515);
11068                         ndr->depth++;
11069                         if (r->info1515) {
11070                                 ndr_print_srvsvc_NetSrvInfo1515(ndr, "info1515", r->info1515);
11071                         }
11072                         ndr->depth--;
11073                 break;
11074
11075                 case 1516:
11076                         ndr_print_ptr(ndr, "info1516", r->info1516);
11077                         ndr->depth++;
11078                         if (r->info1516) {
11079                                 ndr_print_srvsvc_NetSrvInfo1516(ndr, "info1516", r->info1516);
11080                         }
11081                         ndr->depth--;
11082                 break;
11083
11084                 case 1518:
11085                         ndr_print_ptr(ndr, "info1518", r->info1518);
11086                         ndr->depth++;
11087                         if (r->info1518) {
11088                                 ndr_print_srvsvc_NetSrvInfo1518(ndr, "info1518", r->info1518);
11089                         }
11090                         ndr->depth--;
11091                 break;
11092
11093                 case 1520:
11094                         ndr_print_ptr(ndr, "info1520", r->info1520);
11095                         ndr->depth++;
11096                         if (r->info1520) {
11097                                 ndr_print_srvsvc_NetSrvInfo1520(ndr, "info1520", r->info1520);
11098                         }
11099                         ndr->depth--;
11100                 break;
11101
11102                 case 1521:
11103                         ndr_print_ptr(ndr, "info1521", r->info1521);
11104                         ndr->depth++;
11105                         if (r->info1521) {
11106                                 ndr_print_srvsvc_NetSrvInfo1521(ndr, "info1521", r->info1521);
11107                         }
11108                         ndr->depth--;
11109                 break;
11110
11111                 case 1522:
11112                         ndr_print_ptr(ndr, "info1522", r->info1522);
11113                         ndr->depth++;
11114                         if (r->info1522) {
11115                                 ndr_print_srvsvc_NetSrvInfo1522(ndr, "info1522", r->info1522);
11116                         }
11117                         ndr->depth--;
11118                 break;
11119
11120                 case 1523:
11121                         ndr_print_ptr(ndr, "info1523", r->info1523);
11122                         ndr->depth++;
11123                         if (r->info1523) {
11124                                 ndr_print_srvsvc_NetSrvInfo1523(ndr, "info1523", r->info1523);
11125                         }
11126                         ndr->depth--;
11127                 break;
11128
11129                 case 1524:
11130                         ndr_print_ptr(ndr, "info1524", r->info1524);
11131                         ndr->depth++;
11132                         if (r->info1524) {
11133                                 ndr_print_srvsvc_NetSrvInfo1524(ndr, "info1524", r->info1524);
11134                         }
11135                         ndr->depth--;
11136                 break;
11137
11138                 case 1525:
11139                         ndr_print_ptr(ndr, "info1525", r->info1525);
11140                         ndr->depth++;
11141                         if (r->info1525) {
11142                                 ndr_print_srvsvc_NetSrvInfo1525(ndr, "info1525", r->info1525);
11143                         }
11144                         ndr->depth--;
11145                 break;
11146
11147                 case 1528:
11148                         ndr_print_ptr(ndr, "info1528", r->info1528);
11149                         ndr->depth++;
11150                         if (r->info1528) {
11151                                 ndr_print_srvsvc_NetSrvInfo1528(ndr, "info1528", r->info1528);
11152                         }
11153                         ndr->depth--;
11154                 break;
11155
11156                 case 1529:
11157                         ndr_print_ptr(ndr, "info1529", r->info1529);
11158                         ndr->depth++;
11159                         if (r->info1529) {
11160                                 ndr_print_srvsvc_NetSrvInfo1529(ndr, "info1529", r->info1529);
11161                         }
11162                         ndr->depth--;
11163                 break;
11164
11165                 case 1530:
11166                         ndr_print_ptr(ndr, "info1530", r->info1530);
11167                         ndr->depth++;
11168                         if (r->info1530) {
11169                                 ndr_print_srvsvc_NetSrvInfo1530(ndr, "info1530", r->info1530);
11170                         }
11171                         ndr->depth--;
11172                 break;
11173
11174                 case 1533:
11175                         ndr_print_ptr(ndr, "info1533", r->info1533);
11176                         ndr->depth++;
11177                         if (r->info1533) {
11178                                 ndr_print_srvsvc_NetSrvInfo1533(ndr, "info1533", r->info1533);
11179                         }
11180                         ndr->depth--;
11181                 break;
11182
11183                 case 1534:
11184                         ndr_print_ptr(ndr, "info1534", r->info1534);
11185                         ndr->depth++;
11186                         if (r->info1534) {
11187                                 ndr_print_srvsvc_NetSrvInfo1534(ndr, "info1534", r->info1534);
11188                         }
11189                         ndr->depth--;
11190                 break;
11191
11192                 case 1535:
11193                         ndr_print_ptr(ndr, "info1535", r->info1535);
11194                         ndr->depth++;
11195                         if (r->info1535) {
11196                                 ndr_print_srvsvc_NetSrvInfo1535(ndr, "info1535", r->info1535);
11197                         }
11198                         ndr->depth--;
11199                 break;
11200
11201                 case 1536:
11202                         ndr_print_ptr(ndr, "info1536", r->info1536);
11203                         ndr->depth++;
11204                         if (r->info1536) {
11205                                 ndr_print_srvsvc_NetSrvInfo1536(ndr, "info1536", r->info1536);
11206                         }
11207                         ndr->depth--;
11208                 break;
11209
11210                 case 1537:
11211                         ndr_print_ptr(ndr, "info1537", r->info1537);
11212                         ndr->depth++;
11213                         if (r->info1537) {
11214                                 ndr_print_srvsvc_NetSrvInfo1537(ndr, "info1537", r->info1537);
11215                         }
11216                         ndr->depth--;
11217                 break;
11218
11219                 case 1538:
11220                         ndr_print_ptr(ndr, "info1538", r->info1538);
11221                         ndr->depth++;
11222                         if (r->info1538) {
11223                                 ndr_print_srvsvc_NetSrvInfo1538(ndr, "info1538", r->info1538);
11224                         }
11225                         ndr->depth--;
11226                 break;
11227
11228                 case 1539:
11229                         ndr_print_ptr(ndr, "info1539", r->info1539);
11230                         ndr->depth++;
11231                         if (r->info1539) {
11232                                 ndr_print_srvsvc_NetSrvInfo1539(ndr, "info1539", r->info1539);
11233                         }
11234                         ndr->depth--;
11235                 break;
11236
11237                 case 1540:
11238                         ndr_print_ptr(ndr, "info1540", r->info1540);
11239                         ndr->depth++;
11240                         if (r->info1540) {
11241                                 ndr_print_srvsvc_NetSrvInfo1540(ndr, "info1540", r->info1540);
11242                         }
11243                         ndr->depth--;
11244                 break;
11245
11246                 case 1541:
11247                         ndr_print_ptr(ndr, "info1541", r->info1541);
11248                         ndr->depth++;
11249                         if (r->info1541) {
11250                                 ndr_print_srvsvc_NetSrvInfo1541(ndr, "info1541", r->info1541);
11251                         }
11252                         ndr->depth--;
11253                 break;
11254
11255                 case 1542:
11256                         ndr_print_ptr(ndr, "info1542", r->info1542);
11257                         ndr->depth++;
11258                         if (r->info1542) {
11259                                 ndr_print_srvsvc_NetSrvInfo1542(ndr, "info1542", r->info1542);
11260                         }
11261                         ndr->depth--;
11262                 break;
11263
11264                 case 1543:
11265                         ndr_print_ptr(ndr, "info1543", r->info1543);
11266                         ndr->depth++;
11267                         if (r->info1543) {
11268                                 ndr_print_srvsvc_NetSrvInfo1543(ndr, "info1543", r->info1543);
11269                         }
11270                         ndr->depth--;
11271                 break;
11272
11273                 case 1544:
11274                         ndr_print_ptr(ndr, "info1544", r->info1544);
11275                         ndr->depth++;
11276                         if (r->info1544) {
11277                                 ndr_print_srvsvc_NetSrvInfo1544(ndr, "info1544", r->info1544);
11278                         }
11279                         ndr->depth--;
11280                 break;
11281
11282                 case 1545:
11283                         ndr_print_ptr(ndr, "info1545", r->info1545);
11284                         ndr->depth++;
11285                         if (r->info1545) {
11286                                 ndr_print_srvsvc_NetSrvInfo1545(ndr, "info1545", r->info1545);
11287                         }
11288                         ndr->depth--;
11289                 break;
11290
11291                 case 1546:
11292                         ndr_print_ptr(ndr, "info1546", r->info1546);
11293                         ndr->depth++;
11294                         if (r->info1546) {
11295                                 ndr_print_srvsvc_NetSrvInfo1546(ndr, "info1546", r->info1546);
11296                         }
11297                         ndr->depth--;
11298                 break;
11299
11300                 case 1547:
11301                         ndr_print_ptr(ndr, "info1547", r->info1547);
11302                         ndr->depth++;
11303                         if (r->info1547) {
11304                                 ndr_print_srvsvc_NetSrvInfo1547(ndr, "info1547", r->info1547);
11305                         }
11306                         ndr->depth--;
11307                 break;
11308
11309                 case 1548:
11310                         ndr_print_ptr(ndr, "info1548", r->info1548);
11311                         ndr->depth++;
11312                         if (r->info1548) {
11313                                 ndr_print_srvsvc_NetSrvInfo1548(ndr, "info1548", r->info1548);
11314                         }
11315                         ndr->depth--;
11316                 break;
11317
11318                 case 1549:
11319                         ndr_print_ptr(ndr, "info1549", r->info1549);
11320                         ndr->depth++;
11321                         if (r->info1549) {
11322                                 ndr_print_srvsvc_NetSrvInfo1549(ndr, "info1549", r->info1549);
11323                         }
11324                         ndr->depth--;
11325                 break;
11326
11327                 case 1550:
11328                         ndr_print_ptr(ndr, "info1550", r->info1550);
11329                         ndr->depth++;
11330                         if (r->info1550) {
11331                                 ndr_print_srvsvc_NetSrvInfo1550(ndr, "info1550", r->info1550);
11332                         }
11333                         ndr->depth--;
11334                 break;
11335
11336                 case 1552:
11337                         ndr_print_ptr(ndr, "info1552", r->info1552);
11338                         ndr->depth++;
11339                         if (r->info1552) {
11340                                 ndr_print_srvsvc_NetSrvInfo1552(ndr, "info1552", r->info1552);
11341                         }
11342                         ndr->depth--;
11343                 break;
11344
11345                 case 1553:
11346                         ndr_print_ptr(ndr, "info1553", r->info1553);
11347                         ndr->depth++;
11348                         if (r->info1553) {
11349                                 ndr_print_srvsvc_NetSrvInfo1553(ndr, "info1553", r->info1553);
11350                         }
11351                         ndr->depth--;
11352                 break;
11353
11354                 case 1554:
11355                         ndr_print_ptr(ndr, "info1554", r->info1554);
11356                         ndr->depth++;
11357                         if (r->info1554) {
11358                                 ndr_print_srvsvc_NetSrvInfo1554(ndr, "info1554", r->info1554);
11359                         }
11360                         ndr->depth--;
11361                 break;
11362
11363                 case 1555:
11364                         ndr_print_ptr(ndr, "info1555", r->info1555);
11365                         ndr->depth++;
11366                         if (r->info1555) {
11367                                 ndr_print_srvsvc_NetSrvInfo1555(ndr, "info1555", r->info1555);
11368                         }
11369                         ndr->depth--;
11370                 break;
11371
11372                 case 1556:
11373                         ndr_print_ptr(ndr, "info1556", r->info1556);
11374                         ndr->depth++;
11375                         if (r->info1556) {
11376                                 ndr_print_srvsvc_NetSrvInfo1556(ndr, "info1556", r->info1556);
11377                         }
11378                         ndr->depth--;
11379                 break;
11380
11381                 default:
11382                 break;
11383
11384         }
11385 }
11386
11387 static enum ndr_err_code ndr_push_srvsvc_NetDiskInfo0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetDiskInfo0 *r)
11388 {
11389         if (ndr_flags & NDR_SCALARS) {
11390                 NDR_CHECK(ndr_push_align(ndr, 4));
11391                 {
11392                         uint32_t _flags_save_string = ndr->flags;
11393                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_LEN4);
11394                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->disk));
11395                         ndr->flags = _flags_save_string;
11396                 }
11397         }
11398         if (ndr_flags & NDR_BUFFERS) {
11399         }
11400         return NDR_ERR_SUCCESS;
11401 }
11402
11403 static enum ndr_err_code ndr_pull_srvsvc_NetDiskInfo0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetDiskInfo0 *r)
11404 {
11405         if (ndr_flags & NDR_SCALARS) {
11406                 NDR_CHECK(ndr_pull_align(ndr, 4));
11407                 {
11408                         uint32_t _flags_save_string = ndr->flags;
11409                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_LEN4);
11410                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->disk));
11411                         ndr->flags = _flags_save_string;
11412                 }
11413         }
11414         if (ndr_flags & NDR_BUFFERS) {
11415         }
11416         return NDR_ERR_SUCCESS;
11417 }
11418
11419 _PUBLIC_ void ndr_print_srvsvc_NetDiskInfo0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetDiskInfo0 *r)
11420 {
11421         ndr_print_struct(ndr, name, "srvsvc_NetDiskInfo0");
11422         ndr->depth++;
11423         ndr_print_string(ndr, "disk", r->disk);
11424         ndr->depth--;
11425 }
11426
11427 static enum ndr_err_code ndr_push_srvsvc_NetDiskInfo(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetDiskInfo *r)
11428 {
11429         uint32_t cntr_disks_1;
11430         if (ndr_flags & NDR_SCALARS) {
11431                 NDR_CHECK(ndr_push_align(ndr, 4));
11432                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11433                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->disks));
11434         }
11435         if (ndr_flags & NDR_BUFFERS) {
11436                 if (r->disks) {
11437                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11438                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11439                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11440                         for (cntr_disks_1 = 0; cntr_disks_1 < r->count; cntr_disks_1++) {
11441                                 NDR_CHECK(ndr_push_srvsvc_NetDiskInfo0(ndr, NDR_SCALARS, &r->disks[cntr_disks_1]));
11442                         }
11443                 }
11444         }
11445         return NDR_ERR_SUCCESS;
11446 }
11447
11448 static enum ndr_err_code ndr_pull_srvsvc_NetDiskInfo(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetDiskInfo *r)
11449 {
11450         uint32_t _ptr_disks;
11451         uint32_t cntr_disks_1;
11452         TALLOC_CTX *_mem_save_disks_0;
11453         TALLOC_CTX *_mem_save_disks_1;
11454         if (ndr_flags & NDR_SCALARS) {
11455                 NDR_CHECK(ndr_pull_align(ndr, 4));
11456                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11457                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_disks));
11458                 if (_ptr_disks) {
11459                         NDR_PULL_ALLOC(ndr, r->disks);
11460                 } else {
11461                         r->disks = NULL;
11462                 }
11463         }
11464         if (ndr_flags & NDR_BUFFERS) {
11465                 if (r->disks) {
11466                         _mem_save_disks_0 = NDR_PULL_GET_MEM_CTX(ndr);
11467                         NDR_PULL_SET_MEM_CTX(ndr, r->disks, 0);
11468                         NDR_CHECK(ndr_pull_array_size(ndr, &r->disks));
11469                         NDR_CHECK(ndr_pull_array_length(ndr, &r->disks));
11470                         if (ndr_get_array_length(ndr, &r->disks) > ndr_get_array_size(ndr, &r->disks)) {
11471                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->disks), ndr_get_array_length(ndr, &r->disks));
11472                         }
11473                         NDR_PULL_ALLOC_N(ndr, r->disks, ndr_get_array_size(ndr, &r->disks));
11474                         _mem_save_disks_1 = NDR_PULL_GET_MEM_CTX(ndr);
11475                         NDR_PULL_SET_MEM_CTX(ndr, r->disks, 0);
11476                         for (cntr_disks_1 = 0; cntr_disks_1 < r->count; cntr_disks_1++) {
11477                                 NDR_CHECK(ndr_pull_srvsvc_NetDiskInfo0(ndr, NDR_SCALARS, &r->disks[cntr_disks_1]));
11478                         }
11479                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_disks_1, 0);
11480                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_disks_0, 0);
11481                 }
11482                 if (r->disks) {
11483                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->disks, r->count));
11484                 }
11485                 if (r->disks) {
11486                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->disks, r->count));
11487                 }
11488         }
11489         return NDR_ERR_SUCCESS;
11490 }
11491
11492 _PUBLIC_ void ndr_print_srvsvc_NetDiskInfo(struct ndr_print *ndr, const char *name, const struct srvsvc_NetDiskInfo *r)
11493 {
11494         uint32_t cntr_disks_1;
11495         ndr_print_struct(ndr, name, "srvsvc_NetDiskInfo");
11496         ndr->depth++;
11497         ndr_print_uint32(ndr, "count", r->count);
11498         ndr_print_ptr(ndr, "disks", r->disks);
11499         ndr->depth++;
11500         if (r->disks) {
11501                 ndr->print(ndr, "%s: ARRAY(%d)", "disks", r->count);
11502                 ndr->depth++;
11503                 for (cntr_disks_1=0;cntr_disks_1<r->count;cntr_disks_1++) {
11504                         char *idx_1=NULL;
11505                         if (asprintf(&idx_1, "[%d]", cntr_disks_1) != -1) {
11506                                 ndr_print_srvsvc_NetDiskInfo0(ndr, "disks", &r->disks[cntr_disks_1]);
11507                                 free(idx_1);
11508                         }
11509                 }
11510                 ndr->depth--;
11511         }
11512         ndr->depth--;
11513         ndr->depth--;
11514 }
11515
11516 static enum ndr_err_code ndr_push_srvsvc_Statistics(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_Statistics *r)
11517 {
11518         if (ndr_flags & NDR_SCALARS) {
11519                 NDR_CHECK(ndr_push_align(ndr, 4));
11520                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start));
11521                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->fopens));
11522                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->devopens));
11523                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->jobsqueued));
11524                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sopens));
11525                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->stimeouts));
11526                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->serrorout));
11527                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pwerrors));
11528                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->permerrors));
11529                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->syserrors));
11530                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bytessent_low));
11531                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bytessent_high));
11532                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bytesrcvd_low));
11533                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bytesrcvd_high));
11534                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->avresponse));
11535                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reqbufneed));
11536                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bigbufneed));
11537         }
11538         if (ndr_flags & NDR_BUFFERS) {
11539         }
11540         return NDR_ERR_SUCCESS;
11541 }
11542
11543 static enum ndr_err_code ndr_pull_srvsvc_Statistics(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_Statistics *r)
11544 {
11545         if (ndr_flags & NDR_SCALARS) {
11546                 NDR_CHECK(ndr_pull_align(ndr, 4));
11547                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start));
11548                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->fopens));
11549                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->devopens));
11550                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->jobsqueued));
11551                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sopens));
11552                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->stimeouts));
11553                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->serrorout));
11554                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pwerrors));
11555                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->permerrors));
11556                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->syserrors));
11557                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bytessent_low));
11558                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bytessent_high));
11559                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bytesrcvd_low));
11560                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bytesrcvd_high));
11561                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->avresponse));
11562                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reqbufneed));
11563                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bigbufneed));
11564         }
11565         if (ndr_flags & NDR_BUFFERS) {
11566         }
11567         return NDR_ERR_SUCCESS;
11568 }
11569
11570 _PUBLIC_ void ndr_print_srvsvc_Statistics(struct ndr_print *ndr, const char *name, const struct srvsvc_Statistics *r)
11571 {
11572         ndr_print_struct(ndr, name, "srvsvc_Statistics");
11573         ndr->depth++;
11574         ndr_print_uint32(ndr, "start", r->start);
11575         ndr_print_uint32(ndr, "fopens", r->fopens);
11576         ndr_print_uint32(ndr, "devopens", r->devopens);
11577         ndr_print_uint32(ndr, "jobsqueued", r->jobsqueued);
11578         ndr_print_uint32(ndr, "sopens", r->sopens);
11579         ndr_print_uint32(ndr, "stimeouts", r->stimeouts);
11580         ndr_print_uint32(ndr, "serrorout", r->serrorout);
11581         ndr_print_uint32(ndr, "pwerrors", r->pwerrors);
11582         ndr_print_uint32(ndr, "permerrors", r->permerrors);
11583         ndr_print_uint32(ndr, "syserrors", r->syserrors);
11584         ndr_print_uint32(ndr, "bytessent_low", r->bytessent_low);
11585         ndr_print_uint32(ndr, "bytessent_high", r->bytessent_high);
11586         ndr_print_uint32(ndr, "bytesrcvd_low", r->bytesrcvd_low);
11587         ndr_print_uint32(ndr, "bytesrcvd_high", r->bytesrcvd_high);
11588         ndr_print_uint32(ndr, "avresponse", r->avresponse);
11589         ndr_print_uint32(ndr, "reqbufneed", r->reqbufneed);
11590         ndr_print_uint32(ndr, "bigbufneed", r->bigbufneed);
11591         ndr->depth--;
11592 }
11593
11594 static enum ndr_err_code ndr_push_srvsvc_NetTransportInfo0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportInfo0 *r)
11595 {
11596         if (ndr_flags & NDR_SCALARS) {
11597                 NDR_CHECK(ndr_push_align(ndr, 4));
11598                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->vcs));
11599                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
11600                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->addr));
11601                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->addr_len));
11602                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->net_addr));
11603         }
11604         if (ndr_flags & NDR_BUFFERS) {
11605                 if (r->name) {
11606                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
11607                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11608                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
11609                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11610                 }
11611                 if (r->addr) {
11612                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->addr_len));
11613                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->addr, r->addr_len));
11614                 }
11615                 if (r->net_addr) {
11616                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->net_addr, CH_UTF16)));
11617                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11618                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->net_addr, CH_UTF16)));
11619                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->net_addr, ndr_charset_length(r->net_addr, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11620                 }
11621         }
11622         return NDR_ERR_SUCCESS;
11623 }
11624
11625 static enum ndr_err_code ndr_pull_srvsvc_NetTransportInfo0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportInfo0 *r)
11626 {
11627         uint32_t _ptr_name;
11628         TALLOC_CTX *_mem_save_name_0;
11629         uint32_t _ptr_addr;
11630         TALLOC_CTX *_mem_save_addr_0;
11631         uint32_t _ptr_net_addr;
11632         TALLOC_CTX *_mem_save_net_addr_0;
11633         if (ndr_flags & NDR_SCALARS) {
11634                 NDR_CHECK(ndr_pull_align(ndr, 4));
11635                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->vcs));
11636                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
11637                 if (_ptr_name) {
11638                         NDR_PULL_ALLOC(ndr, r->name);
11639                 } else {
11640                         r->name = NULL;
11641                 }
11642                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_addr));
11643                 if (_ptr_addr) {
11644                         NDR_PULL_ALLOC(ndr, r->addr);
11645                 } else {
11646                         r->addr = NULL;
11647                 }
11648                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->addr_len));
11649                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_net_addr));
11650                 if (_ptr_net_addr) {
11651                         NDR_PULL_ALLOC(ndr, r->net_addr);
11652                 } else {
11653                         r->net_addr = NULL;
11654                 }
11655         }
11656         if (ndr_flags & NDR_BUFFERS) {
11657                 if (r->name) {
11658                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11659                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
11660                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
11661                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
11662                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
11663                                 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));
11664                         }
11665                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
11666                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
11667                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
11668                 }
11669                 if (r->addr) {
11670                         _mem_save_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);
11671                         NDR_PULL_SET_MEM_CTX(ndr, r->addr, 0);
11672                         NDR_CHECK(ndr_pull_array_size(ndr, &r->addr));
11673                         NDR_PULL_ALLOC_N(ndr, r->addr, ndr_get_array_size(ndr, &r->addr));
11674                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->addr, ndr_get_array_size(ndr, &r->addr)));
11675                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_addr_0, 0);
11676                 }
11677                 if (r->net_addr) {
11678                         _mem_save_net_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);
11679                         NDR_PULL_SET_MEM_CTX(ndr, r->net_addr, 0);
11680                         NDR_CHECK(ndr_pull_array_size(ndr, &r->net_addr));
11681                         NDR_CHECK(ndr_pull_array_length(ndr, &r->net_addr));
11682                         if (ndr_get_array_length(ndr, &r->net_addr) > ndr_get_array_size(ndr, &r->net_addr)) {
11683                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->net_addr), ndr_get_array_length(ndr, &r->net_addr));
11684                         }
11685                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->net_addr), sizeof(uint16_t)));
11686                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->net_addr, ndr_get_array_length(ndr, &r->net_addr), sizeof(uint16_t), CH_UTF16));
11687                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_net_addr_0, 0);
11688                 }
11689                 if (r->addr) {
11690                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->addr, r->addr_len));
11691                 }
11692         }
11693         return NDR_ERR_SUCCESS;
11694 }
11695
11696 _PUBLIC_ void ndr_print_srvsvc_NetTransportInfo0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportInfo0 *r)
11697 {
11698         ndr_print_struct(ndr, name, "srvsvc_NetTransportInfo0");
11699         ndr->depth++;
11700         ndr_print_uint32(ndr, "vcs", r->vcs);
11701         ndr_print_ptr(ndr, "name", r->name);
11702         ndr->depth++;
11703         if (r->name) {
11704                 ndr_print_string(ndr, "name", r->name);
11705         }
11706         ndr->depth--;
11707         ndr_print_ptr(ndr, "addr", r->addr);
11708         ndr->depth++;
11709         if (r->addr) {
11710                 ndr_print_array_uint8(ndr, "addr", r->addr, r->addr_len);
11711         }
11712         ndr->depth--;
11713         ndr_print_uint32(ndr, "addr_len", r->addr_len);
11714         ndr_print_ptr(ndr, "net_addr", r->net_addr);
11715         ndr->depth++;
11716         if (r->net_addr) {
11717                 ndr_print_string(ndr, "net_addr", r->net_addr);
11718         }
11719         ndr->depth--;
11720         ndr->depth--;
11721 }
11722
11723 static enum ndr_err_code ndr_push_srvsvc_NetTransportCtr0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportCtr0 *r)
11724 {
11725         uint32_t cntr_array_1;
11726         if (ndr_flags & NDR_SCALARS) {
11727                 NDR_CHECK(ndr_push_align(ndr, 4));
11728                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11729                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
11730         }
11731         if (ndr_flags & NDR_BUFFERS) {
11732                 if (r->array) {
11733                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11734                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
11735                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
11736                         }
11737                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
11738                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
11739                         }
11740                 }
11741         }
11742         return NDR_ERR_SUCCESS;
11743 }
11744
11745 static enum ndr_err_code ndr_pull_srvsvc_NetTransportCtr0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportCtr0 *r)
11746 {
11747         uint32_t _ptr_array;
11748         uint32_t cntr_array_1;
11749         TALLOC_CTX *_mem_save_array_0;
11750         TALLOC_CTX *_mem_save_array_1;
11751         if (ndr_flags & NDR_SCALARS) {
11752                 NDR_CHECK(ndr_pull_align(ndr, 4));
11753                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11754                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
11755                 if (_ptr_array) {
11756                         NDR_PULL_ALLOC(ndr, r->array);
11757                 } else {
11758                         r->array = NULL;
11759                 }
11760         }
11761         if (ndr_flags & NDR_BUFFERS) {
11762                 if (r->array) {
11763                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11764                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11765                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11766                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11767                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
11768                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11769                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
11770                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
11771                         }
11772                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
11773                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
11774                         }
11775                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
11776                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11777                 }
11778                 if (r->array) {
11779                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11780                 }
11781         }
11782         return NDR_ERR_SUCCESS;
11783 }
11784
11785 _PUBLIC_ void ndr_print_srvsvc_NetTransportCtr0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportCtr0 *r)
11786 {
11787         uint32_t cntr_array_1;
11788         ndr_print_struct(ndr, name, "srvsvc_NetTransportCtr0");
11789         ndr->depth++;
11790         ndr_print_uint32(ndr, "count", r->count);
11791         ndr_print_ptr(ndr, "array", r->array);
11792         ndr->depth++;
11793         if (r->array) {
11794                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
11795                 ndr->depth++;
11796                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
11797                         char *idx_1=NULL;
11798                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
11799                                 ndr_print_srvsvc_NetTransportInfo0(ndr, "array", &r->array[cntr_array_1]);
11800                                 free(idx_1);
11801                         }
11802                 }
11803                 ndr->depth--;
11804         }
11805         ndr->depth--;
11806         ndr->depth--;
11807 }
11808
11809 static enum ndr_err_code ndr_push_srvsvc_NetTransportInfo1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportInfo1 *r)
11810 {
11811         if (ndr_flags & NDR_SCALARS) {
11812                 NDR_CHECK(ndr_push_align(ndr, 4));
11813                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->vcs));
11814                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
11815                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->addr));
11816                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->addr_len));
11817                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->net_addr));
11818                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
11819         }
11820         if (ndr_flags & NDR_BUFFERS) {
11821                 if (r->name) {
11822                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
11823                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11824                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
11825                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11826                 }
11827                 if (r->addr) {
11828                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->addr_len));
11829                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->addr, r->addr_len));
11830                 }
11831                 if (r->net_addr) {
11832                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->net_addr, CH_UTF16)));
11833                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11834                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->net_addr, CH_UTF16)));
11835                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->net_addr, ndr_charset_length(r->net_addr, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11836                 }
11837                 if (r->domain) {
11838                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
11839                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11840                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
11841                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain, ndr_charset_length(r->domain, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11842                 }
11843         }
11844         return NDR_ERR_SUCCESS;
11845 }
11846
11847 static enum ndr_err_code ndr_pull_srvsvc_NetTransportInfo1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportInfo1 *r)
11848 {
11849         uint32_t _ptr_name;
11850         TALLOC_CTX *_mem_save_name_0;
11851         uint32_t _ptr_addr;
11852         TALLOC_CTX *_mem_save_addr_0;
11853         uint32_t _ptr_net_addr;
11854         TALLOC_CTX *_mem_save_net_addr_0;
11855         uint32_t _ptr_domain;
11856         TALLOC_CTX *_mem_save_domain_0;
11857         if (ndr_flags & NDR_SCALARS) {
11858                 NDR_CHECK(ndr_pull_align(ndr, 4));
11859                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->vcs));
11860                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
11861                 if (_ptr_name) {
11862                         NDR_PULL_ALLOC(ndr, r->name);
11863                 } else {
11864                         r->name = NULL;
11865                 }
11866                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_addr));
11867                 if (_ptr_addr) {
11868                         NDR_PULL_ALLOC(ndr, r->addr);
11869                 } else {
11870                         r->addr = NULL;
11871                 }
11872                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->addr_len));
11873                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_net_addr));
11874                 if (_ptr_net_addr) {
11875                         NDR_PULL_ALLOC(ndr, r->net_addr);
11876                 } else {
11877                         r->net_addr = NULL;
11878                 }
11879                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
11880                 if (_ptr_domain) {
11881                         NDR_PULL_ALLOC(ndr, r->domain);
11882                 } else {
11883                         r->domain = NULL;
11884                 }
11885         }
11886         if (ndr_flags & NDR_BUFFERS) {
11887                 if (r->name) {
11888                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11889                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
11890                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
11891                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
11892                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
11893                                 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));
11894                         }
11895                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
11896                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
11897                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
11898                 }
11899                 if (r->addr) {
11900                         _mem_save_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);
11901                         NDR_PULL_SET_MEM_CTX(ndr, r->addr, 0);
11902                         NDR_CHECK(ndr_pull_array_size(ndr, &r->addr));
11903                         NDR_PULL_ALLOC_N(ndr, r->addr, ndr_get_array_size(ndr, &r->addr));
11904                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->addr, ndr_get_array_size(ndr, &r->addr)));
11905                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_addr_0, 0);
11906                 }
11907                 if (r->net_addr) {
11908                         _mem_save_net_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);
11909                         NDR_PULL_SET_MEM_CTX(ndr, r->net_addr, 0);
11910                         NDR_CHECK(ndr_pull_array_size(ndr, &r->net_addr));
11911                         NDR_CHECK(ndr_pull_array_length(ndr, &r->net_addr));
11912                         if (ndr_get_array_length(ndr, &r->net_addr) > ndr_get_array_size(ndr, &r->net_addr)) {
11913                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->net_addr), ndr_get_array_length(ndr, &r->net_addr));
11914                         }
11915                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->net_addr), sizeof(uint16_t)));
11916                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->net_addr, ndr_get_array_length(ndr, &r->net_addr), sizeof(uint16_t), CH_UTF16));
11917                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_net_addr_0, 0);
11918                 }
11919                 if (r->domain) {
11920                         _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
11921                         NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);
11922                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain));
11923                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain));
11924                         if (ndr_get_array_length(ndr, &r->domain) > ndr_get_array_size(ndr, &r->domain)) {
11925                                 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), ndr_get_array_length(ndr, &r->domain));
11926                         }
11927                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t)));
11928                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t), CH_UTF16));
11929                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);
11930                 }
11931                 if (r->addr) {
11932                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->addr, r->addr_len));
11933                 }
11934         }
11935         return NDR_ERR_SUCCESS;
11936 }
11937
11938 _PUBLIC_ void ndr_print_srvsvc_NetTransportInfo1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportInfo1 *r)
11939 {
11940         ndr_print_struct(ndr, name, "srvsvc_NetTransportInfo1");
11941         ndr->depth++;
11942         ndr_print_uint32(ndr, "vcs", r->vcs);
11943         ndr_print_ptr(ndr, "name", r->name);
11944         ndr->depth++;
11945         if (r->name) {
11946                 ndr_print_string(ndr, "name", r->name);
11947         }
11948         ndr->depth--;
11949         ndr_print_ptr(ndr, "addr", r->addr);
11950         ndr->depth++;
11951         if (r->addr) {
11952                 ndr_print_array_uint8(ndr, "addr", r->addr, r->addr_len);
11953         }
11954         ndr->depth--;
11955         ndr_print_uint32(ndr, "addr_len", r->addr_len);
11956         ndr_print_ptr(ndr, "net_addr", r->net_addr);
11957         ndr->depth++;
11958         if (r->net_addr) {
11959                 ndr_print_string(ndr, "net_addr", r->net_addr);
11960         }
11961         ndr->depth--;
11962         ndr_print_ptr(ndr, "domain", r->domain);
11963         ndr->depth++;
11964         if (r->domain) {
11965                 ndr_print_string(ndr, "domain", r->domain);
11966         }
11967         ndr->depth--;
11968         ndr->depth--;
11969 }
11970
11971 static enum ndr_err_code ndr_push_srvsvc_NetTransportCtr1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportCtr1 *r)
11972 {
11973         uint32_t cntr_array_1;
11974         if (ndr_flags & NDR_SCALARS) {
11975                 NDR_CHECK(ndr_push_align(ndr, 4));
11976                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11977                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
11978         }
11979         if (ndr_flags & NDR_BUFFERS) {
11980                 if (r->array) {
11981                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11982                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
11983                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
11984                         }
11985                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
11986                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
11987                         }
11988                 }
11989         }
11990         return NDR_ERR_SUCCESS;
11991 }
11992
11993 static enum ndr_err_code ndr_pull_srvsvc_NetTransportCtr1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportCtr1 *r)
11994 {
11995         uint32_t _ptr_array;
11996         uint32_t cntr_array_1;
11997         TALLOC_CTX *_mem_save_array_0;
11998         TALLOC_CTX *_mem_save_array_1;
11999         if (ndr_flags & NDR_SCALARS) {
12000                 NDR_CHECK(ndr_pull_align(ndr, 4));
12001                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
12002                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
12003                 if (_ptr_array) {
12004                         NDR_PULL_ALLOC(ndr, r->array);
12005                 } else {
12006                         r->array = NULL;
12007                 }
12008         }
12009         if (ndr_flags & NDR_BUFFERS) {
12010                 if (r->array) {
12011                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12012                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
12013                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
12014                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
12015                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
12016                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
12017                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
12018                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
12019                         }
12020                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
12021                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
12022                         }
12023                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
12024                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
12025                 }
12026                 if (r->array) {
12027                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
12028                 }
12029         }
12030         return NDR_ERR_SUCCESS;
12031 }
12032
12033 _PUBLIC_ void ndr_print_srvsvc_NetTransportCtr1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportCtr1 *r)
12034 {
12035         uint32_t cntr_array_1;
12036         ndr_print_struct(ndr, name, "srvsvc_NetTransportCtr1");
12037         ndr->depth++;
12038         ndr_print_uint32(ndr, "count", r->count);
12039         ndr_print_ptr(ndr, "array", r->array);
12040         ndr->depth++;
12041         if (r->array) {
12042                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
12043                 ndr->depth++;
12044                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
12045                         char *idx_1=NULL;
12046                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
12047                                 ndr_print_srvsvc_NetTransportInfo1(ndr, "array", &r->array[cntr_array_1]);
12048                                 free(idx_1);
12049                         }
12050                 }
12051                 ndr->depth--;
12052         }
12053         ndr->depth--;
12054         ndr->depth--;
12055 }
12056
12057 static enum ndr_err_code ndr_push_srvsvc_NetTransportInfo2(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportInfo2 *r)
12058 {
12059         if (ndr_flags & NDR_SCALARS) {
12060                 NDR_CHECK(ndr_push_align(ndr, 4));
12061                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->vcs));
12062                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
12063                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->addr));
12064                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->addr_len));
12065                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->net_addr));
12066                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
12067                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
12068         }
12069         if (ndr_flags & NDR_BUFFERS) {
12070                 if (r->name) {
12071                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
12072                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12073                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
12074                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12075                 }
12076                 if (r->addr) {
12077                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->addr_len));
12078                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->addr, r->addr_len));
12079                 }
12080                 if (r->net_addr) {
12081                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->net_addr, CH_UTF16)));
12082                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12083                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->net_addr, CH_UTF16)));
12084                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->net_addr, ndr_charset_length(r->net_addr, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12085                 }
12086                 if (r->domain) {
12087                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
12088                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12089                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
12090                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain, ndr_charset_length(r->domain, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12091                 }
12092         }
12093         return NDR_ERR_SUCCESS;
12094 }
12095
12096 static enum ndr_err_code ndr_pull_srvsvc_NetTransportInfo2(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportInfo2 *r)
12097 {
12098         uint32_t _ptr_name;
12099         TALLOC_CTX *_mem_save_name_0;
12100         uint32_t _ptr_addr;
12101         TALLOC_CTX *_mem_save_addr_0;
12102         uint32_t _ptr_net_addr;
12103         TALLOC_CTX *_mem_save_net_addr_0;
12104         uint32_t _ptr_domain;
12105         TALLOC_CTX *_mem_save_domain_0;
12106         if (ndr_flags & NDR_SCALARS) {
12107                 NDR_CHECK(ndr_pull_align(ndr, 4));
12108                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->vcs));
12109                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
12110                 if (_ptr_name) {
12111                         NDR_PULL_ALLOC(ndr, r->name);
12112                 } else {
12113                         r->name = NULL;
12114                 }
12115                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_addr));
12116                 if (_ptr_addr) {
12117                         NDR_PULL_ALLOC(ndr, r->addr);
12118                 } else {
12119                         r->addr = NULL;
12120                 }
12121                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->addr_len));
12122                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_net_addr));
12123                 if (_ptr_net_addr) {
12124                         NDR_PULL_ALLOC(ndr, r->net_addr);
12125                 } else {
12126                         r->net_addr = NULL;
12127                 }
12128                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
12129                 if (_ptr_domain) {
12130                         NDR_PULL_ALLOC(ndr, r->domain);
12131                 } else {
12132                         r->domain = NULL;
12133                 }
12134                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
12135         }
12136         if (ndr_flags & NDR_BUFFERS) {
12137                 if (r->name) {
12138                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12139                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
12140                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
12141                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
12142                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
12143                                 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));
12144                         }
12145                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
12146                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
12147                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
12148                 }
12149                 if (r->addr) {
12150                         _mem_save_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);
12151                         NDR_PULL_SET_MEM_CTX(ndr, r->addr, 0);
12152                         NDR_CHECK(ndr_pull_array_size(ndr, &r->addr));
12153                         NDR_PULL_ALLOC_N(ndr, r->addr, ndr_get_array_size(ndr, &r->addr));
12154                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->addr, ndr_get_array_size(ndr, &r->addr)));
12155                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_addr_0, 0);
12156                 }
12157                 if (r->net_addr) {
12158                         _mem_save_net_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);
12159                         NDR_PULL_SET_MEM_CTX(ndr, r->net_addr, 0);
12160                         NDR_CHECK(ndr_pull_array_size(ndr, &r->net_addr));
12161                         NDR_CHECK(ndr_pull_array_length(ndr, &r->net_addr));
12162                         if (ndr_get_array_length(ndr, &r->net_addr) > ndr_get_array_size(ndr, &r->net_addr)) {
12163                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->net_addr), ndr_get_array_length(ndr, &r->net_addr));
12164                         }
12165                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->net_addr), sizeof(uint16_t)));
12166                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->net_addr, ndr_get_array_length(ndr, &r->net_addr), sizeof(uint16_t), CH_UTF16));
12167                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_net_addr_0, 0);
12168                 }
12169                 if (r->domain) {
12170                         _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
12171                         NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);
12172                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain));
12173                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain));
12174                         if (ndr_get_array_length(ndr, &r->domain) > ndr_get_array_size(ndr, &r->domain)) {
12175                                 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), ndr_get_array_length(ndr, &r->domain));
12176                         }
12177                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t)));
12178                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t), CH_UTF16));
12179                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);
12180                 }
12181                 if (r->addr) {
12182                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->addr, r->addr_len));
12183                 }
12184         }
12185         return NDR_ERR_SUCCESS;
12186 }
12187
12188 _PUBLIC_ void ndr_print_srvsvc_NetTransportInfo2(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportInfo2 *r)
12189 {
12190         ndr_print_struct(ndr, name, "srvsvc_NetTransportInfo2");
12191         ndr->depth++;
12192         ndr_print_uint32(ndr, "vcs", r->vcs);
12193         ndr_print_ptr(ndr, "name", r->name);
12194         ndr->depth++;
12195         if (r->name) {
12196                 ndr_print_string(ndr, "name", r->name);
12197         }
12198         ndr->depth--;
12199         ndr_print_ptr(ndr, "addr", r->addr);
12200         ndr->depth++;
12201         if (r->addr) {
12202                 ndr_print_array_uint8(ndr, "addr", r->addr, r->addr_len);
12203         }
12204         ndr->depth--;
12205         ndr_print_uint32(ndr, "addr_len", r->addr_len);
12206         ndr_print_ptr(ndr, "net_addr", r->net_addr);
12207         ndr->depth++;
12208         if (r->net_addr) {
12209                 ndr_print_string(ndr, "net_addr", r->net_addr);
12210         }
12211         ndr->depth--;
12212         ndr_print_ptr(ndr, "domain", r->domain);
12213         ndr->depth++;
12214         if (r->domain) {
12215                 ndr_print_string(ndr, "domain", r->domain);
12216         }
12217         ndr->depth--;
12218         ndr_print_uint32(ndr, "unknown", r->unknown);
12219         ndr->depth--;
12220 }
12221
12222 static enum ndr_err_code ndr_push_srvsvc_NetTransportCtr2(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportCtr2 *r)
12223 {
12224         uint32_t cntr_array_1;
12225         if (ndr_flags & NDR_SCALARS) {
12226                 NDR_CHECK(ndr_push_align(ndr, 4));
12227                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
12228                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
12229         }
12230         if (ndr_flags & NDR_BUFFERS) {
12231                 if (r->array) {
12232                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
12233                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
12234                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
12235                         }
12236                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
12237                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
12238                         }
12239                 }
12240         }
12241         return NDR_ERR_SUCCESS;
12242 }
12243
12244 static enum ndr_err_code ndr_pull_srvsvc_NetTransportCtr2(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportCtr2 *r)
12245 {
12246         uint32_t _ptr_array;
12247         uint32_t cntr_array_1;
12248         TALLOC_CTX *_mem_save_array_0;
12249         TALLOC_CTX *_mem_save_array_1;
12250         if (ndr_flags & NDR_SCALARS) {
12251                 NDR_CHECK(ndr_pull_align(ndr, 4));
12252                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
12253                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
12254                 if (_ptr_array) {
12255                         NDR_PULL_ALLOC(ndr, r->array);
12256                 } else {
12257                         r->array = NULL;
12258                 }
12259         }
12260         if (ndr_flags & NDR_BUFFERS) {
12261                 if (r->array) {
12262                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12263                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
12264                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
12265                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
12266                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
12267                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
12268                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
12269                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
12270                         }
12271                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
12272                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
12273                         }
12274                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
12275                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
12276                 }
12277                 if (r->array) {
12278                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
12279                 }
12280         }
12281         return NDR_ERR_SUCCESS;
12282 }
12283
12284 _PUBLIC_ void ndr_print_srvsvc_NetTransportCtr2(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportCtr2 *r)
12285 {
12286         uint32_t cntr_array_1;
12287         ndr_print_struct(ndr, name, "srvsvc_NetTransportCtr2");
12288         ndr->depth++;
12289         ndr_print_uint32(ndr, "count", r->count);
12290         ndr_print_ptr(ndr, "array", r->array);
12291         ndr->depth++;
12292         if (r->array) {
12293                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
12294                 ndr->depth++;
12295                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
12296                         char *idx_1=NULL;
12297                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
12298                                 ndr_print_srvsvc_NetTransportInfo2(ndr, "array", &r->array[cntr_array_1]);
12299                                 free(idx_1);
12300                         }
12301                 }
12302                 ndr->depth--;
12303         }
12304         ndr->depth--;
12305         ndr->depth--;
12306 }
12307
12308 static enum ndr_err_code ndr_push_srvsvc_NetTransportInfo3(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportInfo3 *r)
12309 {
12310         if (ndr_flags & NDR_SCALARS) {
12311                 NDR_CHECK(ndr_push_align(ndr, 4));
12312                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->vcs));
12313                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
12314                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->addr));
12315                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->addr_len));
12316                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->net_addr));
12317                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
12318                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
12319                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
12320                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->unknown3, 256));
12321         }
12322         if (ndr_flags & NDR_BUFFERS) {
12323                 if (r->name) {
12324                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
12325                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12326                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
12327                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12328                 }
12329                 if (r->addr) {
12330                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->addr_len));
12331                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->addr, r->addr_len));
12332                 }
12333                 if (r->net_addr) {
12334                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->net_addr, CH_UTF16)));
12335                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12336                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->net_addr, CH_UTF16)));
12337                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->net_addr, ndr_charset_length(r->net_addr, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12338                 }
12339                 if (r->domain) {
12340                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
12341                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12342                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
12343                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain, ndr_charset_length(r->domain, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12344                 }
12345         }
12346         return NDR_ERR_SUCCESS;
12347 }
12348
12349 static enum ndr_err_code ndr_pull_srvsvc_NetTransportInfo3(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportInfo3 *r)
12350 {
12351         uint32_t _ptr_name;
12352         TALLOC_CTX *_mem_save_name_0;
12353         uint32_t _ptr_addr;
12354         TALLOC_CTX *_mem_save_addr_0;
12355         uint32_t _ptr_net_addr;
12356         TALLOC_CTX *_mem_save_net_addr_0;
12357         uint32_t _ptr_domain;
12358         TALLOC_CTX *_mem_save_domain_0;
12359         if (ndr_flags & NDR_SCALARS) {
12360                 NDR_CHECK(ndr_pull_align(ndr, 4));
12361                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->vcs));
12362                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
12363                 if (_ptr_name) {
12364                         NDR_PULL_ALLOC(ndr, r->name);
12365                 } else {
12366                         r->name = NULL;
12367                 }
12368                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_addr));
12369                 if (_ptr_addr) {
12370                         NDR_PULL_ALLOC(ndr, r->addr);
12371                 } else {
12372                         r->addr = NULL;
12373                 }
12374                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->addr_len));
12375                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_net_addr));
12376                 if (_ptr_net_addr) {
12377                         NDR_PULL_ALLOC(ndr, r->net_addr);
12378                 } else {
12379                         r->net_addr = NULL;
12380                 }
12381                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
12382                 if (_ptr_domain) {
12383                         NDR_PULL_ALLOC(ndr, r->domain);
12384                 } else {
12385                         r->domain = NULL;
12386                 }
12387                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
12388                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
12389                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->unknown3, 256));
12390         }
12391         if (ndr_flags & NDR_BUFFERS) {
12392                 if (r->name) {
12393                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12394                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
12395                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
12396                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
12397                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
12398                                 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));
12399                         }
12400                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
12401                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
12402                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
12403                 }
12404                 if (r->addr) {
12405                         _mem_save_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);
12406                         NDR_PULL_SET_MEM_CTX(ndr, r->addr, 0);
12407                         NDR_CHECK(ndr_pull_array_size(ndr, &r->addr));
12408                         NDR_PULL_ALLOC_N(ndr, r->addr, ndr_get_array_size(ndr, &r->addr));
12409                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->addr, ndr_get_array_size(ndr, &r->addr)));
12410                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_addr_0, 0);
12411                 }
12412                 if (r->net_addr) {
12413                         _mem_save_net_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);
12414                         NDR_PULL_SET_MEM_CTX(ndr, r->net_addr, 0);
12415                         NDR_CHECK(ndr_pull_array_size(ndr, &r->net_addr));
12416                         NDR_CHECK(ndr_pull_array_length(ndr, &r->net_addr));
12417                         if (ndr_get_array_length(ndr, &r->net_addr) > ndr_get_array_size(ndr, &r->net_addr)) {
12418                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->net_addr), ndr_get_array_length(ndr, &r->net_addr));
12419                         }
12420                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->net_addr), sizeof(uint16_t)));
12421                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->net_addr, ndr_get_array_length(ndr, &r->net_addr), sizeof(uint16_t), CH_UTF16));
12422                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_net_addr_0, 0);
12423                 }
12424                 if (r->domain) {
12425                         _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
12426                         NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);
12427                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain));
12428                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain));
12429                         if (ndr_get_array_length(ndr, &r->domain) > ndr_get_array_size(ndr, &r->domain)) {
12430                                 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), ndr_get_array_length(ndr, &r->domain));
12431                         }
12432                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t)));
12433                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t), CH_UTF16));
12434                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);
12435                 }
12436                 if (r->addr) {
12437                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->addr, r->addr_len));
12438                 }
12439         }
12440         return NDR_ERR_SUCCESS;
12441 }
12442
12443 _PUBLIC_ void ndr_print_srvsvc_NetTransportInfo3(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportInfo3 *r)
12444 {
12445         ndr_print_struct(ndr, name, "srvsvc_NetTransportInfo3");
12446         ndr->depth++;
12447         ndr_print_uint32(ndr, "vcs", r->vcs);
12448         ndr_print_ptr(ndr, "name", r->name);
12449         ndr->depth++;
12450         if (r->name) {
12451                 ndr_print_string(ndr, "name", r->name);
12452         }
12453         ndr->depth--;
12454         ndr_print_ptr(ndr, "addr", r->addr);
12455         ndr->depth++;
12456         if (r->addr) {
12457                 ndr_print_array_uint8(ndr, "addr", r->addr, r->addr_len);
12458         }
12459         ndr->depth--;
12460         ndr_print_uint32(ndr, "addr_len", r->addr_len);
12461         ndr_print_ptr(ndr, "net_addr", r->net_addr);
12462         ndr->depth++;
12463         if (r->net_addr) {
12464                 ndr_print_string(ndr, "net_addr", r->net_addr);
12465         }
12466         ndr->depth--;
12467         ndr_print_ptr(ndr, "domain", r->domain);
12468         ndr->depth++;
12469         if (r->domain) {
12470                 ndr_print_string(ndr, "domain", r->domain);
12471         }
12472         ndr->depth--;
12473         ndr_print_uint32(ndr, "unknown1", r->unknown1);
12474         ndr_print_uint32(ndr, "unknown2", r->unknown2);
12475         ndr_print_array_uint8(ndr, "unknown3", r->unknown3, 256);
12476         ndr->depth--;
12477 }
12478
12479 static enum ndr_err_code ndr_push_srvsvc_NetTransportCtr3(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportCtr3 *r)
12480 {
12481         uint32_t cntr_array_1;
12482         if (ndr_flags & NDR_SCALARS) {
12483                 NDR_CHECK(ndr_push_align(ndr, 4));
12484                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
12485                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
12486         }
12487         if (ndr_flags & NDR_BUFFERS) {
12488                 if (r->array) {
12489                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
12490                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
12491                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
12492                         }
12493                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
12494                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
12495                         }
12496                 }
12497         }
12498         return NDR_ERR_SUCCESS;
12499 }
12500
12501 static enum ndr_err_code ndr_pull_srvsvc_NetTransportCtr3(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportCtr3 *r)
12502 {
12503         uint32_t _ptr_array;
12504         uint32_t cntr_array_1;
12505         TALLOC_CTX *_mem_save_array_0;
12506         TALLOC_CTX *_mem_save_array_1;
12507         if (ndr_flags & NDR_SCALARS) {
12508                 NDR_CHECK(ndr_pull_align(ndr, 4));
12509                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
12510                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
12511                 if (_ptr_array) {
12512                         NDR_PULL_ALLOC(ndr, r->array);
12513                 } else {
12514                         r->array = NULL;
12515                 }
12516         }
12517         if (ndr_flags & NDR_BUFFERS) {
12518                 if (r->array) {
12519                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12520                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
12521                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
12522                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
12523                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
12524                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
12525                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
12526                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
12527                         }
12528                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
12529                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
12530                         }
12531                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
12532                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
12533                 }
12534                 if (r->array) {
12535                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
12536                 }
12537         }
12538         return NDR_ERR_SUCCESS;
12539 }
12540
12541 _PUBLIC_ void ndr_print_srvsvc_NetTransportCtr3(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportCtr3 *r)
12542 {
12543         uint32_t cntr_array_1;
12544         ndr_print_struct(ndr, name, "srvsvc_NetTransportCtr3");
12545         ndr->depth++;
12546         ndr_print_uint32(ndr, "count", r->count);
12547         ndr_print_ptr(ndr, "array", r->array);
12548         ndr->depth++;
12549         if (r->array) {
12550                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
12551                 ndr->depth++;
12552                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
12553                         char *idx_1=NULL;
12554                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
12555                                 ndr_print_srvsvc_NetTransportInfo3(ndr, "array", &r->array[cntr_array_1]);
12556                                 free(idx_1);
12557                         }
12558                 }
12559                 ndr->depth--;
12560         }
12561         ndr->depth--;
12562         ndr->depth--;
12563 }
12564
12565 static enum ndr_err_code ndr_push_srvsvc_NetTransportCtr(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetTransportCtr *r)
12566 {
12567         if (ndr_flags & NDR_SCALARS) {
12568                 int level = ndr_push_get_switch_value(ndr, r);
12569                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
12570                 switch (level) {
12571                         case 0: {
12572                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
12573                         break; }
12574
12575                         case 1: {
12576                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
12577                         break; }
12578
12579                         case 2: {
12580                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr2));
12581                         break; }
12582
12583                         case 3: {
12584                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr3));
12585                         break; }
12586
12587                         default: {
12588                         break; }
12589
12590                 }
12591         }
12592         if (ndr_flags & NDR_BUFFERS) {
12593                 int level = ndr_push_get_switch_value(ndr, r);
12594                 switch (level) {
12595                         case 0:
12596                                 if (r->ctr0) {
12597                                         NDR_CHECK(ndr_push_srvsvc_NetTransportCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
12598                                 }
12599                         break;
12600
12601                         case 1:
12602                                 if (r->ctr1) {
12603                                         NDR_CHECK(ndr_push_srvsvc_NetTransportCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
12604                                 }
12605                         break;
12606
12607                         case 2:
12608                                 if (r->ctr2) {
12609                                         NDR_CHECK(ndr_push_srvsvc_NetTransportCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
12610                                 }
12611                         break;
12612
12613                         case 3:
12614                                 if (r->ctr3) {
12615                                         NDR_CHECK(ndr_push_srvsvc_NetTransportCtr3(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr3));
12616                                 }
12617                         break;
12618
12619                         default:
12620                         break;
12621
12622                 }
12623         }
12624         return NDR_ERR_SUCCESS;
12625 }
12626
12627 static enum ndr_err_code ndr_pull_srvsvc_NetTransportCtr(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetTransportCtr *r)
12628 {
12629         int level;
12630         uint32_t _level;
12631         TALLOC_CTX *_mem_save_ctr0_0;
12632         TALLOC_CTX *_mem_save_ctr1_0;
12633         TALLOC_CTX *_mem_save_ctr2_0;
12634         TALLOC_CTX *_mem_save_ctr3_0;
12635         level = ndr_pull_get_switch_value(ndr, r);
12636         if (ndr_flags & NDR_SCALARS) {
12637                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
12638                 if (_level != level) {
12639                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
12640                 }
12641                 switch (level) {
12642                         case 0: {
12643                                 uint32_t _ptr_ctr0;
12644                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));
12645                                 if (_ptr_ctr0) {
12646                                         NDR_PULL_ALLOC(ndr, r->ctr0);
12647                                 } else {
12648                                         r->ctr0 = NULL;
12649                                 }
12650                         break; }
12651
12652                         case 1: {
12653                                 uint32_t _ptr_ctr1;
12654                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
12655                                 if (_ptr_ctr1) {
12656                                         NDR_PULL_ALLOC(ndr, r->ctr1);
12657                                 } else {
12658                                         r->ctr1 = NULL;
12659                                 }
12660                         break; }
12661
12662                         case 2: {
12663                                 uint32_t _ptr_ctr2;
12664                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr2));
12665                                 if (_ptr_ctr2) {
12666                                         NDR_PULL_ALLOC(ndr, r->ctr2);
12667                                 } else {
12668                                         r->ctr2 = NULL;
12669                                 }
12670                         break; }
12671
12672                         case 3: {
12673                                 uint32_t _ptr_ctr3;
12674                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr3));
12675                                 if (_ptr_ctr3) {
12676                                         NDR_PULL_ALLOC(ndr, r->ctr3);
12677                                 } else {
12678                                         r->ctr3 = NULL;
12679                                 }
12680                         break; }
12681
12682                         default: {
12683                         break; }
12684
12685                 }
12686         }
12687         if (ndr_flags & NDR_BUFFERS) {
12688                 switch (level) {
12689                         case 0:
12690                                 if (r->ctr0) {
12691                                         _mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);
12692                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr0, 0);
12693                                         NDR_CHECK(ndr_pull_srvsvc_NetTransportCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
12694                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);
12695                                 }
12696                         break;
12697
12698                         case 1:
12699                                 if (r->ctr1) {
12700                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
12701                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
12702                                         NDR_CHECK(ndr_pull_srvsvc_NetTransportCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
12703                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
12704                                 }
12705                         break;
12706
12707                         case 2:
12708                                 if (r->ctr2) {
12709                                         _mem_save_ctr2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12710                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr2, 0);
12711                                         NDR_CHECK(ndr_pull_srvsvc_NetTransportCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
12712                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr2_0, 0);
12713                                 }
12714                         break;
12715
12716                         case 3:
12717                                 if (r->ctr3) {
12718                                         _mem_save_ctr3_0 = NDR_PULL_GET_MEM_CTX(ndr);
12719                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr3, 0);
12720                                         NDR_CHECK(ndr_pull_srvsvc_NetTransportCtr3(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr3));
12721                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr3_0, 0);
12722                                 }
12723                         break;
12724
12725                         default:
12726                         break;
12727
12728                 }
12729         }
12730         return NDR_ERR_SUCCESS;
12731 }
12732
12733 _PUBLIC_ void ndr_print_srvsvc_NetTransportCtr(struct ndr_print *ndr, const char *name, const union srvsvc_NetTransportCtr *r)
12734 {
12735         int level;
12736         level = ndr_print_get_switch_value(ndr, r);
12737         ndr_print_union(ndr, name, level, "srvsvc_NetTransportCtr");
12738         switch (level) {
12739                 case 0:
12740                         ndr_print_ptr(ndr, "ctr0", r->ctr0);
12741                         ndr->depth++;
12742                         if (r->ctr0) {
12743                                 ndr_print_srvsvc_NetTransportCtr0(ndr, "ctr0", r->ctr0);
12744                         }
12745                         ndr->depth--;
12746                 break;
12747
12748                 case 1:
12749                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
12750                         ndr->depth++;
12751                         if (r->ctr1) {
12752                                 ndr_print_srvsvc_NetTransportCtr1(ndr, "ctr1", r->ctr1);
12753                         }
12754                         ndr->depth--;
12755                 break;
12756
12757                 case 2:
12758                         ndr_print_ptr(ndr, "ctr2", r->ctr2);
12759                         ndr->depth++;
12760                         if (r->ctr2) {
12761                                 ndr_print_srvsvc_NetTransportCtr2(ndr, "ctr2", r->ctr2);
12762                         }
12763                         ndr->depth--;
12764                 break;
12765
12766                 case 3:
12767                         ndr_print_ptr(ndr, "ctr3", r->ctr3);
12768                         ndr->depth++;
12769                         if (r->ctr3) {
12770                                 ndr_print_srvsvc_NetTransportCtr3(ndr, "ctr3", r->ctr3);
12771                         }
12772                         ndr->depth--;
12773                 break;
12774
12775                 default:
12776                 break;
12777
12778         }
12779 }
12780
12781 static enum ndr_err_code ndr_push_srvsvc_NetRemoteTODInfo(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetRemoteTODInfo *r)
12782 {
12783         if (ndr_flags & NDR_SCALARS) {
12784                 NDR_CHECK(ndr_push_align(ndr, 4));
12785                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->elapsed));
12786                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->msecs));
12787                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->hours));
12788                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->mins));
12789                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->secs));
12790                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->hunds));
12791                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->timezone));
12792                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->tinterval));
12793                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->day));
12794                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->month));
12795                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->year));
12796                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->weekday));
12797         }
12798         if (ndr_flags & NDR_BUFFERS) {
12799         }
12800         return NDR_ERR_SUCCESS;
12801 }
12802
12803 static enum ndr_err_code ndr_pull_srvsvc_NetRemoteTODInfo(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetRemoteTODInfo *r)
12804 {
12805         if (ndr_flags & NDR_SCALARS) {
12806                 NDR_CHECK(ndr_pull_align(ndr, 4));
12807                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->elapsed));
12808                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->msecs));
12809                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->hours));
12810                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->mins));
12811                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->secs));
12812                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->hunds));
12813                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->timezone));
12814                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->tinterval));
12815                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->day));
12816                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->month));
12817                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->year));
12818                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->weekday));
12819         }
12820         if (ndr_flags & NDR_BUFFERS) {
12821         }
12822         return NDR_ERR_SUCCESS;
12823 }
12824
12825 _PUBLIC_ void ndr_print_srvsvc_NetRemoteTODInfo(struct ndr_print *ndr, const char *name, const struct srvsvc_NetRemoteTODInfo *r)
12826 {
12827         ndr_print_struct(ndr, name, "srvsvc_NetRemoteTODInfo");
12828         ndr->depth++;
12829         ndr_print_uint32(ndr, "elapsed", r->elapsed);
12830         ndr_print_uint32(ndr, "msecs", r->msecs);
12831         ndr_print_uint32(ndr, "hours", r->hours);
12832         ndr_print_uint32(ndr, "mins", r->mins);
12833         ndr_print_uint32(ndr, "secs", r->secs);
12834         ndr_print_uint32(ndr, "hunds", r->hunds);
12835         ndr_print_int32(ndr, "timezone", r->timezone);
12836         ndr_print_uint32(ndr, "tinterval", r->tinterval);
12837         ndr_print_uint32(ndr, "day", r->day);
12838         ndr_print_uint32(ndr, "month", r->month);
12839         ndr_print_uint32(ndr, "year", r->year);
12840         ndr_print_uint32(ndr, "weekday", r->weekday);
12841         ndr->depth--;
12842 }
12843
12844 static enum ndr_err_code ndr_push_srvsvc_NetTransportInfo(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetTransportInfo *r)
12845 {
12846         if (ndr_flags & NDR_SCALARS) {
12847                 int level = ndr_push_get_switch_value(ndr, r);
12848                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
12849                 switch (level) {
12850                         case 0: {
12851                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo0(ndr, NDR_SCALARS, &r->info0));
12852                         break; }
12853
12854                         case 1: {
12855                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo1(ndr, NDR_SCALARS, &r->info1));
12856                         break; }
12857
12858                         case 2: {
12859                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo2(ndr, NDR_SCALARS, &r->info2));
12860                         break; }
12861
12862                         case 3: {
12863                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo3(ndr, NDR_SCALARS, &r->info3));
12864                         break; }
12865
12866                         default:
12867                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12868                 }
12869         }
12870         if (ndr_flags & NDR_BUFFERS) {
12871                 int level = ndr_push_get_switch_value(ndr, r);
12872                 switch (level) {
12873                         case 0:
12874                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo0(ndr, NDR_BUFFERS, &r->info0));
12875                         break;
12876
12877                         case 1:
12878                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo1(ndr, NDR_BUFFERS, &r->info1));
12879                         break;
12880
12881                         case 2:
12882                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo2(ndr, NDR_BUFFERS, &r->info2));
12883                         break;
12884
12885                         case 3:
12886                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo3(ndr, NDR_BUFFERS, &r->info3));
12887                         break;
12888
12889                         default:
12890                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12891                 }
12892         }
12893         return NDR_ERR_SUCCESS;
12894 }
12895
12896 static enum ndr_err_code ndr_pull_srvsvc_NetTransportInfo(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetTransportInfo *r)
12897 {
12898         int level;
12899         uint32_t _level;
12900         level = ndr_pull_get_switch_value(ndr, r);
12901         if (ndr_flags & NDR_SCALARS) {
12902                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
12903                 if (_level != level) {
12904                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
12905                 }
12906                 switch (level) {
12907                         case 0: {
12908                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo0(ndr, NDR_SCALARS, &r->info0));
12909                         break; }
12910
12911                         case 1: {
12912                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo1(ndr, NDR_SCALARS, &r->info1));
12913                         break; }
12914
12915                         case 2: {
12916                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo2(ndr, NDR_SCALARS, &r->info2));
12917                         break; }
12918
12919                         case 3: {
12920                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo3(ndr, NDR_SCALARS, &r->info3));
12921                         break; }
12922
12923                         default:
12924                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12925                 }
12926         }
12927         if (ndr_flags & NDR_BUFFERS) {
12928                 switch (level) {
12929                         case 0:
12930                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo0(ndr, NDR_BUFFERS, &r->info0));
12931                         break;
12932
12933                         case 1:
12934                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo1(ndr, NDR_BUFFERS, &r->info1));
12935                         break;
12936
12937                         case 2:
12938                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo2(ndr, NDR_BUFFERS, &r->info2));
12939                         break;
12940
12941                         case 3:
12942                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo3(ndr, NDR_BUFFERS, &r->info3));
12943                         break;
12944
12945                         default:
12946                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12947                 }
12948         }
12949         return NDR_ERR_SUCCESS;
12950 }
12951
12952 _PUBLIC_ void ndr_print_srvsvc_NetTransportInfo(struct ndr_print *ndr, const char *name, const union srvsvc_NetTransportInfo *r)
12953 {
12954         int level;
12955         level = ndr_print_get_switch_value(ndr, r);
12956         ndr_print_union(ndr, name, level, "srvsvc_NetTransportInfo");
12957         switch (level) {
12958                 case 0:
12959                         ndr_print_srvsvc_NetTransportInfo0(ndr, "info0", &r->info0);
12960                 break;
12961
12962                 case 1:
12963                         ndr_print_srvsvc_NetTransportInfo1(ndr, "info1", &r->info1);
12964                 break;
12965
12966                 case 2:
12967                         ndr_print_srvsvc_NetTransportInfo2(ndr, "info2", &r->info2);
12968                 break;
12969
12970                 case 3:
12971                         ndr_print_srvsvc_NetTransportInfo3(ndr, "info3", &r->info3);
12972                 break;
12973
12974                 default:
12975                         ndr_print_bad_level(ndr, name, level);
12976         }
12977 }
12978
12979 static enum ndr_err_code ndr_push_srvsvc_NetCharDevEnum(struct ndr_push *ndr, int flags, const struct srvsvc_NetCharDevEnum *r)
12980 {
12981         if (flags & NDR_IN) {
12982                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
12983                 if (r->in.server_unc) {
12984                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
12985                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12986                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
12987                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12988                 }
12989                 if (r->in.level == NULL) {
12990                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12991                 }
12992                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.level));
12993                 if (r->in.ctr == NULL) {
12994                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12995                 }
12996                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.ctr, *r->in.level));
12997                 NDR_CHECK(ndr_push_srvsvc_NetCharDevCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
12998                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));
12999                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
13000                 if (r->in.resume_handle) {
13001                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
13002                 }
13003         }
13004         if (flags & NDR_OUT) {
13005                 if (r->out.level == NULL) {
13006                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13007                 }
13008                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level));
13009                 if (r->out.ctr == NULL) {
13010                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13011                 }
13012                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level));
13013                 NDR_CHECK(ndr_push_srvsvc_NetCharDevCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13014                 if (r->out.totalentries == NULL) {
13015                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13016                 }
13017                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
13018                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
13019                 if (r->out.resume_handle) {
13020                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
13021                 }
13022                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13023         }
13024         return NDR_ERR_SUCCESS;
13025 }
13026
13027 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevEnum(struct ndr_pull *ndr, int flags, struct srvsvc_NetCharDevEnum *r)
13028 {
13029         uint32_t _ptr_server_unc;
13030         uint32_t _ptr_resume_handle;
13031         TALLOC_CTX *_mem_save_server_unc_0;
13032         TALLOC_CTX *_mem_save_level_0;
13033         TALLOC_CTX *_mem_save_ctr_0;
13034         TALLOC_CTX *_mem_save_totalentries_0;
13035         TALLOC_CTX *_mem_save_resume_handle_0;
13036         if (flags & NDR_IN) {
13037                 ZERO_STRUCT(r->out);
13038
13039                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
13040                 if (_ptr_server_unc) {
13041                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
13042                 } else {
13043                         r->in.server_unc = NULL;
13044                 }
13045                 if (r->in.server_unc) {
13046                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
13047                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
13048                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
13049                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
13050                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
13051                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
13052                         }
13053                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
13054                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
13055                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
13056                 }
13057                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13058                         NDR_PULL_ALLOC(ndr, r->in.level);
13059                 }
13060                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
13061                 NDR_PULL_SET_MEM_CTX(ndr, r->in.level, LIBNDR_FLAG_REF_ALLOC);
13062                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.level));
13063                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
13064                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13065                         NDR_PULL_ALLOC(ndr, r->in.ctr);
13066                 }
13067                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13068                 NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, LIBNDR_FLAG_REF_ALLOC);
13069                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.ctr, *r->in.level));
13070                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
13071                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13072                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));
13073                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
13074                 if (_ptr_resume_handle) {
13075                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
13076                 } else {
13077                         r->in.resume_handle = NULL;
13078                 }
13079                 if (r->in.resume_handle) {
13080                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13081                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
13082                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
13083                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
13084                 }
13085                 NDR_PULL_ALLOC(ndr, r->out.level);
13086                 *r->out.level = *r->in.level;
13087                 NDR_PULL_ALLOC(ndr, r->out.ctr);
13088                 *r->out.ctr = *r->in.ctr;
13089                 NDR_PULL_ALLOC(ndr, r->out.totalentries);
13090                 ZERO_STRUCTP(r->out.totalentries);
13091         }
13092         if (flags & NDR_OUT) {
13093                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13094                         NDR_PULL_ALLOC(ndr, r->out.level);
13095                 }
13096                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
13097                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level, LIBNDR_FLAG_REF_ALLOC);
13098                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level));
13099                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
13100                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13101                         NDR_PULL_ALLOC(ndr, r->out.ctr);
13102                 }
13103                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13104                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
13105                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level));
13106                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13107                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13108                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13109                         NDR_PULL_ALLOC(ndr, r->out.totalentries);
13110                 }
13111                 _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
13112                 NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);
13113                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
13114                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);
13115                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
13116                 if (_ptr_resume_handle) {
13117                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
13118                 } else {
13119                         r->out.resume_handle = NULL;
13120                 }
13121                 if (r->out.resume_handle) {
13122                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13123                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
13124                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
13125                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
13126                 }
13127                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13128         }
13129         return NDR_ERR_SUCCESS;
13130 }
13131
13132 _PUBLIC_ void ndr_print_srvsvc_NetCharDevEnum(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetCharDevEnum *r)
13133 {
13134         ndr_print_struct(ndr, name, "srvsvc_NetCharDevEnum");
13135         ndr->depth++;
13136         if (flags & NDR_SET_VALUES) {
13137                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13138         }
13139         if (flags & NDR_IN) {
13140                 ndr_print_struct(ndr, "in", "srvsvc_NetCharDevEnum");
13141                 ndr->depth++;
13142                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
13143                 ndr->depth++;
13144                 if (r->in.server_unc) {
13145                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
13146                 }
13147                 ndr->depth--;
13148                 ndr_print_ptr(ndr, "level", r->in.level);
13149                 ndr->depth++;
13150                 ndr_print_uint32(ndr, "level", *r->in.level);
13151                 ndr->depth--;
13152                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
13153                 ndr->depth++;
13154                 ndr_print_set_switch_value(ndr, r->in.ctr, *r->in.level);
13155                 ndr_print_srvsvc_NetCharDevCtr(ndr, "ctr", r->in.ctr);
13156                 ndr->depth--;
13157                 ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);
13158                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
13159                 ndr->depth++;
13160                 if (r->in.resume_handle) {
13161                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
13162                 }
13163                 ndr->depth--;
13164                 ndr->depth--;
13165         }
13166         if (flags & NDR_OUT) {
13167                 ndr_print_struct(ndr, "out", "srvsvc_NetCharDevEnum");
13168                 ndr->depth++;
13169                 ndr_print_ptr(ndr, "level", r->out.level);
13170                 ndr->depth++;
13171                 ndr_print_uint32(ndr, "level", *r->out.level);
13172                 ndr->depth--;
13173                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
13174                 ndr->depth++;
13175                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level);
13176                 ndr_print_srvsvc_NetCharDevCtr(ndr, "ctr", r->out.ctr);
13177                 ndr->depth--;
13178                 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
13179                 ndr->depth++;
13180                 ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
13181                 ndr->depth--;
13182                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
13183                 ndr->depth++;
13184                 if (r->out.resume_handle) {
13185                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
13186                 }
13187                 ndr->depth--;
13188                 ndr_print_WERROR(ndr, "result", r->out.result);
13189                 ndr->depth--;
13190         }
13191         ndr->depth--;
13192 }
13193
13194 static enum ndr_err_code ndr_push_srvsvc_NetCharDevGetInfo(struct ndr_push *ndr, int flags, const struct srvsvc_NetCharDevGetInfo *r)
13195 {
13196         if (flags & NDR_IN) {
13197                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
13198                 if (r->in.server_unc) {
13199                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
13200                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13201                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
13202                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13203                 }
13204                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.device_name, CH_UTF16)));
13205                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13206                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.device_name, CH_UTF16)));
13207                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.device_name, ndr_charset_length(r->in.device_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13208                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13209         }
13210         if (flags & NDR_OUT) {
13211                 if (r->out.info == NULL) {
13212                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13213                 }
13214                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
13215                 NDR_CHECK(ndr_push_srvsvc_NetCharDevInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
13216                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13217         }
13218         return NDR_ERR_SUCCESS;
13219 }
13220
13221 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevGetInfo(struct ndr_pull *ndr, int flags, struct srvsvc_NetCharDevGetInfo *r)
13222 {
13223         uint32_t _ptr_server_unc;
13224         TALLOC_CTX *_mem_save_server_unc_0;
13225         TALLOC_CTX *_mem_save_info_0;
13226         if (flags & NDR_IN) {
13227                 ZERO_STRUCT(r->out);
13228
13229                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
13230                 if (_ptr_server_unc) {
13231                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
13232                 } else {
13233                         r->in.server_unc = NULL;
13234                 }
13235                 if (r->in.server_unc) {
13236                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
13237                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
13238                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
13239                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
13240                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
13241                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
13242                         }
13243                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
13244                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
13245                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
13246                 }
13247                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.device_name));
13248                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.device_name));
13249                 if (ndr_get_array_length(ndr, &r->in.device_name) > ndr_get_array_size(ndr, &r->in.device_name)) {
13250                         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.device_name), ndr_get_array_length(ndr, &r->in.device_name));
13251                 }
13252                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.device_name), sizeof(uint16_t)));
13253                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.device_name, ndr_get_array_length(ndr, &r->in.device_name), sizeof(uint16_t), CH_UTF16));
13254                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13255                 NDR_PULL_ALLOC(ndr, r->out.info);
13256                 ZERO_STRUCTP(r->out.info);
13257         }
13258         if (flags & NDR_OUT) {
13259                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13260                         NDR_PULL_ALLOC(ndr, r->out.info);
13261                 }
13262                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13263                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
13264                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
13265                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
13266                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
13267                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13268         }
13269         return NDR_ERR_SUCCESS;
13270 }
13271
13272 _PUBLIC_ void ndr_print_srvsvc_NetCharDevGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetCharDevGetInfo *r)
13273 {
13274         ndr_print_struct(ndr, name, "srvsvc_NetCharDevGetInfo");
13275         ndr->depth++;
13276         if (flags & NDR_SET_VALUES) {
13277                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13278         }
13279         if (flags & NDR_IN) {
13280                 ndr_print_struct(ndr, "in", "srvsvc_NetCharDevGetInfo");
13281                 ndr->depth++;
13282                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
13283                 ndr->depth++;
13284                 if (r->in.server_unc) {
13285                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
13286                 }
13287                 ndr->depth--;
13288                 ndr_print_string(ndr, "device_name", r->in.device_name);
13289                 ndr_print_uint32(ndr, "level", r->in.level);
13290                 ndr->depth--;
13291         }
13292         if (flags & NDR_OUT) {
13293                 ndr_print_struct(ndr, "out", "srvsvc_NetCharDevGetInfo");
13294                 ndr->depth++;
13295                 ndr_print_ptr(ndr, "info", r->out.info);
13296                 ndr->depth++;
13297                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
13298                 ndr_print_srvsvc_NetCharDevInfo(ndr, "info", r->out.info);
13299                 ndr->depth--;
13300                 ndr_print_WERROR(ndr, "result", r->out.result);
13301                 ndr->depth--;
13302         }
13303         ndr->depth--;
13304 }
13305
13306 static enum ndr_err_code ndr_push_srvsvc_NetCharDevControl(struct ndr_push *ndr, int flags, const struct srvsvc_NetCharDevControl *r)
13307 {
13308         if (flags & NDR_IN) {
13309                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
13310                 if (r->in.server_unc) {
13311                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
13312                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13313                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
13314                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13315                 }
13316                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.device_name, CH_UTF16)));
13317                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13318                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.device_name, CH_UTF16)));
13319                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.device_name, ndr_charset_length(r->in.device_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13320                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.opcode));
13321         }
13322         if (flags & NDR_OUT) {
13323                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13324         }
13325         return NDR_ERR_SUCCESS;
13326 }
13327
13328 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevControl(struct ndr_pull *ndr, int flags, struct srvsvc_NetCharDevControl *r)
13329 {
13330         uint32_t _ptr_server_unc;
13331         TALLOC_CTX *_mem_save_server_unc_0;
13332         if (flags & NDR_IN) {
13333                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
13334                 if (_ptr_server_unc) {
13335                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
13336                 } else {
13337                         r->in.server_unc = NULL;
13338                 }
13339                 if (r->in.server_unc) {
13340                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
13341                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
13342                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
13343                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
13344                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
13345                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
13346                         }
13347                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
13348                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
13349                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
13350                 }
13351                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.device_name));
13352                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.device_name));
13353                 if (ndr_get_array_length(ndr, &r->in.device_name) > ndr_get_array_size(ndr, &r->in.device_name)) {
13354                         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.device_name), ndr_get_array_length(ndr, &r->in.device_name));
13355                 }
13356                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.device_name), sizeof(uint16_t)));
13357                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.device_name, ndr_get_array_length(ndr, &r->in.device_name), sizeof(uint16_t), CH_UTF16));
13358                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.opcode));
13359         }
13360         if (flags & NDR_OUT) {
13361                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13362         }
13363         return NDR_ERR_SUCCESS;
13364 }
13365
13366 _PUBLIC_ void ndr_print_srvsvc_NetCharDevControl(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetCharDevControl *r)
13367 {
13368         ndr_print_struct(ndr, name, "srvsvc_NetCharDevControl");
13369         ndr->depth++;
13370         if (flags & NDR_SET_VALUES) {
13371                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13372         }
13373         if (flags & NDR_IN) {
13374                 ndr_print_struct(ndr, "in", "srvsvc_NetCharDevControl");
13375                 ndr->depth++;
13376                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
13377                 ndr->depth++;
13378                 if (r->in.server_unc) {
13379                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
13380                 }
13381                 ndr->depth--;
13382                 ndr_print_string(ndr, "device_name", r->in.device_name);
13383                 ndr_print_uint32(ndr, "opcode", r->in.opcode);
13384                 ndr->depth--;
13385         }
13386         if (flags & NDR_OUT) {
13387                 ndr_print_struct(ndr, "out", "srvsvc_NetCharDevControl");
13388                 ndr->depth++;
13389                 ndr_print_WERROR(ndr, "result", r->out.result);
13390                 ndr->depth--;
13391         }
13392         ndr->depth--;
13393 }
13394
13395 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQEnum(struct ndr_push *ndr, int flags, const struct srvsvc_NetCharDevQEnum *r)
13396 {
13397         if (flags & NDR_IN) {
13398                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
13399                 if (r->in.server_unc) {
13400                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
13401                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13402                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
13403                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13404                 }
13405                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.user));
13406                 if (r->in.user) {
13407                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));
13408                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13409                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));
13410                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.user, ndr_charset_length(r->in.user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13411                 }
13412                 if (r->in.level == NULL) {
13413                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13414                 }
13415                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.level));
13416                 if (r->in.ctr == NULL) {
13417                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13418                 }
13419                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.ctr, *r->in.level));
13420                 NDR_CHECK(ndr_push_srvsvc_NetCharDevQCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
13421                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));
13422                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
13423                 if (r->in.resume_handle) {
13424                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
13425                 }
13426         }
13427         if (flags & NDR_OUT) {
13428                 if (r->out.level == NULL) {
13429                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13430                 }
13431                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level));
13432                 if (r->out.ctr == NULL) {
13433                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13434                 }
13435                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level));
13436                 NDR_CHECK(ndr_push_srvsvc_NetCharDevQCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13437                 if (r->out.totalentries == NULL) {
13438                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13439                 }
13440                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
13441                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
13442                 if (r->out.resume_handle) {
13443                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
13444                 }
13445                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13446         }
13447         return NDR_ERR_SUCCESS;
13448 }
13449
13450 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQEnum(struct ndr_pull *ndr, int flags, struct srvsvc_NetCharDevQEnum *r)
13451 {
13452         uint32_t _ptr_server_unc;
13453         uint32_t _ptr_user;
13454         uint32_t _ptr_resume_handle;
13455         TALLOC_CTX *_mem_save_server_unc_0;
13456         TALLOC_CTX *_mem_save_user_0;
13457         TALLOC_CTX *_mem_save_level_0;
13458         TALLOC_CTX *_mem_save_ctr_0;
13459         TALLOC_CTX *_mem_save_totalentries_0;
13460         TALLOC_CTX *_mem_save_resume_handle_0;
13461         if (flags & NDR_IN) {
13462                 ZERO_STRUCT(r->out);
13463
13464                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
13465                 if (_ptr_server_unc) {
13466                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
13467                 } else {
13468                         r->in.server_unc = NULL;
13469                 }
13470                 if (r->in.server_unc) {
13471                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
13472                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
13473                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
13474                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
13475                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
13476                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
13477                         }
13478                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
13479                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
13480                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
13481                 }
13482                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
13483                 if (_ptr_user) {
13484                         NDR_PULL_ALLOC(ndr, r->in.user);
13485                 } else {
13486                         r->in.user = NULL;
13487                 }
13488                 if (r->in.user) {
13489                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
13490                         NDR_PULL_SET_MEM_CTX(ndr, r->in.user, 0);
13491                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.user));
13492                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.user));
13493                         if (ndr_get_array_length(ndr, &r->in.user) > ndr_get_array_size(ndr, &r->in.user)) {
13494                                 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.user), ndr_get_array_length(ndr, &r->in.user));
13495                         }
13496                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.user), sizeof(uint16_t)));
13497                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.user, ndr_get_array_length(ndr, &r->in.user), sizeof(uint16_t), CH_UTF16));
13498                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
13499                 }
13500                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13501                         NDR_PULL_ALLOC(ndr, r->in.level);
13502                 }
13503                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
13504                 NDR_PULL_SET_MEM_CTX(ndr, r->in.level, LIBNDR_FLAG_REF_ALLOC);
13505                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.level));
13506                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
13507                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13508                         NDR_PULL_ALLOC(ndr, r->in.ctr);
13509                 }
13510                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13511                 NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, LIBNDR_FLAG_REF_ALLOC);
13512                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.ctr, *r->in.level));
13513                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevQCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
13514                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13515                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));
13516                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
13517                 if (_ptr_resume_handle) {
13518                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
13519                 } else {
13520                         r->in.resume_handle = NULL;
13521                 }
13522                 if (r->in.resume_handle) {
13523                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13524                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
13525                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
13526                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
13527                 }
13528                 NDR_PULL_ALLOC(ndr, r->out.level);
13529                 *r->out.level = *r->in.level;
13530                 NDR_PULL_ALLOC(ndr, r->out.ctr);
13531                 *r->out.ctr = *r->in.ctr;
13532                 NDR_PULL_ALLOC(ndr, r->out.totalentries);
13533                 ZERO_STRUCTP(r->out.totalentries);
13534         }
13535         if (flags & NDR_OUT) {
13536                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13537                         NDR_PULL_ALLOC(ndr, r->out.level);
13538                 }
13539                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
13540                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level, LIBNDR_FLAG_REF_ALLOC);
13541                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level));
13542                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
13543                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13544                         NDR_PULL_ALLOC(ndr, r->out.ctr);
13545                 }
13546                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13547                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
13548                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level));
13549                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevQCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13550                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13551                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13552                         NDR_PULL_ALLOC(ndr, r->out.totalentries);
13553                 }
13554                 _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
13555                 NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);
13556                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
13557                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);
13558                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
13559                 if (_ptr_resume_handle) {
13560                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
13561                 } else {
13562                         r->out.resume_handle = NULL;
13563                 }
13564                 if (r->out.resume_handle) {
13565                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13566                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
13567                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
13568                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
13569                 }
13570                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13571         }
13572         return NDR_ERR_SUCCESS;
13573 }
13574
13575 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQEnum(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetCharDevQEnum *r)
13576 {
13577         ndr_print_struct(ndr, name, "srvsvc_NetCharDevQEnum");
13578         ndr->depth++;
13579         if (flags & NDR_SET_VALUES) {
13580                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13581         }
13582         if (flags & NDR_IN) {
13583                 ndr_print_struct(ndr, "in", "srvsvc_NetCharDevQEnum");
13584                 ndr->depth++;
13585                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
13586                 ndr->depth++;
13587                 if (r->in.server_unc) {
13588                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
13589                 }
13590                 ndr->depth--;
13591                 ndr_print_ptr(ndr, "user", r->in.user);
13592                 ndr->depth++;
13593                 if (r->in.user) {
13594                         ndr_print_string(ndr, "user", r->in.user);
13595                 }
13596                 ndr->depth--;
13597                 ndr_print_ptr(ndr, "level", r->in.level);
13598                 ndr->depth++;
13599                 ndr_print_uint32(ndr, "level", *r->in.level);
13600                 ndr->depth--;
13601                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
13602                 ndr->depth++;
13603                 ndr_print_set_switch_value(ndr, r->in.ctr, *r->in.level);
13604                 ndr_print_srvsvc_NetCharDevQCtr(ndr, "ctr", r->in.ctr);
13605                 ndr->depth--;
13606                 ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);
13607                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
13608                 ndr->depth++;
13609                 if (r->in.resume_handle) {
13610                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
13611                 }
13612                 ndr->depth--;
13613                 ndr->depth--;
13614         }
13615         if (flags & NDR_OUT) {
13616                 ndr_print_struct(ndr, "out", "srvsvc_NetCharDevQEnum");
13617                 ndr->depth++;
13618                 ndr_print_ptr(ndr, "level", r->out.level);
13619                 ndr->depth++;
13620                 ndr_print_uint32(ndr, "level", *r->out.level);
13621                 ndr->depth--;
13622                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
13623                 ndr->depth++;
13624                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level);
13625                 ndr_print_srvsvc_NetCharDevQCtr(ndr, "ctr", r->out.ctr);
13626                 ndr->depth--;
13627                 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
13628                 ndr->depth++;
13629                 ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
13630                 ndr->depth--;
13631                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
13632                 ndr->depth++;
13633                 if (r->out.resume_handle) {
13634                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
13635                 }
13636                 ndr->depth--;
13637                 ndr_print_WERROR(ndr, "result", r->out.result);
13638                 ndr->depth--;
13639         }
13640         ndr->depth--;
13641 }
13642
13643 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQGetInfo(struct ndr_push *ndr, int flags, const struct srvsvc_NetCharDevQGetInfo *r)
13644 {
13645         if (flags & NDR_IN) {
13646                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
13647                 if (r->in.server_unc) {
13648                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
13649                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13650                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
13651                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13652                 }
13653                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.queue_name, CH_UTF16)));
13654                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13655                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.queue_name, CH_UTF16)));
13656                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.queue_name, ndr_charset_length(r->in.queue_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13657                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));
13658                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13659                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));
13660                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.user, ndr_charset_length(r->in.user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13661                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13662         }
13663         if (flags & NDR_OUT) {
13664                 if (r->out.info == NULL) {
13665                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13666                 }
13667                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
13668                 NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
13669                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13670         }
13671         return NDR_ERR_SUCCESS;
13672 }
13673
13674 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQGetInfo(struct ndr_pull *ndr, int flags, struct srvsvc_NetCharDevQGetInfo *r)
13675 {
13676         uint32_t _ptr_server_unc;
13677         TALLOC_CTX *_mem_save_server_unc_0;
13678         TALLOC_CTX *_mem_save_info_0;
13679         if (flags & NDR_IN) {
13680                 ZERO_STRUCT(r->out);
13681
13682                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
13683                 if (_ptr_server_unc) {
13684                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
13685                 } else {
13686                         r->in.server_unc = NULL;
13687                 }
13688                 if (r->in.server_unc) {
13689                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
13690                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
13691                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
13692                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
13693                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
13694                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
13695                         }
13696                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
13697                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
13698                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
13699                 }
13700                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.queue_name));
13701                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.queue_name));
13702                 if (ndr_get_array_length(ndr, &r->in.queue_name) > ndr_get_array_size(ndr, &r->in.queue_name)) {
13703                         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.queue_name), ndr_get_array_length(ndr, &r->in.queue_name));
13704                 }
13705                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.queue_name), sizeof(uint16_t)));
13706                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.queue_name, ndr_get_array_length(ndr, &r->in.queue_name), sizeof(uint16_t), CH_UTF16));
13707                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.user));
13708                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.user));
13709                 if (ndr_get_array_length(ndr, &r->in.user) > ndr_get_array_size(ndr, &r->in.user)) {
13710                         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.user), ndr_get_array_length(ndr, &r->in.user));
13711                 }
13712                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.user), sizeof(uint16_t)));
13713                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.user, ndr_get_array_length(ndr, &r->in.user), sizeof(uint16_t), CH_UTF16));
13714                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13715                 NDR_PULL_ALLOC(ndr, r->out.info);
13716                 ZERO_STRUCTP(r->out.info);
13717         }
13718         if (flags & NDR_OUT) {
13719                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13720                         NDR_PULL_ALLOC(ndr, r->out.info);
13721                 }
13722                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13723                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
13724                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
13725                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
13726                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
13727                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13728         }
13729         return NDR_ERR_SUCCESS;
13730 }
13731
13732 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetCharDevQGetInfo *r)
13733 {
13734         ndr_print_struct(ndr, name, "srvsvc_NetCharDevQGetInfo");
13735         ndr->depth++;
13736         if (flags & NDR_SET_VALUES) {
13737                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13738         }
13739         if (flags & NDR_IN) {
13740                 ndr_print_struct(ndr, "in", "srvsvc_NetCharDevQGetInfo");
13741                 ndr->depth++;
13742                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
13743                 ndr->depth++;
13744                 if (r->in.server_unc) {
13745                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
13746                 }
13747                 ndr->depth--;
13748                 ndr_print_string(ndr, "queue_name", r->in.queue_name);
13749                 ndr_print_string(ndr, "user", r->in.user);
13750                 ndr_print_uint32(ndr, "level", r->in.level);
13751                 ndr->depth--;
13752         }
13753         if (flags & NDR_OUT) {
13754                 ndr_print_struct(ndr, "out", "srvsvc_NetCharDevQGetInfo");
13755                 ndr->depth++;
13756                 ndr_print_ptr(ndr, "info", r->out.info);
13757                 ndr->depth++;
13758                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
13759                 ndr_print_srvsvc_NetCharDevQInfo(ndr, "info", r->out.info);
13760                 ndr->depth--;
13761                 ndr_print_WERROR(ndr, "result", r->out.result);
13762                 ndr->depth--;
13763         }
13764         ndr->depth--;
13765 }
13766
13767 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQSetInfo(struct ndr_push *ndr, int flags, const struct srvsvc_NetCharDevQSetInfo *r)
13768 {
13769         if (flags & NDR_IN) {
13770                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
13771                 if (r->in.server_unc) {
13772                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
13773                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13774                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
13775                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13776                 }
13777                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.queue_name, CH_UTF16)));
13778                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13779                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.queue_name, CH_UTF16)));
13780                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.queue_name, ndr_charset_length(r->in.queue_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13781                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13782                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
13783                 NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
13784                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_error));
13785                 if (r->in.parm_error) {
13786                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_error));
13787                 }
13788         }
13789         if (flags & NDR_OUT) {
13790                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_error));
13791                 if (r->out.parm_error) {
13792                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_error));
13793                 }
13794                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13795         }
13796         return NDR_ERR_SUCCESS;
13797 }
13798
13799 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQSetInfo(struct ndr_pull *ndr, int flags, struct srvsvc_NetCharDevQSetInfo *r)
13800 {
13801         uint32_t _ptr_server_unc;
13802         uint32_t _ptr_parm_error;
13803         TALLOC_CTX *_mem_save_server_unc_0;
13804         TALLOC_CTX *_mem_save_parm_error_0;
13805         if (flags & NDR_IN) {
13806                 ZERO_STRUCT(r->out);
13807
13808                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
13809                 if (_ptr_server_unc) {
13810                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
13811                 } else {
13812                         r->in.server_unc = NULL;
13813                 }
13814                 if (r->in.server_unc) {
13815                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
13816                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
13817                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
13818                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
13819                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
13820                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
13821                         }
13822                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
13823                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
13824                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
13825                 }
13826                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.queue_name));
13827                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.queue_name));
13828                 if (ndr_get_array_length(ndr, &r->in.queue_name) > ndr_get_array_size(ndr, &r->in.queue_name)) {
13829                         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.queue_name), ndr_get_array_length(ndr, &r->in.queue_name));
13830                 }
13831                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.queue_name), sizeof(uint16_t)));
13832                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.queue_name, ndr_get_array_length(ndr, &r->in.queue_name), sizeof(uint16_t), CH_UTF16));
13833                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13834                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
13835                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
13836                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_error));
13837                 if (_ptr_parm_error) {
13838                         NDR_PULL_ALLOC(ndr, r->in.parm_error);
13839                 } else {
13840                         r->in.parm_error = NULL;
13841                 }
13842                 if (r->in.parm_error) {
13843                         _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
13844                         NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_error, 0);
13845                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_error));
13846                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, 0);
13847                 }
13848         }
13849         if (flags & NDR_OUT) {
13850                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_error));
13851                 if (_ptr_parm_error) {
13852                         NDR_PULL_ALLOC(ndr, r->out.parm_error);
13853                 } else {
13854                         r->out.parm_error = NULL;
13855                 }
13856                 if (r->out.parm_error) {
13857                         _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
13858                         NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_error, 0);
13859                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_error));
13860                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, 0);
13861                 }
13862                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13863         }
13864         return NDR_ERR_SUCCESS;
13865 }
13866
13867 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQSetInfo(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetCharDevQSetInfo *r)
13868 {
13869         ndr_print_struct(ndr, name, "srvsvc_NetCharDevQSetInfo");
13870         ndr->depth++;
13871         if (flags & NDR_SET_VALUES) {
13872                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13873         }
13874         if (flags & NDR_IN) {
13875                 ndr_print_struct(ndr, "in", "srvsvc_NetCharDevQSetInfo");
13876                 ndr->depth++;
13877                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
13878                 ndr->depth++;
13879                 if (r->in.server_unc) {
13880                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
13881                 }
13882                 ndr->depth--;
13883                 ndr_print_string(ndr, "queue_name", r->in.queue_name);
13884                 ndr_print_uint32(ndr, "level", r->in.level);
13885                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
13886                 ndr_print_srvsvc_NetCharDevQInfo(ndr, "info", &r->in.info);
13887                 ndr_print_ptr(ndr, "parm_error", r->in.parm_error);
13888                 ndr->depth++;
13889                 if (r->in.parm_error) {
13890                         ndr_print_uint32(ndr, "parm_error", *r->in.parm_error);
13891                 }
13892                 ndr->depth--;
13893                 ndr->depth--;
13894         }
13895         if (flags & NDR_OUT) {
13896                 ndr_print_struct(ndr, "out", "srvsvc_NetCharDevQSetInfo");
13897                 ndr->depth++;
13898                 ndr_print_ptr(ndr, "parm_error", r->out.parm_error);
13899                 ndr->depth++;
13900                 if (r->out.parm_error) {
13901                         ndr_print_uint32(ndr, "parm_error", *r->out.parm_error);
13902                 }
13903                 ndr->depth--;
13904                 ndr_print_WERROR(ndr, "result", r->out.result);
13905                 ndr->depth--;
13906         }
13907         ndr->depth--;
13908 }
13909
13910 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQPurge(struct ndr_push *ndr, int flags, const struct srvsvc_NetCharDevQPurge *r)
13911 {
13912         if (flags & NDR_IN) {
13913                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
13914                 if (r->in.server_unc) {
13915                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
13916                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13917                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
13918                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13919                 }
13920                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.queue_name, CH_UTF16)));
13921                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13922                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.queue_name, CH_UTF16)));
13923                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.queue_name, ndr_charset_length(r->in.queue_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13924         }
13925         if (flags & NDR_OUT) {
13926                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13927         }
13928         return NDR_ERR_SUCCESS;
13929 }
13930
13931 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQPurge(struct ndr_pull *ndr, int flags, struct srvsvc_NetCharDevQPurge *r)
13932 {
13933         uint32_t _ptr_server_unc;
13934         TALLOC_CTX *_mem_save_server_unc_0;
13935         if (flags & NDR_IN) {
13936                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
13937                 if (_ptr_server_unc) {
13938                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
13939                 } else {
13940                         r->in.server_unc = NULL;
13941                 }
13942                 if (r->in.server_unc) {
13943                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
13944                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
13945                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
13946                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
13947                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
13948                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
13949                         }
13950                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
13951                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
13952                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
13953                 }
13954                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.queue_name));
13955                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.queue_name));
13956                 if (ndr_get_array_length(ndr, &r->in.queue_name) > ndr_get_array_size(ndr, &r->in.queue_name)) {
13957                         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.queue_name), ndr_get_array_length(ndr, &r->in.queue_name));
13958                 }
13959                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.queue_name), sizeof(uint16_t)));
13960                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.queue_name, ndr_get_array_length(ndr, &r->in.queue_name), sizeof(uint16_t), CH_UTF16));
13961         }
13962         if (flags & NDR_OUT) {
13963                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13964         }
13965         return NDR_ERR_SUCCESS;
13966 }
13967
13968 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQPurge(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetCharDevQPurge *r)
13969 {
13970         ndr_print_struct(ndr, name, "srvsvc_NetCharDevQPurge");
13971         ndr->depth++;
13972         if (flags & NDR_SET_VALUES) {
13973                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13974         }
13975         if (flags & NDR_IN) {
13976                 ndr_print_struct(ndr, "in", "srvsvc_NetCharDevQPurge");
13977                 ndr->depth++;
13978                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
13979                 ndr->depth++;
13980                 if (r->in.server_unc) {
13981                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
13982                 }
13983                 ndr->depth--;
13984                 ndr_print_string(ndr, "queue_name", r->in.queue_name);
13985                 ndr->depth--;
13986         }
13987         if (flags & NDR_OUT) {
13988                 ndr_print_struct(ndr, "out", "srvsvc_NetCharDevQPurge");
13989                 ndr->depth++;
13990                 ndr_print_WERROR(ndr, "result", r->out.result);
13991                 ndr->depth--;
13992         }
13993         ndr->depth--;
13994 }
13995
13996 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQPurgeSelf(struct ndr_push *ndr, int flags, const struct srvsvc_NetCharDevQPurgeSelf *r)
13997 {
13998         if (flags & NDR_IN) {
13999                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
14000                 if (r->in.server_unc) {
14001                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14002                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14003                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14004                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14005                 }
14006                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.queue_name, CH_UTF16)));
14007                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14008                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.queue_name, CH_UTF16)));
14009                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.queue_name, ndr_charset_length(r->in.queue_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14010                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.computer_name, CH_UTF16)));
14011                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14012                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.computer_name, CH_UTF16)));
14013                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.computer_name, ndr_charset_length(r->in.computer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14014         }
14015         if (flags & NDR_OUT) {
14016                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14017         }
14018         return NDR_ERR_SUCCESS;
14019 }
14020
14021 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQPurgeSelf(struct ndr_pull *ndr, int flags, struct srvsvc_NetCharDevQPurgeSelf *r)
14022 {
14023         uint32_t _ptr_server_unc;
14024         TALLOC_CTX *_mem_save_server_unc_0;
14025         if (flags & NDR_IN) {
14026                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
14027                 if (_ptr_server_unc) {
14028                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
14029                 } else {
14030                         r->in.server_unc = NULL;
14031                 }
14032                 if (r->in.server_unc) {
14033                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
14034                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
14035                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
14036                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
14037                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
14038                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
14039                         }
14040                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
14041                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
14042                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
14043                 }
14044                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.queue_name));
14045                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.queue_name));
14046                 if (ndr_get_array_length(ndr, &r->in.queue_name) > ndr_get_array_size(ndr, &r->in.queue_name)) {
14047                         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.queue_name), ndr_get_array_length(ndr, &r->in.queue_name));
14048                 }
14049                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.queue_name), sizeof(uint16_t)));
14050                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.queue_name, ndr_get_array_length(ndr, &r->in.queue_name), sizeof(uint16_t), CH_UTF16));
14051                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.computer_name));
14052                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.computer_name));
14053                 if (ndr_get_array_length(ndr, &r->in.computer_name) > ndr_get_array_size(ndr, &r->in.computer_name)) {
14054                         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.computer_name), ndr_get_array_length(ndr, &r->in.computer_name));
14055                 }
14056                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.computer_name), sizeof(uint16_t)));
14057                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.computer_name, ndr_get_array_length(ndr, &r->in.computer_name), sizeof(uint16_t), CH_UTF16));
14058         }
14059         if (flags & NDR_OUT) {
14060                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14061         }
14062         return NDR_ERR_SUCCESS;
14063 }
14064
14065 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQPurgeSelf(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetCharDevQPurgeSelf *r)
14066 {
14067         ndr_print_struct(ndr, name, "srvsvc_NetCharDevQPurgeSelf");
14068         ndr->depth++;
14069         if (flags & NDR_SET_VALUES) {
14070                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14071         }
14072         if (flags & NDR_IN) {
14073                 ndr_print_struct(ndr, "in", "srvsvc_NetCharDevQPurgeSelf");
14074                 ndr->depth++;
14075                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
14076                 ndr->depth++;
14077                 if (r->in.server_unc) {
14078                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
14079                 }
14080                 ndr->depth--;
14081                 ndr_print_string(ndr, "queue_name", r->in.queue_name);
14082                 ndr_print_string(ndr, "computer_name", r->in.computer_name);
14083                 ndr->depth--;
14084         }
14085         if (flags & NDR_OUT) {
14086                 ndr_print_struct(ndr, "out", "srvsvc_NetCharDevQPurgeSelf");
14087                 ndr->depth++;
14088                 ndr_print_WERROR(ndr, "result", r->out.result);
14089                 ndr->depth--;
14090         }
14091         ndr->depth--;
14092 }
14093
14094 static enum ndr_err_code ndr_push_srvsvc_NetConnEnum(struct ndr_push *ndr, int flags, const struct srvsvc_NetConnEnum *r)
14095 {
14096         if (flags & NDR_IN) {
14097                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
14098                 if (r->in.server_unc) {
14099                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14100                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14101                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14102                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14103                 }
14104                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.path));
14105                 if (r->in.path) {
14106                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));
14107                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14108                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));
14109                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.path, ndr_charset_length(r->in.path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14110                 }
14111                 if (r->in.level == NULL) {
14112                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14113                 }
14114                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.level));
14115                 if (r->in.ctr == NULL) {
14116                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14117                 }
14118                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.ctr, *r->in.level));
14119                 NDR_CHECK(ndr_push_srvsvc_NetConnCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
14120                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));
14121                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
14122                 if (r->in.resume_handle) {
14123                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
14124                 }
14125         }
14126         if (flags & NDR_OUT) {
14127                 if (r->out.level == NULL) {
14128                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14129                 }
14130                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level));
14131                 if (r->out.ctr == NULL) {
14132                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14133                 }
14134                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level));
14135                 NDR_CHECK(ndr_push_srvsvc_NetConnCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14136                 if (r->out.totalentries == NULL) {
14137                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14138                 }
14139                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
14140                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
14141                 if (r->out.resume_handle) {
14142                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
14143                 }
14144                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14145         }
14146         return NDR_ERR_SUCCESS;
14147 }
14148
14149 static enum ndr_err_code ndr_pull_srvsvc_NetConnEnum(struct ndr_pull *ndr, int flags, struct srvsvc_NetConnEnum *r)
14150 {
14151         uint32_t _ptr_server_unc;
14152         uint32_t _ptr_path;
14153         uint32_t _ptr_resume_handle;
14154         TALLOC_CTX *_mem_save_server_unc_0;
14155         TALLOC_CTX *_mem_save_path_0;
14156         TALLOC_CTX *_mem_save_level_0;
14157         TALLOC_CTX *_mem_save_ctr_0;
14158         TALLOC_CTX *_mem_save_totalentries_0;
14159         TALLOC_CTX *_mem_save_resume_handle_0;
14160         if (flags & NDR_IN) {
14161                 ZERO_STRUCT(r->out);
14162
14163                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
14164                 if (_ptr_server_unc) {
14165                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
14166                 } else {
14167                         r->in.server_unc = NULL;
14168                 }
14169                 if (r->in.server_unc) {
14170                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
14171                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
14172                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
14173                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
14174                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
14175                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
14176                         }
14177                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
14178                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
14179                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
14180                 }
14181                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_path));
14182                 if (_ptr_path) {
14183                         NDR_PULL_ALLOC(ndr, r->in.path);
14184                 } else {
14185                         r->in.path = NULL;
14186                 }
14187                 if (r->in.path) {
14188                         _mem_save_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
14189                         NDR_PULL_SET_MEM_CTX(ndr, r->in.path, 0);
14190                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path));
14191                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path));
14192                         if (ndr_get_array_length(ndr, &r->in.path) > ndr_get_array_size(ndr, &r->in.path)) {
14193                                 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.path), ndr_get_array_length(ndr, &r->in.path));
14194                         }
14195                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path), sizeof(uint16_t)));
14196                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.path, ndr_get_array_length(ndr, &r->in.path), sizeof(uint16_t), CH_UTF16));
14197                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_path_0, 0);
14198                 }
14199                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14200                         NDR_PULL_ALLOC(ndr, r->in.level);
14201                 }
14202                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
14203                 NDR_PULL_SET_MEM_CTX(ndr, r->in.level, LIBNDR_FLAG_REF_ALLOC);
14204                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.level));
14205                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
14206                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14207                         NDR_PULL_ALLOC(ndr, r->in.ctr);
14208                 }
14209                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14210                 NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, LIBNDR_FLAG_REF_ALLOC);
14211                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.ctr, *r->in.level));
14212                 NDR_CHECK(ndr_pull_srvsvc_NetConnCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
14213                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14214                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));
14215                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
14216                 if (_ptr_resume_handle) {
14217                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
14218                 } else {
14219                         r->in.resume_handle = NULL;
14220                 }
14221                 if (r->in.resume_handle) {
14222                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14223                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
14224                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
14225                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
14226                 }
14227                 NDR_PULL_ALLOC(ndr, r->out.level);
14228                 *r->out.level = *r->in.level;
14229                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14230                 *r->out.ctr = *r->in.ctr;
14231                 NDR_PULL_ALLOC(ndr, r->out.totalentries);
14232                 ZERO_STRUCTP(r->out.totalentries);
14233         }
14234         if (flags & NDR_OUT) {
14235                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14236                         NDR_PULL_ALLOC(ndr, r->out.level);
14237                 }
14238                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
14239                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level, LIBNDR_FLAG_REF_ALLOC);
14240                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level));
14241                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
14242                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14243                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14244                 }
14245                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14246                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14247                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level));
14248                 NDR_CHECK(ndr_pull_srvsvc_NetConnCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14249                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14250                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14251                         NDR_PULL_ALLOC(ndr, r->out.totalentries);
14252                 }
14253                 _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
14254                 NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);
14255                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
14256                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);
14257                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
14258                 if (_ptr_resume_handle) {
14259                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
14260                 } else {
14261                         r->out.resume_handle = NULL;
14262                 }
14263                 if (r->out.resume_handle) {
14264                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14265                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
14266                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
14267                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
14268                 }
14269                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14270         }
14271         return NDR_ERR_SUCCESS;
14272 }
14273
14274 _PUBLIC_ void ndr_print_srvsvc_NetConnEnum(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetConnEnum *r)
14275 {
14276         ndr_print_struct(ndr, name, "srvsvc_NetConnEnum");
14277         ndr->depth++;
14278         if (flags & NDR_SET_VALUES) {
14279                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14280         }
14281         if (flags & NDR_IN) {
14282                 ndr_print_struct(ndr, "in", "srvsvc_NetConnEnum");
14283                 ndr->depth++;
14284                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
14285                 ndr->depth++;
14286                 if (r->in.server_unc) {
14287                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
14288                 }
14289                 ndr->depth--;
14290                 ndr_print_ptr(ndr, "path", r->in.path);
14291                 ndr->depth++;
14292                 if (r->in.path) {
14293                         ndr_print_string(ndr, "path", r->in.path);
14294                 }
14295                 ndr->depth--;
14296                 ndr_print_ptr(ndr, "level", r->in.level);
14297                 ndr->depth++;
14298                 ndr_print_uint32(ndr, "level", *r->in.level);
14299                 ndr->depth--;
14300                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
14301                 ndr->depth++;
14302                 ndr_print_set_switch_value(ndr, r->in.ctr, *r->in.level);
14303                 ndr_print_srvsvc_NetConnCtr(ndr, "ctr", r->in.ctr);
14304                 ndr->depth--;
14305                 ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);
14306                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
14307                 ndr->depth++;
14308                 if (r->in.resume_handle) {
14309                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
14310                 }
14311                 ndr->depth--;
14312                 ndr->depth--;
14313         }
14314         if (flags & NDR_OUT) {
14315                 ndr_print_struct(ndr, "out", "srvsvc_NetConnEnum");
14316                 ndr->depth++;
14317                 ndr_print_ptr(ndr, "level", r->out.level);
14318                 ndr->depth++;
14319                 ndr_print_uint32(ndr, "level", *r->out.level);
14320                 ndr->depth--;
14321                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14322                 ndr->depth++;
14323                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level);
14324                 ndr_print_srvsvc_NetConnCtr(ndr, "ctr", r->out.ctr);
14325                 ndr->depth--;
14326                 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
14327                 ndr->depth++;
14328                 ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
14329                 ndr->depth--;
14330                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
14331                 ndr->depth++;
14332                 if (r->out.resume_handle) {
14333                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
14334                 }
14335                 ndr->depth--;
14336                 ndr_print_WERROR(ndr, "result", r->out.result);
14337                 ndr->depth--;
14338         }
14339         ndr->depth--;
14340 }
14341
14342 static enum ndr_err_code ndr_push_srvsvc_NetFileEnum(struct ndr_push *ndr, int flags, const struct srvsvc_NetFileEnum *r)
14343 {
14344         if (flags & NDR_IN) {
14345                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
14346                 if (r->in.server_unc) {
14347                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14348                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14349                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14350                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14351                 }
14352                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.path));
14353                 if (r->in.path) {
14354                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));
14355                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14356                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));
14357                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.path, ndr_charset_length(r->in.path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14358                 }
14359                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.user));
14360                 if (r->in.user) {
14361                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));
14362                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14363                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));
14364                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.user, ndr_charset_length(r->in.user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14365                 }
14366                 if (r->in.level == NULL) {
14367                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14368                 }
14369                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.level));
14370                 if (r->in.ctr == NULL) {
14371                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14372                 }
14373                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.ctr, *r->in.level));
14374                 NDR_CHECK(ndr_push_srvsvc_NetFileCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
14375                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));
14376                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
14377                 if (r->in.resume_handle) {
14378                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
14379                 }
14380         }
14381         if (flags & NDR_OUT) {
14382                 if (r->out.level == NULL) {
14383                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14384                 }
14385                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level));
14386                 if (r->out.ctr == NULL) {
14387                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14388                 }
14389                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level));
14390                 NDR_CHECK(ndr_push_srvsvc_NetFileCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14391                 if (r->out.totalentries == NULL) {
14392                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14393                 }
14394                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
14395                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
14396                 if (r->out.resume_handle) {
14397                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
14398                 }
14399                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14400         }
14401         return NDR_ERR_SUCCESS;
14402 }
14403
14404 static enum ndr_err_code ndr_pull_srvsvc_NetFileEnum(struct ndr_pull *ndr, int flags, struct srvsvc_NetFileEnum *r)
14405 {
14406         uint32_t _ptr_server_unc;
14407         uint32_t _ptr_path;
14408         uint32_t _ptr_user;
14409         uint32_t _ptr_resume_handle;
14410         TALLOC_CTX *_mem_save_server_unc_0;
14411         TALLOC_CTX *_mem_save_path_0;
14412         TALLOC_CTX *_mem_save_user_0;
14413         TALLOC_CTX *_mem_save_level_0;
14414         TALLOC_CTX *_mem_save_ctr_0;
14415         TALLOC_CTX *_mem_save_totalentries_0;
14416         TALLOC_CTX *_mem_save_resume_handle_0;
14417         if (flags & NDR_IN) {
14418                 ZERO_STRUCT(r->out);
14419
14420                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
14421                 if (_ptr_server_unc) {
14422                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
14423                 } else {
14424                         r->in.server_unc = NULL;
14425                 }
14426                 if (r->in.server_unc) {
14427                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
14428                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
14429                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
14430                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
14431                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
14432                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
14433                         }
14434                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
14435                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
14436                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
14437                 }
14438                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_path));
14439                 if (_ptr_path) {
14440                         NDR_PULL_ALLOC(ndr, r->in.path);
14441                 } else {
14442                         r->in.path = NULL;
14443                 }
14444                 if (r->in.path) {
14445                         _mem_save_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
14446                         NDR_PULL_SET_MEM_CTX(ndr, r->in.path, 0);
14447                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path));
14448                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path));
14449                         if (ndr_get_array_length(ndr, &r->in.path) > ndr_get_array_size(ndr, &r->in.path)) {
14450                                 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.path), ndr_get_array_length(ndr, &r->in.path));
14451                         }
14452                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path), sizeof(uint16_t)));
14453                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.path, ndr_get_array_length(ndr, &r->in.path), sizeof(uint16_t), CH_UTF16));
14454                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_path_0, 0);
14455                 }
14456                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
14457                 if (_ptr_user) {
14458                         NDR_PULL_ALLOC(ndr, r->in.user);
14459                 } else {
14460                         r->in.user = NULL;
14461                 }
14462                 if (r->in.user) {
14463                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
14464                         NDR_PULL_SET_MEM_CTX(ndr, r->in.user, 0);
14465                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.user));
14466                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.user));
14467                         if (ndr_get_array_length(ndr, &r->in.user) > ndr_get_array_size(ndr, &r->in.user)) {
14468                                 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.user), ndr_get_array_length(ndr, &r->in.user));
14469                         }
14470                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.user), sizeof(uint16_t)));
14471                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.user, ndr_get_array_length(ndr, &r->in.user), sizeof(uint16_t), CH_UTF16));
14472                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
14473                 }
14474                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14475                         NDR_PULL_ALLOC(ndr, r->in.level);
14476                 }
14477                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
14478                 NDR_PULL_SET_MEM_CTX(ndr, r->in.level, LIBNDR_FLAG_REF_ALLOC);
14479                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.level));
14480                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
14481                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14482                         NDR_PULL_ALLOC(ndr, r->in.ctr);
14483                 }
14484                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14485                 NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, LIBNDR_FLAG_REF_ALLOC);
14486                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.ctr, *r->in.level));
14487                 NDR_CHECK(ndr_pull_srvsvc_NetFileCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
14488                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14489                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));
14490                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
14491                 if (_ptr_resume_handle) {
14492                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
14493                 } else {
14494                         r->in.resume_handle = NULL;
14495                 }
14496                 if (r->in.resume_handle) {
14497                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14498                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
14499                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
14500                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
14501                 }
14502                 NDR_PULL_ALLOC(ndr, r->out.level);
14503                 *r->out.level = *r->in.level;
14504                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14505                 *r->out.ctr = *r->in.ctr;
14506                 NDR_PULL_ALLOC(ndr, r->out.totalentries);
14507                 ZERO_STRUCTP(r->out.totalentries);
14508         }
14509         if (flags & NDR_OUT) {
14510                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14511                         NDR_PULL_ALLOC(ndr, r->out.level);
14512                 }
14513                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
14514                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level, LIBNDR_FLAG_REF_ALLOC);
14515                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level));
14516                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
14517                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14518                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14519                 }
14520                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14521                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14522                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level));
14523                 NDR_CHECK(ndr_pull_srvsvc_NetFileCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14524                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14525                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14526                         NDR_PULL_ALLOC(ndr, r->out.totalentries);
14527                 }
14528                 _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
14529                 NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);
14530                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
14531                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);
14532                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
14533                 if (_ptr_resume_handle) {
14534                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
14535                 } else {
14536                         r->out.resume_handle = NULL;
14537                 }
14538                 if (r->out.resume_handle) {
14539                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14540                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
14541                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
14542                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
14543                 }
14544                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14545         }
14546         return NDR_ERR_SUCCESS;
14547 }
14548
14549 _PUBLIC_ void ndr_print_srvsvc_NetFileEnum(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetFileEnum *r)
14550 {
14551         ndr_print_struct(ndr, name, "srvsvc_NetFileEnum");
14552         ndr->depth++;
14553         if (flags & NDR_SET_VALUES) {
14554                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14555         }
14556         if (flags & NDR_IN) {
14557                 ndr_print_struct(ndr, "in", "srvsvc_NetFileEnum");
14558                 ndr->depth++;
14559                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
14560                 ndr->depth++;
14561                 if (r->in.server_unc) {
14562                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
14563                 }
14564                 ndr->depth--;
14565                 ndr_print_ptr(ndr, "path", r->in.path);
14566                 ndr->depth++;
14567                 if (r->in.path) {
14568                         ndr_print_string(ndr, "path", r->in.path);
14569                 }
14570                 ndr->depth--;
14571                 ndr_print_ptr(ndr, "user", r->in.user);
14572                 ndr->depth++;
14573                 if (r->in.user) {
14574                         ndr_print_string(ndr, "user", r->in.user);
14575                 }
14576                 ndr->depth--;
14577                 ndr_print_ptr(ndr, "level", r->in.level);
14578                 ndr->depth++;
14579                 ndr_print_uint32(ndr, "level", *r->in.level);
14580                 ndr->depth--;
14581                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
14582                 ndr->depth++;
14583                 ndr_print_set_switch_value(ndr, r->in.ctr, *r->in.level);
14584                 ndr_print_srvsvc_NetFileCtr(ndr, "ctr", r->in.ctr);
14585                 ndr->depth--;
14586                 ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);
14587                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
14588                 ndr->depth++;
14589                 if (r->in.resume_handle) {
14590                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
14591                 }
14592                 ndr->depth--;
14593                 ndr->depth--;
14594         }
14595         if (flags & NDR_OUT) {
14596                 ndr_print_struct(ndr, "out", "srvsvc_NetFileEnum");
14597                 ndr->depth++;
14598                 ndr_print_ptr(ndr, "level", r->out.level);
14599                 ndr->depth++;
14600                 ndr_print_uint32(ndr, "level", *r->out.level);
14601                 ndr->depth--;
14602                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14603                 ndr->depth++;
14604                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level);
14605                 ndr_print_srvsvc_NetFileCtr(ndr, "ctr", r->out.ctr);
14606                 ndr->depth--;
14607                 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
14608                 ndr->depth++;
14609                 ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
14610                 ndr->depth--;
14611                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
14612                 ndr->depth++;
14613                 if (r->out.resume_handle) {
14614                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
14615                 }
14616                 ndr->depth--;
14617                 ndr_print_WERROR(ndr, "result", r->out.result);
14618                 ndr->depth--;
14619         }
14620         ndr->depth--;
14621 }
14622
14623 static enum ndr_err_code ndr_push_srvsvc_NetFileGetInfo(struct ndr_push *ndr, int flags, const struct srvsvc_NetFileGetInfo *r)
14624 {
14625         if (flags & NDR_IN) {
14626                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
14627                 if (r->in.server_unc) {
14628                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14629                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14630                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14631                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14632                 }
14633                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.fid));
14634                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14635         }
14636         if (flags & NDR_OUT) {
14637                 if (r->out.info == NULL) {
14638                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14639                 }
14640                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
14641                 NDR_CHECK(ndr_push_srvsvc_NetFileInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14642                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14643         }
14644         return NDR_ERR_SUCCESS;
14645 }
14646
14647 static enum ndr_err_code ndr_pull_srvsvc_NetFileGetInfo(struct ndr_pull *ndr, int flags, struct srvsvc_NetFileGetInfo *r)
14648 {
14649         uint32_t _ptr_server_unc;
14650         TALLOC_CTX *_mem_save_server_unc_0;
14651         TALLOC_CTX *_mem_save_info_0;
14652         if (flags & NDR_IN) {
14653                 ZERO_STRUCT(r->out);
14654
14655                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
14656                 if (_ptr_server_unc) {
14657                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
14658                 } else {
14659                         r->in.server_unc = NULL;
14660                 }
14661                 if (r->in.server_unc) {
14662                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
14663                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
14664                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
14665                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
14666                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
14667                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
14668                         }
14669                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
14670                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
14671                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
14672                 }
14673                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.fid));
14674                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14675                 NDR_PULL_ALLOC(ndr, r->out.info);
14676                 ZERO_STRUCTP(r->out.info);
14677         }
14678         if (flags & NDR_OUT) {
14679                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14680                         NDR_PULL_ALLOC(ndr, r->out.info);
14681                 }
14682                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14683                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
14684                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
14685                 NDR_CHECK(ndr_pull_srvsvc_NetFileInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14686                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
14687                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14688         }
14689         return NDR_ERR_SUCCESS;
14690 }
14691
14692 _PUBLIC_ void ndr_print_srvsvc_NetFileGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetFileGetInfo *r)
14693 {
14694         ndr_print_struct(ndr, name, "srvsvc_NetFileGetInfo");
14695         ndr->depth++;
14696         if (flags & NDR_SET_VALUES) {
14697                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14698         }
14699         if (flags & NDR_IN) {
14700                 ndr_print_struct(ndr, "in", "srvsvc_NetFileGetInfo");
14701                 ndr->depth++;
14702                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
14703                 ndr->depth++;
14704                 if (r->in.server_unc) {
14705                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
14706                 }
14707                 ndr->depth--;
14708                 ndr_print_uint32(ndr, "fid", r->in.fid);
14709                 ndr_print_uint32(ndr, "level", r->in.level);
14710                 ndr->depth--;
14711         }
14712         if (flags & NDR_OUT) {
14713                 ndr_print_struct(ndr, "out", "srvsvc_NetFileGetInfo");
14714                 ndr->depth++;
14715                 ndr_print_ptr(ndr, "info", r->out.info);
14716                 ndr->depth++;
14717                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
14718                 ndr_print_srvsvc_NetFileInfo(ndr, "info", r->out.info);
14719                 ndr->depth--;
14720                 ndr_print_WERROR(ndr, "result", r->out.result);
14721                 ndr->depth--;
14722         }
14723         ndr->depth--;
14724 }
14725
14726 static enum ndr_err_code ndr_push_srvsvc_NetFileClose(struct ndr_push *ndr, int flags, const struct srvsvc_NetFileClose *r)
14727 {
14728         if (flags & NDR_IN) {
14729                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
14730                 if (r->in.server_unc) {
14731                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14732                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14733                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14734                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14735                 }
14736                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.fid));
14737         }
14738         if (flags & NDR_OUT) {
14739                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14740         }
14741         return NDR_ERR_SUCCESS;
14742 }
14743
14744 static enum ndr_err_code ndr_pull_srvsvc_NetFileClose(struct ndr_pull *ndr, int flags, struct srvsvc_NetFileClose *r)
14745 {
14746         uint32_t _ptr_server_unc;
14747         TALLOC_CTX *_mem_save_server_unc_0;
14748         if (flags & NDR_IN) {
14749                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
14750                 if (_ptr_server_unc) {
14751                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
14752                 } else {
14753                         r->in.server_unc = NULL;
14754                 }
14755                 if (r->in.server_unc) {
14756                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
14757                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
14758                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
14759                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
14760                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
14761                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
14762                         }
14763                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
14764                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
14765                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
14766                 }
14767                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.fid));
14768         }
14769         if (flags & NDR_OUT) {
14770                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14771         }
14772         return NDR_ERR_SUCCESS;
14773 }
14774
14775 _PUBLIC_ void ndr_print_srvsvc_NetFileClose(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetFileClose *r)
14776 {
14777         ndr_print_struct(ndr, name, "srvsvc_NetFileClose");
14778         ndr->depth++;
14779         if (flags & NDR_SET_VALUES) {
14780                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14781         }
14782         if (flags & NDR_IN) {
14783                 ndr_print_struct(ndr, "in", "srvsvc_NetFileClose");
14784                 ndr->depth++;
14785                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
14786                 ndr->depth++;
14787                 if (r->in.server_unc) {
14788                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
14789                 }
14790                 ndr->depth--;
14791                 ndr_print_uint32(ndr, "fid", r->in.fid);
14792                 ndr->depth--;
14793         }
14794         if (flags & NDR_OUT) {
14795                 ndr_print_struct(ndr, "out", "srvsvc_NetFileClose");
14796                 ndr->depth++;
14797                 ndr_print_WERROR(ndr, "result", r->out.result);
14798                 ndr->depth--;
14799         }
14800         ndr->depth--;
14801 }
14802
14803 static enum ndr_err_code ndr_push_srvsvc_NetSessEnum(struct ndr_push *ndr, int flags, const struct srvsvc_NetSessEnum *r)
14804 {
14805         if (flags & NDR_IN) {
14806                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
14807                 if (r->in.server_unc) {
14808                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14809                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14810                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14811                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14812                 }
14813                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.client));
14814                 if (r->in.client) {
14815                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.client, CH_UTF16)));
14816                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14817                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.client, CH_UTF16)));
14818                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.client, ndr_charset_length(r->in.client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14819                 }
14820                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.user));
14821                 if (r->in.user) {
14822                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));
14823                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14824                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));
14825                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.user, ndr_charset_length(r->in.user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14826                 }
14827                 if (r->in.level == NULL) {
14828                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14829                 }
14830                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.level));
14831                 if (r->in.ctr == NULL) {
14832                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14833                 }
14834                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.ctr, *r->in.level));
14835                 NDR_CHECK(ndr_push_srvsvc_NetSessCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
14836                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));
14837                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
14838                 if (r->in.resume_handle) {
14839                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
14840                 }
14841         }
14842         if (flags & NDR_OUT) {
14843                 if (r->out.level == NULL) {
14844                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14845                 }
14846                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level));
14847                 if (r->out.ctr == NULL) {
14848                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14849                 }
14850                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level));
14851                 NDR_CHECK(ndr_push_srvsvc_NetSessCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14852                 if (r->out.totalentries == NULL) {
14853                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14854                 }
14855                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
14856                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
14857                 if (r->out.resume_handle) {
14858                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
14859                 }
14860                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14861         }
14862         return NDR_ERR_SUCCESS;
14863 }
14864
14865 static enum ndr_err_code ndr_pull_srvsvc_NetSessEnum(struct ndr_pull *ndr, int flags, struct srvsvc_NetSessEnum *r)
14866 {
14867         uint32_t _ptr_server_unc;
14868         uint32_t _ptr_client;
14869         uint32_t _ptr_user;
14870         uint32_t _ptr_resume_handle;
14871         TALLOC_CTX *_mem_save_server_unc_0;
14872         TALLOC_CTX *_mem_save_client_0;
14873         TALLOC_CTX *_mem_save_user_0;
14874         TALLOC_CTX *_mem_save_level_0;
14875         TALLOC_CTX *_mem_save_ctr_0;
14876         TALLOC_CTX *_mem_save_totalentries_0;
14877         TALLOC_CTX *_mem_save_resume_handle_0;
14878         if (flags & NDR_IN) {
14879                 ZERO_STRUCT(r->out);
14880
14881                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
14882                 if (_ptr_server_unc) {
14883                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
14884                 } else {
14885                         r->in.server_unc = NULL;
14886                 }
14887                 if (r->in.server_unc) {
14888                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
14889                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
14890                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
14891                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
14892                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
14893                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
14894                         }
14895                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
14896                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
14897                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
14898                 }
14899                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
14900                 if (_ptr_client) {
14901                         NDR_PULL_ALLOC(ndr, r->in.client);
14902                 } else {
14903                         r->in.client = NULL;
14904                 }
14905                 if (r->in.client) {
14906                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
14907                         NDR_PULL_SET_MEM_CTX(ndr, r->in.client, 0);
14908                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.client));
14909                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.client));
14910                         if (ndr_get_array_length(ndr, &r->in.client) > ndr_get_array_size(ndr, &r->in.client)) {
14911                                 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.client), ndr_get_array_length(ndr, &r->in.client));
14912                         }
14913                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.client), sizeof(uint16_t)));
14914                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.client, ndr_get_array_length(ndr, &r->in.client), sizeof(uint16_t), CH_UTF16));
14915                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
14916                 }
14917                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
14918                 if (_ptr_user) {
14919                         NDR_PULL_ALLOC(ndr, r->in.user);
14920                 } else {
14921                         r->in.user = NULL;
14922                 }
14923                 if (r->in.user) {
14924                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
14925                         NDR_PULL_SET_MEM_CTX(ndr, r->in.user, 0);
14926                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.user));
14927                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.user));
14928                         if (ndr_get_array_length(ndr, &r->in.user) > ndr_get_array_size(ndr, &r->in.user)) {
14929                                 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.user), ndr_get_array_length(ndr, &r->in.user));
14930                         }
14931                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.user), sizeof(uint16_t)));
14932                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.user, ndr_get_array_length(ndr, &r->in.user), sizeof(uint16_t), CH_UTF16));
14933                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
14934                 }
14935                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14936                         NDR_PULL_ALLOC(ndr, r->in.level);
14937                 }
14938                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
14939                 NDR_PULL_SET_MEM_CTX(ndr, r->in.level, LIBNDR_FLAG_REF_ALLOC);
14940                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.level));
14941                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
14942                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14943                         NDR_PULL_ALLOC(ndr, r->in.ctr);
14944                 }
14945                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14946                 NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, LIBNDR_FLAG_REF_ALLOC);
14947                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.ctr, *r->in.level));
14948                 NDR_CHECK(ndr_pull_srvsvc_NetSessCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
14949                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14950                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));
14951                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
14952                 if (_ptr_resume_handle) {
14953                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
14954                 } else {
14955                         r->in.resume_handle = NULL;
14956                 }
14957                 if (r->in.resume_handle) {
14958                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14959                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
14960                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
14961                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
14962                 }
14963                 NDR_PULL_ALLOC(ndr, r->out.level);
14964                 *r->out.level = *r->in.level;
14965                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14966                 *r->out.ctr = *r->in.ctr;
14967                 NDR_PULL_ALLOC(ndr, r->out.totalentries);
14968                 ZERO_STRUCTP(r->out.totalentries);
14969         }
14970         if (flags & NDR_OUT) {
14971                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14972                         NDR_PULL_ALLOC(ndr, r->out.level);
14973                 }
14974                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
14975                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level, LIBNDR_FLAG_REF_ALLOC);
14976                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level));
14977                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
14978                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14979                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14980                 }
14981                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14982                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14983                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level));
14984                 NDR_CHECK(ndr_pull_srvsvc_NetSessCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14985                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14986                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14987                         NDR_PULL_ALLOC(ndr, r->out.totalentries);
14988                 }
14989                 _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
14990                 NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);
14991                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
14992                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);
14993                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
14994                 if (_ptr_resume_handle) {
14995                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
14996                 } else {
14997                         r->out.resume_handle = NULL;
14998                 }
14999                 if (r->out.resume_handle) {
15000                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15001                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
15002                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
15003                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
15004                 }
15005                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15006         }
15007         return NDR_ERR_SUCCESS;
15008 }
15009
15010 _PUBLIC_ void ndr_print_srvsvc_NetSessEnum(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetSessEnum *r)
15011 {
15012         ndr_print_struct(ndr, name, "srvsvc_NetSessEnum");
15013         ndr->depth++;
15014         if (flags & NDR_SET_VALUES) {
15015                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15016         }
15017         if (flags & NDR_IN) {
15018                 ndr_print_struct(ndr, "in", "srvsvc_NetSessEnum");
15019                 ndr->depth++;
15020                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
15021                 ndr->depth++;
15022                 if (r->in.server_unc) {
15023                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
15024                 }
15025                 ndr->depth--;
15026                 ndr_print_ptr(ndr, "client", r->in.client);
15027                 ndr->depth++;
15028                 if (r->in.client) {
15029                         ndr_print_string(ndr, "client", r->in.client);
15030                 }
15031                 ndr->depth--;
15032                 ndr_print_ptr(ndr, "user", r->in.user);
15033                 ndr->depth++;
15034                 if (r->in.user) {
15035                         ndr_print_string(ndr, "user", r->in.user);
15036                 }
15037                 ndr->depth--;
15038                 ndr_print_ptr(ndr, "level", r->in.level);
15039                 ndr->depth++;
15040                 ndr_print_uint32(ndr, "level", *r->in.level);
15041                 ndr->depth--;
15042                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
15043                 ndr->depth++;
15044                 ndr_print_set_switch_value(ndr, r->in.ctr, *r->in.level);
15045                 ndr_print_srvsvc_NetSessCtr(ndr, "ctr", r->in.ctr);
15046                 ndr->depth--;
15047                 ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);
15048                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
15049                 ndr->depth++;
15050                 if (r->in.resume_handle) {
15051                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
15052                 }
15053                 ndr->depth--;
15054                 ndr->depth--;
15055         }
15056         if (flags & NDR_OUT) {
15057                 ndr_print_struct(ndr, "out", "srvsvc_NetSessEnum");
15058                 ndr->depth++;
15059                 ndr_print_ptr(ndr, "level", r->out.level);
15060                 ndr->depth++;
15061                 ndr_print_uint32(ndr, "level", *r->out.level);
15062                 ndr->depth--;
15063                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15064                 ndr->depth++;
15065                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level);
15066                 ndr_print_srvsvc_NetSessCtr(ndr, "ctr", r->out.ctr);
15067                 ndr->depth--;
15068                 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
15069                 ndr->depth++;
15070                 ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
15071                 ndr->depth--;
15072                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
15073                 ndr->depth++;
15074                 if (r->out.resume_handle) {
15075                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
15076                 }
15077                 ndr->depth--;
15078                 ndr_print_WERROR(ndr, "result", r->out.result);
15079                 ndr->depth--;
15080         }
15081         ndr->depth--;
15082 }
15083
15084 static enum ndr_err_code ndr_push_srvsvc_NetSessDel(struct ndr_push *ndr, int flags, const struct srvsvc_NetSessDel *r)
15085 {
15086         if (flags & NDR_IN) {
15087                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
15088                 if (r->in.server_unc) {
15089                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15090                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15091                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15092                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15093                 }
15094                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.client));
15095                 if (r->in.client) {
15096                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.client, CH_UTF16)));
15097                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15098                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.client, CH_UTF16)));
15099                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.client, ndr_charset_length(r->in.client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15100                 }
15101                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.user));
15102                 if (r->in.user) {
15103                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));
15104                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15105                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));
15106                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.user, ndr_charset_length(r->in.user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15107                 }
15108         }
15109         if (flags & NDR_OUT) {
15110                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15111         }
15112         return NDR_ERR_SUCCESS;
15113 }
15114
15115 static enum ndr_err_code ndr_pull_srvsvc_NetSessDel(struct ndr_pull *ndr, int flags, struct srvsvc_NetSessDel *r)
15116 {
15117         uint32_t _ptr_server_unc;
15118         uint32_t _ptr_client;
15119         uint32_t _ptr_user;
15120         TALLOC_CTX *_mem_save_server_unc_0;
15121         TALLOC_CTX *_mem_save_client_0;
15122         TALLOC_CTX *_mem_save_user_0;
15123         if (flags & NDR_IN) {
15124                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
15125                 if (_ptr_server_unc) {
15126                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
15127                 } else {
15128                         r->in.server_unc = NULL;
15129                 }
15130                 if (r->in.server_unc) {
15131                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
15132                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
15133                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
15134                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
15135                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
15136                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
15137                         }
15138                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
15139                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
15140                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
15141                 }
15142                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
15143                 if (_ptr_client) {
15144                         NDR_PULL_ALLOC(ndr, r->in.client);
15145                 } else {
15146                         r->in.client = NULL;
15147                 }
15148                 if (r->in.client) {
15149                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
15150                         NDR_PULL_SET_MEM_CTX(ndr, r->in.client, 0);
15151                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.client));
15152                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.client));
15153                         if (ndr_get_array_length(ndr, &r->in.client) > ndr_get_array_size(ndr, &r->in.client)) {
15154                                 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.client), ndr_get_array_length(ndr, &r->in.client));
15155                         }
15156                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.client), sizeof(uint16_t)));
15157                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.client, ndr_get_array_length(ndr, &r->in.client), sizeof(uint16_t), CH_UTF16));
15158                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
15159                 }
15160                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
15161                 if (_ptr_user) {
15162                         NDR_PULL_ALLOC(ndr, r->in.user);
15163                 } else {
15164                         r->in.user = NULL;
15165                 }
15166                 if (r->in.user) {
15167                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
15168                         NDR_PULL_SET_MEM_CTX(ndr, r->in.user, 0);
15169                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.user));
15170                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.user));
15171                         if (ndr_get_array_length(ndr, &r->in.user) > ndr_get_array_size(ndr, &r->in.user)) {
15172                                 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.user), ndr_get_array_length(ndr, &r->in.user));
15173                         }
15174                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.user), sizeof(uint16_t)));
15175                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.user, ndr_get_array_length(ndr, &r->in.user), sizeof(uint16_t), CH_UTF16));
15176                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
15177                 }
15178         }
15179         if (flags & NDR_OUT) {
15180                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15181         }
15182         return NDR_ERR_SUCCESS;
15183 }
15184
15185 _PUBLIC_ void ndr_print_srvsvc_NetSessDel(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetSessDel *r)
15186 {
15187         ndr_print_struct(ndr, name, "srvsvc_NetSessDel");
15188         ndr->depth++;
15189         if (flags & NDR_SET_VALUES) {
15190                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15191         }
15192         if (flags & NDR_IN) {
15193                 ndr_print_struct(ndr, "in", "srvsvc_NetSessDel");
15194                 ndr->depth++;
15195                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
15196                 ndr->depth++;
15197                 if (r->in.server_unc) {
15198                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
15199                 }
15200                 ndr->depth--;
15201                 ndr_print_ptr(ndr, "client", r->in.client);
15202                 ndr->depth++;
15203                 if (r->in.client) {
15204                         ndr_print_string(ndr, "client", r->in.client);
15205                 }
15206                 ndr->depth--;
15207                 ndr_print_ptr(ndr, "user", r->in.user);
15208                 ndr->depth++;
15209                 if (r->in.user) {
15210                         ndr_print_string(ndr, "user", r->in.user);
15211                 }
15212                 ndr->depth--;
15213                 ndr->depth--;
15214         }
15215         if (flags & NDR_OUT) {
15216                 ndr_print_struct(ndr, "out", "srvsvc_NetSessDel");
15217                 ndr->depth++;
15218                 ndr_print_WERROR(ndr, "result", r->out.result);
15219                 ndr->depth--;
15220         }
15221         ndr->depth--;
15222 }
15223
15224 static enum ndr_err_code ndr_push_srvsvc_NetShareAdd(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareAdd *r)
15225 {
15226         if (flags & NDR_IN) {
15227                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
15228                 if (r->in.server_unc) {
15229                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15230                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15231                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15232                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15233                 }
15234                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15235                 if (r->in.info == NULL) {
15236                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15237                 }
15238                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
15239                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
15240                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_error));
15241                 if (r->in.parm_error) {
15242                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_error));
15243                 }
15244         }
15245         if (flags & NDR_OUT) {
15246                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_error));
15247                 if (r->out.parm_error) {
15248                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_error));
15249                 }
15250                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15251         }
15252         return NDR_ERR_SUCCESS;
15253 }
15254
15255 static enum ndr_err_code ndr_pull_srvsvc_NetShareAdd(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareAdd *r)
15256 {
15257         uint32_t _ptr_server_unc;
15258         uint32_t _ptr_parm_error;
15259         TALLOC_CTX *_mem_save_server_unc_0;
15260         TALLOC_CTX *_mem_save_info_0;
15261         TALLOC_CTX *_mem_save_parm_error_0;
15262         if (flags & NDR_IN) {
15263                 ZERO_STRUCT(r->out);
15264
15265                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
15266                 if (_ptr_server_unc) {
15267                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
15268                 } else {
15269                         r->in.server_unc = NULL;
15270                 }
15271                 if (r->in.server_unc) {
15272                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
15273                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
15274                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
15275                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
15276                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
15277                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
15278                         }
15279                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
15280                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
15281                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
15282                 }
15283                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15284                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15285                         NDR_PULL_ALLOC(ndr, r->in.info);
15286                 }
15287                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15288                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
15289                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
15290                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
15291                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
15292                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_error));
15293                 if (_ptr_parm_error) {
15294                         NDR_PULL_ALLOC(ndr, r->in.parm_error);
15295                 } else {
15296                         r->in.parm_error = NULL;
15297                 }
15298                 if (r->in.parm_error) {
15299                         _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
15300                         NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_error, 0);
15301                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_error));
15302                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, 0);
15303                 }
15304         }
15305         if (flags & NDR_OUT) {
15306                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_error));
15307                 if (_ptr_parm_error) {
15308                         NDR_PULL_ALLOC(ndr, r->out.parm_error);
15309                 } else {
15310                         r->out.parm_error = NULL;
15311                 }
15312                 if (r->out.parm_error) {
15313                         _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
15314                         NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_error, 0);
15315                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_error));
15316                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, 0);
15317                 }
15318                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15319         }
15320         return NDR_ERR_SUCCESS;
15321 }
15322
15323 _PUBLIC_ void ndr_print_srvsvc_NetShareAdd(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareAdd *r)
15324 {
15325         ndr_print_struct(ndr, name, "srvsvc_NetShareAdd");
15326         ndr->depth++;
15327         if (flags & NDR_SET_VALUES) {
15328                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15329         }
15330         if (flags & NDR_IN) {
15331                 ndr_print_struct(ndr, "in", "srvsvc_NetShareAdd");
15332                 ndr->depth++;
15333                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
15334                 ndr->depth++;
15335                 if (r->in.server_unc) {
15336                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
15337                 }
15338                 ndr->depth--;
15339                 ndr_print_uint32(ndr, "level", r->in.level);
15340                 ndr_print_ptr(ndr, "info", r->in.info);
15341                 ndr->depth++;
15342                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
15343                 ndr_print_srvsvc_NetShareInfo(ndr, "info", r->in.info);
15344                 ndr->depth--;
15345                 ndr_print_ptr(ndr, "parm_error", r->in.parm_error);
15346                 ndr->depth++;
15347                 if (r->in.parm_error) {
15348                         ndr_print_uint32(ndr, "parm_error", *r->in.parm_error);
15349                 }
15350                 ndr->depth--;
15351                 ndr->depth--;
15352         }
15353         if (flags & NDR_OUT) {
15354                 ndr_print_struct(ndr, "out", "srvsvc_NetShareAdd");
15355                 ndr->depth++;
15356                 ndr_print_ptr(ndr, "parm_error", r->out.parm_error);
15357                 ndr->depth++;
15358                 if (r->out.parm_error) {
15359                         ndr_print_uint32(ndr, "parm_error", *r->out.parm_error);
15360                 }
15361                 ndr->depth--;
15362                 ndr_print_WERROR(ndr, "result", r->out.result);
15363                 ndr->depth--;
15364         }
15365         ndr->depth--;
15366 }
15367
15368 static enum ndr_err_code ndr_push_srvsvc_NetShareEnumAll(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareEnumAll *r)
15369 {
15370         if (flags & NDR_IN) {
15371                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
15372                 if (r->in.server_unc) {
15373                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15374                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15375                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15376                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15377                 }
15378                 if (r->in.info_ctr == NULL) {
15379                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15380                 }
15381                 NDR_CHECK(ndr_push_srvsvc_NetShareInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
15382                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));
15383                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
15384                 if (r->in.resume_handle) {
15385                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
15386                 }
15387         }
15388         if (flags & NDR_OUT) {
15389                 if (r->out.info_ctr == NULL) {
15390                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15391                 }
15392                 NDR_CHECK(ndr_push_srvsvc_NetShareInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));
15393                 if (r->out.totalentries == NULL) {
15394                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15395                 }
15396                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
15397                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
15398                 if (r->out.resume_handle) {
15399                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
15400                 }
15401                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15402         }
15403         return NDR_ERR_SUCCESS;
15404 }
15405
15406 static enum ndr_err_code ndr_pull_srvsvc_NetShareEnumAll(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareEnumAll *r)
15407 {
15408         uint32_t _ptr_server_unc;
15409         uint32_t _ptr_resume_handle;
15410         TALLOC_CTX *_mem_save_server_unc_0;
15411         TALLOC_CTX *_mem_save_info_ctr_0;
15412         TALLOC_CTX *_mem_save_totalentries_0;
15413         TALLOC_CTX *_mem_save_resume_handle_0;
15414         if (flags & NDR_IN) {
15415                 ZERO_STRUCT(r->out);
15416
15417                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
15418                 if (_ptr_server_unc) {
15419                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
15420                 } else {
15421                         r->in.server_unc = NULL;
15422                 }
15423                 if (r->in.server_unc) {
15424                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
15425                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
15426                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
15427                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
15428                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
15429                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
15430                         }
15431                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
15432                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
15433                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
15434                 }
15435                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15436                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
15437                 }
15438                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15439                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
15440                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
15441                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15442                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));
15443                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
15444                 if (_ptr_resume_handle) {
15445                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
15446                 } else {
15447                         r->in.resume_handle = NULL;
15448                 }
15449                 if (r->in.resume_handle) {
15450                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15451                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
15452                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
15453                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
15454                 }
15455                 NDR_PULL_ALLOC(ndr, r->out.info_ctr);
15456                 *r->out.info_ctr = *r->in.info_ctr;
15457                 NDR_PULL_ALLOC(ndr, r->out.totalentries);
15458                 ZERO_STRUCTP(r->out.totalentries);
15459         }
15460         if (flags & NDR_OUT) {
15461                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15462                         NDR_PULL_ALLOC(ndr, r->out.info_ctr);
15463                 }
15464                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15465                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_ctr, LIBNDR_FLAG_REF_ALLOC);
15466                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));
15467                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15468                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15469                         NDR_PULL_ALLOC(ndr, r->out.totalentries);
15470                 }
15471                 _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
15472                 NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);
15473                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
15474                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);
15475                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
15476                 if (_ptr_resume_handle) {
15477                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
15478                 } else {
15479                         r->out.resume_handle = NULL;
15480                 }
15481                 if (r->out.resume_handle) {
15482                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15483                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
15484                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
15485                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
15486                 }
15487                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15488         }
15489         return NDR_ERR_SUCCESS;
15490 }
15491
15492 _PUBLIC_ void ndr_print_srvsvc_NetShareEnumAll(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareEnumAll *r)
15493 {
15494         ndr_print_struct(ndr, name, "srvsvc_NetShareEnumAll");
15495         ndr->depth++;
15496         if (flags & NDR_SET_VALUES) {
15497                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15498         }
15499         if (flags & NDR_IN) {
15500                 ndr_print_struct(ndr, "in", "srvsvc_NetShareEnumAll");
15501                 ndr->depth++;
15502                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
15503                 ndr->depth++;
15504                 if (r->in.server_unc) {
15505                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
15506                 }
15507                 ndr->depth--;
15508                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
15509                 ndr->depth++;
15510                 ndr_print_srvsvc_NetShareInfoCtr(ndr, "info_ctr", r->in.info_ctr);
15511                 ndr->depth--;
15512                 ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);
15513                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
15514                 ndr->depth++;
15515                 if (r->in.resume_handle) {
15516                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
15517                 }
15518                 ndr->depth--;
15519                 ndr->depth--;
15520         }
15521         if (flags & NDR_OUT) {
15522                 ndr_print_struct(ndr, "out", "srvsvc_NetShareEnumAll");
15523                 ndr->depth++;
15524                 ndr_print_ptr(ndr, "info_ctr", r->out.info_ctr);
15525                 ndr->depth++;
15526                 ndr_print_srvsvc_NetShareInfoCtr(ndr, "info_ctr", r->out.info_ctr);
15527                 ndr->depth--;
15528                 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
15529                 ndr->depth++;
15530                 ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
15531                 ndr->depth--;
15532                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
15533                 ndr->depth++;
15534                 if (r->out.resume_handle) {
15535                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
15536                 }
15537                 ndr->depth--;
15538                 ndr_print_WERROR(ndr, "result", r->out.result);
15539                 ndr->depth--;
15540         }
15541         ndr->depth--;
15542 }
15543
15544 static enum ndr_err_code ndr_push_srvsvc_NetShareGetInfo(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareGetInfo *r)
15545 {
15546         if (flags & NDR_IN) {
15547                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
15548                 if (r->in.server_unc) {
15549                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15550                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15551                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15552                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15553                 }
15554                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share_name, CH_UTF16)));
15555                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15556                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share_name, CH_UTF16)));
15557                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.share_name, ndr_charset_length(r->in.share_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15558                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15559         }
15560         if (flags & NDR_OUT) {
15561                 if (r->out.info == NULL) {
15562                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15563                 }
15564                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
15565                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15566                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15567         }
15568         return NDR_ERR_SUCCESS;
15569 }
15570
15571 static enum ndr_err_code ndr_pull_srvsvc_NetShareGetInfo(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareGetInfo *r)
15572 {
15573         uint32_t _ptr_server_unc;
15574         TALLOC_CTX *_mem_save_server_unc_0;
15575         TALLOC_CTX *_mem_save_info_0;
15576         if (flags & NDR_IN) {
15577                 ZERO_STRUCT(r->out);
15578
15579                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
15580                 if (_ptr_server_unc) {
15581                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
15582                 } else {
15583                         r->in.server_unc = NULL;
15584                 }
15585                 if (r->in.server_unc) {
15586                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
15587                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
15588                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
15589                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
15590                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
15591                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
15592                         }
15593                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
15594                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
15595                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
15596                 }
15597                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.share_name));
15598                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.share_name));
15599                 if (ndr_get_array_length(ndr, &r->in.share_name) > ndr_get_array_size(ndr, &r->in.share_name)) {
15600                         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.share_name), ndr_get_array_length(ndr, &r->in.share_name));
15601                 }
15602                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.share_name), sizeof(uint16_t)));
15603                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.share_name, ndr_get_array_length(ndr, &r->in.share_name), sizeof(uint16_t), CH_UTF16));
15604                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15605                 NDR_PULL_ALLOC(ndr, r->out.info);
15606                 ZERO_STRUCTP(r->out.info);
15607         }
15608         if (flags & NDR_OUT) {
15609                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15610                         NDR_PULL_ALLOC(ndr, r->out.info);
15611                 }
15612                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15613                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
15614                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
15615                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15616                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
15617                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15618         }
15619         return NDR_ERR_SUCCESS;
15620 }
15621
15622 _PUBLIC_ void ndr_print_srvsvc_NetShareGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareGetInfo *r)
15623 {
15624         ndr_print_struct(ndr, name, "srvsvc_NetShareGetInfo");
15625         ndr->depth++;
15626         if (flags & NDR_SET_VALUES) {
15627                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15628         }
15629         if (flags & NDR_IN) {
15630                 ndr_print_struct(ndr, "in", "srvsvc_NetShareGetInfo");
15631                 ndr->depth++;
15632                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
15633                 ndr->depth++;
15634                 if (r->in.server_unc) {
15635                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
15636                 }
15637                 ndr->depth--;
15638                 ndr_print_string(ndr, "share_name", r->in.share_name);
15639                 ndr_print_uint32(ndr, "level", r->in.level);
15640                 ndr->depth--;
15641         }
15642         if (flags & NDR_OUT) {
15643                 ndr_print_struct(ndr, "out", "srvsvc_NetShareGetInfo");
15644                 ndr->depth++;
15645                 ndr_print_ptr(ndr, "info", r->out.info);
15646                 ndr->depth++;
15647                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
15648                 ndr_print_srvsvc_NetShareInfo(ndr, "info", r->out.info);
15649                 ndr->depth--;
15650                 ndr_print_WERROR(ndr, "result", r->out.result);
15651                 ndr->depth--;
15652         }
15653         ndr->depth--;
15654 }
15655
15656 static enum ndr_err_code ndr_push_srvsvc_NetShareSetInfo(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareSetInfo *r)
15657 {
15658         if (flags & NDR_IN) {
15659                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
15660                 if (r->in.server_unc) {
15661                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15662                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15663                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15664                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15665                 }
15666                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share_name, CH_UTF16)));
15667                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15668                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share_name, CH_UTF16)));
15669                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.share_name, ndr_charset_length(r->in.share_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15670                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15671                 if (r->in.info == NULL) {
15672                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15673                 }
15674                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
15675                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
15676                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_error));
15677                 if (r->in.parm_error) {
15678                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_error));
15679                 }
15680         }
15681         if (flags & NDR_OUT) {
15682                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_error));
15683                 if (r->out.parm_error) {
15684                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_error));
15685                 }
15686                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15687         }
15688         return NDR_ERR_SUCCESS;
15689 }
15690
15691 static enum ndr_err_code ndr_pull_srvsvc_NetShareSetInfo(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareSetInfo *r)
15692 {
15693         uint32_t _ptr_server_unc;
15694         uint32_t _ptr_parm_error;
15695         TALLOC_CTX *_mem_save_server_unc_0;
15696         TALLOC_CTX *_mem_save_info_0;
15697         TALLOC_CTX *_mem_save_parm_error_0;
15698         if (flags & NDR_IN) {
15699                 ZERO_STRUCT(r->out);
15700
15701                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
15702                 if (_ptr_server_unc) {
15703                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
15704                 } else {
15705                         r->in.server_unc = NULL;
15706                 }
15707                 if (r->in.server_unc) {
15708                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
15709                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
15710                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
15711                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
15712                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
15713                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
15714                         }
15715                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
15716                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
15717                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
15718                 }
15719                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.share_name));
15720                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.share_name));
15721                 if (ndr_get_array_length(ndr, &r->in.share_name) > ndr_get_array_size(ndr, &r->in.share_name)) {
15722                         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.share_name), ndr_get_array_length(ndr, &r->in.share_name));
15723                 }
15724                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.share_name), sizeof(uint16_t)));
15725                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.share_name, ndr_get_array_length(ndr, &r->in.share_name), sizeof(uint16_t), CH_UTF16));
15726                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15727                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15728                         NDR_PULL_ALLOC(ndr, r->in.info);
15729                 }
15730                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15731                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
15732                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
15733                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
15734                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
15735                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_error));
15736                 if (_ptr_parm_error) {
15737                         NDR_PULL_ALLOC(ndr, r->in.parm_error);
15738                 } else {
15739                         r->in.parm_error = NULL;
15740                 }
15741                 if (r->in.parm_error) {
15742                         _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
15743                         NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_error, 0);
15744                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_error));
15745                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, 0);
15746                 }
15747         }
15748         if (flags & NDR_OUT) {
15749                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_error));
15750                 if (_ptr_parm_error) {
15751                         NDR_PULL_ALLOC(ndr, r->out.parm_error);
15752                 } else {
15753                         r->out.parm_error = NULL;
15754                 }
15755                 if (r->out.parm_error) {
15756                         _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
15757                         NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_error, 0);
15758                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_error));
15759                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, 0);
15760                 }
15761                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15762         }
15763         return NDR_ERR_SUCCESS;
15764 }
15765
15766 _PUBLIC_ void ndr_print_srvsvc_NetShareSetInfo(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareSetInfo *r)
15767 {
15768         ndr_print_struct(ndr, name, "srvsvc_NetShareSetInfo");
15769         ndr->depth++;
15770         if (flags & NDR_SET_VALUES) {
15771                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15772         }
15773         if (flags & NDR_IN) {
15774                 ndr_print_struct(ndr, "in", "srvsvc_NetShareSetInfo");
15775                 ndr->depth++;
15776                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
15777                 ndr->depth++;
15778                 if (r->in.server_unc) {
15779                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
15780                 }
15781                 ndr->depth--;
15782                 ndr_print_string(ndr, "share_name", r->in.share_name);
15783                 ndr_print_uint32(ndr, "level", r->in.level);
15784                 ndr_print_ptr(ndr, "info", r->in.info);
15785                 ndr->depth++;
15786                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
15787                 ndr_print_srvsvc_NetShareInfo(ndr, "info", r->in.info);
15788                 ndr->depth--;
15789                 ndr_print_ptr(ndr, "parm_error", r->in.parm_error);
15790                 ndr->depth++;
15791                 if (r->in.parm_error) {
15792                         ndr_print_uint32(ndr, "parm_error", *r->in.parm_error);
15793                 }
15794                 ndr->depth--;
15795                 ndr->depth--;
15796         }
15797         if (flags & NDR_OUT) {
15798                 ndr_print_struct(ndr, "out", "srvsvc_NetShareSetInfo");
15799                 ndr->depth++;
15800                 ndr_print_ptr(ndr, "parm_error", r->out.parm_error);
15801                 ndr->depth++;
15802                 if (r->out.parm_error) {
15803                         ndr_print_uint32(ndr, "parm_error", *r->out.parm_error);
15804                 }
15805                 ndr->depth--;
15806                 ndr_print_WERROR(ndr, "result", r->out.result);
15807                 ndr->depth--;
15808         }
15809         ndr->depth--;
15810 }
15811
15812 static enum ndr_err_code ndr_push_srvsvc_NetShareDel(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareDel *r)
15813 {
15814         if (flags & NDR_IN) {
15815                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
15816                 if (r->in.server_unc) {
15817                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15818                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15819                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15820                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15821                 }
15822                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share_name, CH_UTF16)));
15823                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15824                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share_name, CH_UTF16)));
15825                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.share_name, ndr_charset_length(r->in.share_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15826                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reserved));
15827         }
15828         if (flags & NDR_OUT) {
15829                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15830         }
15831         return NDR_ERR_SUCCESS;
15832 }
15833
15834 static enum ndr_err_code ndr_pull_srvsvc_NetShareDel(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareDel *r)
15835 {
15836         uint32_t _ptr_server_unc;
15837         TALLOC_CTX *_mem_save_server_unc_0;
15838         if (flags & NDR_IN) {
15839                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
15840                 if (_ptr_server_unc) {
15841                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
15842                 } else {
15843                         r->in.server_unc = NULL;
15844                 }
15845                 if (r->in.server_unc) {
15846                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
15847                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
15848                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
15849                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
15850                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
15851                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
15852                         }
15853                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
15854                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
15855                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
15856                 }
15857                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.share_name));
15858                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.share_name));
15859                 if (ndr_get_array_length(ndr, &r->in.share_name) > ndr_get_array_size(ndr, &r->in.share_name)) {
15860                         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.share_name), ndr_get_array_length(ndr, &r->in.share_name));
15861                 }
15862                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.share_name), sizeof(uint16_t)));
15863                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.share_name, ndr_get_array_length(ndr, &r->in.share_name), sizeof(uint16_t), CH_UTF16));
15864                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reserved));
15865         }
15866         if (flags & NDR_OUT) {
15867                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15868         }
15869         return NDR_ERR_SUCCESS;
15870 }
15871
15872 _PUBLIC_ void ndr_print_srvsvc_NetShareDel(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareDel *r)
15873 {
15874         ndr_print_struct(ndr, name, "srvsvc_NetShareDel");
15875         ndr->depth++;
15876         if (flags & NDR_SET_VALUES) {
15877                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15878         }
15879         if (flags & NDR_IN) {
15880                 ndr_print_struct(ndr, "in", "srvsvc_NetShareDel");
15881                 ndr->depth++;
15882                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
15883                 ndr->depth++;
15884                 if (r->in.server_unc) {
15885                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
15886                 }
15887                 ndr->depth--;
15888                 ndr_print_string(ndr, "share_name", r->in.share_name);
15889                 ndr_print_uint32(ndr, "reserved", r->in.reserved);
15890                 ndr->depth--;
15891         }
15892         if (flags & NDR_OUT) {
15893                 ndr_print_struct(ndr, "out", "srvsvc_NetShareDel");
15894                 ndr->depth++;
15895                 ndr_print_WERROR(ndr, "result", r->out.result);
15896                 ndr->depth--;
15897         }
15898         ndr->depth--;
15899 }
15900
15901 static enum ndr_err_code ndr_push_srvsvc_NetShareDelSticky(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareDelSticky *r)
15902 {
15903         if (flags & NDR_IN) {
15904                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
15905                 if (r->in.server_unc) {
15906                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15907                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15908                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15909                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15910                 }
15911                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share_name, CH_UTF16)));
15912                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15913                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share_name, CH_UTF16)));
15914                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.share_name, ndr_charset_length(r->in.share_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15915                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reserved));
15916         }
15917         if (flags & NDR_OUT) {
15918                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15919         }
15920         return NDR_ERR_SUCCESS;
15921 }
15922
15923 static enum ndr_err_code ndr_pull_srvsvc_NetShareDelSticky(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareDelSticky *r)
15924 {
15925         uint32_t _ptr_server_unc;
15926         TALLOC_CTX *_mem_save_server_unc_0;
15927         if (flags & NDR_IN) {
15928                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
15929                 if (_ptr_server_unc) {
15930                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
15931                 } else {
15932                         r->in.server_unc = NULL;
15933                 }
15934                 if (r->in.server_unc) {
15935                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
15936                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
15937                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
15938                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
15939                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
15940                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
15941                         }
15942                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
15943                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
15944                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
15945                 }
15946                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.share_name));
15947                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.share_name));
15948                 if (ndr_get_array_length(ndr, &r->in.share_name) > ndr_get_array_size(ndr, &r->in.share_name)) {
15949                         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.share_name), ndr_get_array_length(ndr, &r->in.share_name));
15950                 }
15951                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.share_name), sizeof(uint16_t)));
15952                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.share_name, ndr_get_array_length(ndr, &r->in.share_name), sizeof(uint16_t), CH_UTF16));
15953                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reserved));
15954         }
15955         if (flags & NDR_OUT) {
15956                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15957         }
15958         return NDR_ERR_SUCCESS;
15959 }
15960
15961 _PUBLIC_ void ndr_print_srvsvc_NetShareDelSticky(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareDelSticky *r)
15962 {
15963         ndr_print_struct(ndr, name, "srvsvc_NetShareDelSticky");
15964         ndr->depth++;
15965         if (flags & NDR_SET_VALUES) {
15966                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15967         }
15968         if (flags & NDR_IN) {
15969                 ndr_print_struct(ndr, "in", "srvsvc_NetShareDelSticky");
15970                 ndr->depth++;
15971                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
15972                 ndr->depth++;
15973                 if (r->in.server_unc) {
15974                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
15975                 }
15976                 ndr->depth--;
15977                 ndr_print_string(ndr, "share_name", r->in.share_name);
15978                 ndr_print_uint32(ndr, "reserved", r->in.reserved);
15979                 ndr->depth--;
15980         }
15981         if (flags & NDR_OUT) {
15982                 ndr_print_struct(ndr, "out", "srvsvc_NetShareDelSticky");
15983                 ndr->depth++;
15984                 ndr_print_WERROR(ndr, "result", r->out.result);
15985                 ndr->depth--;
15986         }
15987         ndr->depth--;
15988 }
15989
15990 static enum ndr_err_code ndr_push_srvsvc_NetShareCheck(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareCheck *r)
15991 {
15992         if (flags & NDR_IN) {
15993                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
15994                 if (r->in.server_unc) {
15995                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15996                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15997                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15998                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15999                 }
16000                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.device_name, CH_UTF16)));
16001                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16002                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.device_name, CH_UTF16)));
16003                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.device_name, ndr_charset_length(r->in.device_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16004         }
16005         if (flags & NDR_OUT) {
16006                 if (r->out.type == NULL) {
16007                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16008                 }
16009                 NDR_CHECK(ndr_push_srvsvc_ShareType(ndr, NDR_SCALARS, *r->out.type));
16010                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16011         }
16012         return NDR_ERR_SUCCESS;
16013 }
16014
16015 static enum ndr_err_code ndr_pull_srvsvc_NetShareCheck(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareCheck *r)
16016 {
16017         uint32_t _ptr_server_unc;
16018         TALLOC_CTX *_mem_save_server_unc_0;
16019         TALLOC_CTX *_mem_save_type_0;
16020         if (flags & NDR_IN) {
16021                 ZERO_STRUCT(r->out);
16022
16023                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
16024                 if (_ptr_server_unc) {
16025                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
16026                 } else {
16027                         r->in.server_unc = NULL;
16028                 }
16029                 if (r->in.server_unc) {
16030                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
16031                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
16032                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
16033                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
16034                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
16035                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
16036                         }
16037                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
16038                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
16039                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
16040                 }
16041                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.device_name));
16042                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.device_name));
16043                 if (ndr_get_array_length(ndr, &r->in.device_name) > ndr_get_array_size(ndr, &r->in.device_name)) {
16044                         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.device_name), ndr_get_array_length(ndr, &r->in.device_name));
16045                 }
16046                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.device_name), sizeof(uint16_t)));
16047                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.device_name, ndr_get_array_length(ndr, &r->in.device_name), sizeof(uint16_t), CH_UTF16));
16048                 NDR_PULL_ALLOC(ndr, r->out.type);
16049                 ZERO_STRUCTP(r->out.type);
16050         }
16051         if (flags & NDR_OUT) {
16052                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16053                         NDR_PULL_ALLOC(ndr, r->out.type);
16054                 }
16055                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
16056                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
16057                 NDR_CHECK(ndr_pull_srvsvc_ShareType(ndr, NDR_SCALARS, r->out.type));
16058                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
16059                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16060         }
16061         return NDR_ERR_SUCCESS;
16062 }
16063
16064 _PUBLIC_ void ndr_print_srvsvc_NetShareCheck(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareCheck *r)
16065 {
16066         ndr_print_struct(ndr, name, "srvsvc_NetShareCheck");
16067         ndr->depth++;
16068         if (flags & NDR_SET_VALUES) {
16069                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16070         }
16071         if (flags & NDR_IN) {
16072                 ndr_print_struct(ndr, "in", "srvsvc_NetShareCheck");
16073                 ndr->depth++;
16074                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
16075                 ndr->depth++;
16076                 if (r->in.server_unc) {
16077                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
16078                 }
16079                 ndr->depth--;
16080                 ndr_print_string(ndr, "device_name", r->in.device_name);
16081                 ndr->depth--;
16082         }
16083         if (flags & NDR_OUT) {
16084                 ndr_print_struct(ndr, "out", "srvsvc_NetShareCheck");
16085                 ndr->depth++;
16086                 ndr_print_ptr(ndr, "type", r->out.type);
16087                 ndr->depth++;
16088                 ndr_print_srvsvc_ShareType(ndr, "type", *r->out.type);
16089                 ndr->depth--;
16090                 ndr_print_WERROR(ndr, "result", r->out.result);
16091                 ndr->depth--;
16092         }
16093         ndr->depth--;
16094 }
16095
16096 static enum ndr_err_code ndr_push_srvsvc_NetSrvGetInfo(struct ndr_push *ndr, int flags, const struct srvsvc_NetSrvGetInfo *r)
16097 {
16098         if (flags & NDR_IN) {
16099                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
16100                 if (r->in.server_unc) {
16101                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16102                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16103                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16104                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16105                 }
16106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16107         }
16108         if (flags & NDR_OUT) {
16109                 if (r->out.info == NULL) {
16110                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16111                 }
16112                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
16113                 NDR_CHECK(ndr_push_srvsvc_NetSrvInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
16114                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16115         }
16116         return NDR_ERR_SUCCESS;
16117 }
16118
16119 static enum ndr_err_code ndr_pull_srvsvc_NetSrvGetInfo(struct ndr_pull *ndr, int flags, struct srvsvc_NetSrvGetInfo *r)
16120 {
16121         uint32_t _ptr_server_unc;
16122         TALLOC_CTX *_mem_save_server_unc_0;
16123         TALLOC_CTX *_mem_save_info_0;
16124         if (flags & NDR_IN) {
16125                 ZERO_STRUCT(r->out);
16126
16127                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
16128                 if (_ptr_server_unc) {
16129                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
16130                 } else {
16131                         r->in.server_unc = NULL;
16132                 }
16133                 if (r->in.server_unc) {
16134                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
16135                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
16136                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
16137                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
16138                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
16139                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
16140                         }
16141                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
16142                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
16143                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
16144                 }
16145                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16146                 NDR_PULL_ALLOC(ndr, r->out.info);
16147                 ZERO_STRUCTP(r->out.info);
16148         }
16149         if (flags & NDR_OUT) {
16150                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16151                         NDR_PULL_ALLOC(ndr, r->out.info);
16152                 }
16153                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16154                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
16155                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
16156                 NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
16157                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
16158                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16159         }
16160         return NDR_ERR_SUCCESS;
16161 }
16162
16163 _PUBLIC_ void ndr_print_srvsvc_NetSrvGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetSrvGetInfo *r)
16164 {
16165         ndr_print_struct(ndr, name, "srvsvc_NetSrvGetInfo");
16166         ndr->depth++;
16167         if (flags & NDR_SET_VALUES) {
16168                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16169         }
16170         if (flags & NDR_IN) {
16171                 ndr_print_struct(ndr, "in", "srvsvc_NetSrvGetInfo");
16172                 ndr->depth++;
16173                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
16174                 ndr->depth++;
16175                 if (r->in.server_unc) {
16176                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
16177                 }
16178                 ndr->depth--;
16179                 ndr_print_uint32(ndr, "level", r->in.level);
16180                 ndr->depth--;
16181         }
16182         if (flags & NDR_OUT) {
16183                 ndr_print_struct(ndr, "out", "srvsvc_NetSrvGetInfo");
16184                 ndr->depth++;
16185                 ndr_print_ptr(ndr, "info", r->out.info);
16186                 ndr->depth++;
16187                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
16188                 ndr_print_srvsvc_NetSrvInfo(ndr, "info", r->out.info);
16189                 ndr->depth--;
16190                 ndr_print_WERROR(ndr, "result", r->out.result);
16191                 ndr->depth--;
16192         }
16193         ndr->depth--;
16194 }
16195
16196 static enum ndr_err_code ndr_push_srvsvc_NetSrvSetInfo(struct ndr_push *ndr, int flags, const struct srvsvc_NetSrvSetInfo *r)
16197 {
16198         if (flags & NDR_IN) {
16199                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
16200                 if (r->in.server_unc) {
16201                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16202                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16203                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16204                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16205                 }
16206                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16207                 if (r->in.info == NULL) {
16208                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16209                 }
16210                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
16211                 NDR_CHECK(ndr_push_srvsvc_NetSrvInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
16212                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_error));
16213                 if (r->in.parm_error) {
16214                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_error));
16215                 }
16216         }
16217         if (flags & NDR_OUT) {
16218                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_error));
16219                 if (r->out.parm_error) {
16220                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_error));
16221                 }
16222                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16223         }
16224         return NDR_ERR_SUCCESS;
16225 }
16226
16227 static enum ndr_err_code ndr_pull_srvsvc_NetSrvSetInfo(struct ndr_pull *ndr, int flags, struct srvsvc_NetSrvSetInfo *r)
16228 {
16229         uint32_t _ptr_server_unc;
16230         uint32_t _ptr_parm_error;
16231         TALLOC_CTX *_mem_save_server_unc_0;
16232         TALLOC_CTX *_mem_save_info_0;
16233         TALLOC_CTX *_mem_save_parm_error_0;
16234         if (flags & NDR_IN) {
16235                 ZERO_STRUCT(r->out);
16236
16237                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
16238                 if (_ptr_server_unc) {
16239                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
16240                 } else {
16241                         r->in.server_unc = NULL;
16242                 }
16243                 if (r->in.server_unc) {
16244                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
16245                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
16246                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
16247                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
16248                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
16249                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
16250                         }
16251                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
16252                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
16253                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
16254                 }
16255                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16256                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16257                         NDR_PULL_ALLOC(ndr, r->in.info);
16258                 }
16259                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16260                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
16261                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
16262                 NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
16263                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
16264                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_error));
16265                 if (_ptr_parm_error) {
16266                         NDR_PULL_ALLOC(ndr, r->in.parm_error);
16267                 } else {
16268                         r->in.parm_error = NULL;
16269                 }
16270                 if (r->in.parm_error) {
16271                         _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
16272                         NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_error, 0);
16273                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_error));
16274                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, 0);
16275                 }
16276         }
16277         if (flags & NDR_OUT) {
16278                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_error));
16279                 if (_ptr_parm_error) {
16280                         NDR_PULL_ALLOC(ndr, r->out.parm_error);
16281                 } else {
16282                         r->out.parm_error = NULL;
16283                 }
16284                 if (r->out.parm_error) {
16285                         _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
16286                         NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_error, 0);
16287                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_error));
16288                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, 0);
16289                 }
16290                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16291         }
16292         return NDR_ERR_SUCCESS;
16293 }
16294
16295 _PUBLIC_ void ndr_print_srvsvc_NetSrvSetInfo(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetSrvSetInfo *r)
16296 {
16297         ndr_print_struct(ndr, name, "srvsvc_NetSrvSetInfo");
16298         ndr->depth++;
16299         if (flags & NDR_SET_VALUES) {
16300                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16301         }
16302         if (flags & NDR_IN) {
16303                 ndr_print_struct(ndr, "in", "srvsvc_NetSrvSetInfo");
16304                 ndr->depth++;
16305                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
16306                 ndr->depth++;
16307                 if (r->in.server_unc) {
16308                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
16309                 }
16310                 ndr->depth--;
16311                 ndr_print_uint32(ndr, "level", r->in.level);
16312                 ndr_print_ptr(ndr, "info", r->in.info);
16313                 ndr->depth++;
16314                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
16315                 ndr_print_srvsvc_NetSrvInfo(ndr, "info", r->in.info);
16316                 ndr->depth--;
16317                 ndr_print_ptr(ndr, "parm_error", r->in.parm_error);
16318                 ndr->depth++;
16319                 if (r->in.parm_error) {
16320                         ndr_print_uint32(ndr, "parm_error", *r->in.parm_error);
16321                 }
16322                 ndr->depth--;
16323                 ndr->depth--;
16324         }
16325         if (flags & NDR_OUT) {
16326                 ndr_print_struct(ndr, "out", "srvsvc_NetSrvSetInfo");
16327                 ndr->depth++;
16328                 ndr_print_ptr(ndr, "parm_error", r->out.parm_error);
16329                 ndr->depth++;
16330                 if (r->out.parm_error) {
16331                         ndr_print_uint32(ndr, "parm_error", *r->out.parm_error);
16332                 }
16333                 ndr->depth--;
16334                 ndr_print_WERROR(ndr, "result", r->out.result);
16335                 ndr->depth--;
16336         }
16337         ndr->depth--;
16338 }
16339
16340 static enum ndr_err_code ndr_push_srvsvc_NetDiskEnum(struct ndr_push *ndr, int flags, const struct srvsvc_NetDiskEnum *r)
16341 {
16342         if (flags & NDR_IN) {
16343                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
16344                 if (r->in.server_unc) {
16345                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16346                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16347                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16348                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16349                 }
16350                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16351                 if (r->in.info == NULL) {
16352                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16353                 }
16354                 NDR_CHECK(ndr_push_srvsvc_NetDiskInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
16355                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.maxlen));
16356                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
16357                 if (r->in.resume_handle) {
16358                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
16359                 }
16360         }
16361         if (flags & NDR_OUT) {
16362                 if (r->out.info == NULL) {
16363                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16364                 }
16365                 NDR_CHECK(ndr_push_srvsvc_NetDiskInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
16366                 if (r->out.totalentries == NULL) {
16367                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16368                 }
16369                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
16370                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
16371                 if (r->out.resume_handle) {
16372                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
16373                 }
16374                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16375         }
16376         return NDR_ERR_SUCCESS;
16377 }
16378
16379 static enum ndr_err_code ndr_pull_srvsvc_NetDiskEnum(struct ndr_pull *ndr, int flags, struct srvsvc_NetDiskEnum *r)
16380 {
16381         uint32_t _ptr_server_unc;
16382         uint32_t _ptr_resume_handle;
16383         TALLOC_CTX *_mem_save_server_unc_0;
16384         TALLOC_CTX *_mem_save_info_0;
16385         TALLOC_CTX *_mem_save_totalentries_0;
16386         TALLOC_CTX *_mem_save_resume_handle_0;
16387         if (flags & NDR_IN) {
16388                 ZERO_STRUCT(r->out);
16389
16390                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
16391                 if (_ptr_server_unc) {
16392                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
16393                 } else {
16394                         r->in.server_unc = NULL;
16395                 }
16396                 if (r->in.server_unc) {
16397                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
16398                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
16399                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
16400                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
16401                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
16402                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
16403                         }
16404                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
16405                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
16406                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
16407                 }
16408                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16409                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16410                         NDR_PULL_ALLOC(ndr, r->in.info);
16411                 }
16412                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16413                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
16414                 NDR_CHECK(ndr_pull_srvsvc_NetDiskInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
16415                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
16416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.maxlen));
16417                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
16418                 if (_ptr_resume_handle) {
16419                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
16420                 } else {
16421                         r->in.resume_handle = NULL;
16422                 }
16423                 if (r->in.resume_handle) {
16424                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16425                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
16426                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
16427                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
16428                 }
16429                 NDR_PULL_ALLOC(ndr, r->out.info);
16430                 *r->out.info = *r->in.info;
16431                 NDR_PULL_ALLOC(ndr, r->out.totalentries);
16432                 ZERO_STRUCTP(r->out.totalentries);
16433         }
16434         if (flags & NDR_OUT) {
16435                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16436                         NDR_PULL_ALLOC(ndr, r->out.info);
16437                 }
16438                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16439                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
16440                 NDR_CHECK(ndr_pull_srvsvc_NetDiskInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
16441                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
16442                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16443                         NDR_PULL_ALLOC(ndr, r->out.totalentries);
16444                 }
16445                 _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
16446                 NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);
16447                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
16448                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);
16449                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
16450                 if (_ptr_resume_handle) {
16451                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
16452                 } else {
16453                         r->out.resume_handle = NULL;
16454                 }
16455                 if (r->out.resume_handle) {
16456                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16457                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
16458                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
16459                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
16460                 }
16461                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16462         }
16463         return NDR_ERR_SUCCESS;
16464 }
16465
16466 _PUBLIC_ void ndr_print_srvsvc_NetDiskEnum(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetDiskEnum *r)
16467 {
16468         ndr_print_struct(ndr, name, "srvsvc_NetDiskEnum");
16469         ndr->depth++;
16470         if (flags & NDR_SET_VALUES) {
16471                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16472         }
16473         if (flags & NDR_IN) {
16474                 ndr_print_struct(ndr, "in", "srvsvc_NetDiskEnum");
16475                 ndr->depth++;
16476                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
16477                 ndr->depth++;
16478                 if (r->in.server_unc) {
16479                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
16480                 }
16481                 ndr->depth--;
16482                 ndr_print_uint32(ndr, "level", r->in.level);
16483                 ndr_print_ptr(ndr, "info", r->in.info);
16484                 ndr->depth++;
16485                 ndr_print_srvsvc_NetDiskInfo(ndr, "info", r->in.info);
16486                 ndr->depth--;
16487                 ndr_print_uint32(ndr, "maxlen", r->in.maxlen);
16488                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
16489                 ndr->depth++;
16490                 if (r->in.resume_handle) {
16491                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
16492                 }
16493                 ndr->depth--;
16494                 ndr->depth--;
16495         }
16496         if (flags & NDR_OUT) {
16497                 ndr_print_struct(ndr, "out", "srvsvc_NetDiskEnum");
16498                 ndr->depth++;
16499                 ndr_print_ptr(ndr, "info", r->out.info);
16500                 ndr->depth++;
16501                 ndr_print_srvsvc_NetDiskInfo(ndr, "info", r->out.info);
16502                 ndr->depth--;
16503                 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
16504                 ndr->depth++;
16505                 ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
16506                 ndr->depth--;
16507                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
16508                 ndr->depth++;
16509                 if (r->out.resume_handle) {
16510                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
16511                 }
16512                 ndr->depth--;
16513                 ndr_print_WERROR(ndr, "result", r->out.result);
16514                 ndr->depth--;
16515         }
16516         ndr->depth--;
16517 }
16518
16519 static enum ndr_err_code ndr_push_srvsvc_NetServerStatisticsGet(struct ndr_push *ndr, int flags, const struct srvsvc_NetServerStatisticsGet *r)
16520 {
16521         if (flags & NDR_IN) {
16522                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
16523                 if (r->in.server_unc) {
16524                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16525                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16526                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16527                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16528                 }
16529                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service));
16530                 if (r->in.service) {
16531                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service, CH_UTF16)));
16532                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16533                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service, CH_UTF16)));
16534                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.service, ndr_charset_length(r->in.service, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16535                 }
16536                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16537                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
16538         }
16539         if (flags & NDR_OUT) {
16540                 if (r->out.stats == NULL) {
16541                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16542                 }
16543                 NDR_CHECK(ndr_push_srvsvc_Statistics(ndr, NDR_SCALARS, r->out.stats));
16544                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16545         }
16546         return NDR_ERR_SUCCESS;
16547 }
16548
16549 static enum ndr_err_code ndr_pull_srvsvc_NetServerStatisticsGet(struct ndr_pull *ndr, int flags, struct srvsvc_NetServerStatisticsGet *r)
16550 {
16551         uint32_t _ptr_server_unc;
16552         uint32_t _ptr_service;
16553         TALLOC_CTX *_mem_save_server_unc_0;
16554         TALLOC_CTX *_mem_save_service_0;
16555         TALLOC_CTX *_mem_save_stats_0;
16556         if (flags & NDR_IN) {
16557                 ZERO_STRUCT(r->out);
16558
16559                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
16560                 if (_ptr_server_unc) {
16561                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
16562                 } else {
16563                         r->in.server_unc = NULL;
16564                 }
16565                 if (r->in.server_unc) {
16566                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
16567                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
16568                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
16569                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
16570                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
16571                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
16572                         }
16573                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
16574                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
16575                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
16576                 }
16577                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service));
16578                 if (_ptr_service) {
16579                         NDR_PULL_ALLOC(ndr, r->in.service);
16580                 } else {
16581                         r->in.service = NULL;
16582                 }
16583                 if (r->in.service) {
16584                         _mem_save_service_0 = NDR_PULL_GET_MEM_CTX(ndr);
16585                         NDR_PULL_SET_MEM_CTX(ndr, r->in.service, 0);
16586                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service));
16587                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service));
16588                         if (ndr_get_array_length(ndr, &r->in.service) > ndr_get_array_size(ndr, &r->in.service)) {
16589                                 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.service), ndr_get_array_length(ndr, &r->in.service));
16590                         }
16591                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.service), sizeof(uint16_t)));
16592                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service, ndr_get_array_length(ndr, &r->in.service), sizeof(uint16_t), CH_UTF16));
16593                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_0, 0);
16594                 }
16595                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16596                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
16597                 NDR_PULL_ALLOC(ndr, r->out.stats);
16598                 ZERO_STRUCTP(r->out.stats);
16599         }
16600         if (flags & NDR_OUT) {
16601                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16602                         NDR_PULL_ALLOC(ndr, r->out.stats);
16603                 }
16604                 _mem_save_stats_0 = NDR_PULL_GET_MEM_CTX(ndr);
16605                 NDR_PULL_SET_MEM_CTX(ndr, r->out.stats, LIBNDR_FLAG_REF_ALLOC);
16606                 NDR_CHECK(ndr_pull_srvsvc_Statistics(ndr, NDR_SCALARS, r->out.stats));
16607                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_stats_0, LIBNDR_FLAG_REF_ALLOC);
16608                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16609         }
16610         return NDR_ERR_SUCCESS;
16611 }
16612
16613 _PUBLIC_ void ndr_print_srvsvc_NetServerStatisticsGet(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetServerStatisticsGet *r)
16614 {
16615         ndr_print_struct(ndr, name, "srvsvc_NetServerStatisticsGet");
16616         ndr->depth++;
16617         if (flags & NDR_SET_VALUES) {
16618                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16619         }
16620         if (flags & NDR_IN) {
16621                 ndr_print_struct(ndr, "in", "srvsvc_NetServerStatisticsGet");
16622                 ndr->depth++;
16623                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
16624                 ndr->depth++;
16625                 if (r->in.server_unc) {
16626                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
16627                 }
16628                 ndr->depth--;
16629                 ndr_print_ptr(ndr, "service", r->in.service);
16630                 ndr->depth++;
16631                 if (r->in.service) {
16632                         ndr_print_string(ndr, "service", r->in.service);
16633                 }
16634                 ndr->depth--;
16635                 ndr_print_uint32(ndr, "level", r->in.level);
16636                 ndr_print_uint32(ndr, "options", r->in.options);
16637                 ndr->depth--;
16638         }
16639         if (flags & NDR_OUT) {
16640                 ndr_print_struct(ndr, "out", "srvsvc_NetServerStatisticsGet");
16641                 ndr->depth++;
16642                 ndr_print_ptr(ndr, "stats", r->out.stats);
16643                 ndr->depth++;
16644                 ndr_print_srvsvc_Statistics(ndr, "stats", r->out.stats);
16645                 ndr->depth--;
16646                 ndr_print_WERROR(ndr, "result", r->out.result);
16647                 ndr->depth--;
16648         }
16649         ndr->depth--;
16650 }
16651
16652 static enum ndr_err_code ndr_push_srvsvc_NetTransportAdd(struct ndr_push *ndr, int flags, const struct srvsvc_NetTransportAdd *r)
16653 {
16654         if (flags & NDR_IN) {
16655                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
16656                 if (r->in.server_unc) {
16657                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16658                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16659                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16660                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16661                 }
16662                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16663                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
16664                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
16665         }
16666         if (flags & NDR_OUT) {
16667                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16668         }
16669         return NDR_ERR_SUCCESS;
16670 }
16671
16672 static enum ndr_err_code ndr_pull_srvsvc_NetTransportAdd(struct ndr_pull *ndr, int flags, struct srvsvc_NetTransportAdd *r)
16673 {
16674         uint32_t _ptr_server_unc;
16675         TALLOC_CTX *_mem_save_server_unc_0;
16676         if (flags & NDR_IN) {
16677                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
16678                 if (_ptr_server_unc) {
16679                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
16680                 } else {
16681                         r->in.server_unc = NULL;
16682                 }
16683                 if (r->in.server_unc) {
16684                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
16685                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
16686                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
16687                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
16688                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
16689                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
16690                         }
16691                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
16692                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
16693                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
16694                 }
16695                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16696                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
16697                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
16698         }
16699         if (flags & NDR_OUT) {
16700                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16701         }
16702         return NDR_ERR_SUCCESS;
16703 }
16704
16705 _PUBLIC_ void ndr_print_srvsvc_NetTransportAdd(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetTransportAdd *r)
16706 {
16707         ndr_print_struct(ndr, name, "srvsvc_NetTransportAdd");
16708         ndr->depth++;
16709         if (flags & NDR_SET_VALUES) {
16710                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16711         }
16712         if (flags & NDR_IN) {
16713                 ndr_print_struct(ndr, "in", "srvsvc_NetTransportAdd");
16714                 ndr->depth++;
16715                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
16716                 ndr->depth++;
16717                 if (r->in.server_unc) {
16718                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
16719                 }
16720                 ndr->depth--;
16721                 ndr_print_uint32(ndr, "level", r->in.level);
16722                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
16723                 ndr_print_srvsvc_NetTransportInfo(ndr, "info", &r->in.info);
16724                 ndr->depth--;
16725         }
16726         if (flags & NDR_OUT) {
16727                 ndr_print_struct(ndr, "out", "srvsvc_NetTransportAdd");
16728                 ndr->depth++;
16729                 ndr_print_WERROR(ndr, "result", r->out.result);
16730                 ndr->depth--;
16731         }
16732         ndr->depth--;
16733 }
16734
16735 static enum ndr_err_code ndr_push_srvsvc_NetTransportEnum(struct ndr_push *ndr, int flags, const struct srvsvc_NetTransportEnum *r)
16736 {
16737         if (flags & NDR_IN) {
16738                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
16739                 if (r->in.server_unc) {
16740                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16741                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16742                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16743                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16744                 }
16745                 if (r->in.level == NULL) {
16746                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16747                 }
16748                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.level));
16749                 if (r->in.transports == NULL) {
16750                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16751                 }
16752                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.transports, *r->in.level));
16753                 NDR_CHECK(ndr_push_srvsvc_NetTransportCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.transports));
16754                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));
16755                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
16756                 if (r->in.resume_handle) {
16757                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
16758                 }
16759         }
16760         if (flags & NDR_OUT) {
16761                 if (r->out.level == NULL) {
16762                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16763                 }
16764                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level));
16765                 if (r->out.transports == NULL) {
16766                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16767                 }
16768                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.transports, *r->out.level));
16769                 NDR_CHECK(ndr_push_srvsvc_NetTransportCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.transports));
16770                 if (r->out.totalentries == NULL) {
16771                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16772                 }
16773                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
16774                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
16775                 if (r->out.resume_handle) {
16776                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
16777                 }
16778                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16779         }
16780         return NDR_ERR_SUCCESS;
16781 }
16782
16783 static enum ndr_err_code ndr_pull_srvsvc_NetTransportEnum(struct ndr_pull *ndr, int flags, struct srvsvc_NetTransportEnum *r)
16784 {
16785         uint32_t _ptr_server_unc;
16786         uint32_t _ptr_resume_handle;
16787         TALLOC_CTX *_mem_save_server_unc_0;
16788         TALLOC_CTX *_mem_save_level_0;
16789         TALLOC_CTX *_mem_save_transports_0;
16790         TALLOC_CTX *_mem_save_totalentries_0;
16791         TALLOC_CTX *_mem_save_resume_handle_0;
16792         if (flags & NDR_IN) {
16793                 ZERO_STRUCT(r->out);
16794
16795                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
16796                 if (_ptr_server_unc) {
16797                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
16798                 } else {
16799                         r->in.server_unc = NULL;
16800                 }
16801                 if (r->in.server_unc) {
16802                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
16803                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
16804                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
16805                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
16806                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
16807                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
16808                         }
16809                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
16810                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
16811                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
16812                 }
16813                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16814                         NDR_PULL_ALLOC(ndr, r->in.level);
16815                 }
16816                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
16817                 NDR_PULL_SET_MEM_CTX(ndr, r->in.level, LIBNDR_FLAG_REF_ALLOC);
16818                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.level));
16819                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
16820                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16821                         NDR_PULL_ALLOC(ndr, r->in.transports);
16822                 }
16823                 _mem_save_transports_0 = NDR_PULL_GET_MEM_CTX(ndr);
16824                 NDR_PULL_SET_MEM_CTX(ndr, r->in.transports, LIBNDR_FLAG_REF_ALLOC);
16825                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.transports, *r->in.level));
16826                 NDR_CHECK(ndr_pull_srvsvc_NetTransportCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.transports));
16827                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transports_0, LIBNDR_FLAG_REF_ALLOC);
16828                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));
16829                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
16830                 if (_ptr_resume_handle) {
16831                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
16832                 } else {
16833                         r->in.resume_handle = NULL;
16834                 }
16835                 if (r->in.resume_handle) {
16836                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16837                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
16838                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
16839                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
16840                 }
16841                 NDR_PULL_ALLOC(ndr, r->out.level);
16842                 *r->out.level = *r->in.level;
16843                 NDR_PULL_ALLOC(ndr, r->out.transports);
16844                 *r->out.transports = *r->in.transports;
16845                 NDR_PULL_ALLOC(ndr, r->out.totalentries);
16846                 ZERO_STRUCTP(r->out.totalentries);
16847         }
16848         if (flags & NDR_OUT) {
16849                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16850                         NDR_PULL_ALLOC(ndr, r->out.level);
16851                 }
16852                 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
16853                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level, LIBNDR_FLAG_REF_ALLOC);
16854                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level));
16855                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
16856                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16857                         NDR_PULL_ALLOC(ndr, r->out.transports);
16858                 }
16859                 _mem_save_transports_0 = NDR_PULL_GET_MEM_CTX(ndr);
16860                 NDR_PULL_SET_MEM_CTX(ndr, r->out.transports, LIBNDR_FLAG_REF_ALLOC);
16861                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.transports, *r->out.level));
16862                 NDR_CHECK(ndr_pull_srvsvc_NetTransportCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.transports));
16863                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transports_0, LIBNDR_FLAG_REF_ALLOC);
16864                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16865                         NDR_PULL_ALLOC(ndr, r->out.totalentries);
16866                 }
16867                 _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
16868                 NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);
16869                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
16870                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);
16871                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
16872                 if (_ptr_resume_handle) {
16873                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
16874                 } else {
16875                         r->out.resume_handle = NULL;
16876                 }
16877                 if (r->out.resume_handle) {
16878                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16879                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
16880                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
16881                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
16882                 }
16883                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16884         }
16885         return NDR_ERR_SUCCESS;
16886 }
16887
16888 _PUBLIC_ void ndr_print_srvsvc_NetTransportEnum(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetTransportEnum *r)
16889 {
16890         ndr_print_struct(ndr, name, "srvsvc_NetTransportEnum");
16891         ndr->depth++;
16892         if (flags & NDR_SET_VALUES) {
16893                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16894         }
16895         if (flags & NDR_IN) {
16896                 ndr_print_struct(ndr, "in", "srvsvc_NetTransportEnum");
16897                 ndr->depth++;
16898                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
16899                 ndr->depth++;
16900                 if (r->in.server_unc) {
16901                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
16902                 }
16903                 ndr->depth--;
16904                 ndr_print_ptr(ndr, "level", r->in.level);
16905                 ndr->depth++;
16906                 ndr_print_uint32(ndr, "level", *r->in.level);
16907                 ndr->depth--;
16908                 ndr_print_ptr(ndr, "transports", r->in.transports);
16909                 ndr->depth++;
16910                 ndr_print_set_switch_value(ndr, r->in.transports, *r->in.level);
16911                 ndr_print_srvsvc_NetTransportCtr(ndr, "transports", r->in.transports);
16912                 ndr->depth--;
16913                 ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);
16914                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
16915                 ndr->depth++;
16916                 if (r->in.resume_handle) {
16917                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
16918                 }
16919                 ndr->depth--;
16920                 ndr->depth--;
16921         }
16922         if (flags & NDR_OUT) {
16923                 ndr_print_struct(ndr, "out", "srvsvc_NetTransportEnum");
16924                 ndr->depth++;
16925                 ndr_print_ptr(ndr, "level", r->out.level);
16926                 ndr->depth++;
16927                 ndr_print_uint32(ndr, "level", *r->out.level);
16928                 ndr->depth--;
16929                 ndr_print_ptr(ndr, "transports", r->out.transports);
16930                 ndr->depth++;
16931                 ndr_print_set_switch_value(ndr, r->out.transports, *r->out.level);
16932                 ndr_print_srvsvc_NetTransportCtr(ndr, "transports", r->out.transports);
16933                 ndr->depth--;
16934                 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
16935                 ndr->depth++;
16936                 ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
16937                 ndr->depth--;
16938                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
16939                 ndr->depth++;
16940                 if (r->out.resume_handle) {
16941                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
16942                 }
16943                 ndr->depth--;
16944                 ndr_print_WERROR(ndr, "result", r->out.result);
16945                 ndr->depth--;
16946         }
16947         ndr->depth--;
16948 }
16949
16950 static enum ndr_err_code ndr_push_srvsvc_NetTransportDel(struct ndr_push *ndr, int flags, const struct srvsvc_NetTransportDel *r)
16951 {
16952         if (flags & NDR_IN) {
16953                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
16954                 if (r->in.server_unc) {
16955                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16956                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16957                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16958                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16959                 }
16960                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
16961                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.transport));
16962         }
16963         if (flags & NDR_OUT) {
16964                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16965         }
16966         return NDR_ERR_SUCCESS;
16967 }
16968
16969 static enum ndr_err_code ndr_pull_srvsvc_NetTransportDel(struct ndr_pull *ndr, int flags, struct srvsvc_NetTransportDel *r)
16970 {
16971         uint32_t _ptr_server_unc;
16972         TALLOC_CTX *_mem_save_server_unc_0;
16973         if (flags & NDR_IN) {
16974                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
16975                 if (_ptr_server_unc) {
16976                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
16977                 } else {
16978                         r->in.server_unc = NULL;
16979                 }
16980                 if (r->in.server_unc) {
16981                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
16982                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
16983                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
16984                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
16985                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
16986                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
16987                         }
16988                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
16989                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
16990                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
16991                 }
16992                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
16993                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.transport));
16994         }
16995         if (flags & NDR_OUT) {
16996                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16997         }
16998         return NDR_ERR_SUCCESS;
16999 }
17000
17001 _PUBLIC_ void ndr_print_srvsvc_NetTransportDel(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetTransportDel *r)
17002 {
17003         ndr_print_struct(ndr, name, "srvsvc_NetTransportDel");
17004         ndr->depth++;
17005         if (flags & NDR_SET_VALUES) {
17006                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17007         }
17008         if (flags & NDR_IN) {
17009                 ndr_print_struct(ndr, "in", "srvsvc_NetTransportDel");
17010                 ndr->depth++;
17011                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
17012                 ndr->depth++;
17013                 if (r->in.server_unc) {
17014                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
17015                 }
17016                 ndr->depth--;
17017                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
17018                 ndr_print_srvsvc_NetTransportInfo0(ndr, "transport", &r->in.transport);
17019                 ndr->depth--;
17020         }
17021         if (flags & NDR_OUT) {
17022                 ndr_print_struct(ndr, "out", "srvsvc_NetTransportDel");
17023                 ndr->depth++;
17024                 ndr_print_WERROR(ndr, "result", r->out.result);
17025                 ndr->depth--;
17026         }
17027         ndr->depth--;
17028 }
17029
17030 static enum ndr_err_code ndr_push_srvsvc_NetRemoteTOD(struct ndr_push *ndr, int flags, const struct srvsvc_NetRemoteTOD *r)
17031 {
17032         if (flags & NDR_IN) {
17033                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
17034                 if (r->in.server_unc) {
17035                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17036                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17037                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17038                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17039                 }
17040         }
17041         if (flags & NDR_OUT) {
17042                 if (r->out.info == NULL) {
17043                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17044                 }
17045                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
17046                 if (*r->out.info) {
17047                         NDR_CHECK(ndr_push_srvsvc_NetRemoteTODInfo(ndr, NDR_SCALARS, *r->out.info));
17048                 }
17049                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17050         }
17051         return NDR_ERR_SUCCESS;
17052 }
17053
17054 static enum ndr_err_code ndr_pull_srvsvc_NetRemoteTOD(struct ndr_pull *ndr, int flags, struct srvsvc_NetRemoteTOD *r)
17055 {
17056         uint32_t _ptr_server_unc;
17057         uint32_t _ptr_info;
17058         TALLOC_CTX *_mem_save_server_unc_0;
17059         TALLOC_CTX *_mem_save_info_0;
17060         TALLOC_CTX *_mem_save_info_1;
17061         if (flags & NDR_IN) {
17062                 ZERO_STRUCT(r->out);
17063
17064                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
17065                 if (_ptr_server_unc) {
17066                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
17067                 } else {
17068                         r->in.server_unc = NULL;
17069                 }
17070                 if (r->in.server_unc) {
17071                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
17072                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
17073                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
17074                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
17075                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
17076                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
17077                         }
17078                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
17079                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
17080                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
17081                 }
17082                 NDR_PULL_ALLOC(ndr, r->out.info);
17083                 ZERO_STRUCTP(r->out.info);
17084         }
17085         if (flags & NDR_OUT) {
17086                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17087                         NDR_PULL_ALLOC(ndr, r->out.info);
17088                 }
17089                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
17090                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
17091                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
17092                 if (_ptr_info) {
17093                         NDR_PULL_ALLOC(ndr, *r->out.info);
17094                 } else {
17095                         *r->out.info = NULL;
17096                 }
17097                 if (*r->out.info) {
17098                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
17099                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
17100                         NDR_CHECK(ndr_pull_srvsvc_NetRemoteTODInfo(ndr, NDR_SCALARS, *r->out.info));
17101                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
17102                 }
17103                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
17104                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17105         }
17106         return NDR_ERR_SUCCESS;
17107 }
17108
17109 _PUBLIC_ void ndr_print_srvsvc_NetRemoteTOD(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetRemoteTOD *r)
17110 {
17111         ndr_print_struct(ndr, name, "srvsvc_NetRemoteTOD");
17112         ndr->depth++;
17113         if (flags & NDR_SET_VALUES) {
17114                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17115         }
17116         if (flags & NDR_IN) {
17117                 ndr_print_struct(ndr, "in", "srvsvc_NetRemoteTOD");
17118                 ndr->depth++;
17119                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
17120                 ndr->depth++;
17121                 if (r->in.server_unc) {
17122                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
17123                 }
17124                 ndr->depth--;
17125                 ndr->depth--;
17126         }
17127         if (flags & NDR_OUT) {
17128                 ndr_print_struct(ndr, "out", "srvsvc_NetRemoteTOD");
17129                 ndr->depth++;
17130                 ndr_print_ptr(ndr, "info", r->out.info);
17131                 ndr->depth++;
17132                 ndr_print_ptr(ndr, "info", *r->out.info);
17133                 ndr->depth++;
17134                 if (*r->out.info) {
17135                         ndr_print_srvsvc_NetRemoteTODInfo(ndr, "info", *r->out.info);
17136                 }
17137                 ndr->depth--;
17138                 ndr->depth--;
17139                 ndr_print_WERROR(ndr, "result", r->out.result);
17140                 ndr->depth--;
17141         }
17142         ndr->depth--;
17143 }
17144
17145 static enum ndr_err_code ndr_push_srvsvc_NetSetServiceBits(struct ndr_push *ndr, int flags, const struct srvsvc_NetSetServiceBits *r)
17146 {
17147         if (flags & NDR_IN) {
17148                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
17149                 if (r->in.server_unc) {
17150                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17151                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17152                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17153                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17154                 }
17155                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.transport));
17156                 if (r->in.transport) {
17157                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.transport, CH_UTF16)));
17158                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17159                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.transport, CH_UTF16)));
17160                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.transport, ndr_charset_length(r->in.transport, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17161                 }
17162                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.servicebits));
17163                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.updateimmediately));
17164         }
17165         if (flags & NDR_OUT) {
17166                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17167         }
17168         return NDR_ERR_SUCCESS;
17169 }
17170
17171 static enum ndr_err_code ndr_pull_srvsvc_NetSetServiceBits(struct ndr_pull *ndr, int flags, struct srvsvc_NetSetServiceBits *r)
17172 {
17173         uint32_t _ptr_server_unc;
17174         uint32_t _ptr_transport;
17175         TALLOC_CTX *_mem_save_server_unc_0;
17176         TALLOC_CTX *_mem_save_transport_0;
17177         if (flags & NDR_IN) {
17178                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
17179                 if (_ptr_server_unc) {
17180                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
17181                 } else {
17182                         r->in.server_unc = NULL;
17183                 }
17184                 if (r->in.server_unc) {
17185                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
17186                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
17187                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
17188                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
17189                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
17190                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
17191                         }
17192                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
17193                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
17194                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
17195                 }
17196                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport));
17197                 if (_ptr_transport) {
17198                         NDR_PULL_ALLOC(ndr, r->in.transport);
17199                 } else {
17200                         r->in.transport = NULL;
17201                 }
17202                 if (r->in.transport) {
17203                         _mem_save_transport_0 = NDR_PULL_GET_MEM_CTX(ndr);
17204                         NDR_PULL_SET_MEM_CTX(ndr, r->in.transport, 0);
17205                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.transport));
17206                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.transport));
17207                         if (ndr_get_array_length(ndr, &r->in.transport) > ndr_get_array_size(ndr, &r->in.transport)) {
17208                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.transport), ndr_get_array_length(ndr, &r->in.transport));
17209                         }
17210                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.transport), sizeof(uint16_t)));
17211                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.transport, ndr_get_array_length(ndr, &r->in.transport), sizeof(uint16_t), CH_UTF16));
17212                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_0, 0);
17213                 }
17214                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.servicebits));
17215                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.updateimmediately));
17216         }
17217         if (flags & NDR_OUT) {
17218                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17219         }
17220         return NDR_ERR_SUCCESS;
17221 }
17222
17223 _PUBLIC_ void ndr_print_srvsvc_NetSetServiceBits(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetSetServiceBits *r)
17224 {
17225         ndr_print_struct(ndr, name, "srvsvc_NetSetServiceBits");
17226         ndr->depth++;
17227         if (flags & NDR_SET_VALUES) {
17228                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17229         }
17230         if (flags & NDR_IN) {
17231                 ndr_print_struct(ndr, "in", "srvsvc_NetSetServiceBits");
17232                 ndr->depth++;
17233                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
17234                 ndr->depth++;
17235                 if (r->in.server_unc) {
17236                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
17237                 }
17238                 ndr->depth--;
17239                 ndr_print_ptr(ndr, "transport", r->in.transport);
17240                 ndr->depth++;
17241                 if (r->in.transport) {
17242                         ndr_print_string(ndr, "transport", r->in.transport);
17243                 }
17244                 ndr->depth--;
17245                 ndr_print_uint32(ndr, "servicebits", r->in.servicebits);
17246                 ndr_print_uint32(ndr, "updateimmediately", r->in.updateimmediately);
17247                 ndr->depth--;
17248         }
17249         if (flags & NDR_OUT) {
17250                 ndr_print_struct(ndr, "out", "srvsvc_NetSetServiceBits");
17251                 ndr->depth++;
17252                 ndr_print_WERROR(ndr, "result", r->out.result);
17253                 ndr->depth--;
17254         }
17255         ndr->depth--;
17256 }
17257
17258 static enum ndr_err_code ndr_push_srvsvc_NetPathType(struct ndr_push *ndr, int flags, const struct srvsvc_NetPathType *r)
17259 {
17260         if (flags & NDR_IN) {
17261                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
17262                 if (r->in.server_unc) {
17263                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17264                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17265                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17266                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17267                 }
17268                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));
17269                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17270                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));
17271                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.path, ndr_charset_length(r->in.path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17272                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.pathflags));
17273         }
17274         if (flags & NDR_OUT) {
17275                 if (r->out.pathtype == NULL) {
17276                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17277                 }
17278                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.pathtype));
17279                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17280         }
17281         return NDR_ERR_SUCCESS;
17282 }
17283
17284 static enum ndr_err_code ndr_pull_srvsvc_NetPathType(struct ndr_pull *ndr, int flags, struct srvsvc_NetPathType *r)
17285 {
17286         uint32_t _ptr_server_unc;
17287         TALLOC_CTX *_mem_save_server_unc_0;
17288         TALLOC_CTX *_mem_save_pathtype_0;
17289         if (flags & NDR_IN) {
17290                 ZERO_STRUCT(r->out);
17291
17292                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
17293                 if (_ptr_server_unc) {
17294                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
17295                 } else {
17296                         r->in.server_unc = NULL;
17297                 }
17298                 if (r->in.server_unc) {
17299                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
17300                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
17301                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
17302                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
17303                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
17304                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
17305                         }
17306                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
17307                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
17308                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
17309                 }
17310                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path));
17311                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path));
17312                 if (ndr_get_array_length(ndr, &r->in.path) > ndr_get_array_size(ndr, &r->in.path)) {
17313                         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.path), ndr_get_array_length(ndr, &r->in.path));
17314                 }
17315                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path), sizeof(uint16_t)));
17316                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.path, ndr_get_array_length(ndr, &r->in.path), sizeof(uint16_t), CH_UTF16));
17317                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.pathflags));
17318                 NDR_PULL_ALLOC(ndr, r->out.pathtype);
17319                 ZERO_STRUCTP(r->out.pathtype);
17320         }
17321         if (flags & NDR_OUT) {
17322                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17323                         NDR_PULL_ALLOC(ndr, r->out.pathtype);
17324                 }
17325                 _mem_save_pathtype_0 = NDR_PULL_GET_MEM_CTX(ndr);
17326                 NDR_PULL_SET_MEM_CTX(ndr, r->out.pathtype, LIBNDR_FLAG_REF_ALLOC);
17327                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.pathtype));
17328                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pathtype_0, LIBNDR_FLAG_REF_ALLOC);
17329                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17330         }
17331         return NDR_ERR_SUCCESS;
17332 }
17333
17334 _PUBLIC_ void ndr_print_srvsvc_NetPathType(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetPathType *r)
17335 {
17336         ndr_print_struct(ndr, name, "srvsvc_NetPathType");
17337         ndr->depth++;
17338         if (flags & NDR_SET_VALUES) {
17339                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17340         }
17341         if (flags & NDR_IN) {
17342                 ndr_print_struct(ndr, "in", "srvsvc_NetPathType");
17343                 ndr->depth++;
17344                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
17345                 ndr->depth++;
17346                 if (r->in.server_unc) {
17347                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
17348                 }
17349                 ndr->depth--;
17350                 ndr_print_string(ndr, "path", r->in.path);
17351                 ndr_print_uint32(ndr, "pathflags", r->in.pathflags);
17352                 ndr->depth--;
17353         }
17354         if (flags & NDR_OUT) {
17355                 ndr_print_struct(ndr, "out", "srvsvc_NetPathType");
17356                 ndr->depth++;
17357                 ndr_print_ptr(ndr, "pathtype", r->out.pathtype);
17358                 ndr->depth++;
17359                 ndr_print_uint32(ndr, "pathtype", *r->out.pathtype);
17360                 ndr->depth--;
17361                 ndr_print_WERROR(ndr, "result", r->out.result);
17362                 ndr->depth--;
17363         }
17364         ndr->depth--;
17365 }
17366
17367 static enum ndr_err_code ndr_push_srvsvc_NetPathCanonicalize(struct ndr_push *ndr, int flags, const struct srvsvc_NetPathCanonicalize *r)
17368 {
17369         if (flags & NDR_IN) {
17370                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
17371                 if (r->in.server_unc) {
17372                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17373                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17374                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17375                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17376                 }
17377                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));
17378                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17379                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));
17380                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.path, ndr_charset_length(r->in.path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17381                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.maxbuf));
17382                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.prefix, CH_UTF16)));
17383                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17384                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.prefix, CH_UTF16)));
17385                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.prefix, ndr_charset_length(r->in.prefix, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17386                 if (r->in.pathtype == NULL) {
17387                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17388                 }
17389                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.pathtype));
17390                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.pathflags));
17391         }
17392         if (flags & NDR_OUT) {
17393                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.maxbuf));
17394                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.can_path, r->in.maxbuf));
17395                 if (r->out.pathtype == NULL) {
17396                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17397                 }
17398                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.pathtype));
17399                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17400         }
17401         return NDR_ERR_SUCCESS;
17402 }
17403
17404 static enum ndr_err_code ndr_pull_srvsvc_NetPathCanonicalize(struct ndr_pull *ndr, int flags, struct srvsvc_NetPathCanonicalize *r)
17405 {
17406         uint32_t _ptr_server_unc;
17407         TALLOC_CTX *_mem_save_server_unc_0;
17408         TALLOC_CTX *_mem_save_pathtype_0;
17409         if (flags & NDR_IN) {
17410                 ZERO_STRUCT(r->out);
17411
17412                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
17413                 if (_ptr_server_unc) {
17414                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
17415                 } else {
17416                         r->in.server_unc = NULL;
17417                 }
17418                 if (r->in.server_unc) {
17419                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
17420                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
17421                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
17422                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
17423                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
17424                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
17425                         }
17426                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
17427                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
17428                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
17429                 }
17430                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path));
17431                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path));
17432                 if (ndr_get_array_length(ndr, &r->in.path) > ndr_get_array_size(ndr, &r->in.path)) {
17433                         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.path), ndr_get_array_length(ndr, &r->in.path));
17434                 }
17435                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path), sizeof(uint16_t)));
17436                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.path, ndr_get_array_length(ndr, &r->in.path), sizeof(uint16_t), CH_UTF16));
17437                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.maxbuf));
17438                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.prefix));
17439                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.prefix));
17440                 if (ndr_get_array_length(ndr, &r->in.prefix) > ndr_get_array_size(ndr, &r->in.prefix)) {
17441                         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.prefix), ndr_get_array_length(ndr, &r->in.prefix));
17442                 }
17443                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.prefix), sizeof(uint16_t)));
17444                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.prefix, ndr_get_array_length(ndr, &r->in.prefix), sizeof(uint16_t), CH_UTF16));
17445                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17446                         NDR_PULL_ALLOC(ndr, r->in.pathtype);
17447                 }
17448                 _mem_save_pathtype_0 = NDR_PULL_GET_MEM_CTX(ndr);
17449                 NDR_PULL_SET_MEM_CTX(ndr, r->in.pathtype, LIBNDR_FLAG_REF_ALLOC);
17450                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.pathtype));
17451                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pathtype_0, LIBNDR_FLAG_REF_ALLOC);
17452                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.pathflags));
17453                 NDR_PULL_ALLOC(ndr, r->out.pathtype);
17454                 *r->out.pathtype = *r->in.pathtype;
17455         }
17456         if (flags & NDR_OUT) {
17457                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.can_path));
17458                 NDR_PULL_ALLOC_N(ndr, r->out.can_path, ndr_get_array_size(ndr, &r->out.can_path));
17459                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.can_path, ndr_get_array_size(ndr, &r->out.can_path)));
17460                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17461                         NDR_PULL_ALLOC(ndr, r->out.pathtype);
17462                 }
17463                 _mem_save_pathtype_0 = NDR_PULL_GET_MEM_CTX(ndr);
17464                 NDR_PULL_SET_MEM_CTX(ndr, r->out.pathtype, LIBNDR_FLAG_REF_ALLOC);
17465                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.pathtype));
17466                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pathtype_0, LIBNDR_FLAG_REF_ALLOC);
17467                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17468                 if (r->out.can_path) {
17469                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.can_path, r->in.maxbuf));
17470                 }
17471         }
17472         return NDR_ERR_SUCCESS;
17473 }
17474
17475 _PUBLIC_ void ndr_print_srvsvc_NetPathCanonicalize(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetPathCanonicalize *r)
17476 {
17477         ndr_print_struct(ndr, name, "srvsvc_NetPathCanonicalize");
17478         ndr->depth++;
17479         if (flags & NDR_SET_VALUES) {
17480                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17481         }
17482         if (flags & NDR_IN) {
17483                 ndr_print_struct(ndr, "in", "srvsvc_NetPathCanonicalize");
17484                 ndr->depth++;
17485                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
17486                 ndr->depth++;
17487                 if (r->in.server_unc) {
17488                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
17489                 }
17490                 ndr->depth--;
17491                 ndr_print_string(ndr, "path", r->in.path);
17492                 ndr_print_uint32(ndr, "maxbuf", r->in.maxbuf);
17493                 ndr_print_string(ndr, "prefix", r->in.prefix);
17494                 ndr_print_ptr(ndr, "pathtype", r->in.pathtype);
17495                 ndr->depth++;
17496                 ndr_print_uint32(ndr, "pathtype", *r->in.pathtype);
17497                 ndr->depth--;
17498                 ndr_print_uint32(ndr, "pathflags", r->in.pathflags);
17499                 ndr->depth--;
17500         }
17501         if (flags & NDR_OUT) {
17502                 ndr_print_struct(ndr, "out", "srvsvc_NetPathCanonicalize");
17503                 ndr->depth++;
17504                 ndr_print_array_uint8(ndr, "can_path", r->out.can_path, r->in.maxbuf);
17505                 ndr_print_ptr(ndr, "pathtype", r->out.pathtype);
17506                 ndr->depth++;
17507                 ndr_print_uint32(ndr, "pathtype", *r->out.pathtype);
17508                 ndr->depth--;
17509                 ndr_print_WERROR(ndr, "result", r->out.result);
17510                 ndr->depth--;
17511         }
17512         ndr->depth--;
17513 }
17514
17515 static enum ndr_err_code ndr_push_srvsvc_NetPathCompare(struct ndr_push *ndr, int flags, const struct srvsvc_NetPathCompare *r)
17516 {
17517         if (flags & NDR_IN) {
17518                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
17519                 if (r->in.server_unc) {
17520                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17521                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17522                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17523                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17524                 }
17525                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path1, CH_UTF16)));
17526                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17527                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path1, CH_UTF16)));
17528                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.path1, ndr_charset_length(r->in.path1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17529                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path2, CH_UTF16)));
17530                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17531                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path2, CH_UTF16)));
17532                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.path2, ndr_charset_length(r->in.path2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17533                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.pathtype));
17534                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.pathflags));
17535         }
17536         if (flags & NDR_OUT) {
17537                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17538         }
17539         return NDR_ERR_SUCCESS;
17540 }
17541
17542 static enum ndr_err_code ndr_pull_srvsvc_NetPathCompare(struct ndr_pull *ndr, int flags, struct srvsvc_NetPathCompare *r)
17543 {
17544         uint32_t _ptr_server_unc;
17545         TALLOC_CTX *_mem_save_server_unc_0;
17546         if (flags & NDR_IN) {
17547                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
17548                 if (_ptr_server_unc) {
17549                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
17550                 } else {
17551                         r->in.server_unc = NULL;
17552                 }
17553                 if (r->in.server_unc) {
17554                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
17555                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
17556                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
17557                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
17558                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
17559                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
17560                         }
17561                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
17562                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
17563                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
17564                 }
17565                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path1));
17566                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path1));
17567                 if (ndr_get_array_length(ndr, &r->in.path1) > ndr_get_array_size(ndr, &r->in.path1)) {
17568                         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.path1), ndr_get_array_length(ndr, &r->in.path1));
17569                 }
17570                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path1), sizeof(uint16_t)));
17571                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.path1, ndr_get_array_length(ndr, &r->in.path1), sizeof(uint16_t), CH_UTF16));
17572                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path2));
17573                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path2));
17574                 if (ndr_get_array_length(ndr, &r->in.path2) > ndr_get_array_size(ndr, &r->in.path2)) {
17575                         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.path2), ndr_get_array_length(ndr, &r->in.path2));
17576                 }
17577                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path2), sizeof(uint16_t)));
17578                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.path2, ndr_get_array_length(ndr, &r->in.path2), sizeof(uint16_t), CH_UTF16));
17579                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.pathtype));
17580                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.pathflags));
17581         }
17582         if (flags & NDR_OUT) {
17583                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17584         }
17585         return NDR_ERR_SUCCESS;
17586 }
17587
17588 _PUBLIC_ void ndr_print_srvsvc_NetPathCompare(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetPathCompare *r)
17589 {
17590         ndr_print_struct(ndr, name, "srvsvc_NetPathCompare");
17591         ndr->depth++;
17592         if (flags & NDR_SET_VALUES) {
17593                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17594         }
17595         if (flags & NDR_IN) {
17596                 ndr_print_struct(ndr, "in", "srvsvc_NetPathCompare");
17597                 ndr->depth++;
17598                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
17599                 ndr->depth++;
17600                 if (r->in.server_unc) {
17601                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
17602                 }
17603                 ndr->depth--;
17604                 ndr_print_string(ndr, "path1", r->in.path1);
17605                 ndr_print_string(ndr, "path2", r->in.path2);
17606                 ndr_print_uint32(ndr, "pathtype", r->in.pathtype);
17607                 ndr_print_uint32(ndr, "pathflags", r->in.pathflags);
17608                 ndr->depth--;
17609         }
17610         if (flags & NDR_OUT) {
17611                 ndr_print_struct(ndr, "out", "srvsvc_NetPathCompare");
17612                 ndr->depth++;
17613                 ndr_print_WERROR(ndr, "result", r->out.result);
17614                 ndr->depth--;
17615         }
17616         ndr->depth--;
17617 }
17618
17619 static enum ndr_err_code ndr_push_srvsvc_NetNameValidate(struct ndr_push *ndr, int flags, const struct srvsvc_NetNameValidate *r)
17620 {
17621         if (flags & NDR_IN) {
17622                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
17623                 if (r->in.server_unc) {
17624                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17625                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17626                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17627                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17628                 }
17629                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF16)));
17630                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17631                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF16)));
17632                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.name, ndr_charset_length(r->in.name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17633                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.name_type));
17634                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
17635         }
17636         if (flags & NDR_OUT) {
17637                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17638         }
17639         return NDR_ERR_SUCCESS;
17640 }
17641
17642 static enum ndr_err_code ndr_pull_srvsvc_NetNameValidate(struct ndr_pull *ndr, int flags, struct srvsvc_NetNameValidate *r)
17643 {
17644         uint32_t _ptr_server_unc;
17645         TALLOC_CTX *_mem_save_server_unc_0;
17646         if (flags & NDR_IN) {
17647                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
17648                 if (_ptr_server_unc) {
17649                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
17650                 } else {
17651                         r->in.server_unc = NULL;
17652                 }
17653                 if (r->in.server_unc) {
17654                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
17655                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
17656                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
17657                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
17658                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
17659                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
17660                         }
17661                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
17662                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
17663                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
17664                 }
17665                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.name));
17666                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.name));
17667                 if (ndr_get_array_length(ndr, &r->in.name) > ndr_get_array_size(ndr, &r->in.name)) {
17668                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.name), ndr_get_array_length(ndr, &r->in.name));
17669                 }
17670                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.name), sizeof(uint16_t)));
17671                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.name, ndr_get_array_length(ndr, &r->in.name), sizeof(uint16_t), CH_UTF16));
17672                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.name_type));
17673                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
17674         }
17675         if (flags & NDR_OUT) {
17676                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17677         }
17678         return NDR_ERR_SUCCESS;
17679 }
17680
17681 _PUBLIC_ void ndr_print_srvsvc_NetNameValidate(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetNameValidate *r)
17682 {
17683         ndr_print_struct(ndr, name, "srvsvc_NetNameValidate");
17684         ndr->depth++;
17685         if (flags & NDR_SET_VALUES) {
17686                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17687         }
17688         if (flags & NDR_IN) {
17689                 ndr_print_struct(ndr, "in", "srvsvc_NetNameValidate");
17690                 ndr->depth++;
17691                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
17692                 ndr->depth++;
17693                 if (r->in.server_unc) {
17694                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
17695                 }
17696                 ndr->depth--;
17697                 ndr_print_string(ndr, "name", r->in.name);
17698                 ndr_print_uint32(ndr, "name_type", r->in.name_type);
17699                 ndr_print_uint32(ndr, "flags", r->in.flags);
17700                 ndr->depth--;
17701         }
17702         if (flags & NDR_OUT) {
17703                 ndr_print_struct(ndr, "out", "srvsvc_NetNameValidate");
17704                 ndr->depth++;
17705                 ndr_print_WERROR(ndr, "result", r->out.result);
17706                 ndr->depth--;
17707         }
17708         ndr->depth--;
17709 }
17710
17711 static enum ndr_err_code ndr_push_srvsvc_NETRPRNAMECANONICALIZE(struct ndr_push *ndr, int flags, const struct srvsvc_NETRPRNAMECANONICALIZE *r)
17712 {
17713         if (flags & NDR_IN) {
17714         }
17715         if (flags & NDR_OUT) {
17716                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17717         }
17718         return NDR_ERR_SUCCESS;
17719 }
17720
17721 static enum ndr_err_code ndr_pull_srvsvc_NETRPRNAMECANONICALIZE(struct ndr_pull *ndr, int flags, struct srvsvc_NETRPRNAMECANONICALIZE *r)
17722 {
17723         if (flags & NDR_IN) {
17724         }
17725         if (flags & NDR_OUT) {
17726                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17727         }
17728         return NDR_ERR_SUCCESS;
17729 }
17730
17731 _PUBLIC_ void ndr_print_srvsvc_NETRPRNAMECANONICALIZE(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRPRNAMECANONICALIZE *r)
17732 {
17733         ndr_print_struct(ndr, name, "srvsvc_NETRPRNAMECANONICALIZE");
17734         ndr->depth++;
17735         if (flags & NDR_SET_VALUES) {
17736                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17737         }
17738         if (flags & NDR_IN) {
17739                 ndr_print_struct(ndr, "in", "srvsvc_NETRPRNAMECANONICALIZE");
17740                 ndr->depth++;
17741                 ndr->depth--;
17742         }
17743         if (flags & NDR_OUT) {
17744                 ndr_print_struct(ndr, "out", "srvsvc_NETRPRNAMECANONICALIZE");
17745                 ndr->depth++;
17746                 ndr_print_WERROR(ndr, "result", r->out.result);
17747                 ndr->depth--;
17748         }
17749         ndr->depth--;
17750 }
17751
17752 static enum ndr_err_code ndr_push_srvsvc_NetPRNameCompare(struct ndr_push *ndr, int flags, const struct srvsvc_NetPRNameCompare *r)
17753 {
17754         if (flags & NDR_IN) {
17755                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
17756                 if (r->in.server_unc) {
17757                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17758                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17759                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17760                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17761                 }
17762                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name1, CH_UTF16)));
17763                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17764                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name1, CH_UTF16)));
17765                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.name1, ndr_charset_length(r->in.name1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17766                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name2, CH_UTF16)));
17767                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17768                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name2, CH_UTF16)));
17769                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.name2, ndr_charset_length(r->in.name2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17770                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.name_type));
17771                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
17772         }
17773         if (flags & NDR_OUT) {
17774                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17775         }
17776         return NDR_ERR_SUCCESS;
17777 }
17778
17779 static enum ndr_err_code ndr_pull_srvsvc_NetPRNameCompare(struct ndr_pull *ndr, int flags, struct srvsvc_NetPRNameCompare *r)
17780 {
17781         uint32_t _ptr_server_unc;
17782         TALLOC_CTX *_mem_save_server_unc_0;
17783         if (flags & NDR_IN) {
17784                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
17785                 if (_ptr_server_unc) {
17786                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
17787                 } else {
17788                         r->in.server_unc = NULL;
17789                 }
17790                 if (r->in.server_unc) {
17791                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
17792                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
17793                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
17794                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
17795                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
17796                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
17797                         }
17798                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
17799                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
17800                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
17801                 }
17802                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.name1));
17803                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.name1));
17804                 if (ndr_get_array_length(ndr, &r->in.name1) > ndr_get_array_size(ndr, &r->in.name1)) {
17805                         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.name1), ndr_get_array_length(ndr, &r->in.name1));
17806                 }
17807                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.name1), sizeof(uint16_t)));
17808                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.name1, ndr_get_array_length(ndr, &r->in.name1), sizeof(uint16_t), CH_UTF16));
17809                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.name2));
17810                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.name2));
17811                 if (ndr_get_array_length(ndr, &r->in.name2) > ndr_get_array_size(ndr, &r->in.name2)) {
17812                         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.name2), ndr_get_array_length(ndr, &r->in.name2));
17813                 }
17814                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.name2), sizeof(uint16_t)));
17815                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.name2, ndr_get_array_length(ndr, &r->in.name2), sizeof(uint16_t), CH_UTF16));
17816                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.name_type));
17817                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
17818         }
17819         if (flags & NDR_OUT) {
17820                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17821         }
17822         return NDR_ERR_SUCCESS;
17823 }
17824
17825 _PUBLIC_ void ndr_print_srvsvc_NetPRNameCompare(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetPRNameCompare *r)
17826 {
17827         ndr_print_struct(ndr, name, "srvsvc_NetPRNameCompare");
17828         ndr->depth++;
17829         if (flags & NDR_SET_VALUES) {
17830                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17831         }
17832         if (flags & NDR_IN) {
17833                 ndr_print_struct(ndr, "in", "srvsvc_NetPRNameCompare");
17834                 ndr->depth++;
17835                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
17836                 ndr->depth++;
17837                 if (r->in.server_unc) {
17838                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
17839                 }
17840                 ndr->depth--;
17841                 ndr_print_string(ndr, "name1", r->in.name1);
17842                 ndr_print_string(ndr, "name2", r->in.name2);
17843                 ndr_print_uint32(ndr, "name_type", r->in.name_type);
17844                 ndr_print_uint32(ndr, "flags", r->in.flags);
17845                 ndr->depth--;
17846         }
17847         if (flags & NDR_OUT) {
17848                 ndr_print_struct(ndr, "out", "srvsvc_NetPRNameCompare");
17849                 ndr->depth++;
17850                 ndr_print_WERROR(ndr, "result", r->out.result);
17851                 ndr->depth--;
17852         }
17853         ndr->depth--;
17854 }
17855
17856 static enum ndr_err_code ndr_push_srvsvc_NetShareEnum(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareEnum *r)
17857 {
17858         if (flags & NDR_IN) {
17859                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
17860                 if (r->in.server_unc) {
17861                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17862                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17863                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17864                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17865                 }
17866                 if (r->in.info_ctr == NULL) {
17867                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17868                 }
17869                 NDR_CHECK(ndr_push_srvsvc_NetShareInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
17870                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));
17871                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
17872                 if (r->in.resume_handle) {
17873                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
17874                 }
17875         }
17876         if (flags & NDR_OUT) {
17877                 if (r->out.info_ctr == NULL) {
17878                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17879                 }
17880                 NDR_CHECK(ndr_push_srvsvc_NetShareInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));
17881                 if (r->out.totalentries == NULL) {
17882                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17883                 }
17884                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
17885                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
17886                 if (r->out.resume_handle) {
17887                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
17888                 }
17889                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17890         }
17891         return NDR_ERR_SUCCESS;
17892 }
17893
17894 static enum ndr_err_code ndr_pull_srvsvc_NetShareEnum(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareEnum *r)
17895 {
17896         uint32_t _ptr_server_unc;
17897         uint32_t _ptr_resume_handle;
17898         TALLOC_CTX *_mem_save_server_unc_0;
17899         TALLOC_CTX *_mem_save_info_ctr_0;
17900         TALLOC_CTX *_mem_save_totalentries_0;
17901         TALLOC_CTX *_mem_save_resume_handle_0;
17902         if (flags & NDR_IN) {
17903                 ZERO_STRUCT(r->out);
17904
17905                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
17906                 if (_ptr_server_unc) {
17907                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
17908                 } else {
17909                         r->in.server_unc = NULL;
17910                 }
17911                 if (r->in.server_unc) {
17912                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
17913                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
17914                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
17915                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
17916                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
17917                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
17918                         }
17919                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
17920                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
17921                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
17922                 }
17923                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17924                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
17925                 }
17926                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
17927                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
17928                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
17929                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
17930                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));
17931                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
17932                 if (_ptr_resume_handle) {
17933                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
17934                 } else {
17935                         r->in.resume_handle = NULL;
17936                 }
17937                 if (r->in.resume_handle) {
17938                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17939                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
17940                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
17941                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
17942                 }
17943                 NDR_PULL_ALLOC(ndr, r->out.info_ctr);
17944                 *r->out.info_ctr = *r->in.info_ctr;
17945                 NDR_PULL_ALLOC(ndr, r->out.totalentries);
17946                 ZERO_STRUCTP(r->out.totalentries);
17947         }
17948         if (flags & NDR_OUT) {
17949                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17950                         NDR_PULL_ALLOC(ndr, r->out.info_ctr);
17951                 }
17952                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
17953                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_ctr, LIBNDR_FLAG_REF_ALLOC);
17954                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));
17955                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
17956                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17957                         NDR_PULL_ALLOC(ndr, r->out.totalentries);
17958                 }
17959                 _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
17960                 NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);
17961                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
17962                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);
17963                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
17964                 if (_ptr_resume_handle) {
17965                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
17966                 } else {
17967                         r->out.resume_handle = NULL;
17968                 }
17969                 if (r->out.resume_handle) {
17970                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17971                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
17972                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
17973                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
17974                 }
17975                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17976         }
17977         return NDR_ERR_SUCCESS;
17978 }
17979
17980 _PUBLIC_ void ndr_print_srvsvc_NetShareEnum(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareEnum *r)
17981 {
17982         ndr_print_struct(ndr, name, "srvsvc_NetShareEnum");
17983         ndr->depth++;
17984         if (flags & NDR_SET_VALUES) {
17985                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17986         }
17987         if (flags & NDR_IN) {
17988                 ndr_print_struct(ndr, "in", "srvsvc_NetShareEnum");
17989                 ndr->depth++;
17990                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
17991                 ndr->depth++;
17992                 if (r->in.server_unc) {
17993                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
17994                 }
17995                 ndr->depth--;
17996                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
17997                 ndr->depth++;
17998                 ndr_print_srvsvc_NetShareInfoCtr(ndr, "info_ctr", r->in.info_ctr);
17999                 ndr->depth--;
18000                 ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);
18001                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
18002                 ndr->depth++;
18003                 if (r->in.resume_handle) {
18004                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
18005                 }
18006                 ndr->depth--;
18007                 ndr->depth--;
18008         }
18009         if (flags & NDR_OUT) {
18010                 ndr_print_struct(ndr, "out", "srvsvc_NetShareEnum");
18011                 ndr->depth++;
18012                 ndr_print_ptr(ndr, "info_ctr", r->out.info_ctr);
18013                 ndr->depth++;
18014                 ndr_print_srvsvc_NetShareInfoCtr(ndr, "info_ctr", r->out.info_ctr);
18015                 ndr->depth--;
18016                 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
18017                 ndr->depth++;
18018                 ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
18019                 ndr->depth--;
18020                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
18021                 ndr->depth++;
18022                 if (r->out.resume_handle) {
18023                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
18024                 }
18025                 ndr->depth--;
18026                 ndr_print_WERROR(ndr, "result", r->out.result);
18027                 ndr->depth--;
18028         }
18029         ndr->depth--;
18030 }
18031
18032 static enum ndr_err_code ndr_push_srvsvc_NetShareDelStart(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareDelStart *r)
18033 {
18034         if (flags & NDR_IN) {
18035                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
18036                 if (r->in.server_unc) {
18037                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18038                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18039                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18040                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18041                 }
18042                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share, CH_UTF16)));
18043                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18044                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share, CH_UTF16)));
18045                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.share, ndr_charset_length(r->in.share, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18046                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reserved));
18047         }
18048         if (flags & NDR_OUT) {
18049                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.hnd));
18050                 if (r->out.hnd) {
18051                         NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.hnd));
18052                 }
18053                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18054         }
18055         return NDR_ERR_SUCCESS;
18056 }
18057
18058 static enum ndr_err_code ndr_pull_srvsvc_NetShareDelStart(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareDelStart *r)
18059 {
18060         uint32_t _ptr_server_unc;
18061         uint32_t _ptr_hnd;
18062         TALLOC_CTX *_mem_save_server_unc_0;
18063         TALLOC_CTX *_mem_save_hnd_0;
18064         if (flags & NDR_IN) {
18065                 ZERO_STRUCT(r->out);
18066
18067                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
18068                 if (_ptr_server_unc) {
18069                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
18070                 } else {
18071                         r->in.server_unc = NULL;
18072                 }
18073                 if (r->in.server_unc) {
18074                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
18075                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
18076                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
18077                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
18078                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
18079                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
18080                         }
18081                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
18082                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
18083                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
18084                 }
18085                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.share));
18086                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.share));
18087                 if (ndr_get_array_length(ndr, &r->in.share) > ndr_get_array_size(ndr, &r->in.share)) {
18088                         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.share), ndr_get_array_length(ndr, &r->in.share));
18089                 }
18090                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.share), sizeof(uint16_t)));
18091                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.share, ndr_get_array_length(ndr, &r->in.share), sizeof(uint16_t), CH_UTF16));
18092                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reserved));
18093         }
18094         if (flags & NDR_OUT) {
18095                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hnd));
18096                 if (_ptr_hnd) {
18097                         NDR_PULL_ALLOC(ndr, r->out.hnd);
18098                 } else {
18099                         r->out.hnd = NULL;
18100                 }
18101                 if (r->out.hnd) {
18102                         _mem_save_hnd_0 = NDR_PULL_GET_MEM_CTX(ndr);
18103                         NDR_PULL_SET_MEM_CTX(ndr, r->out.hnd, 0);
18104                         NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.hnd));
18105                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hnd_0, 0);
18106                 }
18107                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18108         }
18109         return NDR_ERR_SUCCESS;
18110 }
18111
18112 _PUBLIC_ void ndr_print_srvsvc_NetShareDelStart(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareDelStart *r)
18113 {
18114         ndr_print_struct(ndr, name, "srvsvc_NetShareDelStart");
18115         ndr->depth++;
18116         if (flags & NDR_SET_VALUES) {
18117                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18118         }
18119         if (flags & NDR_IN) {
18120                 ndr_print_struct(ndr, "in", "srvsvc_NetShareDelStart");
18121                 ndr->depth++;
18122                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
18123                 ndr->depth++;
18124                 if (r->in.server_unc) {
18125                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
18126                 }
18127                 ndr->depth--;
18128                 ndr_print_string(ndr, "share", r->in.share);
18129                 ndr_print_uint32(ndr, "reserved", r->in.reserved);
18130                 ndr->depth--;
18131         }
18132         if (flags & NDR_OUT) {
18133                 ndr_print_struct(ndr, "out", "srvsvc_NetShareDelStart");
18134                 ndr->depth++;
18135                 ndr_print_ptr(ndr, "hnd", r->out.hnd);
18136                 ndr->depth++;
18137                 if (r->out.hnd) {
18138                         ndr_print_policy_handle(ndr, "hnd", r->out.hnd);
18139                 }
18140                 ndr->depth--;
18141                 ndr_print_WERROR(ndr, "result", r->out.result);
18142                 ndr->depth--;
18143         }
18144         ndr->depth--;
18145 }
18146
18147 static enum ndr_err_code ndr_push_srvsvc_NetShareDelCommit(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareDelCommit *r)
18148 {
18149         if (flags & NDR_IN) {
18150                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.hnd));
18151                 if (r->in.hnd) {
18152                         NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.hnd));
18153                 }
18154         }
18155         if (flags & NDR_OUT) {
18156                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.hnd));
18157                 if (r->out.hnd) {
18158                         NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.hnd));
18159                 }
18160                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18161         }
18162         return NDR_ERR_SUCCESS;
18163 }
18164
18165 static enum ndr_err_code ndr_pull_srvsvc_NetShareDelCommit(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareDelCommit *r)
18166 {
18167         uint32_t _ptr_hnd;
18168         TALLOC_CTX *_mem_save_hnd_0;
18169         if (flags & NDR_IN) {
18170                 ZERO_STRUCT(r->out);
18171
18172                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hnd));
18173                 if (_ptr_hnd) {
18174                         NDR_PULL_ALLOC(ndr, r->in.hnd);
18175                 } else {
18176                         r->in.hnd = NULL;
18177                 }
18178                 if (r->in.hnd) {
18179                         _mem_save_hnd_0 = NDR_PULL_GET_MEM_CTX(ndr);
18180                         NDR_PULL_SET_MEM_CTX(ndr, r->in.hnd, 0);
18181                         NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.hnd));
18182                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hnd_0, 0);
18183                 }
18184         }
18185         if (flags & NDR_OUT) {
18186                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hnd));
18187                 if (_ptr_hnd) {
18188                         NDR_PULL_ALLOC(ndr, r->out.hnd);
18189                 } else {
18190                         r->out.hnd = NULL;
18191                 }
18192                 if (r->out.hnd) {
18193                         _mem_save_hnd_0 = NDR_PULL_GET_MEM_CTX(ndr);
18194                         NDR_PULL_SET_MEM_CTX(ndr, r->out.hnd, 0);
18195                         NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.hnd));
18196                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hnd_0, 0);
18197                 }
18198                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18199         }
18200         return NDR_ERR_SUCCESS;
18201 }
18202
18203 _PUBLIC_ void ndr_print_srvsvc_NetShareDelCommit(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareDelCommit *r)
18204 {
18205         ndr_print_struct(ndr, name, "srvsvc_NetShareDelCommit");
18206         ndr->depth++;
18207         if (flags & NDR_SET_VALUES) {
18208                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18209         }
18210         if (flags & NDR_IN) {
18211                 ndr_print_struct(ndr, "in", "srvsvc_NetShareDelCommit");
18212                 ndr->depth++;
18213                 ndr_print_ptr(ndr, "hnd", r->in.hnd);
18214                 ndr->depth++;
18215                 if (r->in.hnd) {
18216                         ndr_print_policy_handle(ndr, "hnd", r->in.hnd);
18217                 }
18218                 ndr->depth--;
18219                 ndr->depth--;
18220         }
18221         if (flags & NDR_OUT) {
18222                 ndr_print_struct(ndr, "out", "srvsvc_NetShareDelCommit");
18223                 ndr->depth++;
18224                 ndr_print_ptr(ndr, "hnd", r->out.hnd);
18225                 ndr->depth++;
18226                 if (r->out.hnd) {
18227                         ndr_print_policy_handle(ndr, "hnd", r->out.hnd);
18228                 }
18229                 ndr->depth--;
18230                 ndr_print_WERROR(ndr, "result", r->out.result);
18231                 ndr->depth--;
18232         }
18233         ndr->depth--;
18234 }
18235
18236 static enum ndr_err_code ndr_push_srvsvc_NetGetFileSecurity(struct ndr_push *ndr, int flags, const struct srvsvc_NetGetFileSecurity *r)
18237 {
18238         if (flags & NDR_IN) {
18239                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
18240                 if (r->in.server_unc) {
18241                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18242                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18243                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18244                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18245                 }
18246                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.share));
18247                 if (r->in.share) {
18248                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share, CH_UTF16)));
18249                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18250                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share, CH_UTF16)));
18251                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.share, ndr_charset_length(r->in.share, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18252                 }
18253                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.file, CH_UTF16)));
18254                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18255                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.file, CH_UTF16)));
18256                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.file, ndr_charset_length(r->in.file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18257                 NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.securityinformation));
18258         }
18259         if (flags & NDR_OUT) {
18260                 if (r->out.sd_buf == NULL) {
18261                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18262                 }
18263                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sd_buf));
18264                 if (*r->out.sd_buf) {
18265                         NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sd_buf));
18266                 }
18267                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18268         }
18269         return NDR_ERR_SUCCESS;
18270 }
18271
18272 static enum ndr_err_code ndr_pull_srvsvc_NetGetFileSecurity(struct ndr_pull *ndr, int flags, struct srvsvc_NetGetFileSecurity *r)
18273 {
18274         uint32_t _ptr_server_unc;
18275         uint32_t _ptr_share;
18276         uint32_t _ptr_sd_buf;
18277         TALLOC_CTX *_mem_save_server_unc_0;
18278         TALLOC_CTX *_mem_save_share_0;
18279         TALLOC_CTX *_mem_save_sd_buf_0;
18280         TALLOC_CTX *_mem_save_sd_buf_1;
18281         if (flags & NDR_IN) {
18282                 ZERO_STRUCT(r->out);
18283
18284                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
18285                 if (_ptr_server_unc) {
18286                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
18287                 } else {
18288                         r->in.server_unc = NULL;
18289                 }
18290                 if (r->in.server_unc) {
18291                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
18292                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
18293                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
18294                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
18295                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
18296                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
18297                         }
18298                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
18299                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
18300                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
18301                 }
18302                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_share));
18303                 if (_ptr_share) {
18304                         NDR_PULL_ALLOC(ndr, r->in.share);
18305                 } else {
18306                         r->in.share = NULL;
18307                 }
18308                 if (r->in.share) {
18309                         _mem_save_share_0 = NDR_PULL_GET_MEM_CTX(ndr);
18310                         NDR_PULL_SET_MEM_CTX(ndr, r->in.share, 0);
18311                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.share));
18312                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.share));
18313                         if (ndr_get_array_length(ndr, &r->in.share) > ndr_get_array_size(ndr, &r->in.share)) {
18314                                 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.share), ndr_get_array_length(ndr, &r->in.share));
18315                         }
18316                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.share), sizeof(uint16_t)));
18317                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.share, ndr_get_array_length(ndr, &r->in.share), sizeof(uint16_t), CH_UTF16));
18318                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_share_0, 0);
18319                 }
18320                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.file));
18321                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.file));
18322                 if (ndr_get_array_length(ndr, &r->in.file) > ndr_get_array_size(ndr, &r->in.file)) {
18323                         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.file), ndr_get_array_length(ndr, &r->in.file));
18324                 }
18325                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.file), sizeof(uint16_t)));
18326                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.file, ndr_get_array_length(ndr, &r->in.file), sizeof(uint16_t), CH_UTF16));
18327                 NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.securityinformation));
18328                 NDR_PULL_ALLOC(ndr, r->out.sd_buf);
18329                 ZERO_STRUCTP(r->out.sd_buf);
18330         }
18331         if (flags & NDR_OUT) {
18332                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18333                         NDR_PULL_ALLOC(ndr, r->out.sd_buf);
18334                 }
18335                 _mem_save_sd_buf_0 = NDR_PULL_GET_MEM_CTX(ndr);
18336                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sd_buf, LIBNDR_FLAG_REF_ALLOC);
18337                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sd_buf));
18338                 if (_ptr_sd_buf) {
18339                         NDR_PULL_ALLOC(ndr, *r->out.sd_buf);
18340                 } else {
18341                         *r->out.sd_buf = NULL;
18342                 }
18343                 if (*r->out.sd_buf) {
18344                         _mem_save_sd_buf_1 = NDR_PULL_GET_MEM_CTX(ndr);
18345                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sd_buf, 0);
18346                         NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sd_buf));
18347                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_buf_1, 0);
18348                 }
18349                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_buf_0, LIBNDR_FLAG_REF_ALLOC);
18350                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18351         }
18352         return NDR_ERR_SUCCESS;
18353 }
18354
18355 _PUBLIC_ void ndr_print_srvsvc_NetGetFileSecurity(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetGetFileSecurity *r)
18356 {
18357         ndr_print_struct(ndr, name, "srvsvc_NetGetFileSecurity");
18358         ndr->depth++;
18359         if (flags & NDR_SET_VALUES) {
18360                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18361         }
18362         if (flags & NDR_IN) {
18363                 ndr_print_struct(ndr, "in", "srvsvc_NetGetFileSecurity");
18364                 ndr->depth++;
18365                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
18366                 ndr->depth++;
18367                 if (r->in.server_unc) {
18368                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
18369                 }
18370                 ndr->depth--;
18371                 ndr_print_ptr(ndr, "share", r->in.share);
18372                 ndr->depth++;
18373                 if (r->in.share) {
18374                         ndr_print_string(ndr, "share", r->in.share);
18375                 }
18376                 ndr->depth--;
18377                 ndr_print_string(ndr, "file", r->in.file);
18378                 ndr_print_security_secinfo(ndr, "securityinformation", r->in.securityinformation);
18379                 ndr->depth--;
18380         }
18381         if (flags & NDR_OUT) {
18382                 ndr_print_struct(ndr, "out", "srvsvc_NetGetFileSecurity");
18383                 ndr->depth++;
18384                 ndr_print_ptr(ndr, "sd_buf", r->out.sd_buf);
18385                 ndr->depth++;
18386                 ndr_print_ptr(ndr, "sd_buf", *r->out.sd_buf);
18387                 ndr->depth++;
18388                 if (*r->out.sd_buf) {
18389                         ndr_print_sec_desc_buf(ndr, "sd_buf", *r->out.sd_buf);
18390                 }
18391                 ndr->depth--;
18392                 ndr->depth--;
18393                 ndr_print_WERROR(ndr, "result", r->out.result);
18394                 ndr->depth--;
18395         }
18396         ndr->depth--;
18397 }
18398
18399 static enum ndr_err_code ndr_push_srvsvc_NetSetFileSecurity(struct ndr_push *ndr, int flags, const struct srvsvc_NetSetFileSecurity *r)
18400 {
18401         if (flags & NDR_IN) {
18402                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
18403                 if (r->in.server_unc) {
18404                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18405                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18406                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18407                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18408                 }
18409                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.share));
18410                 if (r->in.share) {
18411                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share, CH_UTF16)));
18412                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18413                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share, CH_UTF16)));
18414                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.share, ndr_charset_length(r->in.share, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18415                 }
18416                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.file, CH_UTF16)));
18417                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18418                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.file, CH_UTF16)));
18419                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.file, ndr_charset_length(r->in.file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18420                 NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.securityinformation));
18421                 if (r->in.sd_buf == NULL) {
18422                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18423                 }
18424                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sd_buf));
18425         }
18426         if (flags & NDR_OUT) {
18427                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18428         }
18429         return NDR_ERR_SUCCESS;
18430 }
18431
18432 static enum ndr_err_code ndr_pull_srvsvc_NetSetFileSecurity(struct ndr_pull *ndr, int flags, struct srvsvc_NetSetFileSecurity *r)
18433 {
18434         uint32_t _ptr_server_unc;
18435         uint32_t _ptr_share;
18436         TALLOC_CTX *_mem_save_server_unc_0;
18437         TALLOC_CTX *_mem_save_share_0;
18438         TALLOC_CTX *_mem_save_sd_buf_0;
18439         if (flags & NDR_IN) {
18440                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
18441                 if (_ptr_server_unc) {
18442                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
18443                 } else {
18444                         r->in.server_unc = NULL;
18445                 }
18446                 if (r->in.server_unc) {
18447                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
18448                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
18449                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
18450                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
18451                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
18452                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
18453                         }
18454                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
18455                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
18456                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
18457                 }
18458                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_share));
18459                 if (_ptr_share) {
18460                         NDR_PULL_ALLOC(ndr, r->in.share);
18461                 } else {
18462                         r->in.share = NULL;
18463                 }
18464                 if (r->in.share) {
18465                         _mem_save_share_0 = NDR_PULL_GET_MEM_CTX(ndr);
18466                         NDR_PULL_SET_MEM_CTX(ndr, r->in.share, 0);
18467                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.share));
18468                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.share));
18469                         if (ndr_get_array_length(ndr, &r->in.share) > ndr_get_array_size(ndr, &r->in.share)) {
18470                                 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.share), ndr_get_array_length(ndr, &r->in.share));
18471                         }
18472                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.share), sizeof(uint16_t)));
18473                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.share, ndr_get_array_length(ndr, &r->in.share), sizeof(uint16_t), CH_UTF16));
18474                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_share_0, 0);
18475                 }
18476                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.file));
18477                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.file));
18478                 if (ndr_get_array_length(ndr, &r->in.file) > ndr_get_array_size(ndr, &r->in.file)) {
18479                         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.file), ndr_get_array_length(ndr, &r->in.file));
18480                 }
18481                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.file), sizeof(uint16_t)));
18482                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.file, ndr_get_array_length(ndr, &r->in.file), sizeof(uint16_t), CH_UTF16));
18483                 NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.securityinformation));
18484                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18485                         NDR_PULL_ALLOC(ndr, r->in.sd_buf);
18486                 }
18487                 _mem_save_sd_buf_0 = NDR_PULL_GET_MEM_CTX(ndr);
18488                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sd_buf, LIBNDR_FLAG_REF_ALLOC);
18489                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sd_buf));
18490                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_buf_0, LIBNDR_FLAG_REF_ALLOC);
18491         }
18492         if (flags & NDR_OUT) {
18493                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18494         }
18495         return NDR_ERR_SUCCESS;
18496 }
18497
18498 _PUBLIC_ void ndr_print_srvsvc_NetSetFileSecurity(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetSetFileSecurity *r)
18499 {
18500         ndr_print_struct(ndr, name, "srvsvc_NetSetFileSecurity");
18501         ndr->depth++;
18502         if (flags & NDR_SET_VALUES) {
18503                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18504         }
18505         if (flags & NDR_IN) {
18506                 ndr_print_struct(ndr, "in", "srvsvc_NetSetFileSecurity");
18507                 ndr->depth++;
18508                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
18509                 ndr->depth++;
18510                 if (r->in.server_unc) {
18511                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
18512                 }
18513                 ndr->depth--;
18514                 ndr_print_ptr(ndr, "share", r->in.share);
18515                 ndr->depth++;
18516                 if (r->in.share) {
18517                         ndr_print_string(ndr, "share", r->in.share);
18518                 }
18519                 ndr->depth--;
18520                 ndr_print_string(ndr, "file", r->in.file);
18521                 ndr_print_security_secinfo(ndr, "securityinformation", r->in.securityinformation);
18522                 ndr_print_ptr(ndr, "sd_buf", r->in.sd_buf);
18523                 ndr->depth++;
18524                 ndr_print_sec_desc_buf(ndr, "sd_buf", r->in.sd_buf);
18525                 ndr->depth--;
18526                 ndr->depth--;
18527         }
18528         if (flags & NDR_OUT) {
18529                 ndr_print_struct(ndr, "out", "srvsvc_NetSetFileSecurity");
18530                 ndr->depth++;
18531                 ndr_print_WERROR(ndr, "result", r->out.result);
18532                 ndr->depth--;
18533         }
18534         ndr->depth--;
18535 }
18536
18537 static enum ndr_err_code ndr_push_srvsvc_NetServerTransportAddEx(struct ndr_push *ndr, int flags, const struct srvsvc_NetServerTransportAddEx *r)
18538 {
18539         if (flags & NDR_IN) {
18540                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
18541                 if (r->in.server_unc) {
18542                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18543                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18544                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18545                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18546                 }
18547                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18548                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
18549                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
18550         }
18551         if (flags & NDR_OUT) {
18552                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18553         }
18554         return NDR_ERR_SUCCESS;
18555 }
18556
18557 static enum ndr_err_code ndr_pull_srvsvc_NetServerTransportAddEx(struct ndr_pull *ndr, int flags, struct srvsvc_NetServerTransportAddEx *r)
18558 {
18559         uint32_t _ptr_server_unc;
18560         TALLOC_CTX *_mem_save_server_unc_0;
18561         if (flags & NDR_IN) {
18562                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
18563                 if (_ptr_server_unc) {
18564                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
18565                 } else {
18566                         r->in.server_unc = NULL;
18567                 }
18568                 if (r->in.server_unc) {
18569                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
18570                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
18571                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
18572                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
18573                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
18574                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
18575                         }
18576                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
18577                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
18578                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
18579                 }
18580                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18581                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
18582                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
18583         }
18584         if (flags & NDR_OUT) {
18585                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18586         }
18587         return NDR_ERR_SUCCESS;
18588 }
18589
18590 _PUBLIC_ void ndr_print_srvsvc_NetServerTransportAddEx(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetServerTransportAddEx *r)
18591 {
18592         ndr_print_struct(ndr, name, "srvsvc_NetServerTransportAddEx");
18593         ndr->depth++;
18594         if (flags & NDR_SET_VALUES) {
18595                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18596         }
18597         if (flags & NDR_IN) {
18598                 ndr_print_struct(ndr, "in", "srvsvc_NetServerTransportAddEx");
18599                 ndr->depth++;
18600                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
18601                 ndr->depth++;
18602                 if (r->in.server_unc) {
18603                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
18604                 }
18605                 ndr->depth--;
18606                 ndr_print_uint32(ndr, "level", r->in.level);
18607                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
18608                 ndr_print_srvsvc_NetTransportInfo(ndr, "info", &r->in.info);
18609                 ndr->depth--;
18610         }
18611         if (flags & NDR_OUT) {
18612                 ndr_print_struct(ndr, "out", "srvsvc_NetServerTransportAddEx");
18613                 ndr->depth++;
18614                 ndr_print_WERROR(ndr, "result", r->out.result);
18615                 ndr->depth--;
18616         }
18617         ndr->depth--;
18618 }
18619
18620 static enum ndr_err_code ndr_push_srvsvc_NetServerSetServiceBitsEx(struct ndr_push *ndr, int flags, const struct srvsvc_NetServerSetServiceBitsEx *r)
18621 {
18622         if (flags & NDR_IN) {
18623                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
18624                 if (r->in.server_unc) {
18625                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18626                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18627                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18628                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18629                 }
18630                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.emulated_server_unc));
18631                 if (r->in.emulated_server_unc) {
18632                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.emulated_server_unc, CH_UTF16)));
18633                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18634                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.emulated_server_unc, CH_UTF16)));
18635                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.emulated_server_unc, ndr_charset_length(r->in.emulated_server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18636                 }
18637                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.transport));
18638                 if (r->in.transport) {
18639                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.transport, CH_UTF16)));
18640                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18641                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.transport, CH_UTF16)));
18642                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.transport, ndr_charset_length(r->in.transport, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18643                 }
18644                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.servicebitsofinterest));
18645                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.servicebits));
18646                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.updateimmediately));
18647         }
18648         if (flags & NDR_OUT) {
18649                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18650         }
18651         return NDR_ERR_SUCCESS;
18652 }
18653
18654 static enum ndr_err_code ndr_pull_srvsvc_NetServerSetServiceBitsEx(struct ndr_pull *ndr, int flags, struct srvsvc_NetServerSetServiceBitsEx *r)
18655 {
18656         uint32_t _ptr_server_unc;
18657         uint32_t _ptr_emulated_server_unc;
18658         uint32_t _ptr_transport;
18659         TALLOC_CTX *_mem_save_server_unc_0;
18660         TALLOC_CTX *_mem_save_emulated_server_unc_0;
18661         TALLOC_CTX *_mem_save_transport_0;
18662         if (flags & NDR_IN) {
18663                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
18664                 if (_ptr_server_unc) {
18665                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
18666                 } else {
18667                         r->in.server_unc = NULL;
18668                 }
18669                 if (r->in.server_unc) {
18670                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
18671                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
18672                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
18673                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
18674                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
18675                                 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_unc), ndr_get_array_length(ndr, &r->in.server_unc));
18676                         }
18677                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
18678                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));
18679                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
18680                 }
18681                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_emulated_server_unc));
18682                 if (_ptr_emulated_server_unc) {
18683                         NDR_PULL_ALLOC(ndr, r->in.emulated_server_unc);
18684                 } else {
18685                         r->in.emulated_server_unc = NULL;
18686                 }
18687                 if (r->in.emulated_server_unc) {
18688                         _mem_save_emulated_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
18689                         NDR_PULL_SET_MEM_CTX(ndr, r->in.emulated_server_unc, 0);
18690                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.emulated_server_unc));
18691                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.emulated_server_unc));
18692                         if (ndr_get_array_length(ndr, &r->in.emulated_server_unc) > ndr_get_array_size(ndr, &r->in.emulated_server_unc)) {
18693                                 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.emulated_server_unc), ndr_get_array_length(ndr, &r->in.emulated_server_unc));
18694                         }
18695                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.emulated_server_unc), sizeof(uint16_t)));
18696                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.emulated_server_unc, ndr_get_array_length(ndr, &r->in.emulated_server_unc), sizeof(uint16_t), CH_UTF16));
18697                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_emulated_server_unc_0, 0);
18698                 }
18699                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport));
18700                 if (_ptr_transport) {
18701                         NDR_PULL_ALLOC(ndr, r->in.transport);
18702                 } else {
18703                         r->in.transport = NULL;
18704                 }
18705                 if (r->in.transport) {
18706                         _mem_save_transport_0 = NDR_PULL_GET_MEM_CTX(ndr);
18707                         NDR_PULL_SET_MEM_CTX(ndr, r->in.transport, 0);
18708                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.transport));
18709                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.transport));
18710                         if (ndr_get_array_length(ndr, &r->in.transport) > ndr_get_array_size(ndr, &r->in.transport)) {
18711                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.transport), ndr_get_array_length(ndr, &r->in.transport));
18712                         }
18713                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.transport), sizeof(uint16_t)));
18714                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.transport, ndr_get_array_length(ndr, &r->in.transport), sizeof(uint16_t), CH_UTF16));
18715                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_0, 0);
18716                 }
18717                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.servicebitsofinterest));
18718                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.servicebits));
18719                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.updateimmediately));
18720         }
18721         if (flags & NDR_OUT) {
18722                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18723         }
18724         return NDR_ERR_SUCCESS;
18725 }
18726
18727 _PUBLIC_ void ndr_print_srvsvc_NetServerSetServiceBitsEx(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetServerSetServiceBitsEx *r)
18728 {
18729         ndr_print_struct(ndr, name, "srvsvc_NetServerSetServiceBitsEx");
18730         ndr->depth++;
18731         if (flags & NDR_SET_VALUES) {
18732                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18733         }
18734         if (flags & NDR_IN) {
18735                 ndr_print_struct(ndr, "in", "srvsvc_NetServerSetServiceBitsEx");
18736                 ndr->depth++;
18737                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
18738                 ndr->depth++;
18739                 if (r->in.server_unc) {
18740                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
18741                 }
18742                 ndr->depth--;
18743                 ndr_print_ptr(ndr, "emulated_server_unc", r->in.emulated_server_unc);
18744                 ndr->depth++;
18745                 if (r->in.emulated_server_unc) {
18746                         ndr_print_string(ndr, "emulated_server_unc", r->in.emulated_server_unc);
18747                 }
18748                 ndr->depth--;
18749                 ndr_print_ptr(ndr, "transport", r->in.transport);
18750                 ndr->depth++;
18751                 if (r->in.transport) {
18752                         ndr_print_string(ndr, "transport", r->in.transport);
18753                 }
18754                 ndr->depth--;
18755                 ndr_print_uint32(ndr, "servicebitsofinterest", r->in.servicebitsofinterest);
18756                 ndr_print_uint32(ndr, "servicebits", r->in.servicebits);
18757                 ndr_print_uint32(ndr, "updateimmediately", r->in.updateimmediately);
18758                 ndr->depth--;
18759         }
18760         if (flags & NDR_OUT) {
18761                 ndr_print_struct(ndr, "out", "srvsvc_NetServerSetServiceBitsEx");
18762                 ndr->depth++;
18763                 ndr_print_WERROR(ndr, "result", r->out.result);
18764                 ndr->depth--;
18765         }
18766         ndr->depth--;
18767 }
18768
18769 static enum ndr_err_code ndr_push_srvsvc_NETRDFSGETVERSION(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSGETVERSION *r)
18770 {
18771         if (flags & NDR_IN) {
18772         }
18773         if (flags & NDR_OUT) {
18774                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18775         }
18776         return NDR_ERR_SUCCESS;
18777 }
18778
18779 static enum ndr_err_code ndr_pull_srvsvc_NETRDFSGETVERSION(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSGETVERSION *r)
18780 {
18781         if (flags & NDR_IN) {
18782         }
18783         if (flags & NDR_OUT) {
18784                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18785         }
18786         return NDR_ERR_SUCCESS;
18787 }
18788
18789 _PUBLIC_ void ndr_print_srvsvc_NETRDFSGETVERSION(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSGETVERSION *r)
18790 {
18791         ndr_print_struct(ndr, name, "srvsvc_NETRDFSGETVERSION");
18792         ndr->depth++;
18793         if (flags & NDR_SET_VALUES) {
18794                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18795         }
18796         if (flags & NDR_IN) {
18797                 ndr_print_struct(ndr, "in", "srvsvc_NETRDFSGETVERSION");
18798                 ndr->depth++;
18799                 ndr->depth--;
18800         }
18801         if (flags & NDR_OUT) {
18802                 ndr_print_struct(ndr, "out", "srvsvc_NETRDFSGETVERSION");
18803                 ndr->depth++;
18804                 ndr_print_WERROR(ndr, "result", r->out.result);
18805                 ndr->depth--;
18806         }
18807         ndr->depth--;
18808 }
18809
18810 static enum ndr_err_code ndr_push_srvsvc_NETRDFSCREATELOCALPARTITION(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSCREATELOCALPARTITION *r)
18811 {
18812         if (flags & NDR_IN) {
18813         }
18814         if (flags & NDR_OUT) {
18815                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18816         }
18817         return NDR_ERR_SUCCESS;
18818 }
18819
18820 static enum ndr_err_code ndr_pull_srvsvc_NETRDFSCREATELOCALPARTITION(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSCREATELOCALPARTITION *r)
18821 {
18822         if (flags & NDR_IN) {
18823         }
18824         if (flags & NDR_OUT) {
18825                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18826         }
18827         return NDR_ERR_SUCCESS;
18828 }
18829
18830 _PUBLIC_ void ndr_print_srvsvc_NETRDFSCREATELOCALPARTITION(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSCREATELOCALPARTITION *r)
18831 {
18832         ndr_print_struct(ndr, name, "srvsvc_NETRDFSCREATELOCALPARTITION");
18833         ndr->depth++;
18834         if (flags & NDR_SET_VALUES) {
18835                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18836         }
18837         if (flags & NDR_IN) {
18838                 ndr_print_struct(ndr, "in", "srvsvc_NETRDFSCREATELOCALPARTITION");
18839                 ndr->depth++;
18840                 ndr->depth--;
18841         }
18842         if (flags & NDR_OUT) {
18843                 ndr_print_struct(ndr, "out", "srvsvc_NETRDFSCREATELOCALPARTITION");
18844                 ndr->depth++;
18845                 ndr_print_WERROR(ndr, "result", r->out.result);
18846                 ndr->depth--;
18847         }
18848         ndr->depth--;
18849 }
18850
18851 static enum ndr_err_code ndr_push_srvsvc_NETRDFSDELETELOCALPARTITION(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSDELETELOCALPARTITION *r)
18852 {
18853         if (flags & NDR_IN) {
18854         }
18855         if (flags & NDR_OUT) {
18856                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18857         }
18858         return NDR_ERR_SUCCESS;
18859 }
18860
18861 static enum ndr_err_code ndr_pull_srvsvc_NETRDFSDELETELOCALPARTITION(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSDELETELOCALPARTITION *r)
18862 {
18863         if (flags & NDR_IN) {
18864         }
18865         if (flags & NDR_OUT) {
18866                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18867         }
18868         return NDR_ERR_SUCCESS;
18869 }
18870
18871 _PUBLIC_ void ndr_print_srvsvc_NETRDFSDELETELOCALPARTITION(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSDELETELOCALPARTITION *r)
18872 {
18873         ndr_print_struct(ndr, name, "srvsvc_NETRDFSDELETELOCALPARTITION");
18874         ndr->depth++;
18875         if (flags & NDR_SET_VALUES) {
18876                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18877         }
18878         if (flags & NDR_IN) {
18879                 ndr_print_struct(ndr, "in", "srvsvc_NETRDFSDELETELOCALPARTITION");
18880                 ndr->depth++;
18881                 ndr->depth--;
18882         }
18883         if (flags & NDR_OUT) {
18884                 ndr_print_struct(ndr, "out", "srvsvc_NETRDFSDELETELOCALPARTITION");
18885                 ndr->depth++;
18886                 ndr_print_WERROR(ndr, "result", r->out.result);
18887                 ndr->depth--;
18888         }
18889         ndr->depth--;
18890 }
18891
18892 static enum ndr_err_code ndr_push_srvsvc_NETRDFSSETLOCALVOLUMESTATE(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *r)
18893 {
18894         if (flags & NDR_IN) {
18895         }
18896         if (flags & NDR_OUT) {
18897                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18898         }
18899         return NDR_ERR_SUCCESS;
18900 }
18901
18902 static enum ndr_err_code ndr_pull_srvsvc_NETRDFSSETLOCALVOLUMESTATE(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *r)
18903 {
18904         if (flags & NDR_IN) {
18905         }
18906         if (flags & NDR_OUT) {
18907                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18908         }
18909         return NDR_ERR_SUCCESS;
18910 }
18911
18912 _PUBLIC_ void ndr_print_srvsvc_NETRDFSSETLOCALVOLUMESTATE(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *r)
18913 {
18914         ndr_print_struct(ndr, name, "srvsvc_NETRDFSSETLOCALVOLUMESTATE");
18915         ndr->depth++;
18916         if (flags & NDR_SET_VALUES) {
18917                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18918         }
18919         if (flags & NDR_IN) {
18920                 ndr_print_struct(ndr, "in", "srvsvc_NETRDFSSETLOCALVOLUMESTATE");
18921                 ndr->depth++;
18922                 ndr->depth--;
18923         }
18924         if (flags & NDR_OUT) {
18925                 ndr_print_struct(ndr, "out", "srvsvc_NETRDFSSETLOCALVOLUMESTATE");
18926                 ndr->depth++;
18927                 ndr_print_WERROR(ndr, "result", r->out.result);
18928                 ndr->depth--;
18929         }
18930         ndr->depth--;
18931 }
18932
18933 static enum ndr_err_code ndr_push_srvsvc_NETRDFSSETSERVERINFO(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSSETSERVERINFO *r)
18934 {
18935         if (flags & NDR_IN) {
18936         }
18937         if (flags & NDR_OUT) {
18938                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18939         }
18940         return NDR_ERR_SUCCESS;
18941 }
18942
18943 static enum ndr_err_code ndr_pull_srvsvc_NETRDFSSETSERVERINFO(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSSETSERVERINFO *r)
18944 {
18945         if (flags & NDR_IN) {
18946         }
18947         if (flags & NDR_OUT) {
18948                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18949         }
18950         return NDR_ERR_SUCCESS;
18951 }
18952
18953 _PUBLIC_ void ndr_print_srvsvc_NETRDFSSETSERVERINFO(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSSETSERVERINFO *r)
18954 {
18955         ndr_print_struct(ndr, name, "srvsvc_NETRDFSSETSERVERINFO");
18956         ndr->depth++;
18957         if (flags & NDR_SET_VALUES) {
18958                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18959         }
18960         if (flags & NDR_IN) {
18961                 ndr_print_struct(ndr, "in", "srvsvc_NETRDFSSETSERVERINFO");
18962                 ndr->depth++;
18963                 ndr->depth--;
18964         }
18965         if (flags & NDR_OUT) {
18966                 ndr_print_struct(ndr, "out", "srvsvc_NETRDFSSETSERVERINFO");
18967                 ndr->depth++;
18968                 ndr_print_WERROR(ndr, "result", r->out.result);
18969                 ndr->depth--;
18970         }
18971         ndr->depth--;
18972 }
18973
18974 static enum ndr_err_code ndr_push_srvsvc_NETRDFSCREATEEXITPOINT(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSCREATEEXITPOINT *r)
18975 {
18976         if (flags & NDR_IN) {
18977         }
18978         if (flags & NDR_OUT) {
18979                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18980         }
18981         return NDR_ERR_SUCCESS;
18982 }
18983
18984 static enum ndr_err_code ndr_pull_srvsvc_NETRDFSCREATEEXITPOINT(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSCREATEEXITPOINT *r)
18985 {
18986         if (flags & NDR_IN) {
18987         }
18988         if (flags & NDR_OUT) {
18989                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18990         }
18991         return NDR_ERR_SUCCESS;
18992 }
18993
18994 _PUBLIC_ void ndr_print_srvsvc_NETRDFSCREATEEXITPOINT(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSCREATEEXITPOINT *r)
18995 {
18996         ndr_print_struct(ndr, name, "srvsvc_NETRDFSCREATEEXITPOINT");
18997         ndr->depth++;
18998         if (flags & NDR_SET_VALUES) {
18999                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19000         }
19001         if (flags & NDR_IN) {
19002                 ndr_print_struct(ndr, "in", "srvsvc_NETRDFSCREATEEXITPOINT");
19003                 ndr->depth++;
19004                 ndr->depth--;
19005         }
19006         if (flags & NDR_OUT) {
19007                 ndr_print_struct(ndr, "out", "srvsvc_NETRDFSCREATEEXITPOINT");
19008                 ndr->depth++;
19009                 ndr_print_WERROR(ndr, "result", r->out.result);
19010                 ndr->depth--;
19011         }
19012         ndr->depth--;
19013 }
19014
19015 static enum ndr_err_code ndr_push_srvsvc_NETRDFSDELETEEXITPOINT(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSDELETEEXITPOINT *r)
19016 {
19017         if (flags & NDR_IN) {
19018         }
19019         if (flags & NDR_OUT) {
19020                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19021         }
19022         return NDR_ERR_SUCCESS;
19023 }
19024
19025 static enum ndr_err_code ndr_pull_srvsvc_NETRDFSDELETEEXITPOINT(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSDELETEEXITPOINT *r)
19026 {
19027         if (flags & NDR_IN) {
19028         }
19029         if (flags & NDR_OUT) {
19030                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19031         }
19032         return NDR_ERR_SUCCESS;
19033 }
19034
19035 _PUBLIC_ void ndr_print_srvsvc_NETRDFSDELETEEXITPOINT(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSDELETEEXITPOINT *r)
19036 {
19037         ndr_print_struct(ndr, name, "srvsvc_NETRDFSDELETEEXITPOINT");
19038         ndr->depth++;
19039         if (flags & NDR_SET_VALUES) {
19040                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19041         }
19042         if (flags & NDR_IN) {
19043                 ndr_print_struct(ndr, "in", "srvsvc_NETRDFSDELETEEXITPOINT");
19044                 ndr->depth++;
19045                 ndr->depth--;
19046         }
19047         if (flags & NDR_OUT) {
19048                 ndr_print_struct(ndr, "out", "srvsvc_NETRDFSDELETEEXITPOINT");
19049                 ndr->depth++;
19050                 ndr_print_WERROR(ndr, "result", r->out.result);
19051                 ndr->depth--;
19052         }
19053         ndr->depth--;
19054 }
19055
19056 static enum ndr_err_code ndr_push_srvsvc_NETRDFSMODIFYPREFIX(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSMODIFYPREFIX *r)
19057 {
19058         if (flags & NDR_IN) {
19059         }
19060         if (flags & NDR_OUT) {
19061                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19062         }
19063         return NDR_ERR_SUCCESS;
19064 }
19065
19066 static enum ndr_err_code ndr_pull_srvsvc_NETRDFSMODIFYPREFIX(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSMODIFYPREFIX *r)
19067 {
19068         if (flags & NDR_IN) {
19069         }
19070         if (flags & NDR_OUT) {
19071                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19072         }
19073         return NDR_ERR_SUCCESS;
19074 }
19075
19076 _PUBLIC_ void ndr_print_srvsvc_NETRDFSMODIFYPREFIX(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSMODIFYPREFIX *r)
19077 {
19078         ndr_print_struct(ndr, name, "srvsvc_NETRDFSMODIFYPREFIX");
19079         ndr->depth++;
19080         if (flags & NDR_SET_VALUES) {
19081                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19082         }
19083         if (flags & NDR_IN) {
19084                 ndr_print_struct(ndr, "in", "srvsvc_NETRDFSMODIFYPREFIX");
19085                 ndr->depth++;
19086                 ndr->depth--;
19087         }
19088         if (flags & NDR_OUT) {
19089                 ndr_print_struct(ndr, "out", "srvsvc_NETRDFSMODIFYPREFIX");
19090                 ndr->depth++;
19091                 ndr_print_WERROR(ndr, "result", r->out.result);
19092                 ndr->depth--;
19093         }
19094         ndr->depth--;
19095 }
19096
19097 static enum ndr_err_code ndr_push_srvsvc_NETRDFSFIXLOCALVOLUME(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSFIXLOCALVOLUME *r)
19098 {
19099         if (flags & NDR_IN) {
19100         }
19101         if (flags & NDR_OUT) {
19102                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19103         }
19104         return NDR_ERR_SUCCESS;
19105 }
19106
19107 static enum ndr_err_code ndr_pull_srvsvc_NETRDFSFIXLOCALVOLUME(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSFIXLOCALVOLUME *r)
19108 {
19109         if (flags & NDR_IN) {
19110         }
19111         if (flags & NDR_OUT) {
19112                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19113         }
19114         return NDR_ERR_SUCCESS;
19115 }
19116
19117 _PUBLIC_ void ndr_print_srvsvc_NETRDFSFIXLOCALVOLUME(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSFIXLOCALVOLUME *r)
19118 {
19119         ndr_print_struct(ndr, name, "srvsvc_NETRDFSFIXLOCALVOLUME");
19120         ndr->depth++;
19121         if (flags & NDR_SET_VALUES) {
19122                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19123         }
19124         if (flags & NDR_IN) {
19125                 ndr_print_struct(ndr, "in", "srvsvc_NETRDFSFIXLOCALVOLUME");
19126                 ndr->depth++;
19127                 ndr->depth--;
19128         }
19129         if (flags & NDR_OUT) {
19130                 ndr_print_struct(ndr, "out", "srvsvc_NETRDFSFIXLOCALVOLUME");
19131                 ndr->depth++;
19132                 ndr_print_WERROR(ndr, "result", r->out.result);
19133                 ndr->depth--;
19134         }
19135         ndr->depth--;
19136 }
19137
19138 static enum ndr_err_code ndr_push_srvsvc_NETRDFSMANAGERREPORTSITEINFO(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *r)
19139 {
19140         if (flags & NDR_IN) {
19141         }
19142         if (flags & NDR_OUT) {
19143                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19144         }
19145         return NDR_ERR_SUCCESS;
19146 }
19147
19148 static enum ndr_err_code ndr_pull_srvsvc_NETRDFSMANAGERREPORTSITEINFO(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *r)
19149 {
19150         if (flags & NDR_IN) {
19151         }
19152         if (flags & NDR_OUT) {
19153                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19154         }
19155         return NDR_ERR_SUCCESS;
19156 }
19157
19158 _PUBLIC_ void ndr_print_srvsvc_NETRDFSMANAGERREPORTSITEINFO(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *r)
19159 {
19160         ndr_print_struct(ndr, name, "srvsvc_NETRDFSMANAGERREPORTSITEINFO");
19161         ndr->depth++;
19162         if (flags & NDR_SET_VALUES) {
19163                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19164         }
19165         if (flags & NDR_IN) {
19166                 ndr_print_struct(ndr, "in", "srvsvc_NETRDFSMANAGERREPORTSITEINFO");
19167                 ndr->depth++;
19168                 ndr->depth--;
19169         }
19170         if (flags & NDR_OUT) {
19171                 ndr_print_struct(ndr, "out", "srvsvc_NETRDFSMANAGERREPORTSITEINFO");
19172                 ndr->depth++;
19173                 ndr_print_WERROR(ndr, "result", r->out.result);
19174                 ndr->depth--;
19175         }
19176         ndr->depth--;
19177 }
19178
19179 static enum ndr_err_code ndr_push_srvsvc_NETRSERVERTRANSPORTDELEX(struct ndr_push *ndr, int flags, const struct srvsvc_NETRSERVERTRANSPORTDELEX *r)
19180 {
19181         if (flags & NDR_IN) {
19182         }
19183         if (flags & NDR_OUT) {
19184                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19185         }
19186         return NDR_ERR_SUCCESS;
19187 }
19188
19189 static enum ndr_err_code ndr_pull_srvsvc_NETRSERVERTRANSPORTDELEX(struct ndr_pull *ndr, int flags, struct srvsvc_NETRSERVERTRANSPORTDELEX *r)
19190 {
19191         if (flags & NDR_IN) {
19192         }
19193         if (flags & NDR_OUT) {
19194                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19195         }
19196         return NDR_ERR_SUCCESS;
19197 }
19198
19199 _PUBLIC_ void ndr_print_srvsvc_NETRSERVERTRANSPORTDELEX(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRSERVERTRANSPORTDELEX *r)
19200 {
19201         ndr_print_struct(ndr, name, "srvsvc_NETRSERVERTRANSPORTDELEX");
19202         ndr->depth++;
19203         if (flags & NDR_SET_VALUES) {
19204                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19205         }
19206         if (flags & NDR_IN) {
19207                 ndr_print_struct(ndr, "in", "srvsvc_NETRSERVERTRANSPORTDELEX");
19208                 ndr->depth++;
19209                 ndr->depth--;
19210         }
19211         if (flags & NDR_OUT) {
19212                 ndr_print_struct(ndr, "out", "srvsvc_NETRSERVERTRANSPORTDELEX");
19213                 ndr->depth++;
19214                 ndr_print_WERROR(ndr, "result", r->out.result);
19215                 ndr->depth--;
19216         }
19217         ndr->depth--;
19218 }
19219
19220 static const struct ndr_interface_call srvsvc_calls[] = {
19221         {
19222                 "srvsvc_NetCharDevEnum",
19223                 sizeof(struct srvsvc_NetCharDevEnum),
19224                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetCharDevEnum,
19225                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetCharDevEnum,
19226                 (ndr_print_function_t) ndr_print_srvsvc_NetCharDevEnum,
19227                 false,
19228         },
19229         {
19230                 "srvsvc_NetCharDevGetInfo",
19231                 sizeof(struct srvsvc_NetCharDevGetInfo),
19232                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetCharDevGetInfo,
19233                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetCharDevGetInfo,
19234                 (ndr_print_function_t) ndr_print_srvsvc_NetCharDevGetInfo,
19235                 false,
19236         },
19237         {
19238                 "srvsvc_NetCharDevControl",
19239                 sizeof(struct srvsvc_NetCharDevControl),
19240                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetCharDevControl,
19241                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetCharDevControl,
19242                 (ndr_print_function_t) ndr_print_srvsvc_NetCharDevControl,
19243                 false,
19244         },
19245         {
19246                 "srvsvc_NetCharDevQEnum",
19247                 sizeof(struct srvsvc_NetCharDevQEnum),
19248                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetCharDevQEnum,
19249                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetCharDevQEnum,
19250                 (ndr_print_function_t) ndr_print_srvsvc_NetCharDevQEnum,
19251                 false,
19252         },
19253         {
19254                 "srvsvc_NetCharDevQGetInfo",
19255                 sizeof(struct srvsvc_NetCharDevQGetInfo),
19256                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetCharDevQGetInfo,
19257                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetCharDevQGetInfo,
19258                 (ndr_print_function_t) ndr_print_srvsvc_NetCharDevQGetInfo,
19259                 false,
19260         },
19261         {
19262                 "srvsvc_NetCharDevQSetInfo",
19263                 sizeof(struct srvsvc_NetCharDevQSetInfo),
19264                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetCharDevQSetInfo,
19265                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetCharDevQSetInfo,
19266                 (ndr_print_function_t) ndr_print_srvsvc_NetCharDevQSetInfo,
19267                 false,
19268         },
19269         {
19270                 "srvsvc_NetCharDevQPurge",
19271                 sizeof(struct srvsvc_NetCharDevQPurge),
19272                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetCharDevQPurge,
19273                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetCharDevQPurge,
19274                 (ndr_print_function_t) ndr_print_srvsvc_NetCharDevQPurge,
19275                 false,
19276         },
19277         {
19278                 "srvsvc_NetCharDevQPurgeSelf",
19279                 sizeof(struct srvsvc_NetCharDevQPurgeSelf),
19280                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetCharDevQPurgeSelf,
19281                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetCharDevQPurgeSelf,
19282                 (ndr_print_function_t) ndr_print_srvsvc_NetCharDevQPurgeSelf,
19283                 false,
19284         },
19285         {
19286                 "srvsvc_NetConnEnum",
19287                 sizeof(struct srvsvc_NetConnEnum),
19288                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetConnEnum,
19289                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetConnEnum,
19290                 (ndr_print_function_t) ndr_print_srvsvc_NetConnEnum,
19291                 false,
19292         },
19293         {
19294                 "srvsvc_NetFileEnum",
19295                 sizeof(struct srvsvc_NetFileEnum),
19296                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetFileEnum,
19297                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetFileEnum,
19298                 (ndr_print_function_t) ndr_print_srvsvc_NetFileEnum,
19299                 false,
19300         },
19301         {
19302                 "srvsvc_NetFileGetInfo",
19303                 sizeof(struct srvsvc_NetFileGetInfo),
19304                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetFileGetInfo,
19305                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetFileGetInfo,
19306                 (ndr_print_function_t) ndr_print_srvsvc_NetFileGetInfo,
19307                 false,
19308         },
19309         {
19310                 "srvsvc_NetFileClose",
19311                 sizeof(struct srvsvc_NetFileClose),
19312                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetFileClose,
19313                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetFileClose,
19314                 (ndr_print_function_t) ndr_print_srvsvc_NetFileClose,
19315                 false,
19316         },
19317         {
19318                 "srvsvc_NetSessEnum",
19319                 sizeof(struct srvsvc_NetSessEnum),
19320                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetSessEnum,
19321                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetSessEnum,
19322                 (ndr_print_function_t) ndr_print_srvsvc_NetSessEnum,
19323                 false,
19324         },
19325         {
19326                 "srvsvc_NetSessDel",
19327                 sizeof(struct srvsvc_NetSessDel),
19328                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetSessDel,
19329                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetSessDel,
19330                 (ndr_print_function_t) ndr_print_srvsvc_NetSessDel,
19331                 false,
19332         },
19333         {
19334                 "srvsvc_NetShareAdd",
19335                 sizeof(struct srvsvc_NetShareAdd),
19336                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareAdd,
19337                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareAdd,
19338                 (ndr_print_function_t) ndr_print_srvsvc_NetShareAdd,
19339                 false,
19340         },
19341         {
19342                 "srvsvc_NetShareEnumAll",
19343                 sizeof(struct srvsvc_NetShareEnumAll),
19344                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareEnumAll,
19345                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareEnumAll,
19346                 (ndr_print_function_t) ndr_print_srvsvc_NetShareEnumAll,
19347                 false,
19348         },
19349         {
19350                 "srvsvc_NetShareGetInfo",
19351                 sizeof(struct srvsvc_NetShareGetInfo),
19352                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareGetInfo,
19353                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareGetInfo,
19354                 (ndr_print_function_t) ndr_print_srvsvc_NetShareGetInfo,
19355                 false,
19356         },
19357         {
19358                 "srvsvc_NetShareSetInfo",
19359                 sizeof(struct srvsvc_NetShareSetInfo),
19360                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareSetInfo,
19361                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareSetInfo,
19362                 (ndr_print_function_t) ndr_print_srvsvc_NetShareSetInfo,
19363                 false,
19364         },
19365         {
19366                 "srvsvc_NetShareDel",
19367                 sizeof(struct srvsvc_NetShareDel),
19368                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareDel,
19369                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareDel,
19370                 (ndr_print_function_t) ndr_print_srvsvc_NetShareDel,
19371                 false,
19372         },
19373         {
19374                 "srvsvc_NetShareDelSticky",
19375                 sizeof(struct srvsvc_NetShareDelSticky),
19376                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareDelSticky,
19377                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareDelSticky,
19378                 (ndr_print_function_t) ndr_print_srvsvc_NetShareDelSticky,
19379                 false,
19380         },
19381         {
19382                 "srvsvc_NetShareCheck",
19383                 sizeof(struct srvsvc_NetShareCheck),
19384                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareCheck,
19385                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareCheck,
19386                 (ndr_print_function_t) ndr_print_srvsvc_NetShareCheck,
19387                 false,
19388         },
19389         {
19390                 "srvsvc_NetSrvGetInfo",
19391                 sizeof(struct srvsvc_NetSrvGetInfo),
19392                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetSrvGetInfo,
19393                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetSrvGetInfo,
19394                 (ndr_print_function_t) ndr_print_srvsvc_NetSrvGetInfo,
19395                 false,
19396         },
19397         {
19398                 "srvsvc_NetSrvSetInfo",
19399                 sizeof(struct srvsvc_NetSrvSetInfo),
19400                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetSrvSetInfo,
19401                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetSrvSetInfo,
19402                 (ndr_print_function_t) ndr_print_srvsvc_NetSrvSetInfo,
19403                 false,
19404         },
19405         {
19406                 "srvsvc_NetDiskEnum",
19407                 sizeof(struct srvsvc_NetDiskEnum),
19408                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetDiskEnum,
19409                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetDiskEnum,
19410                 (ndr_print_function_t) ndr_print_srvsvc_NetDiskEnum,
19411                 false,
19412         },
19413         {
19414                 "srvsvc_NetServerStatisticsGet",
19415                 sizeof(struct srvsvc_NetServerStatisticsGet),
19416                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetServerStatisticsGet,
19417                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetServerStatisticsGet,
19418                 (ndr_print_function_t) ndr_print_srvsvc_NetServerStatisticsGet,
19419                 false,
19420         },
19421         {
19422                 "srvsvc_NetTransportAdd",
19423                 sizeof(struct srvsvc_NetTransportAdd),
19424                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetTransportAdd,
19425                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetTransportAdd,
19426                 (ndr_print_function_t) ndr_print_srvsvc_NetTransportAdd,
19427                 false,
19428         },
19429         {
19430                 "srvsvc_NetTransportEnum",
19431                 sizeof(struct srvsvc_NetTransportEnum),
19432                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetTransportEnum,
19433                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetTransportEnum,
19434                 (ndr_print_function_t) ndr_print_srvsvc_NetTransportEnum,
19435                 false,
19436         },
19437         {
19438                 "srvsvc_NetTransportDel",
19439                 sizeof(struct srvsvc_NetTransportDel),
19440                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetTransportDel,
19441                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetTransportDel,
19442                 (ndr_print_function_t) ndr_print_srvsvc_NetTransportDel,
19443                 false,
19444         },
19445         {
19446                 "srvsvc_NetRemoteTOD",
19447                 sizeof(struct srvsvc_NetRemoteTOD),
19448                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetRemoteTOD,
19449                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetRemoteTOD,
19450                 (ndr_print_function_t) ndr_print_srvsvc_NetRemoteTOD,
19451                 false,
19452         },
19453         {
19454                 "srvsvc_NetSetServiceBits",
19455                 sizeof(struct srvsvc_NetSetServiceBits),
19456                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetSetServiceBits,
19457                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetSetServiceBits,
19458                 (ndr_print_function_t) ndr_print_srvsvc_NetSetServiceBits,
19459                 false,
19460         },
19461         {
19462                 "srvsvc_NetPathType",
19463                 sizeof(struct srvsvc_NetPathType),
19464                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetPathType,
19465                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetPathType,
19466                 (ndr_print_function_t) ndr_print_srvsvc_NetPathType,
19467                 false,
19468         },
19469         {
19470                 "srvsvc_NetPathCanonicalize",
19471                 sizeof(struct srvsvc_NetPathCanonicalize),
19472                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetPathCanonicalize,
19473                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetPathCanonicalize,
19474                 (ndr_print_function_t) ndr_print_srvsvc_NetPathCanonicalize,
19475                 false,
19476         },
19477         {
19478                 "srvsvc_NetPathCompare",
19479                 sizeof(struct srvsvc_NetPathCompare),
19480                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetPathCompare,
19481                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetPathCompare,
19482                 (ndr_print_function_t) ndr_print_srvsvc_NetPathCompare,
19483                 false,
19484         },
19485         {
19486                 "srvsvc_NetNameValidate",
19487                 sizeof(struct srvsvc_NetNameValidate),
19488                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetNameValidate,
19489                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetNameValidate,
19490                 (ndr_print_function_t) ndr_print_srvsvc_NetNameValidate,
19491                 false,
19492         },
19493         {
19494                 "srvsvc_NETRPRNAMECANONICALIZE",
19495                 sizeof(struct srvsvc_NETRPRNAMECANONICALIZE),
19496                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRPRNAMECANONICALIZE,
19497                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRPRNAMECANONICALIZE,
19498                 (ndr_print_function_t) ndr_print_srvsvc_NETRPRNAMECANONICALIZE,
19499                 false,
19500         },
19501         {
19502                 "srvsvc_NetPRNameCompare",
19503                 sizeof(struct srvsvc_NetPRNameCompare),
19504                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetPRNameCompare,
19505                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetPRNameCompare,
19506                 (ndr_print_function_t) ndr_print_srvsvc_NetPRNameCompare,
19507                 false,
19508         },
19509         {
19510                 "srvsvc_NetShareEnum",
19511                 sizeof(struct srvsvc_NetShareEnum),
19512                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareEnum,
19513                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareEnum,
19514                 (ndr_print_function_t) ndr_print_srvsvc_NetShareEnum,
19515                 false,
19516         },
19517         {
19518                 "srvsvc_NetShareDelStart",
19519                 sizeof(struct srvsvc_NetShareDelStart),
19520                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareDelStart,
19521                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareDelStart,
19522                 (ndr_print_function_t) ndr_print_srvsvc_NetShareDelStart,
19523                 false,
19524         },
19525         {
19526                 "srvsvc_NetShareDelCommit",
19527                 sizeof(struct srvsvc_NetShareDelCommit),
19528                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareDelCommit,
19529                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareDelCommit,
19530                 (ndr_print_function_t) ndr_print_srvsvc_NetShareDelCommit,
19531                 false,
19532         },
19533         {
19534                 "srvsvc_NetGetFileSecurity",
19535                 sizeof(struct srvsvc_NetGetFileSecurity),
19536                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetGetFileSecurity,
19537                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetGetFileSecurity,
19538                 (ndr_print_function_t) ndr_print_srvsvc_NetGetFileSecurity,
19539                 false,
19540         },
19541         {
19542                 "srvsvc_NetSetFileSecurity",
19543                 sizeof(struct srvsvc_NetSetFileSecurity),
19544                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetSetFileSecurity,
19545                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetSetFileSecurity,
19546                 (ndr_print_function_t) ndr_print_srvsvc_NetSetFileSecurity,
19547                 false,
19548         },
19549         {
19550                 "srvsvc_NetServerTransportAddEx",
19551                 sizeof(struct srvsvc_NetServerTransportAddEx),
19552                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetServerTransportAddEx,
19553                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetServerTransportAddEx,
19554                 (ndr_print_function_t) ndr_print_srvsvc_NetServerTransportAddEx,
19555                 false,
19556         },
19557         {
19558                 "srvsvc_NetServerSetServiceBitsEx",
19559                 sizeof(struct srvsvc_NetServerSetServiceBitsEx),
19560                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetServerSetServiceBitsEx,
19561                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetServerSetServiceBitsEx,
19562                 (ndr_print_function_t) ndr_print_srvsvc_NetServerSetServiceBitsEx,
19563                 false,
19564         },
19565         {
19566                 "srvsvc_NETRDFSGETVERSION",
19567                 sizeof(struct srvsvc_NETRDFSGETVERSION),
19568                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSGETVERSION,
19569                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSGETVERSION,
19570                 (ndr_print_function_t) ndr_print_srvsvc_NETRDFSGETVERSION,
19571                 false,
19572         },
19573         {
19574                 "srvsvc_NETRDFSCREATELOCALPARTITION",
19575                 sizeof(struct srvsvc_NETRDFSCREATELOCALPARTITION),
19576                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSCREATELOCALPARTITION,
19577                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSCREATELOCALPARTITION,
19578                 (ndr_print_function_t) ndr_print_srvsvc_NETRDFSCREATELOCALPARTITION,
19579                 false,
19580         },
19581         {
19582                 "srvsvc_NETRDFSDELETELOCALPARTITION",
19583                 sizeof(struct srvsvc_NETRDFSDELETELOCALPARTITION),
19584                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSDELETELOCALPARTITION,
19585                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSDELETELOCALPARTITION,
19586                 (ndr_print_function_t) ndr_print_srvsvc_NETRDFSDELETELOCALPARTITION,
19587                 false,
19588         },
19589         {
19590                 "srvsvc_NETRDFSSETLOCALVOLUMESTATE",
19591                 sizeof(struct srvsvc_NETRDFSSETLOCALVOLUMESTATE),
19592                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSSETLOCALVOLUMESTATE,
19593                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSSETLOCALVOLUMESTATE,
19594                 (ndr_print_function_t) ndr_print_srvsvc_NETRDFSSETLOCALVOLUMESTATE,
19595                 false,
19596         },
19597         {
19598                 "srvsvc_NETRDFSSETSERVERINFO",
19599                 sizeof(struct srvsvc_NETRDFSSETSERVERINFO),
19600                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSSETSERVERINFO,
19601                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSSETSERVERINFO,
19602                 (ndr_print_function_t) ndr_print_srvsvc_NETRDFSSETSERVERINFO,
19603                 false,
19604         },
19605         {
19606                 "srvsvc_NETRDFSCREATEEXITPOINT",
19607                 sizeof(struct srvsvc_NETRDFSCREATEEXITPOINT),
19608                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSCREATEEXITPOINT,
19609                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSCREATEEXITPOINT,
19610                 (ndr_print_function_t) ndr_print_srvsvc_NETRDFSCREATEEXITPOINT,
19611                 false,
19612         },
19613         {
19614                 "srvsvc_NETRDFSDELETEEXITPOINT",
19615                 sizeof(struct srvsvc_NETRDFSDELETEEXITPOINT),
19616                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSDELETEEXITPOINT,
19617                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSDELETEEXITPOINT,
19618                 (ndr_print_function_t) ndr_print_srvsvc_NETRDFSDELETEEXITPOINT,
19619                 false,
19620         },
19621         {
19622                 "srvsvc_NETRDFSMODIFYPREFIX",
19623                 sizeof(struct srvsvc_NETRDFSMODIFYPREFIX),
19624                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSMODIFYPREFIX,
19625                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSMODIFYPREFIX,
19626                 (ndr_print_function_t) ndr_print_srvsvc_NETRDFSMODIFYPREFIX,
19627                 false,
19628         },
19629         {
19630                 "srvsvc_NETRDFSFIXLOCALVOLUME",
19631                 sizeof(struct srvsvc_NETRDFSFIXLOCALVOLUME),
19632                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSFIXLOCALVOLUME,
19633                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSFIXLOCALVOLUME,
19634                 (ndr_print_function_t) ndr_print_srvsvc_NETRDFSFIXLOCALVOLUME,
19635                 false,
19636         },
19637         {
19638                 "srvsvc_NETRDFSMANAGERREPORTSITEINFO",
19639                 sizeof(struct srvsvc_NETRDFSMANAGERREPORTSITEINFO),
19640                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSMANAGERREPORTSITEINFO,
19641                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSMANAGERREPORTSITEINFO,
19642                 (ndr_print_function_t) ndr_print_srvsvc_NETRDFSMANAGERREPORTSITEINFO,
19643                 false,
19644         },
19645         {
19646                 "srvsvc_NETRSERVERTRANSPORTDELEX",
19647                 sizeof(struct srvsvc_NETRSERVERTRANSPORTDELEX),
19648                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRSERVERTRANSPORTDELEX,
19649                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRSERVERTRANSPORTDELEX,
19650                 (ndr_print_function_t) ndr_print_srvsvc_NETRSERVERTRANSPORTDELEX,
19651                 false,
19652         },
19653         { NULL, 0, NULL, NULL, NULL, false }
19654 };
19655
19656 static const char * const srvsvc_endpoint_strings[] = {
19657         "ncacn_np:[\\pipe\\srvsvc]",
19658         "ncacn_ip_tcp:",
19659         "ncalrpc:",
19660 };
19661
19662 static const struct ndr_interface_string_array srvsvc_endpoints = {
19663         .count  = 3,
19664         .names  = srvsvc_endpoint_strings
19665 };
19666
19667 static const char * const srvsvc_authservice_strings[] = {
19668         "host",
19669 };
19670
19671 static const struct ndr_interface_string_array srvsvc_authservices = {
19672         .count  = 3,
19673         .names  = srvsvc_authservice_strings
19674 };
19675
19676
19677 const struct ndr_interface_table ndr_table_srvsvc = {
19678         .name           = "srvsvc",
19679         .syntax_id      = {
19680                 {0x4b324fc8,0x1670,0x01d3,{0x12,0x78},{0x5a,0x47,0xbf,0x6e,0xe1,0x88}},
19681                 NDR_SRVSVC_VERSION
19682         },
19683         .helpstring     = NDR_SRVSVC_HELPSTRING,
19684         .num_calls      = 54,
19685         .calls          = srvsvc_calls,
19686         .endpoints      = &srvsvc_endpoints,
19687         .authservices   = &srvsvc_authservices
19688 };
19689