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", (int)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", (int)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_NetCharDevInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevInfoCtr *r)
 616 {
 617         if (ndr_flags & NDR_SCALARS) {
 618                 NDR_CHECK(ndr_push_align(ndr, 4));
 619                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
 620                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
 621                 NDR_CHECK(ndr_push_srvsvc_NetCharDevCtr(ndr, NDR_SCALARS, &r->ctr));
 622         }
 623         if (ndr_flags & NDR_BUFFERS) {
 624                 NDR_CHECK(ndr_push_srvsvc_NetCharDevCtr(ndr, NDR_BUFFERS, &r->ctr));
 625         }
 626         return NDR_ERR_SUCCESS;
 627 }
 628
 629 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevInfoCtr *r)
 630 {
 631         if (ndr_flags & NDR_SCALARS) {
 632                 NDR_CHECK(ndr_pull_align(ndr, 4));
 633                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
 634                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
 635                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevCtr(ndr, NDR_SCALARS, &r->ctr));
 636         }
 637         if (ndr_flags & NDR_BUFFERS) {
 638                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevCtr(ndr, NDR_BUFFERS, &r->ctr));
 639         }
 640         return NDR_ERR_SUCCESS;
 641 }
 642
 643 _PUBLIC_ void ndr_print_srvsvc_NetCharDevInfoCtr(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevInfoCtr *r)
 644 {
 645         ndr_print_struct(ndr, name, "srvsvc_NetCharDevInfoCtr");
 646         ndr->depth++;
 647         ndr_print_uint32(ndr, "level", r->level);
 648         ndr_print_set_switch_value(ndr, &r->ctr, r->level);
 649         ndr_print_srvsvc_NetCharDevCtr(ndr, "ctr", &r->ctr);
 650         ndr->depth--;
 651 }
 652
 653 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQInfo0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevQInfo0 *r)
 654 {
 655         if (ndr_flags & NDR_SCALARS) {
 656                 NDR_CHECK(ndr_push_align(ndr, 4));
 657                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->device));
 658         }
 659         if (ndr_flags & NDR_BUFFERS) {
 660                 if (r->device) {
 661                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->device, CH_UTF16)));
 662                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 663                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->device, CH_UTF16)));
 664                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device, ndr_charset_length(r->device, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 665                 }
 666         }
 667         return NDR_ERR_SUCCESS;
 668 }
 669
 670 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQInfo0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevQInfo0 *r)
 671 {
 672         uint32_t _ptr_device;
 673         TALLOC_CTX *_mem_save_device_0;
 674         if (ndr_flags & NDR_SCALARS) {
 675                 NDR_CHECK(ndr_pull_align(ndr, 4));
 676                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_device));
 677                 if (_ptr_device) {
 678                         NDR_PULL_ALLOC(ndr, r->device);
 679                 } else {
 680                         r->device = NULL;
 681                 }
 682         }
 683         if (ndr_flags & NDR_BUFFERS) {
 684                 if (r->device) {
 685                         _mem_save_device_0 = NDR_PULL_GET_MEM_CTX(ndr);
 686                         NDR_PULL_SET_MEM_CTX(ndr, r->device, 0);
 687                         NDR_CHECK(ndr_pull_array_size(ndr, &r->device));
 688                         NDR_CHECK(ndr_pull_array_length(ndr, &r->device));
 689                         if (ndr_get_array_length(ndr, &r->device) > ndr_get_array_size(ndr, &r->device)) {
 690                                 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));
 691                         }
 692                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->device), sizeof(uint16_t)));
 693                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device, ndr_get_array_length(ndr, &r->device), sizeof(uint16_t), CH_UTF16));
 694                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_device_0, 0);
 695                 }
 696         }
 697         return NDR_ERR_SUCCESS;
 698 }
 699
 700 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQInfo0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevQInfo0 *r)
 701 {
 702         ndr_print_struct(ndr, name, "srvsvc_NetCharDevQInfo0");
 703         ndr->depth++;
 704         ndr_print_ptr(ndr, "device", r->device);
 705         ndr->depth++;
 706         if (r->device) {
 707                 ndr_print_string(ndr, "device", r->device);
 708         }
 709         ndr->depth--;
 710         ndr->depth--;
 711 }
 712
 713 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQCtr0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevQCtr0 *r)
 714 {
 715         uint32_t cntr_array_1;
 716         if (ndr_flags & NDR_SCALARS) {
 717                 NDR_CHECK(ndr_push_align(ndr, 4));
 718                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 719                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
 720         }
 721         if (ndr_flags & NDR_BUFFERS) {
 722                 if (r->array) {
 723                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 724                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
 725                                 NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
 726                         }
 727                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
 728                                 NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
 729                         }
 730                 }
 731         }
 732         return NDR_ERR_SUCCESS;
 733 }
 734
 735 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQCtr0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevQCtr0 *r)
 736 {
 737         uint32_t _ptr_array;
 738         uint32_t cntr_array_1;
 739         TALLOC_CTX *_mem_save_array_0;
 740         TALLOC_CTX *_mem_save_array_1;
 741         if (ndr_flags & NDR_SCALARS) {
 742                 NDR_CHECK(ndr_pull_align(ndr, 4));
 743                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 744                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
 745                 if (_ptr_array) {
 746                         NDR_PULL_ALLOC(ndr, r->array);
 747                 } else {
 748                         r->array = NULL;
 749                 }
 750         }
 751         if (ndr_flags & NDR_BUFFERS) {
 752                 if (r->array) {
 753                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
 754                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
 755                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
 756                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
 757                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
 758                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
 759                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
 760                                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
 761                         }
 762                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
 763                                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
 764                         }
 765                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
 766                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
 767                 }
 768                 if (r->array) {
 769                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
 770                 }
 771         }
 772         return NDR_ERR_SUCCESS;
 773 }
 774
 775 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQCtr0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevQCtr0 *r)
 776 {
 777         uint32_t cntr_array_1;
 778         ndr_print_struct(ndr, name, "srvsvc_NetCharDevQCtr0");
 779         ndr->depth++;
 780         ndr_print_uint32(ndr, "count", r->count);
 781         ndr_print_ptr(ndr, "array", r->array);
 782         ndr->depth++;
 783         if (r->array) {
 784                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
 785                 ndr->depth++;
 786                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
 787                         char *idx_1=NULL;
 788                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
 789                                 ndr_print_srvsvc_NetCharDevQInfo0(ndr, "array", &r->array[cntr_array_1]);
 790                                 free(idx_1);
 791                         }
 792                 }
 793                 ndr->depth--;
 794         }
 795         ndr->depth--;
 796         ndr->depth--;
 797 }
 798
 799 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQInfo1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevQInfo1 *r)
 800 {
 801         if (ndr_flags & NDR_SCALARS) {
 802                 NDR_CHECK(ndr_push_align(ndr, 4));
 803                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->device));
 804                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
 805                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devices));
 806                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->users));
 807                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_ahead));
 808         }
 809         if (ndr_flags & NDR_BUFFERS) {
 810                 if (r->device) {
 811                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->device, CH_UTF16)));
 812                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 813                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->device, CH_UTF16)));
 814                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device, ndr_charset_length(r->device, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 815                 }
 816                 if (r->devices) {
 817                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->devices, CH_UTF16)));
 818                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 819                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->devices, CH_UTF16)));
 820                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->devices, ndr_charset_length(r->devices, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 821                 }
 822         }
 823         return NDR_ERR_SUCCESS;
 824 }
 825
 826 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQInfo1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevQInfo1 *r)
 827 {
 828         uint32_t _ptr_device;
 829         TALLOC_CTX *_mem_save_device_0;
 830         uint32_t _ptr_devices;
 831         TALLOC_CTX *_mem_save_devices_0;
 832         if (ndr_flags & NDR_SCALARS) {
 833                 NDR_CHECK(ndr_pull_align(ndr, 4));
 834                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_device));
 835                 if (_ptr_device) {
 836                         NDR_PULL_ALLOC(ndr, r->device);
 837                 } else {
 838                         r->device = NULL;
 839                 }
 840                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
 841                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devices));
 842                 if (_ptr_devices) {
 843                         NDR_PULL_ALLOC(ndr, r->devices);
 844                 } else {
 845                         r->devices = NULL;
 846                 }
 847                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->users));
 848                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_ahead));
 849         }
 850         if (ndr_flags & NDR_BUFFERS) {
 851                 if (r->device) {
 852                         _mem_save_device_0 = NDR_PULL_GET_MEM_CTX(ndr);
 853                         NDR_PULL_SET_MEM_CTX(ndr, r->device, 0);
 854                         NDR_CHECK(ndr_pull_array_size(ndr, &r->device));
 855                         NDR_CHECK(ndr_pull_array_length(ndr, &r->device));
 856                         if (ndr_get_array_length(ndr, &r->device) > ndr_get_array_size(ndr, &r->device)) {
 857                                 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));
 858                         }
 859                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->device), sizeof(uint16_t)));
 860                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device, ndr_get_array_length(ndr, &r->device), sizeof(uint16_t), CH_UTF16));
 861                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_device_0, 0);
 862                 }
 863                 if (r->devices) {
 864                         _mem_save_devices_0 = NDR_PULL_GET_MEM_CTX(ndr);
 865                         NDR_PULL_SET_MEM_CTX(ndr, r->devices, 0);
 866                         NDR_CHECK(ndr_pull_array_size(ndr, &r->devices));
 867                         NDR_CHECK(ndr_pull_array_length(ndr, &r->devices));
 868                         if (ndr_get_array_length(ndr, &r->devices) > ndr_get_array_size(ndr, &r->devices)) {
 869                                 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));
 870                         }
 871                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->devices), sizeof(uint16_t)));
 872                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->devices, ndr_get_array_length(ndr, &r->devices), sizeof(uint16_t), CH_UTF16));
 873                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devices_0, 0);
 874                 }
 875         }
 876         return NDR_ERR_SUCCESS;
 877 }
 878
 879 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQInfo1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevQInfo1 *r)
 880 {
 881         ndr_print_struct(ndr, name, "srvsvc_NetCharDevQInfo1");
 882         ndr->depth++;
 883         ndr_print_ptr(ndr, "device", r->device);
 884         ndr->depth++;
 885         if (r->device) {
 886                 ndr_print_string(ndr, "device", r->device);
 887         }
 888         ndr->depth--;
 889         ndr_print_uint32(ndr, "priority", r->priority);
 890         ndr_print_ptr(ndr, "devices", r->devices);
 891         ndr->depth++;
 892         if (r->devices) {
 893                 ndr_print_string(ndr, "devices", r->devices);
 894         }
 895         ndr->depth--;
 896         ndr_print_uint32(ndr, "users", r->users);
 897         ndr_print_uint32(ndr, "num_ahead", r->num_ahead);
 898         ndr->depth--;
 899 }
 900
 901 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQCtr1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevQCtr1 *r)
 902 {
 903         uint32_t cntr_array_1;
 904         if (ndr_flags & NDR_SCALARS) {
 905                 NDR_CHECK(ndr_push_align(ndr, 4));
 906                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 907                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
 908         }
 909         if (ndr_flags & NDR_BUFFERS) {
 910                 if (r->array) {
 911                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 912                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
 913                                 NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
 914                         }
 915                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
 916                                 NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
 917                         }
 918                 }
 919         }
 920         return NDR_ERR_SUCCESS;
 921 }
 922
 923 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQCtr1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevQCtr1 *r)
 924 {
 925         uint32_t _ptr_array;
 926         uint32_t cntr_array_1;
 927         TALLOC_CTX *_mem_save_array_0;
 928         TALLOC_CTX *_mem_save_array_1;
 929         if (ndr_flags & NDR_SCALARS) {
 930                 NDR_CHECK(ndr_pull_align(ndr, 4));
 931                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 932                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
 933                 if (_ptr_array) {
 934                         NDR_PULL_ALLOC(ndr, r->array);
 935                 } else {
 936                         r->array = NULL;
 937                 }
 938         }
 939         if (ndr_flags & NDR_BUFFERS) {
 940                 if (r->array) {
 941                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
 942                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
 943                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
 944                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
 945                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
 946                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
 947                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
 948                                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
 949                         }
 950                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
 951                                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
 952                         }
 953                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
 954                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
 955                 }
 956                 if (r->array) {
 957                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
 958                 }
 959         }
 960         return NDR_ERR_SUCCESS;
 961 }
 962
 963 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQCtr1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevQCtr1 *r)
 964 {
 965         uint32_t cntr_array_1;
 966         ndr_print_struct(ndr, name, "srvsvc_NetCharDevQCtr1");
 967         ndr->depth++;
 968         ndr_print_uint32(ndr, "count", r->count);
 969         ndr_print_ptr(ndr, "array", r->array);
 970         ndr->depth++;
 971         if (r->array) {
 972                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
 973                 ndr->depth++;
 974                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
 975                         char *idx_1=NULL;
 976                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
 977                                 ndr_print_srvsvc_NetCharDevQInfo1(ndr, "array", &r->array[cntr_array_1]);
 978                                 free(idx_1);
 979                         }
 980                 }
 981                 ndr->depth--;
 982         }
 983         ndr->depth--;
 984         ndr->depth--;
 985 }
 986
 987 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQInfo(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetCharDevQInfo *r)
 988 {
 989         if (ndr_flags & NDR_SCALARS) {
 990                 int level = ndr_push_get_switch_value(ndr, r);
 991                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
 992                 switch (level) {
 993                         case 0: {
 994                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
 995                         break; }
 996
 997                         case 1: {
 998                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
 999                         break; }
1000
1001                         default: {
1002                         break; }
1003
1004                 }
1005         }
1006         if (ndr_flags & NDR_BUFFERS) {
1007                 int level = ndr_push_get_switch_value(ndr, r);
1008                 switch (level) {
1009                         case 0:
1010                                 if (r->info0) {
1011                                         NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
1012                                 }
1013                         break;
1014
1015                         case 1:
1016                                 if (r->info1) {
1017                                         NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
1018                                 }
1019                         break;
1020
1021                         default:
1022                         break;
1023
1024                 }
1025         }
1026         return NDR_ERR_SUCCESS;
1027 }
1028
1029 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQInfo(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetCharDevQInfo *r)
1030 {
1031         int level;
1032         uint32_t _level;
1033         TALLOC_CTX *_mem_save_info0_0;
1034         TALLOC_CTX *_mem_save_info1_0;
1035         level = ndr_pull_get_switch_value(ndr, r);
1036         if (ndr_flags & NDR_SCALARS) {
1037                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
1038                 if (_level != level) {
1039                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1040                 }
1041                 switch (level) {
1042                         case 0: {
1043                                 uint32_t _ptr_info0;
1044                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
1045                                 if (_ptr_info0) {
1046                                         NDR_PULL_ALLOC(ndr, r->info0);
1047                                 } else {
1048                                         r->info0 = NULL;
1049                                 }
1050                         break; }
1051
1052                         case 1: {
1053                                 uint32_t _ptr_info1;
1054                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
1055                                 if (_ptr_info1) {
1056                                         NDR_PULL_ALLOC(ndr, r->info1);
1057                                 } else {
1058                                         r->info1 = NULL;
1059                                 }
1060                         break; }
1061
1062                         default: {
1063                         break; }
1064
1065                 }
1066         }
1067         if (ndr_flags & NDR_BUFFERS) {
1068                 switch (level) {
1069                         case 0:
1070                                 if (r->info0) {
1071                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
1072                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
1073                                         NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
1074                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
1075                                 }
1076                         break;
1077
1078                         case 1:
1079                                 if (r->info1) {
1080                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
1081                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
1082                                         NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
1083                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
1084                                 }
1085                         break;
1086
1087                         default:
1088                         break;
1089
1090                 }
1091         }
1092         return NDR_ERR_SUCCESS;
1093 }
1094
1095 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQInfo(struct ndr_print *ndr, const char *name, const union srvsvc_NetCharDevQInfo *r)
1096 {
1097         int level;
1098         level = ndr_print_get_switch_value(ndr, r);
1099         ndr_print_union(ndr, name, level, "srvsvc_NetCharDevQInfo");
1100         switch (level) {
1101                 case 0:
1102                         ndr_print_ptr(ndr, "info0", r->info0);
1103                         ndr->depth++;
1104                         if (r->info0) {
1105                                 ndr_print_srvsvc_NetCharDevQInfo0(ndr, "info0", r->info0);
1106                         }
1107                         ndr->depth--;
1108                 break;
1109
1110                 case 1:
1111                         ndr_print_ptr(ndr, "info1", r->info1);
1112                         ndr->depth++;
1113                         if (r->info1) {
1114                                 ndr_print_srvsvc_NetCharDevQInfo1(ndr, "info1", r->info1);
1115                         }
1116                         ndr->depth--;
1117                 break;
1118
1119                 default:
1120                 break;
1121
1122         }
1123 }
1124
1125 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQCtr(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetCharDevQCtr *r)
1126 {
1127         if (ndr_flags & NDR_SCALARS) {
1128                 int level = ndr_push_get_switch_value(ndr, r);
1129                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
1130                 switch (level) {
1131                         case 0: {
1132                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
1133                         break; }
1134
1135                         case 1: {
1136                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
1137                         break; }
1138
1139                         default: {
1140                         break; }
1141
1142                 }
1143         }
1144         if (ndr_flags & NDR_BUFFERS) {
1145                 int level = ndr_push_get_switch_value(ndr, r);
1146                 switch (level) {
1147                         case 0:
1148                                 if (r->ctr0) {
1149                                         NDR_CHECK(ndr_push_srvsvc_NetCharDevQCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
1150                                 }
1151                         break;
1152
1153                         case 1:
1154                                 if (r->ctr1) {
1155                                         NDR_CHECK(ndr_push_srvsvc_NetCharDevQCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
1156                                 }
1157                         break;
1158
1159                         default:
1160                         break;
1161
1162                 }
1163         }
1164         return NDR_ERR_SUCCESS;
1165 }
1166
1167 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQCtr(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetCharDevQCtr *r)
1168 {
1169         int level;
1170         uint32_t _level;
1171         TALLOC_CTX *_mem_save_ctr0_0;
1172         TALLOC_CTX *_mem_save_ctr1_0;
1173         level = ndr_pull_get_switch_value(ndr, r);
1174         if (ndr_flags & NDR_SCALARS) {
1175                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
1176                 if (_level != level) {
1177                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1178                 }
1179                 switch (level) {
1180                         case 0: {
1181                                 uint32_t _ptr_ctr0;
1182                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));
1183                                 if (_ptr_ctr0) {
1184                                         NDR_PULL_ALLOC(ndr, r->ctr0);
1185                                 } else {
1186                                         r->ctr0 = NULL;
1187                                 }
1188                         break; }
1189
1190                         case 1: {
1191                                 uint32_t _ptr_ctr1;
1192                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
1193                                 if (_ptr_ctr1) {
1194                                         NDR_PULL_ALLOC(ndr, r->ctr1);
1195                                 } else {
1196                                         r->ctr1 = NULL;
1197                                 }
1198                         break; }
1199
1200                         default: {
1201                         break; }
1202
1203                 }
1204         }
1205         if (ndr_flags & NDR_BUFFERS) {
1206                 switch (level) {
1207                         case 0:
1208                                 if (r->ctr0) {
1209                                         _mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);
1210                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr0, 0);
1211                                         NDR_CHECK(ndr_pull_srvsvc_NetCharDevQCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
1212                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);
1213                                 }
1214                         break;
1215
1216                         case 1:
1217                                 if (r->ctr1) {
1218                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
1219                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
1220                                         NDR_CHECK(ndr_pull_srvsvc_NetCharDevQCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
1221                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
1222                                 }
1223                         break;
1224
1225                         default:
1226                         break;
1227
1228                 }
1229         }
1230         return NDR_ERR_SUCCESS;
1231 }
1232
1233 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQCtr(struct ndr_print *ndr, const char *name, const union srvsvc_NetCharDevQCtr *r)
1234 {
1235         int level;
1236         level = ndr_print_get_switch_value(ndr, r);
1237         ndr_print_union(ndr, name, level, "srvsvc_NetCharDevQCtr");
1238         switch (level) {
1239                 case 0:
1240                         ndr_print_ptr(ndr, "ctr0", r->ctr0);
1241                         ndr->depth++;
1242                         if (r->ctr0) {
1243                                 ndr_print_srvsvc_NetCharDevQCtr0(ndr, "ctr0", r->ctr0);
1244                         }
1245                         ndr->depth--;
1246                 break;
1247
1248                 case 1:
1249                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
1250                         ndr->depth++;
1251                         if (r->ctr1) {
1252                                 ndr_print_srvsvc_NetCharDevQCtr1(ndr, "ctr1", r->ctr1);
1253                         }
1254                         ndr->depth--;
1255                 break;
1256
1257                 default:
1258                 break;
1259
1260         }
1261 }
1262
1263 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevQInfoCtr *r)
1264 {
1265         if (ndr_flags & NDR_SCALARS) {
1266                 NDR_CHECK(ndr_push_align(ndr, 4));
1267                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
1268                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
1269                 NDR_CHECK(ndr_push_srvsvc_NetCharDevQCtr(ndr, NDR_SCALARS, &r->ctr));
1270         }
1271         if (ndr_flags & NDR_BUFFERS) {
1272                 NDR_CHECK(ndr_push_srvsvc_NetCharDevQCtr(ndr, NDR_BUFFERS, &r->ctr));
1273         }
1274         return NDR_ERR_SUCCESS;
1275 }
1276
1277 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevQInfoCtr *r)
1278 {
1279         if (ndr_flags & NDR_SCALARS) {
1280                 NDR_CHECK(ndr_pull_align(ndr, 4));
1281                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
1282                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
1283                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevQCtr(ndr, NDR_SCALARS, &r->ctr));
1284         }
1285         if (ndr_flags & NDR_BUFFERS) {
1286                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevQCtr(ndr, NDR_BUFFERS, &r->ctr));
1287         }
1288         return NDR_ERR_SUCCESS;
1289 }
1290
1291 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQInfoCtr(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevQInfoCtr *r)
1292 {
1293         ndr_print_struct(ndr, name, "srvsvc_NetCharDevQInfoCtr");
1294         ndr->depth++;
1295         ndr_print_uint32(ndr, "level", r->level);
1296         ndr_print_set_switch_value(ndr, &r->ctr, r->level);
1297         ndr_print_srvsvc_NetCharDevQCtr(ndr, "ctr", &r->ctr);
1298         ndr->depth--;
1299 }
1300
1301 static enum ndr_err_code ndr_push_srvsvc_NetConnInfo0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetConnInfo0 *r)
1302 {
1303         if (ndr_flags & NDR_SCALARS) {
1304                 NDR_CHECK(ndr_push_align(ndr, 4));
1305                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->conn_id));
1306         }
1307         if (ndr_flags & NDR_BUFFERS) {
1308         }
1309         return NDR_ERR_SUCCESS;
1310 }
1311
1312 static enum ndr_err_code ndr_pull_srvsvc_NetConnInfo0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetConnInfo0 *r)
1313 {
1314         if (ndr_flags & NDR_SCALARS) {
1315                 NDR_CHECK(ndr_pull_align(ndr, 4));
1316                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->conn_id));
1317         }
1318         if (ndr_flags & NDR_BUFFERS) {
1319         }
1320         return NDR_ERR_SUCCESS;
1321 }
1322
1323 _PUBLIC_ void ndr_print_srvsvc_NetConnInfo0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetConnInfo0 *r)
1324 {
1325         ndr_print_struct(ndr, name, "srvsvc_NetConnInfo0");
1326         ndr->depth++;
1327         ndr_print_uint32(ndr, "conn_id", r->conn_id);
1328         ndr->depth--;
1329 }
1330
1331 static enum ndr_err_code ndr_push_srvsvc_NetConnCtr0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetConnCtr0 *r)
1332 {
1333         uint32_t cntr_array_1;
1334         if (ndr_flags & NDR_SCALARS) {
1335                 NDR_CHECK(ndr_push_align(ndr, 4));
1336                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1337                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
1338         }
1339         if (ndr_flags & NDR_BUFFERS) {
1340                 if (r->array) {
1341                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1342                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
1343                                 NDR_CHECK(ndr_push_srvsvc_NetConnInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
1344                         }
1345                 }
1346         }
1347         return NDR_ERR_SUCCESS;
1348 }
1349
1350 static enum ndr_err_code ndr_pull_srvsvc_NetConnCtr0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetConnCtr0 *r)
1351 {
1352         uint32_t _ptr_array;
1353         uint32_t cntr_array_1;
1354         TALLOC_CTX *_mem_save_array_0;
1355         TALLOC_CTX *_mem_save_array_1;
1356         if (ndr_flags & NDR_SCALARS) {
1357                 NDR_CHECK(ndr_pull_align(ndr, 4));
1358                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1359                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
1360                 if (_ptr_array) {
1361                         NDR_PULL_ALLOC(ndr, r->array);
1362                 } else {
1363                         r->array = NULL;
1364                 }
1365         }
1366         if (ndr_flags & NDR_BUFFERS) {
1367                 if (r->array) {
1368                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
1369                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
1370                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
1371                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
1372                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
1373                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
1374                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
1375                                 NDR_CHECK(ndr_pull_srvsvc_NetConnInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
1376                         }
1377                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
1378                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
1379                 }
1380                 if (r->array) {
1381                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
1382                 }
1383         }
1384         return NDR_ERR_SUCCESS;
1385 }
1386
1387 _PUBLIC_ void ndr_print_srvsvc_NetConnCtr0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetConnCtr0 *r)
1388 {
1389         uint32_t cntr_array_1;
1390         ndr_print_struct(ndr, name, "srvsvc_NetConnCtr0");
1391         ndr->depth++;
1392         ndr_print_uint32(ndr, "count", r->count);
1393         ndr_print_ptr(ndr, "array", r->array);
1394         ndr->depth++;
1395         if (r->array) {
1396                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
1397                 ndr->depth++;
1398                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
1399                         char *idx_1=NULL;
1400                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
1401                                 ndr_print_srvsvc_NetConnInfo0(ndr, "array", &r->array[cntr_array_1]);
1402                                 free(idx_1);
1403                         }
1404                 }
1405                 ndr->depth--;
1406         }
1407         ndr->depth--;
1408         ndr->depth--;
1409 }
1410
1411 static enum ndr_err_code ndr_push_srvsvc_NetConnInfo1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetConnInfo1 *r)
1412 {
1413         if (ndr_flags & NDR_SCALARS) {
1414                 NDR_CHECK(ndr_push_align(ndr, 4));
1415                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->conn_id));
1416                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->conn_type));
1417                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_open));
1418                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_users));
1419                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->conn_time));
1420                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
1421                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->share));
1422         }
1423         if (ndr_flags & NDR_BUFFERS) {
1424                 if (r->user) {
1425                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
1426                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1427                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
1428                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
1429                 }
1430                 if (r->share) {
1431                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->share, CH_UTF16)));
1432                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1433                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->share, CH_UTF16)));
1434                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->share, ndr_charset_length(r->share, CH_UTF16), sizeof(uint16_t), CH_UTF16));
1435                 }
1436         }
1437         return NDR_ERR_SUCCESS;
1438 }
1439
1440 static enum ndr_err_code ndr_pull_srvsvc_NetConnInfo1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetConnInfo1 *r)
1441 {
1442         uint32_t _ptr_user;
1443         TALLOC_CTX *_mem_save_user_0;
1444         uint32_t _ptr_share;
1445         TALLOC_CTX *_mem_save_share_0;
1446         if (ndr_flags & NDR_SCALARS) {
1447                 NDR_CHECK(ndr_pull_align(ndr, 4));
1448                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->conn_id));
1449                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->conn_type));
1450                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_open));
1451                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_users));
1452                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->conn_time));
1453                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
1454                 if (_ptr_user) {
1455                         NDR_PULL_ALLOC(ndr, r->user);
1456                 } else {
1457                         r->user = NULL;
1458                 }
1459                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_share));
1460                 if (_ptr_share) {
1461                         NDR_PULL_ALLOC(ndr, r->share);
1462                 } else {
1463                         r->share = NULL;
1464                 }
1465         }
1466         if (ndr_flags & NDR_BUFFERS) {
1467                 if (r->user) {
1468                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
1469                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
1470                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
1471                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
1472                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
1473                                 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));
1474                         }
1475                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
1476                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
1477                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
1478                 }
1479                 if (r->share) {
1480                         _mem_save_share_0 = NDR_PULL_GET_MEM_CTX(ndr);
1481                         NDR_PULL_SET_MEM_CTX(ndr, r->share, 0);
1482                         NDR_CHECK(ndr_pull_array_size(ndr, &r->share));
1483                         NDR_CHECK(ndr_pull_array_length(ndr, &r->share));
1484                         if (ndr_get_array_length(ndr, &r->share) > ndr_get_array_size(ndr, &r->share)) {
1485                                 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));
1486                         }
1487                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->share), sizeof(uint16_t)));
1488                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->share, ndr_get_array_length(ndr, &r->share), sizeof(uint16_t), CH_UTF16));
1489                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_share_0, 0);
1490                 }
1491         }
1492         return NDR_ERR_SUCCESS;
1493 }
1494
1495 _PUBLIC_ void ndr_print_srvsvc_NetConnInfo1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetConnInfo1 *r)
1496 {
1497         ndr_print_struct(ndr, name, "srvsvc_NetConnInfo1");
1498         ndr->depth++;
1499         ndr_print_uint32(ndr, "conn_id", r->conn_id);
1500         ndr_print_uint32(ndr, "conn_type", r->conn_type);
1501         ndr_print_uint32(ndr, "num_open", r->num_open);
1502         ndr_print_uint32(ndr, "num_users", r->num_users);
1503         ndr_print_uint32(ndr, "conn_time", r->conn_time);
1504         ndr_print_ptr(ndr, "user", r->user);
1505         ndr->depth++;
1506         if (r->user) {
1507                 ndr_print_string(ndr, "user", r->user);
1508         }
1509         ndr->depth--;
1510         ndr_print_ptr(ndr, "share", r->share);
1511         ndr->depth++;
1512         if (r->share) {
1513                 ndr_print_string(ndr, "share", r->share);
1514         }
1515         ndr->depth--;
1516         ndr->depth--;
1517 }
1518
1519 static enum ndr_err_code ndr_push_srvsvc_NetConnCtr1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetConnCtr1 *r)
1520 {
1521         uint32_t cntr_array_1;
1522         if (ndr_flags & NDR_SCALARS) {
1523                 NDR_CHECK(ndr_push_align(ndr, 4));
1524                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1525                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
1526         }
1527         if (ndr_flags & NDR_BUFFERS) {
1528                 if (r->array) {
1529                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1530                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
1531                                 NDR_CHECK(ndr_push_srvsvc_NetConnInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
1532                         }
1533                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
1534                                 NDR_CHECK(ndr_push_srvsvc_NetConnInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
1535                         }
1536                 }
1537         }
1538         return NDR_ERR_SUCCESS;
1539 }
1540
1541 static enum ndr_err_code ndr_pull_srvsvc_NetConnCtr1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetConnCtr1 *r)
1542 {
1543         uint32_t _ptr_array;
1544         uint32_t cntr_array_1;
1545         TALLOC_CTX *_mem_save_array_0;
1546         TALLOC_CTX *_mem_save_array_1;
1547         if (ndr_flags & NDR_SCALARS) {
1548                 NDR_CHECK(ndr_pull_align(ndr, 4));
1549                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1550                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
1551                 if (_ptr_array) {
1552                         NDR_PULL_ALLOC(ndr, r->array);
1553                 } else {
1554                         r->array = NULL;
1555                 }
1556         }
1557         if (ndr_flags & NDR_BUFFERS) {
1558                 if (r->array) {
1559                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
1560                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
1561                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
1562                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
1563                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
1564                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
1565                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
1566                                 NDR_CHECK(ndr_pull_srvsvc_NetConnInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
1567                         }
1568                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
1569                                 NDR_CHECK(ndr_pull_srvsvc_NetConnInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
1570                         }
1571                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
1572                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
1573                 }
1574                 if (r->array) {
1575                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
1576                 }
1577         }
1578         return NDR_ERR_SUCCESS;
1579 }
1580
1581 _PUBLIC_ void ndr_print_srvsvc_NetConnCtr1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetConnCtr1 *r)
1582 {
1583         uint32_t cntr_array_1;
1584         ndr_print_struct(ndr, name, "srvsvc_NetConnCtr1");
1585         ndr->depth++;
1586         ndr_print_uint32(ndr, "count", r->count);
1587         ndr_print_ptr(ndr, "array", r->array);
1588         ndr->depth++;
1589         if (r->array) {
1590                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
1591                 ndr->depth++;
1592                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
1593                         char *idx_1=NULL;
1594                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
1595                                 ndr_print_srvsvc_NetConnInfo1(ndr, "array", &r->array[cntr_array_1]);
1596                                 free(idx_1);
1597                         }
1598                 }
1599                 ndr->depth--;
1600         }
1601         ndr->depth--;
1602         ndr->depth--;
1603 }
1604
1605 static enum ndr_err_code ndr_push_srvsvc_NetConnCtr(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetConnCtr *r)
1606 {
1607         if (ndr_flags & NDR_SCALARS) {
1608                 int level = ndr_push_get_switch_value(ndr, r);
1609                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
1610                 switch (level) {
1611                         case 0: {
1612                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
1613                         break; }
1614
1615                         case 1: {
1616                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
1617                         break; }
1618
1619                         default: {
1620                         break; }
1621
1622                 }
1623         }
1624         if (ndr_flags & NDR_BUFFERS) {
1625                 int level = ndr_push_get_switch_value(ndr, r);
1626                 switch (level) {
1627                         case 0:
1628                                 if (r->ctr0) {
1629                                         NDR_CHECK(ndr_push_srvsvc_NetConnCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
1630                                 }
1631                         break;
1632
1633                         case 1:
1634                                 if (r->ctr1) {
1635                                         NDR_CHECK(ndr_push_srvsvc_NetConnCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
1636                                 }
1637                         break;
1638
1639                         default:
1640                         break;
1641
1642                 }
1643         }
1644         return NDR_ERR_SUCCESS;
1645 }
1646
1647 static enum ndr_err_code ndr_pull_srvsvc_NetConnCtr(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetConnCtr *r)
1648 {
1649         int level;
1650         uint32_t _level;
1651         TALLOC_CTX *_mem_save_ctr0_0;
1652         TALLOC_CTX *_mem_save_ctr1_0;
1653         level = ndr_pull_get_switch_value(ndr, r);
1654         if (ndr_flags & NDR_SCALARS) {
1655                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
1656                 if (_level != level) {
1657                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1658                 }
1659                 switch (level) {
1660                         case 0: {
1661                                 uint32_t _ptr_ctr0;
1662                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));
1663                                 if (_ptr_ctr0) {
1664                                         NDR_PULL_ALLOC(ndr, r->ctr0);
1665                                 } else {
1666                                         r->ctr0 = NULL;
1667                                 }
1668                         break; }
1669
1670                         case 1: {
1671                                 uint32_t _ptr_ctr1;
1672                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
1673                                 if (_ptr_ctr1) {
1674                                         NDR_PULL_ALLOC(ndr, r->ctr1);
1675                                 } else {
1676                                         r->ctr1 = NULL;
1677                                 }
1678                         break; }
1679
1680                         default: {
1681                         break; }
1682
1683                 }
1684         }
1685         if (ndr_flags & NDR_BUFFERS) {
1686                 switch (level) {
1687                         case 0:
1688                                 if (r->ctr0) {
1689                                         _mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);
1690                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr0, 0);
1691                                         NDR_CHECK(ndr_pull_srvsvc_NetConnCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
1692                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);
1693                                 }
1694                         break;
1695
1696                         case 1:
1697                                 if (r->ctr1) {
1698                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
1699                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
1700                                         NDR_CHECK(ndr_pull_srvsvc_NetConnCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
1701                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
1702                                 }
1703                         break;
1704
1705                         default:
1706                         break;
1707
1708                 }
1709         }
1710         return NDR_ERR_SUCCESS;
1711 }
1712
1713 _PUBLIC_ void ndr_print_srvsvc_NetConnCtr(struct ndr_print *ndr, const char *name, const union srvsvc_NetConnCtr *r)
1714 {
1715         int level;
1716         level = ndr_print_get_switch_value(ndr, r);
1717         ndr_print_union(ndr, name, level, "srvsvc_NetConnCtr");
1718         switch (level) {
1719                 case 0:
1720                         ndr_print_ptr(ndr, "ctr0", r->ctr0);
1721                         ndr->depth++;
1722                         if (r->ctr0) {
1723                                 ndr_print_srvsvc_NetConnCtr0(ndr, "ctr0", r->ctr0);
1724                         }
1725                         ndr->depth--;
1726                 break;
1727
1728                 case 1:
1729                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
1730                         ndr->depth++;
1731                         if (r->ctr1) {
1732                                 ndr_print_srvsvc_NetConnCtr1(ndr, "ctr1", r->ctr1);
1733                         }
1734                         ndr->depth--;
1735                 break;
1736
1737                 default:
1738                 break;
1739
1740         }
1741 }
1742
1743 static enum ndr_err_code ndr_push_srvsvc_NetConnInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetConnInfoCtr *r)
1744 {
1745         if (ndr_flags & NDR_SCALARS) {
1746                 NDR_CHECK(ndr_push_align(ndr, 4));
1747                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
1748                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
1749                 NDR_CHECK(ndr_push_srvsvc_NetConnCtr(ndr, NDR_SCALARS, &r->ctr));
1750         }
1751         if (ndr_flags & NDR_BUFFERS) {
1752                 NDR_CHECK(ndr_push_srvsvc_NetConnCtr(ndr, NDR_BUFFERS, &r->ctr));
1753         }
1754         return NDR_ERR_SUCCESS;
1755 }
1756
1757 static enum ndr_err_code ndr_pull_srvsvc_NetConnInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetConnInfoCtr *r)
1758 {
1759         if (ndr_flags & NDR_SCALARS) {
1760                 NDR_CHECK(ndr_pull_align(ndr, 4));
1761                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
1762                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
1763                 NDR_CHECK(ndr_pull_srvsvc_NetConnCtr(ndr, NDR_SCALARS, &r->ctr));
1764         }
1765         if (ndr_flags & NDR_BUFFERS) {
1766                 NDR_CHECK(ndr_pull_srvsvc_NetConnCtr(ndr, NDR_BUFFERS, &r->ctr));
1767         }
1768         return NDR_ERR_SUCCESS;
1769 }
1770
1771 _PUBLIC_ void ndr_print_srvsvc_NetConnInfoCtr(struct ndr_print *ndr, const char *name, const struct srvsvc_NetConnInfoCtr *r)
1772 {
1773         ndr_print_struct(ndr, name, "srvsvc_NetConnInfoCtr");
1774         ndr->depth++;
1775         ndr_print_uint32(ndr, "level", r->level);
1776         ndr_print_set_switch_value(ndr, &r->ctr, r->level);
1777         ndr_print_srvsvc_NetConnCtr(ndr, "ctr", &r->ctr);
1778         ndr->depth--;
1779 }
1780
1781 static enum ndr_err_code ndr_push_srvsvc_NetFileInfo2(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetFileInfo2 *r)
1782 {
1783         if (ndr_flags & NDR_SCALARS) {
1784                 NDR_CHECK(ndr_push_align(ndr, 4));
1785                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->fid));
1786         }
1787         if (ndr_flags & NDR_BUFFERS) {
1788         }
1789         return NDR_ERR_SUCCESS;
1790 }
1791
1792 static enum ndr_err_code ndr_pull_srvsvc_NetFileInfo2(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetFileInfo2 *r)
1793 {
1794         if (ndr_flags & NDR_SCALARS) {
1795                 NDR_CHECK(ndr_pull_align(ndr, 4));
1796                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->fid));
1797         }
1798         if (ndr_flags & NDR_BUFFERS) {
1799         }
1800         return NDR_ERR_SUCCESS;
1801 }
1802
1803 _PUBLIC_ void ndr_print_srvsvc_NetFileInfo2(struct ndr_print *ndr, const char *name, const struct srvsvc_NetFileInfo2 *r)
1804 {
1805         ndr_print_struct(ndr, name, "srvsvc_NetFileInfo2");
1806         ndr->depth++;
1807         ndr_print_uint32(ndr, "fid", r->fid);
1808         ndr->depth--;
1809 }
1810
1811 static enum ndr_err_code ndr_push_srvsvc_NetFileCtr2(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetFileCtr2 *r)
1812 {
1813         uint32_t cntr_array_1;
1814         if (ndr_flags & NDR_SCALARS) {
1815                 NDR_CHECK(ndr_push_align(ndr, 4));
1816                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1817                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
1818         }
1819         if (ndr_flags & NDR_BUFFERS) {
1820                 if (r->array) {
1821                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1822                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
1823                                 NDR_CHECK(ndr_push_srvsvc_NetFileInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
1824                         }
1825                 }
1826         }
1827         return NDR_ERR_SUCCESS;
1828 }
1829
1830 static enum ndr_err_code ndr_pull_srvsvc_NetFileCtr2(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetFileCtr2 *r)
1831 {
1832         uint32_t _ptr_array;
1833         uint32_t cntr_array_1;
1834         TALLOC_CTX *_mem_save_array_0;
1835         TALLOC_CTX *_mem_save_array_1;
1836         if (ndr_flags & NDR_SCALARS) {
1837                 NDR_CHECK(ndr_pull_align(ndr, 4));
1838                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1839                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
1840                 if (_ptr_array) {
1841                         NDR_PULL_ALLOC(ndr, r->array);
1842                 } else {
1843                         r->array = NULL;
1844                 }
1845         }
1846         if (ndr_flags & NDR_BUFFERS) {
1847                 if (r->array) {
1848                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
1849                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
1850                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
1851                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
1852                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
1853                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
1854                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
1855                                 NDR_CHECK(ndr_pull_srvsvc_NetFileInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
1856                         }
1857                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
1858                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
1859                 }
1860                 if (r->array) {
1861                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
1862                 }
1863         }
1864         return NDR_ERR_SUCCESS;
1865 }
1866
1867 _PUBLIC_ void ndr_print_srvsvc_NetFileCtr2(struct ndr_print *ndr, const char *name, const struct srvsvc_NetFileCtr2 *r)
1868 {
1869         uint32_t cntr_array_1;
1870         ndr_print_struct(ndr, name, "srvsvc_NetFileCtr2");
1871         ndr->depth++;
1872         ndr_print_uint32(ndr, "count", r->count);
1873         ndr_print_ptr(ndr, "array", r->array);
1874         ndr->depth++;
1875         if (r->array) {
1876                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
1877                 ndr->depth++;
1878                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
1879                         char *idx_1=NULL;
1880                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
1881                                 ndr_print_srvsvc_NetFileInfo2(ndr, "array", &r->array[cntr_array_1]);
1882                                 free(idx_1);
1883                         }
1884                 }
1885                 ndr->depth--;
1886         }
1887         ndr->depth--;
1888         ndr->depth--;
1889 }
1890
1891 static enum ndr_err_code ndr_push_srvsvc_NetFileInfo3(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetFileInfo3 *r)
1892 {
1893         if (ndr_flags & NDR_SCALARS) {
1894                 NDR_CHECK(ndr_push_align(ndr, 4));
1895                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->fid));
1896                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->permissions));
1897                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_locks));
1898                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->path));
1899                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
1900         }
1901         if (ndr_flags & NDR_BUFFERS) {
1902                 if (r->path) {
1903                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));
1904                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1905                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));
1906                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->path, ndr_charset_length(r->path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
1907                 }
1908                 if (r->user) {
1909                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
1910                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1911                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
1912                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
1913                 }
1914         }
1915         return NDR_ERR_SUCCESS;
1916 }
1917
1918 static enum ndr_err_code ndr_pull_srvsvc_NetFileInfo3(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetFileInfo3 *r)
1919 {
1920         uint32_t _ptr_path;
1921         TALLOC_CTX *_mem_save_path_0;
1922         uint32_t _ptr_user;
1923         TALLOC_CTX *_mem_save_user_0;
1924         if (ndr_flags & NDR_SCALARS) {
1925                 NDR_CHECK(ndr_pull_align(ndr, 4));
1926                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->fid));
1927                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->permissions));
1928                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_locks));
1929                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_path));
1930                 if (_ptr_path) {
1931                         NDR_PULL_ALLOC(ndr, r->path);
1932                 } else {
1933                         r->path = NULL;
1934                 }
1935                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
1936                 if (_ptr_user) {
1937                         NDR_PULL_ALLOC(ndr, r->user);
1938                 } else {
1939                         r->user = NULL;
1940                 }
1941         }
1942         if (ndr_flags & NDR_BUFFERS) {
1943                 if (r->path) {
1944                         _mem_save_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
1945                         NDR_PULL_SET_MEM_CTX(ndr, r->path, 0);
1946                         NDR_CHECK(ndr_pull_array_size(ndr, &r->path));
1947                         NDR_CHECK(ndr_pull_array_length(ndr, &r->path));
1948                         if (ndr_get_array_length(ndr, &r->path) > ndr_get_array_size(ndr, &r->path)) {
1949                                 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));
1950                         }
1951                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->path), sizeof(uint16_t)));
1952                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->path, ndr_get_array_length(ndr, &r->path), sizeof(uint16_t), CH_UTF16));
1953                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_path_0, 0);
1954                 }
1955                 if (r->user) {
1956                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
1957                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
1958                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
1959                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
1960                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
1961                                 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));
1962                         }
1963                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
1964                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
1965                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
1966                 }
1967         }
1968         return NDR_ERR_SUCCESS;
1969 }
1970
1971 _PUBLIC_ void ndr_print_srvsvc_NetFileInfo3(struct ndr_print *ndr, const char *name, const struct srvsvc_NetFileInfo3 *r)
1972 {
1973         ndr_print_struct(ndr, name, "srvsvc_NetFileInfo3");
1974         ndr->depth++;
1975         ndr_print_uint32(ndr, "fid", r->fid);
1976         ndr_print_uint32(ndr, "permissions", r->permissions);
1977         ndr_print_uint32(ndr, "num_locks", r->num_locks);
1978         ndr_print_ptr(ndr, "path", r->path);
1979         ndr->depth++;
1980         if (r->path) {
1981                 ndr_print_string(ndr, "path", r->path);
1982         }
1983         ndr->depth--;
1984         ndr_print_ptr(ndr, "user", r->user);
1985         ndr->depth++;
1986         if (r->user) {
1987                 ndr_print_string(ndr, "user", r->user);
1988         }
1989         ndr->depth--;
1990         ndr->depth--;
1991 }
1992
1993 static enum ndr_err_code ndr_push_srvsvc_NetFileCtr3(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetFileCtr3 *r)
1994 {
1995         uint32_t cntr_array_1;
1996         if (ndr_flags & NDR_SCALARS) {
1997                 NDR_CHECK(ndr_push_align(ndr, 4));
1998                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1999                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
2000         }
2001         if (ndr_flags & NDR_BUFFERS) {
2002                 if (r->array) {
2003                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2004                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2005                                 NDR_CHECK(ndr_push_srvsvc_NetFileInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
2006                         }
2007                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2008                                 NDR_CHECK(ndr_push_srvsvc_NetFileInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
2009                         }
2010                 }
2011         }
2012         return NDR_ERR_SUCCESS;
2013 }
2014
2015 static enum ndr_err_code ndr_pull_srvsvc_NetFileCtr3(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetFileCtr3 *r)
2016 {
2017         uint32_t _ptr_array;
2018         uint32_t cntr_array_1;
2019         TALLOC_CTX *_mem_save_array_0;
2020         TALLOC_CTX *_mem_save_array_1;
2021         if (ndr_flags & NDR_SCALARS) {
2022                 NDR_CHECK(ndr_pull_align(ndr, 4));
2023                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2024                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
2025                 if (_ptr_array) {
2026                         NDR_PULL_ALLOC(ndr, r->array);
2027                 } else {
2028                         r->array = NULL;
2029                 }
2030         }
2031         if (ndr_flags & NDR_BUFFERS) {
2032                 if (r->array) {
2033                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
2034                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
2035                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
2036                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
2037                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
2038                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
2039                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2040                                 NDR_CHECK(ndr_pull_srvsvc_NetFileInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
2041                         }
2042                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2043                                 NDR_CHECK(ndr_pull_srvsvc_NetFileInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
2044                         }
2045                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
2046                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
2047                 }
2048                 if (r->array) {
2049                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
2050                 }
2051         }
2052         return NDR_ERR_SUCCESS;
2053 }
2054
2055 _PUBLIC_ void ndr_print_srvsvc_NetFileCtr3(struct ndr_print *ndr, const char *name, const struct srvsvc_NetFileCtr3 *r)
2056 {
2057         uint32_t cntr_array_1;
2058         ndr_print_struct(ndr, name, "srvsvc_NetFileCtr3");
2059         ndr->depth++;
2060         ndr_print_uint32(ndr, "count", r->count);
2061         ndr_print_ptr(ndr, "array", r->array);
2062         ndr->depth++;
2063         if (r->array) {
2064                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
2065                 ndr->depth++;
2066                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
2067                         char *idx_1=NULL;
2068                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
2069                                 ndr_print_srvsvc_NetFileInfo3(ndr, "array", &r->array[cntr_array_1]);
2070                                 free(idx_1);
2071                         }
2072                 }
2073                 ndr->depth--;
2074         }
2075         ndr->depth--;
2076         ndr->depth--;
2077 }
2078
2079 static enum ndr_err_code ndr_push_srvsvc_NetFileInfo(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetFileInfo *r)
2080 {
2081         if (ndr_flags & NDR_SCALARS) {
2082                 int level = ndr_push_get_switch_value(ndr, r);
2083                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
2084                 switch (level) {
2085                         case 2: {
2086                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
2087                         break; }
2088
2089                         case 3: {
2090                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
2091                         break; }
2092
2093                         default: {
2094                         break; }
2095
2096                 }
2097         }
2098         if (ndr_flags & NDR_BUFFERS) {
2099                 int level = ndr_push_get_switch_value(ndr, r);
2100                 switch (level) {
2101                         case 2:
2102                                 if (r->info2) {
2103                                         NDR_CHECK(ndr_push_srvsvc_NetFileInfo2(ndr, NDR_SCALARS, r->info2));
2104                                 }
2105                         break;
2106
2107                         case 3:
2108                                 if (r->info3) {
2109                                         NDR_CHECK(ndr_push_srvsvc_NetFileInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
2110                                 }
2111                         break;
2112
2113                         default:
2114                         break;
2115
2116                 }
2117         }
2118         return NDR_ERR_SUCCESS;
2119 }
2120
2121 static enum ndr_err_code ndr_pull_srvsvc_NetFileInfo(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetFileInfo *r)
2122 {
2123         int level;
2124         uint32_t _level;
2125         TALLOC_CTX *_mem_save_info2_0;
2126         TALLOC_CTX *_mem_save_info3_0;
2127         level = ndr_pull_get_switch_value(ndr, r);
2128         if (ndr_flags & NDR_SCALARS) {
2129                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
2130                 if (_level != level) {
2131                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
2132                 }
2133                 switch (level) {
2134                         case 2: {
2135                                 uint32_t _ptr_info2;
2136                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
2137                                 if (_ptr_info2) {
2138                                         NDR_PULL_ALLOC(ndr, r->info2);
2139                                 } else {
2140                                         r->info2 = NULL;
2141                                 }
2142                         break; }
2143
2144                         case 3: {
2145                                 uint32_t _ptr_info3;
2146                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
2147                                 if (_ptr_info3) {
2148                                         NDR_PULL_ALLOC(ndr, r->info3);
2149                                 } else {
2150                                         r->info3 = NULL;
2151                                 }
2152                         break; }
2153
2154                         default: {
2155                         break; }
2156
2157                 }
2158         }
2159         if (ndr_flags & NDR_BUFFERS) {
2160                 switch (level) {
2161                         case 2:
2162                                 if (r->info2) {
2163                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
2164                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
2165                                         NDR_CHECK(ndr_pull_srvsvc_NetFileInfo2(ndr, NDR_SCALARS, r->info2));
2166                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
2167                                 }
2168                         break;
2169
2170                         case 3:
2171                                 if (r->info3) {
2172                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
2173                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
2174                                         NDR_CHECK(ndr_pull_srvsvc_NetFileInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
2175                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
2176                                 }
2177                         break;
2178
2179                         default:
2180                         break;
2181
2182                 }
2183         }
2184         return NDR_ERR_SUCCESS;
2185 }
2186
2187 _PUBLIC_ void ndr_print_srvsvc_NetFileInfo(struct ndr_print *ndr, const char *name, const union srvsvc_NetFileInfo *r)
2188 {
2189         int level;
2190         level = ndr_print_get_switch_value(ndr, r);
2191         ndr_print_union(ndr, name, level, "srvsvc_NetFileInfo");
2192         switch (level) {
2193                 case 2:
2194                         ndr_print_ptr(ndr, "info2", r->info2);
2195                         ndr->depth++;
2196                         if (r->info2) {
2197                                 ndr_print_srvsvc_NetFileInfo2(ndr, "info2", r->info2);
2198                         }
2199                         ndr->depth--;
2200                 break;
2201
2202                 case 3:
2203                         ndr_print_ptr(ndr, "info3", r->info3);
2204                         ndr->depth++;
2205                         if (r->info3) {
2206                                 ndr_print_srvsvc_NetFileInfo3(ndr, "info3", r->info3);
2207                         }
2208                         ndr->depth--;
2209                 break;
2210
2211                 default:
2212                 break;
2213
2214         }
2215 }
2216
2217 static enum ndr_err_code ndr_push_srvsvc_NetFileCtr(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetFileCtr *r)
2218 {
2219         if (ndr_flags & NDR_SCALARS) {
2220                 int level = ndr_push_get_switch_value(ndr, r);
2221                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
2222                 switch (level) {
2223                         case 2: {
2224                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr2));
2225                         break; }
2226
2227                         case 3: {
2228                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr3));
2229                         break; }
2230
2231                         default: {
2232                         break; }
2233
2234                 }
2235         }
2236         if (ndr_flags & NDR_BUFFERS) {
2237                 int level = ndr_push_get_switch_value(ndr, r);
2238                 switch (level) {
2239                         case 2:
2240                                 if (r->ctr2) {
2241                                         NDR_CHECK(ndr_push_srvsvc_NetFileCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
2242                                 }
2243                         break;
2244
2245                         case 3:
2246                                 if (r->ctr3) {
2247                                         NDR_CHECK(ndr_push_srvsvc_NetFileCtr3(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr3));
2248                                 }
2249                         break;
2250
2251                         default:
2252                         break;
2253
2254                 }
2255         }
2256         return NDR_ERR_SUCCESS;
2257 }
2258
2259 static enum ndr_err_code ndr_pull_srvsvc_NetFileCtr(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetFileCtr *r)
2260 {
2261         int level;
2262         uint32_t _level;
2263         TALLOC_CTX *_mem_save_ctr2_0;
2264         TALLOC_CTX *_mem_save_ctr3_0;
2265         level = ndr_pull_get_switch_value(ndr, r);
2266         if (ndr_flags & NDR_SCALARS) {
2267                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
2268                 if (_level != level) {
2269                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
2270                 }
2271                 switch (level) {
2272                         case 2: {
2273                                 uint32_t _ptr_ctr2;
2274                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr2));
2275                                 if (_ptr_ctr2) {
2276                                         NDR_PULL_ALLOC(ndr, r->ctr2);
2277                                 } else {
2278                                         r->ctr2 = NULL;
2279                                 }
2280                         break; }
2281
2282                         case 3: {
2283                                 uint32_t _ptr_ctr3;
2284                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr3));
2285                                 if (_ptr_ctr3) {
2286                                         NDR_PULL_ALLOC(ndr, r->ctr3);
2287                                 } else {
2288                                         r->ctr3 = NULL;
2289                                 }
2290                         break; }
2291
2292                         default: {
2293                         break; }
2294
2295                 }
2296         }
2297         if (ndr_flags & NDR_BUFFERS) {
2298                 switch (level) {
2299                         case 2:
2300                                 if (r->ctr2) {
2301                                         _mem_save_ctr2_0 = NDR_PULL_GET_MEM_CTX(ndr);
2302                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr2, 0);
2303                                         NDR_CHECK(ndr_pull_srvsvc_NetFileCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
2304                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr2_0, 0);
2305                                 }
2306                         break;
2307
2308                         case 3:
2309                                 if (r->ctr3) {
2310                                         _mem_save_ctr3_0 = NDR_PULL_GET_MEM_CTX(ndr);
2311                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr3, 0);
2312                                         NDR_CHECK(ndr_pull_srvsvc_NetFileCtr3(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr3));
2313                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr3_0, 0);
2314                                 }
2315                         break;
2316
2317                         default:
2318                         break;
2319
2320                 }
2321         }
2322         return NDR_ERR_SUCCESS;
2323 }
2324
2325 _PUBLIC_ void ndr_print_srvsvc_NetFileCtr(struct ndr_print *ndr, const char *name, const union srvsvc_NetFileCtr *r)
2326 {
2327         int level;
2328         level = ndr_print_get_switch_value(ndr, r);
2329         ndr_print_union(ndr, name, level, "srvsvc_NetFileCtr");
2330         switch (level) {
2331                 case 2:
2332                         ndr_print_ptr(ndr, "ctr2", r->ctr2);
2333                         ndr->depth++;
2334                         if (r->ctr2) {
2335                                 ndr_print_srvsvc_NetFileCtr2(ndr, "ctr2", r->ctr2);
2336                         }
2337                         ndr->depth--;
2338                 break;
2339
2340                 case 3:
2341                         ndr_print_ptr(ndr, "ctr3", r->ctr3);
2342                         ndr->depth++;
2343                         if (r->ctr3) {
2344                                 ndr_print_srvsvc_NetFileCtr3(ndr, "ctr3", r->ctr3);
2345                         }
2346                         ndr->depth--;
2347                 break;
2348
2349                 default:
2350                 break;
2351
2352         }
2353 }
2354
2355 static enum ndr_err_code ndr_push_srvsvc_NetFileInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetFileInfoCtr *r)
2356 {
2357         if (ndr_flags & NDR_SCALARS) {
2358                 NDR_CHECK(ndr_push_align(ndr, 4));
2359                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
2360                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
2361                 NDR_CHECK(ndr_push_srvsvc_NetFileCtr(ndr, NDR_SCALARS, &r->ctr));
2362         }
2363         if (ndr_flags & NDR_BUFFERS) {
2364                 NDR_CHECK(ndr_push_srvsvc_NetFileCtr(ndr, NDR_BUFFERS, &r->ctr));
2365         }
2366         return NDR_ERR_SUCCESS;
2367 }
2368
2369 static enum ndr_err_code ndr_pull_srvsvc_NetFileInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetFileInfoCtr *r)
2370 {
2371         if (ndr_flags & NDR_SCALARS) {
2372                 NDR_CHECK(ndr_pull_align(ndr, 4));
2373                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
2374                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
2375                 NDR_CHECK(ndr_pull_srvsvc_NetFileCtr(ndr, NDR_SCALARS, &r->ctr));
2376         }
2377         if (ndr_flags & NDR_BUFFERS) {
2378                 NDR_CHECK(ndr_pull_srvsvc_NetFileCtr(ndr, NDR_BUFFERS, &r->ctr));
2379         }
2380         return NDR_ERR_SUCCESS;
2381 }
2382
2383 _PUBLIC_ void ndr_print_srvsvc_NetFileInfoCtr(struct ndr_print *ndr, const char *name, const struct srvsvc_NetFileInfoCtr *r)
2384 {
2385         ndr_print_struct(ndr, name, "srvsvc_NetFileInfoCtr");
2386         ndr->depth++;
2387         ndr_print_uint32(ndr, "level", r->level);
2388         ndr_print_set_switch_value(ndr, &r->ctr, r->level);
2389         ndr_print_srvsvc_NetFileCtr(ndr, "ctr", &r->ctr);
2390         ndr->depth--;
2391 }
2392
2393 static enum ndr_err_code ndr_push_srvsvc_NetSessInfo0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessInfo0 *r)
2394 {
2395         if (ndr_flags & NDR_SCALARS) {
2396                 NDR_CHECK(ndr_push_align(ndr, 4));
2397                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
2398         }
2399         if (ndr_flags & NDR_BUFFERS) {
2400                 if (r->client) {
2401                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
2402                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2403                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
2404                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2405                 }
2406         }
2407         return NDR_ERR_SUCCESS;
2408 }
2409
2410 static enum ndr_err_code ndr_pull_srvsvc_NetSessInfo0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessInfo0 *r)
2411 {
2412         uint32_t _ptr_client;
2413         TALLOC_CTX *_mem_save_client_0;
2414         if (ndr_flags & NDR_SCALARS) {
2415                 NDR_CHECK(ndr_pull_align(ndr, 4));
2416                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
2417                 if (_ptr_client) {
2418                         NDR_PULL_ALLOC(ndr, r->client);
2419                 } else {
2420                         r->client = NULL;
2421                 }
2422         }
2423         if (ndr_flags & NDR_BUFFERS) {
2424                 if (r->client) {
2425                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
2426                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
2427                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
2428                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
2429                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
2430                                 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));
2431                         }
2432                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
2433                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
2434                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
2435                 }
2436         }
2437         return NDR_ERR_SUCCESS;
2438 }
2439
2440 _PUBLIC_ void ndr_print_srvsvc_NetSessInfo0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessInfo0 *r)
2441 {
2442         ndr_print_struct(ndr, name, "srvsvc_NetSessInfo0");
2443         ndr->depth++;
2444         ndr_print_ptr(ndr, "client", r->client);
2445         ndr->depth++;
2446         if (r->client) {
2447                 ndr_print_string(ndr, "client", r->client);
2448         }
2449         ndr->depth--;
2450         ndr->depth--;
2451 }
2452
2453 static enum ndr_err_code ndr_push_srvsvc_NetSessCtr0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessCtr0 *r)
2454 {
2455         uint32_t cntr_array_1;
2456         if (ndr_flags & NDR_SCALARS) {
2457                 NDR_CHECK(ndr_push_align(ndr, 4));
2458                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2459                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
2460         }
2461         if (ndr_flags & NDR_BUFFERS) {
2462                 if (r->array) {
2463                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2464                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2465                                 NDR_CHECK(ndr_push_srvsvc_NetSessInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
2466                         }
2467                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2468                                 NDR_CHECK(ndr_push_srvsvc_NetSessInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
2469                         }
2470                 }
2471         }
2472         return NDR_ERR_SUCCESS;
2473 }
2474
2475 static enum ndr_err_code ndr_pull_srvsvc_NetSessCtr0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessCtr0 *r)
2476 {
2477         uint32_t _ptr_array;
2478         uint32_t cntr_array_1;
2479         TALLOC_CTX *_mem_save_array_0;
2480         TALLOC_CTX *_mem_save_array_1;
2481         if (ndr_flags & NDR_SCALARS) {
2482                 NDR_CHECK(ndr_pull_align(ndr, 4));
2483                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2484                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
2485                 if (_ptr_array) {
2486                         NDR_PULL_ALLOC(ndr, r->array);
2487                 } else {
2488                         r->array = NULL;
2489                 }
2490         }
2491         if (ndr_flags & NDR_BUFFERS) {
2492                 if (r->array) {
2493                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
2494                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
2495                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
2496                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
2497                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
2498                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
2499                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2500                                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
2501                         }
2502                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2503                                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
2504                         }
2505                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
2506                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
2507                 }
2508                 if (r->array) {
2509                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
2510                 }
2511         }
2512         return NDR_ERR_SUCCESS;
2513 }
2514
2515 _PUBLIC_ void ndr_print_srvsvc_NetSessCtr0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessCtr0 *r)
2516 {
2517         uint32_t cntr_array_1;
2518         ndr_print_struct(ndr, name, "srvsvc_NetSessCtr0");
2519         ndr->depth++;
2520         ndr_print_uint32(ndr, "count", r->count);
2521         ndr_print_ptr(ndr, "array", r->array);
2522         ndr->depth++;
2523         if (r->array) {
2524                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
2525                 ndr->depth++;
2526                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
2527                         char *idx_1=NULL;
2528                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
2529                                 ndr_print_srvsvc_NetSessInfo0(ndr, "array", &r->array[cntr_array_1]);
2530                                 free(idx_1);
2531                         }
2532                 }
2533                 ndr->depth--;
2534         }
2535         ndr->depth--;
2536         ndr->depth--;
2537 }
2538
2539 static enum ndr_err_code ndr_push_srvsvc_NetSessInfo1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessInfo1 *r)
2540 {
2541         if (ndr_flags & NDR_SCALARS) {
2542                 NDR_CHECK(ndr_push_align(ndr, 4));
2543                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
2544                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
2545                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_open));
2546                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
2547                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idle_time));
2548                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->user_flags));
2549         }
2550         if (ndr_flags & NDR_BUFFERS) {
2551                 if (r->client) {
2552                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
2553                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2554                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
2555                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2556                 }
2557                 if (r->user) {
2558                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
2559                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2560                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
2561                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2562                 }
2563         }
2564         return NDR_ERR_SUCCESS;
2565 }
2566
2567 static enum ndr_err_code ndr_pull_srvsvc_NetSessInfo1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessInfo1 *r)
2568 {
2569         uint32_t _ptr_client;
2570         TALLOC_CTX *_mem_save_client_0;
2571         uint32_t _ptr_user;
2572         TALLOC_CTX *_mem_save_user_0;
2573         if (ndr_flags & NDR_SCALARS) {
2574                 NDR_CHECK(ndr_pull_align(ndr, 4));
2575                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
2576                 if (_ptr_client) {
2577                         NDR_PULL_ALLOC(ndr, r->client);
2578                 } else {
2579                         r->client = NULL;
2580                 }
2581                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
2582                 if (_ptr_user) {
2583                         NDR_PULL_ALLOC(ndr, r->user);
2584                 } else {
2585                         r->user = NULL;
2586                 }
2587                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_open));
2588                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
2589                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idle_time));
2590                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->user_flags));
2591         }
2592         if (ndr_flags & NDR_BUFFERS) {
2593                 if (r->client) {
2594                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
2595                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
2596                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
2597                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
2598                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
2599                                 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));
2600                         }
2601                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
2602                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
2603                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
2604                 }
2605                 if (r->user) {
2606                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
2607                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
2608                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
2609                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
2610                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
2611                                 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));
2612                         }
2613                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
2614                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
2615                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
2616                 }
2617         }
2618         return NDR_ERR_SUCCESS;
2619 }
2620
2621 _PUBLIC_ void ndr_print_srvsvc_NetSessInfo1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessInfo1 *r)
2622 {
2623         ndr_print_struct(ndr, name, "srvsvc_NetSessInfo1");
2624         ndr->depth++;
2625         ndr_print_ptr(ndr, "client", r->client);
2626         ndr->depth++;
2627         if (r->client) {
2628                 ndr_print_string(ndr, "client", r->client);
2629         }
2630         ndr->depth--;
2631         ndr_print_ptr(ndr, "user", r->user);
2632         ndr->depth++;
2633         if (r->user) {
2634                 ndr_print_string(ndr, "user", r->user);
2635         }
2636         ndr->depth--;
2637         ndr_print_uint32(ndr, "num_open", r->num_open);
2638         ndr_print_uint32(ndr, "time", r->time);
2639         ndr_print_uint32(ndr, "idle_time", r->idle_time);
2640         ndr_print_uint32(ndr, "user_flags", r->user_flags);
2641         ndr->depth--;
2642 }
2643
2644 static enum ndr_err_code ndr_push_srvsvc_NetSessCtr1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessCtr1 *r)
2645 {
2646         uint32_t cntr_array_1;
2647         if (ndr_flags & NDR_SCALARS) {
2648                 NDR_CHECK(ndr_push_align(ndr, 4));
2649                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2650                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
2651         }
2652         if (ndr_flags & NDR_BUFFERS) {
2653                 if (r->array) {
2654                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2655                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2656                                 NDR_CHECK(ndr_push_srvsvc_NetSessInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
2657                         }
2658                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2659                                 NDR_CHECK(ndr_push_srvsvc_NetSessInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
2660                         }
2661                 }
2662         }
2663         return NDR_ERR_SUCCESS;
2664 }
2665
2666 static enum ndr_err_code ndr_pull_srvsvc_NetSessCtr1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessCtr1 *r)
2667 {
2668         uint32_t _ptr_array;
2669         uint32_t cntr_array_1;
2670         TALLOC_CTX *_mem_save_array_0;
2671         TALLOC_CTX *_mem_save_array_1;
2672         if (ndr_flags & NDR_SCALARS) {
2673                 NDR_CHECK(ndr_pull_align(ndr, 4));
2674                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2675                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
2676                 if (_ptr_array) {
2677                         NDR_PULL_ALLOC(ndr, r->array);
2678                 } else {
2679                         r->array = NULL;
2680                 }
2681         }
2682         if (ndr_flags & NDR_BUFFERS) {
2683                 if (r->array) {
2684                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
2685                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
2686                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
2687                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
2688                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
2689                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
2690                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2691                                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
2692                         }
2693                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2694                                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
2695                         }
2696                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
2697                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
2698                 }
2699                 if (r->array) {
2700                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
2701                 }
2702         }
2703         return NDR_ERR_SUCCESS;
2704 }
2705
2706 _PUBLIC_ void ndr_print_srvsvc_NetSessCtr1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessCtr1 *r)
2707 {
2708         uint32_t cntr_array_1;
2709         ndr_print_struct(ndr, name, "srvsvc_NetSessCtr1");
2710         ndr->depth++;
2711         ndr_print_uint32(ndr, "count", r->count);
2712         ndr_print_ptr(ndr, "array", r->array);
2713         ndr->depth++;
2714         if (r->array) {
2715                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
2716                 ndr->depth++;
2717                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
2718                         char *idx_1=NULL;
2719                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
2720                                 ndr_print_srvsvc_NetSessInfo1(ndr, "array", &r->array[cntr_array_1]);
2721                                 free(idx_1);
2722                         }
2723                 }
2724                 ndr->depth--;
2725         }
2726         ndr->depth--;
2727         ndr->depth--;
2728 }
2729
2730 static enum ndr_err_code ndr_push_srvsvc_NetSessInfo2(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessInfo2 *r)
2731 {
2732         if (ndr_flags & NDR_SCALARS) {
2733                 NDR_CHECK(ndr_push_align(ndr, 4));
2734                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
2735                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
2736                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_open));
2737                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
2738                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idle_time));
2739                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->user_flags));
2740                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client_type));
2741         }
2742         if (ndr_flags & NDR_BUFFERS) {
2743                 if (r->client) {
2744                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
2745                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2746                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
2747                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2748                 }
2749                 if (r->user) {
2750                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
2751                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2752                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
2753                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2754                 }
2755                 if (r->client_type) {
2756                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client_type, CH_UTF16)));
2757                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2758                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client_type, CH_UTF16)));
2759                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client_type, ndr_charset_length(r->client_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2760                 }
2761         }
2762         return NDR_ERR_SUCCESS;
2763 }
2764
2765 static enum ndr_err_code ndr_pull_srvsvc_NetSessInfo2(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessInfo2 *r)
2766 {
2767         uint32_t _ptr_client;
2768         TALLOC_CTX *_mem_save_client_0;
2769         uint32_t _ptr_user;
2770         TALLOC_CTX *_mem_save_user_0;
2771         uint32_t _ptr_client_type;
2772         TALLOC_CTX *_mem_save_client_type_0;
2773         if (ndr_flags & NDR_SCALARS) {
2774                 NDR_CHECK(ndr_pull_align(ndr, 4));
2775                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
2776                 if (_ptr_client) {
2777                         NDR_PULL_ALLOC(ndr, r->client);
2778                 } else {
2779                         r->client = NULL;
2780                 }
2781                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
2782                 if (_ptr_user) {
2783                         NDR_PULL_ALLOC(ndr, r->user);
2784                 } else {
2785                         r->user = NULL;
2786                 }
2787                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_open));
2788                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
2789                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idle_time));
2790                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->user_flags));
2791                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client_type));
2792                 if (_ptr_client_type) {
2793                         NDR_PULL_ALLOC(ndr, r->client_type);
2794                 } else {
2795                         r->client_type = NULL;
2796                 }
2797         }
2798         if (ndr_flags & NDR_BUFFERS) {
2799                 if (r->client) {
2800                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
2801                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
2802                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
2803                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
2804                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
2805                                 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));
2806                         }
2807                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
2808                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
2809                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
2810                 }
2811                 if (r->user) {
2812                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
2813                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
2814                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
2815                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
2816                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
2817                                 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));
2818                         }
2819                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
2820                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
2821                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
2822                 }
2823                 if (r->client_type) {
2824                         _mem_save_client_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
2825                         NDR_PULL_SET_MEM_CTX(ndr, r->client_type, 0);
2826                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client_type));
2827                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client_type));
2828                         if (ndr_get_array_length(ndr, &r->client_type) > ndr_get_array_size(ndr, &r->client_type)) {
2829                                 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));
2830                         }
2831                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client_type), sizeof(uint16_t)));
2832                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client_type, ndr_get_array_length(ndr, &r->client_type), sizeof(uint16_t), CH_UTF16));
2833                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_type_0, 0);
2834                 }
2835         }
2836         return NDR_ERR_SUCCESS;
2837 }
2838
2839 _PUBLIC_ void ndr_print_srvsvc_NetSessInfo2(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessInfo2 *r)
2840 {
2841         ndr_print_struct(ndr, name, "srvsvc_NetSessInfo2");
2842         ndr->depth++;
2843         ndr_print_ptr(ndr, "client", r->client);
2844         ndr->depth++;
2845         if (r->client) {
2846                 ndr_print_string(ndr, "client", r->client);
2847         }
2848         ndr->depth--;
2849         ndr_print_ptr(ndr, "user", r->user);
2850         ndr->depth++;
2851         if (r->user) {
2852                 ndr_print_string(ndr, "user", r->user);
2853         }
2854         ndr->depth--;
2855         ndr_print_uint32(ndr, "num_open", r->num_open);
2856         ndr_print_uint32(ndr, "time", r->time);
2857         ndr_print_uint32(ndr, "idle_time", r->idle_time);
2858         ndr_print_uint32(ndr, "user_flags", r->user_flags);
2859         ndr_print_ptr(ndr, "client_type", r->client_type);
2860         ndr->depth++;
2861         if (r->client_type) {
2862                 ndr_print_string(ndr, "client_type", r->client_type);
2863         }
2864         ndr->depth--;
2865         ndr->depth--;
2866 }
2867
2868 static enum ndr_err_code ndr_push_srvsvc_NetSessCtr2(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessCtr2 *r)
2869 {
2870         uint32_t cntr_array_1;
2871         if (ndr_flags & NDR_SCALARS) {
2872                 NDR_CHECK(ndr_push_align(ndr, 4));
2873                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2874                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
2875         }
2876         if (ndr_flags & NDR_BUFFERS) {
2877                 if (r->array) {
2878                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2879                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2880                                 NDR_CHECK(ndr_push_srvsvc_NetSessInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
2881                         }
2882                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2883                                 NDR_CHECK(ndr_push_srvsvc_NetSessInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
2884                         }
2885                 }
2886         }
2887         return NDR_ERR_SUCCESS;
2888 }
2889
2890 static enum ndr_err_code ndr_pull_srvsvc_NetSessCtr2(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessCtr2 *r)
2891 {
2892         uint32_t _ptr_array;
2893         uint32_t cntr_array_1;
2894         TALLOC_CTX *_mem_save_array_0;
2895         TALLOC_CTX *_mem_save_array_1;
2896         if (ndr_flags & NDR_SCALARS) {
2897                 NDR_CHECK(ndr_pull_align(ndr, 4));
2898                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2899                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
2900                 if (_ptr_array) {
2901                         NDR_PULL_ALLOC(ndr, r->array);
2902                 } else {
2903                         r->array = NULL;
2904                 }
2905         }
2906         if (ndr_flags & NDR_BUFFERS) {
2907                 if (r->array) {
2908                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
2909                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
2910                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
2911                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
2912                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
2913                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
2914                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2915                                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
2916                         }
2917                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2918                                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
2919                         }
2920                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
2921                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
2922                 }
2923                 if (r->array) {
2924                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
2925                 }
2926         }
2927         return NDR_ERR_SUCCESS;
2928 }
2929
2930 _PUBLIC_ void ndr_print_srvsvc_NetSessCtr2(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessCtr2 *r)
2931 {
2932         uint32_t cntr_array_1;
2933         ndr_print_struct(ndr, name, "srvsvc_NetSessCtr2");
2934         ndr->depth++;
2935         ndr_print_uint32(ndr, "count", r->count);
2936         ndr_print_ptr(ndr, "array", r->array);
2937         ndr->depth++;
2938         if (r->array) {
2939                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
2940                 ndr->depth++;
2941                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
2942                         char *idx_1=NULL;
2943                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
2944                                 ndr_print_srvsvc_NetSessInfo2(ndr, "array", &r->array[cntr_array_1]);
2945                                 free(idx_1);
2946                         }
2947                 }
2948                 ndr->depth--;
2949         }
2950         ndr->depth--;
2951         ndr->depth--;
2952 }
2953
2954 static enum ndr_err_code ndr_push_srvsvc_NetSessInfo10(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessInfo10 *r)
2955 {
2956         if (ndr_flags & NDR_SCALARS) {
2957                 NDR_CHECK(ndr_push_align(ndr, 4));
2958                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
2959                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
2960                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
2961                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idle_time));
2962         }
2963         if (ndr_flags & NDR_BUFFERS) {
2964                 if (r->client) {
2965                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
2966                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2967                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
2968                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2969                 }
2970                 if (r->user) {
2971                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
2972                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2973                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
2974                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2975                 }
2976         }
2977         return NDR_ERR_SUCCESS;
2978 }
2979
2980 static enum ndr_err_code ndr_pull_srvsvc_NetSessInfo10(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessInfo10 *r)
2981 {
2982         uint32_t _ptr_client;
2983         TALLOC_CTX *_mem_save_client_0;
2984         uint32_t _ptr_user;
2985         TALLOC_CTX *_mem_save_user_0;
2986         if (ndr_flags & NDR_SCALARS) {
2987                 NDR_CHECK(ndr_pull_align(ndr, 4));
2988                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
2989                 if (_ptr_client) {
2990                         NDR_PULL_ALLOC(ndr, r->client);
2991                 } else {
2992                         r->client = NULL;
2993                 }
2994                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
2995                 if (_ptr_user) {
2996                         NDR_PULL_ALLOC(ndr, r->user);
2997                 } else {
2998                         r->user = NULL;
2999                 }
3000                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3001                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idle_time));
3002         }
3003         if (ndr_flags & NDR_BUFFERS) {
3004                 if (r->client) {
3005                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
3006                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
3007                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
3008                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
3009                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
3010                                 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));
3011                         }
3012                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
3013                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
3014                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
3015                 }
3016                 if (r->user) {
3017                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
3018                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
3019                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
3020                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
3021                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
3022                                 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));
3023                         }
3024                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
3025                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
3026                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
3027                 }
3028         }
3029         return NDR_ERR_SUCCESS;
3030 }
3031
3032 _PUBLIC_ void ndr_print_srvsvc_NetSessInfo10(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessInfo10 *r)
3033 {
3034         ndr_print_struct(ndr, name, "srvsvc_NetSessInfo10");
3035         ndr->depth++;
3036         ndr_print_ptr(ndr, "client", r->client);
3037         ndr->depth++;
3038         if (r->client) {
3039                 ndr_print_string(ndr, "client", r->client);
3040         }
3041         ndr->depth--;
3042         ndr_print_ptr(ndr, "user", r->user);
3043         ndr->depth++;
3044         if (r->user) {
3045                 ndr_print_string(ndr, "user", r->user);
3046         }
3047         ndr->depth--;
3048         ndr_print_uint32(ndr, "time", r->time);
3049         ndr_print_uint32(ndr, "idle_time", r->idle_time);
3050         ndr->depth--;
3051 }
3052
3053 static enum ndr_err_code ndr_push_srvsvc_NetSessCtr10(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessCtr10 *r)
3054 {
3055         uint32_t cntr_array_1;
3056         if (ndr_flags & NDR_SCALARS) {
3057                 NDR_CHECK(ndr_push_align(ndr, 4));
3058                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3059                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
3060         }
3061         if (ndr_flags & NDR_BUFFERS) {
3062                 if (r->array) {
3063                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3064                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3065                                 NDR_CHECK(ndr_push_srvsvc_NetSessInfo10(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
3066                         }
3067                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3068                                 NDR_CHECK(ndr_push_srvsvc_NetSessInfo10(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
3069                         }
3070                 }
3071         }
3072         return NDR_ERR_SUCCESS;
3073 }
3074
3075 static enum ndr_err_code ndr_pull_srvsvc_NetSessCtr10(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessCtr10 *r)
3076 {
3077         uint32_t _ptr_array;
3078         uint32_t cntr_array_1;
3079         TALLOC_CTX *_mem_save_array_0;
3080         TALLOC_CTX *_mem_save_array_1;
3081         if (ndr_flags & NDR_SCALARS) {
3082                 NDR_CHECK(ndr_pull_align(ndr, 4));
3083                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3084                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
3085                 if (_ptr_array) {
3086                         NDR_PULL_ALLOC(ndr, r->array);
3087                 } else {
3088                         r->array = NULL;
3089                 }
3090         }
3091         if (ndr_flags & NDR_BUFFERS) {
3092                 if (r->array) {
3093                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
3094                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
3095                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
3096                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
3097                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
3098                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
3099                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3100                                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfo10(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
3101                         }
3102                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3103                                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfo10(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
3104                         }
3105                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
3106                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
3107                 }
3108                 if (r->array) {
3109                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
3110                 }
3111         }
3112         return NDR_ERR_SUCCESS;
3113 }
3114
3115 _PUBLIC_ void ndr_print_srvsvc_NetSessCtr10(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessCtr10 *r)
3116 {
3117         uint32_t cntr_array_1;
3118         ndr_print_struct(ndr, name, "srvsvc_NetSessCtr10");
3119         ndr->depth++;
3120         ndr_print_uint32(ndr, "count", r->count);
3121         ndr_print_ptr(ndr, "array", r->array);
3122         ndr->depth++;
3123         if (r->array) {
3124                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
3125                 ndr->depth++;
3126                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
3127                         char *idx_1=NULL;
3128                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
3129                                 ndr_print_srvsvc_NetSessInfo10(ndr, "array", &r->array[cntr_array_1]);
3130                                 free(idx_1);
3131                         }
3132                 }
3133                 ndr->depth--;
3134         }
3135         ndr->depth--;
3136         ndr->depth--;
3137 }
3138
3139 static enum ndr_err_code ndr_push_srvsvc_NetSessInfo502(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessInfo502 *r)
3140 {
3141         if (ndr_flags & NDR_SCALARS) {
3142                 NDR_CHECK(ndr_push_align(ndr, 4));
3143                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
3144                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
3145                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_open));
3146                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3147                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idle_time));
3148                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->user_flags));
3149                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client_type));
3150                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport));
3151         }
3152         if (ndr_flags & NDR_BUFFERS) {
3153                 if (r->client) {
3154                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
3155                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3156                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
3157                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3158                 }
3159                 if (r->user) {
3160                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
3161                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3162                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
3163                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3164                 }
3165                 if (r->client_type) {
3166                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client_type, CH_UTF16)));
3167                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3168                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client_type, CH_UTF16)));
3169                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client_type, ndr_charset_length(r->client_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3170                 }
3171                 if (r->transport) {
3172                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->transport, CH_UTF16)));
3173                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3174                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->transport, CH_UTF16)));
3175                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->transport, ndr_charset_length(r->transport, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3176                 }
3177         }
3178         return NDR_ERR_SUCCESS;
3179 }
3180
3181 static enum ndr_err_code ndr_pull_srvsvc_NetSessInfo502(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessInfo502 *r)
3182 {
3183         uint32_t _ptr_client;
3184         TALLOC_CTX *_mem_save_client_0;
3185         uint32_t _ptr_user;
3186         TALLOC_CTX *_mem_save_user_0;
3187         uint32_t _ptr_client_type;
3188         TALLOC_CTX *_mem_save_client_type_0;
3189         uint32_t _ptr_transport;
3190         TALLOC_CTX *_mem_save_transport_0;
3191         if (ndr_flags & NDR_SCALARS) {
3192                 NDR_CHECK(ndr_pull_align(ndr, 4));
3193                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
3194                 if (_ptr_client) {
3195                         NDR_PULL_ALLOC(ndr, r->client);
3196                 } else {
3197                         r->client = NULL;
3198                 }
3199                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
3200                 if (_ptr_user) {
3201                         NDR_PULL_ALLOC(ndr, r->user);
3202                 } else {
3203                         r->user = NULL;
3204                 }
3205                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_open));
3206                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3207                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idle_time));
3208                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->user_flags));
3209                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client_type));
3210                 if (_ptr_client_type) {
3211                         NDR_PULL_ALLOC(ndr, r->client_type);
3212                 } else {
3213                         r->client_type = NULL;
3214                 }
3215                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport));
3216                 if (_ptr_transport) {
3217                         NDR_PULL_ALLOC(ndr, r->transport);
3218                 } else {
3219                         r->transport = NULL;
3220                 }
3221         }
3222         if (ndr_flags & NDR_BUFFERS) {
3223                 if (r->client) {
3224                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
3225                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
3226                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
3227                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
3228                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
3229                                 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));
3230                         }
3231                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
3232                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
3233                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
3234                 }
3235                 if (r->user) {
3236                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
3237                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
3238                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
3239                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
3240                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
3241                                 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));
3242                         }
3243                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
3244                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
3245                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
3246                 }
3247                 if (r->client_type) {
3248                         _mem_save_client_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3249                         NDR_PULL_SET_MEM_CTX(ndr, r->client_type, 0);
3250                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client_type));
3251                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client_type));
3252                         if (ndr_get_array_length(ndr, &r->client_type) > ndr_get_array_size(ndr, &r->client_type)) {
3253                                 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));
3254                         }
3255                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client_type), sizeof(uint16_t)));
3256                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client_type, ndr_get_array_length(ndr, &r->client_type), sizeof(uint16_t), CH_UTF16));
3257                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_type_0, 0);
3258                 }
3259                 if (r->transport) {
3260                         _mem_save_transport_0 = NDR_PULL_GET_MEM_CTX(ndr);
3261                         NDR_PULL_SET_MEM_CTX(ndr, r->transport, 0);
3262                         NDR_CHECK(ndr_pull_array_size(ndr, &r->transport));
3263                         NDR_CHECK(ndr_pull_array_length(ndr, &r->transport));
3264                         if (ndr_get_array_length(ndr, &r->transport) > ndr_get_array_size(ndr, &r->transport)) {
3265                                 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));
3266                         }
3267                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->transport), sizeof(uint16_t)));
3268                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->transport, ndr_get_array_length(ndr, &r->transport), sizeof(uint16_t), CH_UTF16));
3269                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_0, 0);
3270                 }
3271         }
3272         return NDR_ERR_SUCCESS;
3273 }
3274
3275 _PUBLIC_ void ndr_print_srvsvc_NetSessInfo502(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessInfo502 *r)
3276 {
3277         ndr_print_struct(ndr, name, "srvsvc_NetSessInfo502");
3278         ndr->depth++;
3279         ndr_print_ptr(ndr, "client", r->client);
3280         ndr->depth++;
3281         if (r->client) {
3282                 ndr_print_string(ndr, "client", r->client);
3283         }
3284         ndr->depth--;
3285         ndr_print_ptr(ndr, "user", r->user);
3286         ndr->depth++;
3287         if (r->user) {
3288                 ndr_print_string(ndr, "user", r->user);
3289         }
3290         ndr->depth--;
3291         ndr_print_uint32(ndr, "num_open", r->num_open);
3292         ndr_print_uint32(ndr, "time", r->time);
3293         ndr_print_uint32(ndr, "idle_time", r->idle_time);
3294         ndr_print_uint32(ndr, "user_flags", r->user_flags);
3295         ndr_print_ptr(ndr, "client_type", r->client_type);
3296         ndr->depth++;
3297         if (r->client_type) {
3298                 ndr_print_string(ndr, "client_type", r->client_type);
3299         }
3300         ndr->depth--;
3301         ndr_print_ptr(ndr, "transport", r->transport);
3302         ndr->depth++;
3303         if (r->transport) {
3304                 ndr_print_string(ndr, "transport", r->transport);
3305         }
3306         ndr->depth--;
3307         ndr->depth--;
3308 }
3309
3310 static enum ndr_err_code ndr_push_srvsvc_NetSessCtr502(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessCtr502 *r)
3311 {
3312         uint32_t cntr_array_1;
3313         if (ndr_flags & NDR_SCALARS) {
3314                 NDR_CHECK(ndr_push_align(ndr, 4));
3315                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3316                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
3317         }
3318         if (ndr_flags & NDR_BUFFERS) {
3319                 if (r->array) {
3320                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3321                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3322                                 NDR_CHECK(ndr_push_srvsvc_NetSessInfo502(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
3323                         }
3324                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3325                                 NDR_CHECK(ndr_push_srvsvc_NetSessInfo502(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
3326                         }
3327                 }
3328         }
3329         return NDR_ERR_SUCCESS;
3330 }
3331
3332 static enum ndr_err_code ndr_pull_srvsvc_NetSessCtr502(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessCtr502 *r)
3333 {
3334         uint32_t _ptr_array;
3335         uint32_t cntr_array_1;
3336         TALLOC_CTX *_mem_save_array_0;
3337         TALLOC_CTX *_mem_save_array_1;
3338         if (ndr_flags & NDR_SCALARS) {
3339                 NDR_CHECK(ndr_pull_align(ndr, 4));
3340                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3341                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
3342                 if (_ptr_array) {
3343                         NDR_PULL_ALLOC(ndr, r->array);
3344                 } else {
3345                         r->array = NULL;
3346                 }
3347         }
3348         if (ndr_flags & NDR_BUFFERS) {
3349                 if (r->array) {
3350                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
3351                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
3352                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
3353                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
3354                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
3355                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
3356                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3357                                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfo502(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
3358                         }
3359                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3360                                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfo502(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
3361                         }
3362                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
3363                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
3364                 }
3365                 if (r->array) {
3366                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
3367                 }
3368         }
3369         return NDR_ERR_SUCCESS;
3370 }
3371
3372 _PUBLIC_ void ndr_print_srvsvc_NetSessCtr502(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessCtr502 *r)
3373 {
3374         uint32_t cntr_array_1;
3375         ndr_print_struct(ndr, name, "srvsvc_NetSessCtr502");
3376         ndr->depth++;
3377         ndr_print_uint32(ndr, "count", r->count);
3378         ndr_print_ptr(ndr, "array", r->array);
3379         ndr->depth++;
3380         if (r->array) {
3381                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
3382                 ndr->depth++;
3383                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
3384                         char *idx_1=NULL;
3385                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
3386                                 ndr_print_srvsvc_NetSessInfo502(ndr, "array", &r->array[cntr_array_1]);
3387                                 free(idx_1);
3388                         }
3389                 }
3390                 ndr->depth--;
3391         }
3392         ndr->depth--;
3393         ndr->depth--;
3394 }
3395
3396 static enum ndr_err_code ndr_push_srvsvc_NetSessCtr(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetSessCtr *r)
3397 {
3398         if (ndr_flags & NDR_SCALARS) {
3399                 int level = ndr_push_get_switch_value(ndr, r);
3400                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
3401                 switch (level) {
3402                         case 0: {
3403                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
3404                         break; }
3405
3406                         case 1: {
3407                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
3408                         break; }
3409
3410                         case 2: {
3411                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr2));
3412                         break; }
3413
3414                         case 10: {
3415                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr10));
3416                         break; }
3417
3418                         case 502: {
3419                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr502));
3420                         break; }
3421
3422                         default: {
3423                         break; }
3424
3425                 }
3426         }
3427         if (ndr_flags & NDR_BUFFERS) {
3428                 int level = ndr_push_get_switch_value(ndr, r);
3429                 switch (level) {
3430                         case 0:
3431                                 if (r->ctr0) {
3432                                         NDR_CHECK(ndr_push_srvsvc_NetSessCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
3433                                 }
3434                         break;
3435
3436                         case 1:
3437                                 if (r->ctr1) {
3438                                         NDR_CHECK(ndr_push_srvsvc_NetSessCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
3439                                 }
3440                         break;
3441
3442                         case 2:
3443                                 if (r->ctr2) {
3444                                         NDR_CHECK(ndr_push_srvsvc_NetSessCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
3445                                 }
3446                         break;
3447
3448                         case 10:
3449                                 if (r->ctr10) {
3450                                         NDR_CHECK(ndr_push_srvsvc_NetSessCtr10(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr10));
3451                                 }
3452                         break;
3453
3454                         case 502:
3455                                 if (r->ctr502) {
3456                                         NDR_CHECK(ndr_push_srvsvc_NetSessCtr502(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr502));
3457                                 }
3458                         break;
3459
3460                         default:
3461                         break;
3462
3463                 }
3464         }
3465         return NDR_ERR_SUCCESS;
3466 }
3467
3468 static enum ndr_err_code ndr_pull_srvsvc_NetSessCtr(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetSessCtr *r)
3469 {
3470         int level;
3471         uint32_t _level;
3472         TALLOC_CTX *_mem_save_ctr0_0;
3473         TALLOC_CTX *_mem_save_ctr1_0;
3474         TALLOC_CTX *_mem_save_ctr2_0;
3475         TALLOC_CTX *_mem_save_ctr10_0;
3476         TALLOC_CTX *_mem_save_ctr502_0;
3477         level = ndr_pull_get_switch_value(ndr, r);
3478         if (ndr_flags & NDR_SCALARS) {
3479                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
3480                 if (_level != level) {
3481                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
3482                 }
3483                 switch (level) {
3484                         case 0: {
3485                                 uint32_t _ptr_ctr0;
3486                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));
3487                                 if (_ptr_ctr0) {
3488                                         NDR_PULL_ALLOC(ndr, r->ctr0);
3489                                 } else {
3490                                         r->ctr0 = NULL;
3491                                 }
3492                         break; }
3493
3494                         case 1: {
3495                                 uint32_t _ptr_ctr1;
3496                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
3497                                 if (_ptr_ctr1) {
3498                                         NDR_PULL_ALLOC(ndr, r->ctr1);
3499                                 } else {
3500                                         r->ctr1 = NULL;
3501                                 }
3502                         break; }
3503
3504                         case 2: {
3505                                 uint32_t _ptr_ctr2;
3506                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr2));
3507                                 if (_ptr_ctr2) {
3508                                         NDR_PULL_ALLOC(ndr, r->ctr2);
3509                                 } else {
3510                                         r->ctr2 = NULL;
3511                                 }
3512                         break; }
3513
3514                         case 10: {
3515                                 uint32_t _ptr_ctr10;
3516                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr10));
3517                                 if (_ptr_ctr10) {
3518                                         NDR_PULL_ALLOC(ndr, r->ctr10);
3519                                 } else {
3520                                         r->ctr10 = NULL;
3521                                 }
3522                         break; }
3523
3524                         case 502: {
3525                                 uint32_t _ptr_ctr502;
3526                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr502));
3527                                 if (_ptr_ctr502) {
3528                                         NDR_PULL_ALLOC(ndr, r->ctr502);
3529                                 } else {
3530                                         r->ctr502 = NULL;
3531                                 }
3532                         break; }
3533
3534                         default: {
3535                         break; }
3536
3537                 }
3538         }
3539         if (ndr_flags & NDR_BUFFERS) {
3540                 switch (level) {
3541                         case 0:
3542                                 if (r->ctr0) {
3543                                         _mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);
3544                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr0, 0);
3545                                         NDR_CHECK(ndr_pull_srvsvc_NetSessCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
3546                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);
3547                                 }
3548                         break;
3549
3550                         case 1:
3551                                 if (r->ctr1) {
3552                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
3553                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
3554                                         NDR_CHECK(ndr_pull_srvsvc_NetSessCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
3555                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
3556                                 }
3557                         break;
3558
3559                         case 2:
3560                                 if (r->ctr2) {
3561                                         _mem_save_ctr2_0 = NDR_PULL_GET_MEM_CTX(ndr);
3562                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr2, 0);
3563                                         NDR_CHECK(ndr_pull_srvsvc_NetSessCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
3564                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr2_0, 0);
3565                                 }
3566                         break;
3567
3568                         case 10:
3569                                 if (r->ctr10) {
3570                                         _mem_save_ctr10_0 = NDR_PULL_GET_MEM_CTX(ndr);
3571                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr10, 0);
3572                                         NDR_CHECK(ndr_pull_srvsvc_NetSessCtr10(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr10));
3573                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr10_0, 0);
3574                                 }
3575                         break;
3576
3577                         case 502:
3578                                 if (r->ctr502) {
3579                                         _mem_save_ctr502_0 = NDR_PULL_GET_MEM_CTX(ndr);
3580                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr502, 0);
3581                                         NDR_CHECK(ndr_pull_srvsvc_NetSessCtr502(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr502));
3582                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr502_0, 0);
3583                                 }
3584                         break;
3585
3586                         default:
3587                         break;
3588
3589                 }
3590         }
3591         return NDR_ERR_SUCCESS;
3592 }
3593
3594 _PUBLIC_ void ndr_print_srvsvc_NetSessCtr(struct ndr_print *ndr, const char *name, const union srvsvc_NetSessCtr *r)
3595 {
3596         int level;
3597         level = ndr_print_get_switch_value(ndr, r);
3598         ndr_print_union(ndr, name, level, "srvsvc_NetSessCtr");
3599         switch (level) {
3600                 case 0:
3601                         ndr_print_ptr(ndr, "ctr0", r->ctr0);
3602                         ndr->depth++;
3603                         if (r->ctr0) {
3604                                 ndr_print_srvsvc_NetSessCtr0(ndr, "ctr0", r->ctr0);
3605                         }
3606                         ndr->depth--;
3607                 break;
3608
3609                 case 1:
3610                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
3611                         ndr->depth++;
3612                         if (r->ctr1) {
3613                                 ndr_print_srvsvc_NetSessCtr1(ndr, "ctr1", r->ctr1);
3614                         }
3615                         ndr->depth--;
3616                 break;
3617
3618                 case 2:
3619                         ndr_print_ptr(ndr, "ctr2", r->ctr2);
3620                         ndr->depth++;
3621                         if (r->ctr2) {
3622                                 ndr_print_srvsvc_NetSessCtr2(ndr, "ctr2", r->ctr2);
3623                         }
3624                         ndr->depth--;
3625                 break;
3626
3627                 case 10:
3628                         ndr_print_ptr(ndr, "ctr10", r->ctr10);
3629                         ndr->depth++;
3630                         if (r->ctr10) {
3631                                 ndr_print_srvsvc_NetSessCtr10(ndr, "ctr10", r->ctr10);
3632                         }
3633                         ndr->depth--;
3634                 break;
3635
3636                 case 502:
3637                         ndr_print_ptr(ndr, "ctr502", r->ctr502);
3638                         ndr->depth++;
3639                         if (r->ctr502) {
3640                                 ndr_print_srvsvc_NetSessCtr502(ndr, "ctr502", r->ctr502);
3641                         }
3642                         ndr->depth--;
3643                 break;
3644
3645                 default:
3646                 break;
3647
3648         }
3649 }
3650
3651 static enum ndr_err_code ndr_push_srvsvc_NetSessInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessInfoCtr *r)
3652 {
3653         if (ndr_flags & NDR_SCALARS) {
3654                 NDR_CHECK(ndr_push_align(ndr, 4));
3655                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
3656                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
3657                 NDR_CHECK(ndr_push_srvsvc_NetSessCtr(ndr, NDR_SCALARS, &r->ctr));
3658         }
3659         if (ndr_flags & NDR_BUFFERS) {
3660                 NDR_CHECK(ndr_push_srvsvc_NetSessCtr(ndr, NDR_BUFFERS, &r->ctr));
3661         }
3662         return NDR_ERR_SUCCESS;
3663 }
3664
3665 static enum ndr_err_code ndr_pull_srvsvc_NetSessInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessInfoCtr *r)
3666 {
3667         if (ndr_flags & NDR_SCALARS) {
3668                 NDR_CHECK(ndr_pull_align(ndr, 4));
3669                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
3670                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
3671                 NDR_CHECK(ndr_pull_srvsvc_NetSessCtr(ndr, NDR_SCALARS, &r->ctr));
3672         }
3673         if (ndr_flags & NDR_BUFFERS) {
3674                 NDR_CHECK(ndr_pull_srvsvc_NetSessCtr(ndr, NDR_BUFFERS, &r->ctr));
3675         }
3676         return NDR_ERR_SUCCESS;
3677 }
3678
3679 _PUBLIC_ void ndr_print_srvsvc_NetSessInfoCtr(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessInfoCtr *r)
3680 {
3681         ndr_print_struct(ndr, name, "srvsvc_NetSessInfoCtr");
3682         ndr->depth++;
3683         ndr_print_uint32(ndr, "level", r->level);
3684         ndr_print_set_switch_value(ndr, &r->ctr, r->level);
3685         ndr_print_srvsvc_NetSessCtr(ndr, "ctr", &r->ctr);
3686         ndr->depth--;
3687 }
3688
3689 static enum ndr_err_code ndr_push_srvsvc_ShareType(struct ndr_push *ndr, int ndr_flags, enum srvsvc_ShareType r)
3690 {
3691         {
3692                 uint32_t _flags_save_ENUM = ndr->flags;
3693                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3694                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3695                 ndr->flags = _flags_save_ENUM;
3696         }
3697         return NDR_ERR_SUCCESS;
3698 }
3699
3700 static enum ndr_err_code ndr_pull_srvsvc_ShareType(struct ndr_pull *ndr, int ndr_flags, enum srvsvc_ShareType *r)
3701 {
3702         uint32_t v;
3703         {
3704                 uint32_t _flags_save_ENUM = ndr->flags;
3705                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3706                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3707                 *r = v;
3708                 ndr->flags = _flags_save_ENUM;
3709         }
3710         return NDR_ERR_SUCCESS;
3711 }
3712
3713 _PUBLIC_ void ndr_print_srvsvc_ShareType(struct ndr_print *ndr, const char *name, enum srvsvc_ShareType r)
3714 {
3715         const char *val = NULL;
3716
3717         {
3718                 uint32_t _flags_save_ENUM = ndr->flags;
3719                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3720                 switch (r) {
3721                         case STYPE_DISKTREE: val = "STYPE_DISKTREE"; break;
3722                         case STYPE_DISKTREE_TEMPORARY: val = "STYPE_DISKTREE_TEMPORARY"; break;
3723                         case STYPE_DISKTREE_HIDDEN: val = "STYPE_DISKTREE_HIDDEN"; break;
3724                         case STYPE_PRINTQ: val = "STYPE_PRINTQ"; break;
3725                         case STYPE_PRINTQ_TEMPORARY: val = "STYPE_PRINTQ_TEMPORARY"; break;
3726                         case STYPE_PRINTQ_HIDDEN: val = "STYPE_PRINTQ_HIDDEN"; break;
3727                         case STYPE_DEVICE: val = "STYPE_DEVICE"; break;
3728                         case STYPE_DEVICE_TEMPORARY: val = "STYPE_DEVICE_TEMPORARY"; break;
3729                         case STYPE_DEVICE_HIDDEN: val = "STYPE_DEVICE_HIDDEN"; break;
3730                         case STYPE_IPC: val = "STYPE_IPC"; break;
3731                         case STYPE_IPC_TEMPORARY: val = "STYPE_IPC_TEMPORARY"; break;
3732                         case STYPE_IPC_HIDDEN: val = "STYPE_IPC_HIDDEN"; break;
3733                 }
3734                 ndr_print_enum(ndr, name, "ENUM", val, r);
3735                 ndr->flags = _flags_save_ENUM;
3736         }
3737 }
3738
3739 static enum ndr_err_code ndr_push_srvsvc_NetShareInfo0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo0 *r)
3740 {
3741         if (ndr_flags & NDR_SCALARS) {
3742                 NDR_CHECK(ndr_push_align(ndr, 4));
3743                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
3744         }
3745         if (ndr_flags & NDR_BUFFERS) {
3746                 if (r->name) {
3747                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
3748                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3749                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
3750                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3751                 }
3752         }
3753         return NDR_ERR_SUCCESS;
3754 }
3755
3756 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo0 *r)
3757 {
3758         uint32_t _ptr_name;
3759         TALLOC_CTX *_mem_save_name_0;
3760         if (ndr_flags & NDR_SCALARS) {
3761                 NDR_CHECK(ndr_pull_align(ndr, 4));
3762                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
3763                 if (_ptr_name) {
3764                         NDR_PULL_ALLOC(ndr, r->name);
3765                 } else {
3766                         r->name = NULL;
3767                 }
3768         }
3769         if (ndr_flags & NDR_BUFFERS) {
3770                 if (r->name) {
3771                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3772                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
3773                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
3774                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
3775                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
3776                                 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));
3777                         }
3778                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
3779                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
3780                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
3781                 }
3782         }
3783         return NDR_ERR_SUCCESS;
3784 }
3785
3786 _PUBLIC_ void ndr_print_srvsvc_NetShareInfo0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo0 *r)
3787 {
3788         ndr_print_struct(ndr, name, "srvsvc_NetShareInfo0");
3789         ndr->depth++;
3790         ndr_print_ptr(ndr, "name", r->name);
3791         ndr->depth++;
3792         if (r->name) {
3793                 ndr_print_string(ndr, "name", r->name);
3794         }
3795         ndr->depth--;
3796         ndr->depth--;
3797 }
3798
3799 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr0 *r)
3800 {
3801         uint32_t cntr_array_1;
3802         if (ndr_flags & NDR_SCALARS) {
3803                 NDR_CHECK(ndr_push_align(ndr, 4));
3804                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3805                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
3806         }
3807         if (ndr_flags & NDR_BUFFERS) {
3808                 if (r->array) {
3809                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3810                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3811                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
3812                         }
3813                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3814                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
3815                         }
3816                 }
3817         }
3818         return NDR_ERR_SUCCESS;
3819 }
3820
3821 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr0 *r)
3822 {
3823         uint32_t _ptr_array;
3824         uint32_t cntr_array_1;
3825         TALLOC_CTX *_mem_save_array_0;
3826         TALLOC_CTX *_mem_save_array_1;
3827         if (ndr_flags & NDR_SCALARS) {
3828                 NDR_CHECK(ndr_pull_align(ndr, 4));
3829                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3830                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
3831                 if (_ptr_array) {
3832                         NDR_PULL_ALLOC(ndr, r->array);
3833                 } else {
3834                         r->array = NULL;
3835                 }
3836         }
3837         if (ndr_flags & NDR_BUFFERS) {
3838                 if (r->array) {
3839                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
3840                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
3841                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
3842                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
3843                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
3844                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
3845                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3846                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
3847                         }
3848                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3849                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
3850                         }
3851                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
3852                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
3853                 }
3854                 if (r->array) {
3855                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
3856                 }
3857         }
3858         return NDR_ERR_SUCCESS;
3859 }
3860
3861 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr0 *r)
3862 {
3863         uint32_t cntr_array_1;
3864         ndr_print_struct(ndr, name, "srvsvc_NetShareCtr0");
3865         ndr->depth++;
3866         ndr_print_uint32(ndr, "count", r->count);
3867         ndr_print_ptr(ndr, "array", r->array);
3868         ndr->depth++;
3869         if (r->array) {
3870                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
3871                 ndr->depth++;
3872                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
3873                         char *idx_1=NULL;
3874                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
3875                                 ndr_print_srvsvc_NetShareInfo0(ndr, "array", &r->array[cntr_array_1]);
3876                                 free(idx_1);
3877                         }
3878                 }
3879                 ndr->depth--;
3880         }
3881         ndr->depth--;
3882         ndr->depth--;
3883 }
3884
3885 static enum ndr_err_code ndr_push_srvsvc_NetShareInfo1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo1 *r)
3886 {
3887         if (ndr_flags & NDR_SCALARS) {
3888                 NDR_CHECK(ndr_push_align(ndr, 4));
3889                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
3890                 NDR_CHECK(ndr_push_srvsvc_ShareType(ndr, NDR_SCALARS, r->type));
3891                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
3892         }
3893         if (ndr_flags & NDR_BUFFERS) {
3894                 if (r->name) {
3895                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
3896                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3897                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
3898                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3899                 }
3900                 if (r->comment) {
3901                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
3902                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3903                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
3904                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3905                 }
3906         }
3907         return NDR_ERR_SUCCESS;
3908 }
3909
3910 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo1 *r)
3911 {
3912         uint32_t _ptr_name;
3913         TALLOC_CTX *_mem_save_name_0;
3914         uint32_t _ptr_comment;
3915         TALLOC_CTX *_mem_save_comment_0;
3916         if (ndr_flags & NDR_SCALARS) {
3917                 NDR_CHECK(ndr_pull_align(ndr, 4));
3918                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
3919                 if (_ptr_name) {
3920                         NDR_PULL_ALLOC(ndr, r->name);
3921                 } else {
3922                         r->name = NULL;
3923                 }
3924                 NDR_CHECK(ndr_pull_srvsvc_ShareType(ndr, NDR_SCALARS, &r->type));
3925                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
3926                 if (_ptr_comment) {
3927                         NDR_PULL_ALLOC(ndr, r->comment);
3928                 } else {
3929                         r->comment = NULL;
3930                 }
3931         }
3932         if (ndr_flags & NDR_BUFFERS) {
3933                 if (r->name) {
3934                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3935                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
3936                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
3937                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
3938                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
3939                                 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));
3940                         }
3941                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
3942                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
3943                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
3944                 }
3945                 if (r->comment) {
3946                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
3947                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
3948                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
3949                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
3950                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
3951                                 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));
3952                         }
3953                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
3954                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
3955                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
3956                 }
3957         }
3958         return NDR_ERR_SUCCESS;
3959 }
3960
3961 _PUBLIC_ void ndr_print_srvsvc_NetShareInfo1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo1 *r)
3962 {
3963         ndr_print_struct(ndr, name, "srvsvc_NetShareInfo1");
3964         ndr->depth++;
3965         ndr_print_ptr(ndr, "name", r->name);
3966         ndr->depth++;
3967         if (r->name) {
3968                 ndr_print_string(ndr, "name", r->name);
3969         }
3970         ndr->depth--;
3971         ndr_print_srvsvc_ShareType(ndr, "type", r->type);
3972         ndr_print_ptr(ndr, "comment", r->comment);
3973         ndr->depth++;
3974         if (r->comment) {
3975                 ndr_print_string(ndr, "comment", r->comment);
3976         }
3977         ndr->depth--;
3978         ndr->depth--;
3979 }
3980
3981 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr1 *r)
3982 {
3983         uint32_t cntr_array_1;
3984         if (ndr_flags & NDR_SCALARS) {
3985                 NDR_CHECK(ndr_push_align(ndr, 4));
3986                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3987                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
3988         }
3989         if (ndr_flags & NDR_BUFFERS) {
3990                 if (r->array) {
3991                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3992                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3993                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
3994                         }
3995                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3996                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
3997                         }
3998                 }
3999         }
4000         return NDR_ERR_SUCCESS;
4001 }
4002
4003 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr1 *r)
4004 {
4005         uint32_t _ptr_array;
4006         uint32_t cntr_array_1;
4007         TALLOC_CTX *_mem_save_array_0;
4008         TALLOC_CTX *_mem_save_array_1;
4009         if (ndr_flags & NDR_SCALARS) {
4010                 NDR_CHECK(ndr_pull_align(ndr, 4));
4011                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4012                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
4013                 if (_ptr_array) {
4014                         NDR_PULL_ALLOC(ndr, r->array);
4015                 } else {
4016                         r->array = NULL;
4017                 }
4018         }
4019         if (ndr_flags & NDR_BUFFERS) {
4020                 if (r->array) {
4021                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4022                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4023                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
4024                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
4025                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4026                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4027                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4028                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4029                         }
4030                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4031                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4032                         }
4033                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
4034                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
4035                 }
4036                 if (r->array) {
4037                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
4038                 }
4039         }
4040         return NDR_ERR_SUCCESS;
4041 }
4042
4043 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr1 *r)
4044 {
4045         uint32_t cntr_array_1;
4046         ndr_print_struct(ndr, name, "srvsvc_NetShareCtr1");
4047         ndr->depth++;
4048         ndr_print_uint32(ndr, "count", r->count);
4049         ndr_print_ptr(ndr, "array", r->array);
4050         ndr->depth++;
4051         if (r->array) {
4052                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
4053                 ndr->depth++;
4054                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
4055                         char *idx_1=NULL;
4056                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
4057                                 ndr_print_srvsvc_NetShareInfo1(ndr, "array", &r->array[cntr_array_1]);
4058                                 free(idx_1);
4059                         }
4060                 }
4061                 ndr->depth--;
4062         }
4063         ndr->depth--;
4064         ndr->depth--;
4065 }
4066
4067 static enum ndr_err_code ndr_push_srvsvc_NetShareInfo2(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo2 *r)
4068 {
4069         if (ndr_flags & NDR_SCALARS) {
4070                 NDR_CHECK(ndr_push_align(ndr, 4));
4071                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
4072                 NDR_CHECK(ndr_push_srvsvc_ShareType(ndr, NDR_SCALARS, r->type));
4073                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
4074                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->permissions));
4075                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_users));
4076                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->current_users));
4077                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->path));
4078                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->password));
4079         }
4080         if (ndr_flags & NDR_BUFFERS) {
4081                 if (r->name) {
4082                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
4083                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4084                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
4085                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4086                 }
4087                 if (r->comment) {
4088                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
4089                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4090                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
4091                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4092                 }
4093                 if (r->path) {
4094                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));
4095                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4096                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));
4097                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->path, ndr_charset_length(r->path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4098                 }
4099                 if (r->password) {
4100                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));
4101                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4102                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));
4103                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->password, ndr_charset_length(r->password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4104                 }
4105         }
4106         return NDR_ERR_SUCCESS;
4107 }
4108
4109 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo2(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo2 *r)
4110 {
4111         uint32_t _ptr_name;
4112         TALLOC_CTX *_mem_save_name_0;
4113         uint32_t _ptr_comment;
4114         TALLOC_CTX *_mem_save_comment_0;
4115         uint32_t _ptr_path;
4116         TALLOC_CTX *_mem_save_path_0;
4117         uint32_t _ptr_password;
4118         TALLOC_CTX *_mem_save_password_0;
4119         if (ndr_flags & NDR_SCALARS) {
4120                 NDR_CHECK(ndr_pull_align(ndr, 4));
4121                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
4122                 if (_ptr_name) {
4123                         NDR_PULL_ALLOC(ndr, r->name);
4124                 } else {
4125                         r->name = NULL;
4126                 }
4127                 NDR_CHECK(ndr_pull_srvsvc_ShareType(ndr, NDR_SCALARS, &r->type));
4128                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
4129                 if (_ptr_comment) {
4130                         NDR_PULL_ALLOC(ndr, r->comment);
4131                 } else {
4132                         r->comment = NULL;
4133                 }
4134                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->permissions));
4135                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_users));
4136                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->current_users));
4137                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_path));
4138                 if (_ptr_path) {
4139                         NDR_PULL_ALLOC(ndr, r->path);
4140                 } else {
4141                         r->path = NULL;
4142                 }
4143                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
4144                 if (_ptr_password) {
4145                         NDR_PULL_ALLOC(ndr, r->password);
4146                 } else {
4147                         r->password = NULL;
4148                 }
4149         }
4150         if (ndr_flags & NDR_BUFFERS) {
4151                 if (r->name) {
4152                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4153                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
4154                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
4155                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
4156                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
4157                                 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));
4158                         }
4159                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
4160                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
4161                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
4162                 }
4163                 if (r->comment) {
4164                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
4165                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
4166                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
4167                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
4168                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
4169                                 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));
4170                         }
4171                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
4172                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
4173                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
4174                 }
4175                 if (r->path) {
4176                         _mem_save_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
4177                         NDR_PULL_SET_MEM_CTX(ndr, r->path, 0);
4178                         NDR_CHECK(ndr_pull_array_size(ndr, &r->path));
4179                         NDR_CHECK(ndr_pull_array_length(ndr, &r->path));
4180                         if (ndr_get_array_length(ndr, &r->path) > ndr_get_array_size(ndr, &r->path)) {
4181                                 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));
4182                         }
4183                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->path), sizeof(uint16_t)));
4184                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->path, ndr_get_array_length(ndr, &r->path), sizeof(uint16_t), CH_UTF16));
4185                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_path_0, 0);
4186                 }
4187                 if (r->password) {
4188                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
4189                         NDR_PULL_SET_MEM_CTX(ndr, r->password, 0);
4190                         NDR_CHECK(ndr_pull_array_size(ndr, &r->password));
4191                         NDR_CHECK(ndr_pull_array_length(ndr, &r->password));
4192                         if (ndr_get_array_length(ndr, &r->password) > ndr_get_array_size(ndr, &r->password)) {
4193                                 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));
4194                         }
4195                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t)));
4196                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->password, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t), CH_UTF16));
4197                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
4198                 }
4199         }
4200         return NDR_ERR_SUCCESS;
4201 }
4202
4203 _PUBLIC_ void ndr_print_srvsvc_NetShareInfo2(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo2 *r)
4204 {
4205         ndr_print_struct(ndr, name, "srvsvc_NetShareInfo2");
4206         ndr->depth++;
4207         ndr_print_ptr(ndr, "name", r->name);
4208         ndr->depth++;
4209         if (r->name) {
4210                 ndr_print_string(ndr, "name", r->name);
4211         }
4212         ndr->depth--;
4213         ndr_print_srvsvc_ShareType(ndr, "type", r->type);
4214         ndr_print_ptr(ndr, "comment", r->comment);
4215         ndr->depth++;
4216         if (r->comment) {
4217                 ndr_print_string(ndr, "comment", r->comment);
4218         }
4219         ndr->depth--;
4220         ndr_print_uint32(ndr, "permissions", r->permissions);
4221         ndr_print_uint32(ndr, "max_users", r->max_users);
4222         ndr_print_uint32(ndr, "current_users", r->current_users);
4223         ndr_print_ptr(ndr, "path", r->path);
4224         ndr->depth++;
4225         if (r->path) {
4226                 ndr_print_string(ndr, "path", r->path);
4227         }
4228         ndr->depth--;
4229         ndr_print_ptr(ndr, "password", r->password);
4230         ndr->depth++;
4231         if (r->password) {
4232                 ndr_print_string(ndr, "password", r->password);
4233         }
4234         ndr->depth--;
4235         ndr->depth--;
4236 }
4237
4238 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr2(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr2 *r)
4239 {
4240         uint32_t cntr_array_1;
4241         if (ndr_flags & NDR_SCALARS) {
4242                 NDR_CHECK(ndr_push_align(ndr, 4));
4243                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4244                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
4245         }
4246         if (ndr_flags & NDR_BUFFERS) {
4247                 if (r->array) {
4248                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4249                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4250                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4251                         }
4252                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4253                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4254                         }
4255                 }
4256         }
4257         return NDR_ERR_SUCCESS;
4258 }
4259
4260 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr2(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr2 *r)
4261 {
4262         uint32_t _ptr_array;
4263         uint32_t cntr_array_1;
4264         TALLOC_CTX *_mem_save_array_0;
4265         TALLOC_CTX *_mem_save_array_1;
4266         if (ndr_flags & NDR_SCALARS) {
4267                 NDR_CHECK(ndr_pull_align(ndr, 4));
4268                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4269                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
4270                 if (_ptr_array) {
4271                         NDR_PULL_ALLOC(ndr, r->array);
4272                 } else {
4273                         r->array = NULL;
4274                 }
4275         }
4276         if (ndr_flags & NDR_BUFFERS) {
4277                 if (r->array) {
4278                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4279                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4280                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
4281                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
4282                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4283                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4284                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4285                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4286                         }
4287                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4288                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4289                         }
4290                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
4291                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
4292                 }
4293                 if (r->array) {
4294                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
4295                 }
4296         }
4297         return NDR_ERR_SUCCESS;
4298 }
4299
4300 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr2(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr2 *r)
4301 {
4302         uint32_t cntr_array_1;
4303         ndr_print_struct(ndr, name, "srvsvc_NetShareCtr2");
4304         ndr->depth++;
4305         ndr_print_uint32(ndr, "count", r->count);
4306         ndr_print_ptr(ndr, "array", r->array);
4307         ndr->depth++;
4308         if (r->array) {
4309                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
4310                 ndr->depth++;
4311                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
4312                         char *idx_1=NULL;
4313                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
4314                                 ndr_print_srvsvc_NetShareInfo2(ndr, "array", &r->array[cntr_array_1]);
4315                                 free(idx_1);
4316                         }
4317                 }
4318                 ndr->depth--;
4319         }
4320         ndr->depth--;
4321         ndr->depth--;
4322 }
4323
4324 static enum ndr_err_code ndr_push_srvsvc_NetShareInfo501(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo501 *r)
4325 {
4326         if (ndr_flags & NDR_SCALARS) {
4327                 NDR_CHECK(ndr_push_align(ndr, 4));
4328                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
4329                 NDR_CHECK(ndr_push_srvsvc_ShareType(ndr, NDR_SCALARS, r->type));
4330                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
4331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->csc_policy));
4332         }
4333         if (ndr_flags & NDR_BUFFERS) {
4334                 if (r->name) {
4335                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
4336                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4337                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
4338                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4339                 }
4340                 if (r->comment) {
4341                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
4342                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4343                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
4344                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4345                 }
4346         }
4347         return NDR_ERR_SUCCESS;
4348 }
4349
4350 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo501(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo501 *r)
4351 {
4352         uint32_t _ptr_name;
4353         TALLOC_CTX *_mem_save_name_0;
4354         uint32_t _ptr_comment;
4355         TALLOC_CTX *_mem_save_comment_0;
4356         if (ndr_flags & NDR_SCALARS) {
4357                 NDR_CHECK(ndr_pull_align(ndr, 4));
4358                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
4359                 if (_ptr_name) {
4360                         NDR_PULL_ALLOC(ndr, r->name);
4361                 } else {
4362                         r->name = NULL;
4363                 }
4364                 NDR_CHECK(ndr_pull_srvsvc_ShareType(ndr, NDR_SCALARS, &r->type));
4365                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
4366                 if (_ptr_comment) {
4367                         NDR_PULL_ALLOC(ndr, r->comment);
4368                 } else {
4369                         r->comment = NULL;
4370                 }
4371                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->csc_policy));
4372         }
4373         if (ndr_flags & NDR_BUFFERS) {
4374                 if (r->name) {
4375                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4376                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
4377                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
4378                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
4379                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
4380                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));
4381                         }
4382                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
4383                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
4384                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
4385                 }
4386                 if (r->comment) {
4387                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
4388                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
4389                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
4390                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
4391                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
4392                                 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));
4393                         }
4394                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
4395                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
4396                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
4397                 }
4398         }
4399         return NDR_ERR_SUCCESS;
4400 }
4401
4402 _PUBLIC_ void ndr_print_srvsvc_NetShareInfo501(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo501 *r)
4403 {
4404         ndr_print_struct(ndr, name, "srvsvc_NetShareInfo501");
4405         ndr->depth++;
4406         ndr_print_ptr(ndr, "name", r->name);
4407         ndr->depth++;
4408         if (r->name) {
4409                 ndr_print_string(ndr, "name", r->name);
4410         }
4411         ndr->depth--;
4412         ndr_print_srvsvc_ShareType(ndr, "type", r->type);
4413         ndr_print_ptr(ndr, "comment", r->comment);
4414         ndr->depth++;
4415         if (r->comment) {
4416                 ndr_print_string(ndr, "comment", r->comment);
4417         }
4418         ndr->depth--;
4419         ndr_print_uint32(ndr, "csc_policy", r->csc_policy);
4420         ndr->depth--;
4421 }
4422
4423 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr501(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr501 *r)
4424 {
4425         uint32_t cntr_array_1;
4426         if (ndr_flags & NDR_SCALARS) {
4427                 NDR_CHECK(ndr_push_align(ndr, 4));
4428                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4429                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
4430         }
4431         if (ndr_flags & NDR_BUFFERS) {
4432                 if (r->array) {
4433                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4434                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4435                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo501(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4436                         }
4437                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4438                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo501(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4439                         }
4440                 }
4441         }
4442         return NDR_ERR_SUCCESS;
4443 }
4444
4445 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr501(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr501 *r)
4446 {
4447         uint32_t _ptr_array;
4448         uint32_t cntr_array_1;
4449         TALLOC_CTX *_mem_save_array_0;
4450         TALLOC_CTX *_mem_save_array_1;
4451         if (ndr_flags & NDR_SCALARS) {
4452                 NDR_CHECK(ndr_pull_align(ndr, 4));
4453                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4454                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
4455                 if (_ptr_array) {
4456                         NDR_PULL_ALLOC(ndr, r->array);
4457                 } else {
4458                         r->array = NULL;
4459                 }
4460         }
4461         if (ndr_flags & NDR_BUFFERS) {
4462                 if (r->array) {
4463                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4464                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4465                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
4466                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
4467                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4468                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4469                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4470                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo501(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4471                         }
4472                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4473                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo501(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4474                         }
4475                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
4476                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
4477                 }
4478                 if (r->array) {
4479                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
4480                 }
4481         }
4482         return NDR_ERR_SUCCESS;
4483 }
4484
4485 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr501(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr501 *r)
4486 {
4487         uint32_t cntr_array_1;
4488         ndr_print_struct(ndr, name, "srvsvc_NetShareCtr501");
4489         ndr->depth++;
4490         ndr_print_uint32(ndr, "count", r->count);
4491         ndr_print_ptr(ndr, "array", r->array);
4492         ndr->depth++;
4493         if (r->array) {
4494                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
4495                 ndr->depth++;
4496                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
4497                         char *idx_1=NULL;
4498                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
4499                                 ndr_print_srvsvc_NetShareInfo501(ndr, "array", &r->array[cntr_array_1]);
4500                                 free(idx_1);
4501                         }
4502                 }
4503                 ndr->depth--;
4504         }
4505         ndr->depth--;
4506         ndr->depth--;
4507 }
4508
4509 static enum ndr_err_code ndr_push_srvsvc_NetShareInfo502(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo502 *r)
4510 {
4511         if (ndr_flags & NDR_SCALARS) {
4512                 NDR_CHECK(ndr_push_align(ndr, 4));
4513                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
4514                 NDR_CHECK(ndr_push_srvsvc_ShareType(ndr, NDR_SCALARS, r->type));
4515                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
4516                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->permissions));
4517                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_users));
4518                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->current_users));
4519                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->path));
4520                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->password));
4521                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd_buf));
4522         }
4523         if (ndr_flags & NDR_BUFFERS) {
4524                 if (r->name) {
4525                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
4526                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4527                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
4528                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4529                 }
4530                 if (r->comment) {
4531                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
4532                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4533                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
4534                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4535                 }
4536                 if (r->path) {
4537                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));
4538                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4539                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));
4540                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->path, ndr_charset_length(r->path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4541                 }
4542                 if (r->password) {
4543                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));
4544                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4545                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));
4546                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->password, ndr_charset_length(r->password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4547                 }
4548                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd_buf));
4549         }
4550         return NDR_ERR_SUCCESS;
4551 }
4552
4553 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo502(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo502 *r)
4554 {
4555         uint32_t _ptr_name;
4556         TALLOC_CTX *_mem_save_name_0;
4557         uint32_t _ptr_comment;
4558         TALLOC_CTX *_mem_save_comment_0;
4559         uint32_t _ptr_path;
4560         TALLOC_CTX *_mem_save_path_0;
4561         uint32_t _ptr_password;
4562         TALLOC_CTX *_mem_save_password_0;
4563         if (ndr_flags & NDR_SCALARS) {
4564                 NDR_CHECK(ndr_pull_align(ndr, 4));
4565                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
4566                 if (_ptr_name) {
4567                         NDR_PULL_ALLOC(ndr, r->name);
4568                 } else {
4569                         r->name = NULL;
4570                 }
4571                 NDR_CHECK(ndr_pull_srvsvc_ShareType(ndr, NDR_SCALARS, &r->type));
4572                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
4573                 if (_ptr_comment) {
4574                         NDR_PULL_ALLOC(ndr, r->comment);
4575                 } else {
4576                         r->comment = NULL;
4577                 }
4578                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->permissions));
4579                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_users));
4580                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->current_users));
4581                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_path));
4582                 if (_ptr_path) {
4583                         NDR_PULL_ALLOC(ndr, r->path);
4584                 } else {
4585                         r->path = NULL;
4586                 }
4587                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
4588                 if (_ptr_password) {
4589                         NDR_PULL_ALLOC(ndr, r->password);
4590                 } else {
4591                         r->password = NULL;
4592                 }
4593                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd_buf));
4594         }
4595         if (ndr_flags & NDR_BUFFERS) {
4596                 if (r->name) {
4597                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4598                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
4599                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
4600                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
4601                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
4602                                 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));
4603                         }
4604                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
4605                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
4606                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
4607                 }
4608                 if (r->comment) {
4609                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
4610                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
4611                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
4612                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
4613                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
4614                                 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));
4615                         }
4616                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
4617                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
4618                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
4619                 }
4620                 if (r->path) {
4621                         _mem_save_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
4622                         NDR_PULL_SET_MEM_CTX(ndr, r->path, 0);
4623                         NDR_CHECK(ndr_pull_array_size(ndr, &r->path));
4624                         NDR_CHECK(ndr_pull_array_length(ndr, &r->path));
4625                         if (ndr_get_array_length(ndr, &r->path) > ndr_get_array_size(ndr, &r->path)) {
4626                                 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));
4627                         }
4628                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->path), sizeof(uint16_t)));
4629                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->path, ndr_get_array_length(ndr, &r->path), sizeof(uint16_t), CH_UTF16));
4630                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_path_0, 0);
4631                 }
4632                 if (r->password) {
4633                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
4634                         NDR_PULL_SET_MEM_CTX(ndr, r->password, 0);
4635                         NDR_CHECK(ndr_pull_array_size(ndr, &r->password));
4636                         NDR_CHECK(ndr_pull_array_length(ndr, &r->password));
4637                         if (ndr_get_array_length(ndr, &r->password) > ndr_get_array_size(ndr, &r->password)) {
4638                                 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));
4639                         }
4640                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t)));
4641                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->password, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t), CH_UTF16));
4642                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
4643                 }
4644                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd_buf));
4645         }
4646         return NDR_ERR_SUCCESS;
4647 }
4648
4649 _PUBLIC_ void ndr_print_srvsvc_NetShareInfo502(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo502 *r)
4650 {
4651         ndr_print_struct(ndr, name, "srvsvc_NetShareInfo502");
4652         ndr->depth++;
4653         ndr_print_ptr(ndr, "name", r->name);
4654         ndr->depth++;
4655         if (r->name) {
4656                 ndr_print_string(ndr, "name", r->name);
4657         }
4658         ndr->depth--;
4659         ndr_print_srvsvc_ShareType(ndr, "type", r->type);
4660         ndr_print_ptr(ndr, "comment", r->comment);
4661         ndr->depth++;
4662         if (r->comment) {
4663                 ndr_print_string(ndr, "comment", r->comment);
4664         }
4665         ndr->depth--;
4666         ndr_print_uint32(ndr, "permissions", r->permissions);
4667         ndr_print_uint32(ndr, "max_users", r->max_users);
4668         ndr_print_uint32(ndr, "current_users", r->current_users);
4669         ndr_print_ptr(ndr, "path", r->path);
4670         ndr->depth++;
4671         if (r->path) {
4672                 ndr_print_string(ndr, "path", r->path);
4673         }
4674         ndr->depth--;
4675         ndr_print_ptr(ndr, "password", r->password);
4676         ndr->depth++;
4677         if (r->password) {
4678                 ndr_print_string(ndr, "password", r->password);
4679         }
4680         ndr->depth--;
4681         ndr_print_sec_desc_buf(ndr, "sd_buf", &r->sd_buf);
4682         ndr->depth--;
4683 }
4684
4685 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr502(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr502 *r)
4686 {
4687         uint32_t cntr_array_1;
4688         if (ndr_flags & NDR_SCALARS) {
4689                 NDR_CHECK(ndr_push_align(ndr, 4));
4690                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4691                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
4692         }
4693         if (ndr_flags & NDR_BUFFERS) {
4694                 if (r->array) {
4695                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4696                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4697                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo502(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4698                         }
4699                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4700                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo502(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4701                         }
4702                 }
4703         }
4704         return NDR_ERR_SUCCESS;
4705 }
4706
4707 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr502(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr502 *r)
4708 {
4709         uint32_t _ptr_array;
4710         uint32_t cntr_array_1;
4711         TALLOC_CTX *_mem_save_array_0;
4712         TALLOC_CTX *_mem_save_array_1;
4713         if (ndr_flags & NDR_SCALARS) {
4714                 NDR_CHECK(ndr_pull_align(ndr, 4));
4715                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4716                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
4717                 if (_ptr_array) {
4718                         NDR_PULL_ALLOC(ndr, r->array);
4719                 } else {
4720                         r->array = NULL;
4721                 }
4722         }
4723         if (ndr_flags & NDR_BUFFERS) {
4724                 if (r->array) {
4725                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4726                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4727                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
4728                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
4729                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4730                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4731                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4732                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo502(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4733                         }
4734                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4735                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo502(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4736                         }
4737                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
4738                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
4739                 }
4740                 if (r->array) {
4741                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
4742                 }
4743         }
4744         return NDR_ERR_SUCCESS;
4745 }
4746
4747 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr502(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr502 *r)
4748 {
4749         uint32_t cntr_array_1;
4750         ndr_print_struct(ndr, name, "srvsvc_NetShareCtr502");
4751         ndr->depth++;
4752         ndr_print_uint32(ndr, "count", r->count);
4753         ndr_print_ptr(ndr, "array", r->array);
4754         ndr->depth++;
4755         if (r->array) {
4756                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
4757                 ndr->depth++;
4758                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
4759                         char *idx_1=NULL;
4760                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
4761                                 ndr_print_srvsvc_NetShareInfo502(ndr, "array", &r->array[cntr_array_1]);
4762                                 free(idx_1);
4763                         }
4764                 }
4765                 ndr->depth--;
4766         }
4767         ndr->depth--;
4768         ndr->depth--;
4769 }
4770
4771 static enum ndr_err_code ndr_push_srvsvc_NetShareInfo1004(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo1004 *r)
4772 {
4773         if (ndr_flags & NDR_SCALARS) {
4774                 NDR_CHECK(ndr_push_align(ndr, 4));
4775                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
4776         }
4777         if (ndr_flags & NDR_BUFFERS) {
4778                 if (r->comment) {
4779                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
4780                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4781                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
4782                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4783                 }
4784         }
4785         return NDR_ERR_SUCCESS;
4786 }
4787
4788 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo1004(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo1004 *r)
4789 {
4790         uint32_t _ptr_comment;
4791         TALLOC_CTX *_mem_save_comment_0;
4792         if (ndr_flags & NDR_SCALARS) {
4793                 NDR_CHECK(ndr_pull_align(ndr, 4));
4794                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
4795                 if (_ptr_comment) {
4796                         NDR_PULL_ALLOC(ndr, r->comment);
4797                 } else {
4798                         r->comment = NULL;
4799                 }
4800         }
4801         if (ndr_flags & NDR_BUFFERS) {
4802                 if (r->comment) {
4803                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
4804                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
4805                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
4806                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
4807                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
4808                                 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));
4809                         }
4810                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
4811                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
4812                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
4813                 }
4814         }
4815         return NDR_ERR_SUCCESS;
4816 }
4817
4818 _PUBLIC_ void ndr_print_srvsvc_NetShareInfo1004(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo1004 *r)
4819 {
4820         ndr_print_struct(ndr, name, "srvsvc_NetShareInfo1004");
4821         ndr->depth++;
4822         ndr_print_ptr(ndr, "comment", r->comment);
4823         ndr->depth++;
4824         if (r->comment) {
4825                 ndr_print_string(ndr, "comment", r->comment);
4826         }
4827         ndr->depth--;
4828         ndr->depth--;
4829 }
4830
4831 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr1004(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr1004 *r)
4832 {
4833         uint32_t cntr_array_1;
4834         if (ndr_flags & NDR_SCALARS) {
4835                 NDR_CHECK(ndr_push_align(ndr, 4));
4836                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4837                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
4838         }
4839         if (ndr_flags & NDR_BUFFERS) {
4840                 if (r->array) {
4841                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4842                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4843                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo1004(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4844                         }
4845                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4846                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo1004(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4847                         }
4848                 }
4849         }
4850         return NDR_ERR_SUCCESS;
4851 }
4852
4853 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr1004(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr1004 *r)
4854 {
4855         uint32_t _ptr_array;
4856         uint32_t cntr_array_1;
4857         TALLOC_CTX *_mem_save_array_0;
4858         TALLOC_CTX *_mem_save_array_1;
4859         if (ndr_flags & NDR_SCALARS) {
4860                 NDR_CHECK(ndr_pull_align(ndr, 4));
4861                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4862                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
4863                 if (_ptr_array) {
4864                         NDR_PULL_ALLOC(ndr, r->array);
4865                 } else {
4866                         r->array = NULL;
4867                 }
4868         }
4869         if (ndr_flags & NDR_BUFFERS) {
4870                 if (r->array) {
4871                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4872                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4873                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
4874                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
4875                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4876                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4877                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4878                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1004(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4879                         }
4880                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4881                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1004(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4882                         }
4883                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
4884                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
4885                 }
4886                 if (r->array) {
4887                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
4888                 }
4889         }
4890         return NDR_ERR_SUCCESS;
4891 }
4892
4893 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr1004(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr1004 *r)
4894 {
4895         uint32_t cntr_array_1;
4896         ndr_print_struct(ndr, name, "srvsvc_NetShareCtr1004");
4897         ndr->depth++;
4898         ndr_print_uint32(ndr, "count", r->count);
4899         ndr_print_ptr(ndr, "array", r->array);
4900         ndr->depth++;
4901         if (r->array) {
4902                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
4903                 ndr->depth++;
4904                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
4905                         char *idx_1=NULL;
4906                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
4907                                 ndr_print_srvsvc_NetShareInfo1004(ndr, "array", &r->array[cntr_array_1]);
4908                                 free(idx_1);
4909                         }
4910                 }
4911                 ndr->depth--;
4912         }
4913         ndr->depth--;
4914         ndr->depth--;
4915 }
4916
4917 static enum ndr_err_code ndr_push_NetShareInfo1005Flags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
4918 {
4919         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4920         return NDR_ERR_SUCCESS;
4921 }
4922
4923 static enum ndr_err_code ndr_pull_NetShareInfo1005Flags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
4924 {
4925         uint32_t v;
4926         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4927         *r = v;
4928         return NDR_ERR_SUCCESS;
4929 }
4930
4931 _PUBLIC_ void ndr_print_NetShareInfo1005Flags(struct ndr_print *ndr, const char *name, uint32_t r)
4932 {
4933         ndr_print_uint32(ndr, name, r);
4934         ndr->depth++;
4935         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SHARE_1005_IN_DFS", SHARE_1005_IN_DFS, r);
4936         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SHARE_1005_DFS_ROOT", SHARE_1005_DFS_ROOT, r);
4937         ndr->depth--;
4938 }
4939
4940 static enum ndr_err_code ndr_push_srvsvc_NetShareInfo1005(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo1005 *r)
4941 {
4942         if (ndr_flags & NDR_SCALARS) {
4943                 NDR_CHECK(ndr_push_align(ndr, 4));
4944                 NDR_CHECK(ndr_push_NetShareInfo1005Flags(ndr, NDR_SCALARS, r->dfs_flags));
4945         }
4946         if (ndr_flags & NDR_BUFFERS) {
4947         }
4948         return NDR_ERR_SUCCESS;
4949 }
4950
4951 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo1005(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo1005 *r)
4952 {
4953         if (ndr_flags & NDR_SCALARS) {
4954                 NDR_CHECK(ndr_pull_align(ndr, 4));
4955                 NDR_CHECK(ndr_pull_NetShareInfo1005Flags(ndr, NDR_SCALARS, &r->dfs_flags));
4956         }
4957         if (ndr_flags & NDR_BUFFERS) {
4958         }
4959         return NDR_ERR_SUCCESS;
4960 }
4961
4962 _PUBLIC_ void ndr_print_srvsvc_NetShareInfo1005(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo1005 *r)
4963 {
4964         ndr_print_struct(ndr, name, "srvsvc_NetShareInfo1005");
4965         ndr->depth++;
4966         ndr_print_NetShareInfo1005Flags(ndr, "dfs_flags", r->dfs_flags);
4967         ndr->depth--;
4968 }
4969
4970 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr1005(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr1005 *r)
4971 {
4972         uint32_t cntr_array_1;
4973         if (ndr_flags & NDR_SCALARS) {
4974                 NDR_CHECK(ndr_push_align(ndr, 4));
4975                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4976                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
4977         }
4978         if (ndr_flags & NDR_BUFFERS) {
4979                 if (r->array) {
4980                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4981                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4982                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo1005(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4983                         }
4984                 }
4985         }
4986         return NDR_ERR_SUCCESS;
4987 }
4988
4989 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr1005(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr1005 *r)
4990 {
4991         uint32_t _ptr_array;
4992         uint32_t cntr_array_1;
4993         TALLOC_CTX *_mem_save_array_0;
4994         TALLOC_CTX *_mem_save_array_1;
4995         if (ndr_flags & NDR_SCALARS) {
4996                 NDR_CHECK(ndr_pull_align(ndr, 4));
4997                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4998                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
4999                 if (_ptr_array) {
5000                         NDR_PULL_ALLOC(ndr, r->array);
5001                 } else {
5002                         r->array = NULL;
5003                 }
5004         }
5005         if (ndr_flags & NDR_BUFFERS) {
5006                 if (r->array) {
5007                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5008                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5009                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
5010                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
5011                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5012                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5013                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5014                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1005(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5015                         }
5016                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
5017                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
5018                 }
5019                 if (r->array) {
5020                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
5021                 }
5022         }
5023         return NDR_ERR_SUCCESS;
5024 }
5025
5026 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr1005(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr1005 *r)
5027 {
5028         uint32_t cntr_array_1;
5029         ndr_print_struct(ndr, name, "srvsvc_NetShareCtr1005");
5030         ndr->depth++;
5031         ndr_print_uint32(ndr, "count", r->count);
5032         ndr_print_ptr(ndr, "array", r->array);
5033         ndr->depth++;
5034         if (r->array) {
5035                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
5036                 ndr->depth++;
5037                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
5038                         char *idx_1=NULL;
5039                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
5040                                 ndr_print_srvsvc_NetShareInfo1005(ndr, "array", &r->array[cntr_array_1]);
5041                                 free(idx_1);
5042                         }
5043                 }
5044                 ndr->depth--;
5045         }
5046         ndr->depth--;
5047         ndr->depth--;
5048 }
5049
5050 static enum ndr_err_code ndr_push_srvsvc_NetShareInfo1006(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo1006 *r)
5051 {
5052         if (ndr_flags & NDR_SCALARS) {
5053                 NDR_CHECK(ndr_push_align(ndr, 4));
5054                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_users));
5055         }
5056         if (ndr_flags & NDR_BUFFERS) {
5057         }
5058         return NDR_ERR_SUCCESS;
5059 }
5060
5061 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo1006(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo1006 *r)
5062 {
5063         if (ndr_flags & NDR_SCALARS) {
5064                 NDR_CHECK(ndr_pull_align(ndr, 4));
5065                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_users));
5066         }
5067         if (ndr_flags & NDR_BUFFERS) {
5068         }
5069         return NDR_ERR_SUCCESS;
5070 }
5071
5072 _PUBLIC_ void ndr_print_srvsvc_NetShareInfo1006(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo1006 *r)
5073 {
5074         ndr_print_struct(ndr, name, "srvsvc_NetShareInfo1006");
5075         ndr->depth++;
5076         ndr_print_uint32(ndr, "max_users", r->max_users);
5077         ndr->depth--;
5078 }
5079
5080 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr1006(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr1006 *r)
5081 {
5082         uint32_t cntr_array_1;
5083         if (ndr_flags & NDR_SCALARS) {
5084                 NDR_CHECK(ndr_push_align(ndr, 4));
5085                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5086                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
5087         }
5088         if (ndr_flags & NDR_BUFFERS) {
5089                 if (r->array) {
5090                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5091                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5092                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo1006(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5093                         }
5094                 }
5095         }
5096         return NDR_ERR_SUCCESS;
5097 }
5098
5099 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr1006(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr1006 *r)
5100 {
5101         uint32_t _ptr_array;
5102         uint32_t cntr_array_1;
5103         TALLOC_CTX *_mem_save_array_0;
5104         TALLOC_CTX *_mem_save_array_1;
5105         if (ndr_flags & NDR_SCALARS) {
5106                 NDR_CHECK(ndr_pull_align(ndr, 4));
5107                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5108                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
5109                 if (_ptr_array) {
5110                         NDR_PULL_ALLOC(ndr, r->array);
5111                 } else {
5112                         r->array = NULL;
5113                 }
5114         }
5115         if (ndr_flags & NDR_BUFFERS) {
5116                 if (r->array) {
5117                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5118                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5119                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
5120                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
5121                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5122                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5123                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5124                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1006(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5125                         }
5126                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
5127                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
5128                 }
5129                 if (r->array) {
5130                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
5131                 }
5132         }
5133         return NDR_ERR_SUCCESS;
5134 }
5135
5136 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr1006(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr1006 *r)
5137 {
5138         uint32_t cntr_array_1;
5139         ndr_print_struct(ndr, name, "srvsvc_NetShareCtr1006");
5140         ndr->depth++;
5141         ndr_print_uint32(ndr, "count", r->count);
5142         ndr_print_ptr(ndr, "array", r->array);
5143         ndr->depth++;
5144         if (r->array) {
5145                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
5146                 ndr->depth++;
5147                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
5148                         char *idx_1=NULL;
5149                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
5150                                 ndr_print_srvsvc_NetShareInfo1006(ndr, "array", &r->array[cntr_array_1]);
5151                                 free(idx_1);
5152                         }
5153                 }
5154                 ndr->depth--;
5155         }
5156         ndr->depth--;
5157         ndr->depth--;
5158 }
5159
5160 static enum ndr_err_code ndr_push_srvsvc_NetShareInfo1007(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo1007 *r)
5161 {
5162         if (ndr_flags & NDR_SCALARS) {
5163                 NDR_CHECK(ndr_push_align(ndr, 4));
5164                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
5165                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->alternate_directory_name));
5166         }
5167         if (ndr_flags & NDR_BUFFERS) {
5168                 if (r->alternate_directory_name) {
5169                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->alternate_directory_name, CH_UTF16)));
5170                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5171                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->alternate_directory_name, CH_UTF16)));
5172                         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));
5173                 }
5174         }
5175         return NDR_ERR_SUCCESS;
5176 }
5177
5178 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo1007(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo1007 *r)
5179 {
5180         uint32_t _ptr_alternate_directory_name;
5181         TALLOC_CTX *_mem_save_alternate_directory_name_0;
5182         if (ndr_flags & NDR_SCALARS) {
5183                 NDR_CHECK(ndr_pull_align(ndr, 4));
5184                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
5185                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_alternate_directory_name));
5186                 if (_ptr_alternate_directory_name) {
5187                         NDR_PULL_ALLOC(ndr, r->alternate_directory_name);
5188                 } else {
5189                         r->alternate_directory_name = NULL;
5190                 }
5191         }
5192         if (ndr_flags & NDR_BUFFERS) {
5193                 if (r->alternate_directory_name) {
5194                         _mem_save_alternate_directory_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5195                         NDR_PULL_SET_MEM_CTX(ndr, r->alternate_directory_name, 0);
5196                         NDR_CHECK(ndr_pull_array_size(ndr, &r->alternate_directory_name));
5197                         NDR_CHECK(ndr_pull_array_length(ndr, &r->alternate_directory_name));
5198                         if (ndr_get_array_length(ndr, &r->alternate_directory_name) > ndr_get_array_size(ndr, &r->alternate_directory_name)) {
5199                                 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));
5200                         }
5201                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->alternate_directory_name), sizeof(uint16_t)));
5202                         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));
5203                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alternate_directory_name_0, 0);
5204                 }
5205         }
5206         return NDR_ERR_SUCCESS;
5207 }
5208
5209 _PUBLIC_ void ndr_print_srvsvc_NetShareInfo1007(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo1007 *r)
5210 {
5211         ndr_print_struct(ndr, name, "srvsvc_NetShareInfo1007");
5212         ndr->depth++;
5213         ndr_print_uint32(ndr, "flags", r->flags);
5214         ndr_print_ptr(ndr, "alternate_directory_name", r->alternate_directory_name);
5215         ndr->depth++;
5216         if (r->alternate_directory_name) {
5217                 ndr_print_string(ndr, "alternate_directory_name", r->alternate_directory_name);
5218         }
5219         ndr->depth--;
5220         ndr->depth--;
5221 }
5222
5223 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr1007(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr1007 *r)
5224 {
5225         uint32_t cntr_array_1;
5226         if (ndr_flags & NDR_SCALARS) {
5227                 NDR_CHECK(ndr_push_align(ndr, 4));
5228                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5229                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
5230         }
5231         if (ndr_flags & NDR_BUFFERS) {
5232                 if (r->array) {
5233                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5234                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5235                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo1007(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5236                         }
5237                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5238                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo1007(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5239                         }
5240                 }
5241         }
5242         return NDR_ERR_SUCCESS;
5243 }
5244
5245 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr1007(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr1007 *r)
5246 {
5247         uint32_t _ptr_array;
5248         uint32_t cntr_array_1;
5249         TALLOC_CTX *_mem_save_array_0;
5250         TALLOC_CTX *_mem_save_array_1;
5251         if (ndr_flags & NDR_SCALARS) {
5252                 NDR_CHECK(ndr_pull_align(ndr, 4));
5253                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5254                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
5255                 if (_ptr_array) {
5256                         NDR_PULL_ALLOC(ndr, r->array);
5257                 } else {
5258                         r->array = NULL;
5259                 }
5260         }
5261         if (ndr_flags & NDR_BUFFERS) {
5262                 if (r->array) {
5263                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5264                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5265                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
5266                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
5267                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5268                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5269                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5270                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1007(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5271                         }
5272                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5273                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1007(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5274                         }
5275                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
5276                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
5277                 }
5278                 if (r->array) {
5279                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
5280                 }
5281         }
5282         return NDR_ERR_SUCCESS;
5283 }
5284
5285 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr1007(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr1007 *r)
5286 {
5287         uint32_t cntr_array_1;
5288         ndr_print_struct(ndr, name, "srvsvc_NetShareCtr1007");
5289         ndr->depth++;
5290         ndr_print_uint32(ndr, "count", r->count);
5291         ndr_print_ptr(ndr, "array", r->array);
5292         ndr->depth++;
5293         if (r->array) {
5294                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
5295                 ndr->depth++;
5296                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
5297                         char *idx_1=NULL;
5298                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
5299                                 ndr_print_srvsvc_NetShareInfo1007(ndr, "array", &r->array[cntr_array_1]);
5300                                 free(idx_1);
5301                         }
5302                 }
5303                 ndr->depth--;
5304         }
5305         ndr->depth--;
5306         ndr->depth--;
5307 }
5308
5309 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr1501(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr1501 *r)
5310 {
5311         uint32_t cntr_array_1;
5312         if (ndr_flags & NDR_SCALARS) {
5313                 NDR_CHECK(ndr_push_align(ndr, 4));
5314                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5315                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
5316         }
5317         if (ndr_flags & NDR_BUFFERS) {
5318                 if (r->array) {
5319                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5320                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5321                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5322                         }
5323                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5324                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5325                         }
5326                 }
5327         }
5328         return NDR_ERR_SUCCESS;
5329 }
5330
5331 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr1501(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr1501 *r)
5332 {
5333         uint32_t _ptr_array;
5334         uint32_t cntr_array_1;
5335         TALLOC_CTX *_mem_save_array_0;
5336         TALLOC_CTX *_mem_save_array_1;
5337         if (ndr_flags & NDR_SCALARS) {
5338                 NDR_CHECK(ndr_pull_align(ndr, 4));
5339                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5340                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
5341                 if (_ptr_array) {
5342                         NDR_PULL_ALLOC(ndr, r->array);
5343                 } else {
5344                         r->array = NULL;
5345                 }
5346         }
5347         if (ndr_flags & NDR_BUFFERS) {
5348                 if (r->array) {
5349                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5350                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5351                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
5352                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
5353                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5354                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5355                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5356                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5357                         }
5358                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5359                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5360                         }
5361                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
5362                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
5363                 }
5364                 if (r->array) {
5365                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
5366                 }
5367         }
5368         return NDR_ERR_SUCCESS;
5369 }
5370
5371 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr1501(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr1501 *r)
5372 {
5373         uint32_t cntr_array_1;
5374         ndr_print_struct(ndr, name, "srvsvc_NetShareCtr1501");
5375         ndr->depth++;
5376         ndr_print_uint32(ndr, "count", r->count);
5377         ndr_print_ptr(ndr, "array", r->array);
5378         ndr->depth++;
5379         if (r->array) {
5380                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
5381                 ndr->depth++;
5382                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
5383                         char *idx_1=NULL;
5384                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
5385                                 ndr_print_sec_desc_buf(ndr, "array", &r->array[cntr_array_1]);
5386                                 free(idx_1);
5387                         }
5388                 }
5389                 ndr->depth--;
5390         }
5391         ndr->depth--;
5392         ndr->depth--;
5393 }
5394
5395 static enum ndr_err_code ndr_push_srvsvc_NetShareInfo(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetShareInfo *r)
5396 {
5397         if (ndr_flags & NDR_SCALARS) {
5398                 int level = ndr_push_get_switch_value(ndr, r);
5399                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5400                 switch (level) {
5401                         case 0: {
5402                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
5403                         break; }
5404
5405                         case 1: {
5406                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
5407                         break; }
5408
5409                         case 2: {
5410                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
5411                         break; }
5412
5413                         case 501: {
5414                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info501));
5415                         break; }
5416
5417                         case 502: {
5418                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info502));
5419                         break; }
5420
5421                         case 1004: {
5422                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1004));
5423                         break; }
5424
5425                         case 1005: {
5426                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1005));
5427                         break; }
5428
5429                         case 1006: {
5430                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1006));
5431                         break; }
5432
5433                         case 1007: {
5434                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1007));
5435                         break; }
5436
5437                         case 1501: {
5438                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1501));
5439                         break; }
5440
5441                         default: {
5442                         break; }
5443
5444                 }
5445         }
5446         if (ndr_flags & NDR_BUFFERS) {
5447                 int level = ndr_push_get_switch_value(ndr, r);
5448                 switch (level) {
5449                         case 0:
5450                                 if (r->info0) {
5451                                         NDR_CHECK(ndr_push_srvsvc_NetShareInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
5452                                 }
5453                         break;
5454
5455                         case 1:
5456                                 if (r->info1) {
5457                                         NDR_CHECK(ndr_push_srvsvc_NetShareInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
5458                                 }
5459                         break;
5460
5461                         case 2:
5462                                 if (r->info2) {
5463                                         NDR_CHECK(ndr_push_srvsvc_NetShareInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
5464                                 }
5465                         break;
5466
5467                         case 501:
5468                                 if (r->info501) {
5469                                         NDR_CHECK(ndr_push_srvsvc_NetShareInfo501(ndr, NDR_SCALARS|NDR_BUFFERS, r->info501));
5470                                 }
5471                         break;
5472
5473                         case 502:
5474                                 if (r->info502) {
5475                                         NDR_CHECK(ndr_push_srvsvc_NetShareInfo502(ndr, NDR_SCALARS|NDR_BUFFERS, r->info502));
5476                                 }
5477                         break;
5478
5479                         case 1004:
5480                                 if (r->info1004) {
5481                                         NDR_CHECK(ndr_push_srvsvc_NetShareInfo1004(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1004));
5482                                 }
5483                         break;
5484
5485                         case 1005:
5486                                 if (r->info1005) {
5487                                         NDR_CHECK(ndr_push_srvsvc_NetShareInfo1005(ndr, NDR_SCALARS, r->info1005));
5488                                 }
5489                         break;
5490
5491                         case 1006:
5492                                 if (r->info1006) {
5493                                         NDR_CHECK(ndr_push_srvsvc_NetShareInfo1006(ndr, NDR_SCALARS, r->info1006));
5494                                 }
5495                         break;
5496
5497                         case 1007:
5498                                 if (r->info1007) {
5499                                         NDR_CHECK(ndr_push_srvsvc_NetShareInfo1007(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1007));
5500                                 }
5501                         break;
5502
5503                         case 1501:
5504                                 if (r->info1501) {
5505                                         NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1501));
5506                                 }
5507                         break;
5508
5509                         default:
5510                         break;
5511
5512                 }
5513         }
5514         return NDR_ERR_SUCCESS;
5515 }
5516
5517 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetShareInfo *r)
5518 {
5519         int level;
5520         uint32_t _level;
5521         TALLOC_CTX *_mem_save_info0_0;
5522         TALLOC_CTX *_mem_save_info1_0;
5523         TALLOC_CTX *_mem_save_info2_0;
5524         TALLOC_CTX *_mem_save_info501_0;
5525         TALLOC_CTX *_mem_save_info502_0;
5526         TALLOC_CTX *_mem_save_info1004_0;
5527         TALLOC_CTX *_mem_save_info1005_0;
5528         TALLOC_CTX *_mem_save_info1006_0;
5529         TALLOC_CTX *_mem_save_info1007_0;
5530         TALLOC_CTX *_mem_save_info1501_0;
5531         level = ndr_pull_get_switch_value(ndr, r);
5532         if (ndr_flags & NDR_SCALARS) {
5533                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5534                 if (_level != level) {
5535                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5536                 }
5537                 switch (level) {
5538                         case 0: {
5539                                 uint32_t _ptr_info0;
5540                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
5541                                 if (_ptr_info0) {
5542                                         NDR_PULL_ALLOC(ndr, r->info0);
5543                                 } else {
5544                                         r->info0 = NULL;
5545                                 }
5546                         break; }
5547
5548                         case 1: {
5549                                 uint32_t _ptr_info1;
5550                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
5551                                 if (_ptr_info1) {
5552                                         NDR_PULL_ALLOC(ndr, r->info1);
5553                                 } else {
5554                                         r->info1 = NULL;
5555                                 }
5556                         break; }
5557
5558                         case 2: {
5559                                 uint32_t _ptr_info2;
5560                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
5561                                 if (_ptr_info2) {
5562                                         NDR_PULL_ALLOC(ndr, r->info2);
5563                                 } else {
5564                                         r->info2 = NULL;
5565                                 }
5566                         break; }
5567
5568                         case 501: {
5569                                 uint32_t _ptr_info501;
5570                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info501));
5571                                 if (_ptr_info501) {
5572                                         NDR_PULL_ALLOC(ndr, r->info501);
5573                                 } else {
5574                                         r->info501 = NULL;
5575                                 }
5576                         break; }
5577
5578                         case 502: {
5579                                 uint32_t _ptr_info502;
5580                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info502));
5581                                 if (_ptr_info502) {
5582                                         NDR_PULL_ALLOC(ndr, r->info502);
5583                                 } else {
5584                                         r->info502 = NULL;
5585                                 }
5586                         break; }
5587
5588                         case 1004: {
5589                                 uint32_t _ptr_info1004;
5590                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1004));
5591                                 if (_ptr_info1004) {
5592                                         NDR_PULL_ALLOC(ndr, r->info1004);
5593                                 } else {
5594                                         r->info1004 = NULL;
5595                                 }
5596                         break; }
5597
5598                         case 1005: {
5599                                 uint32_t _ptr_info1005;
5600                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1005));
5601                                 if (_ptr_info1005) {
5602                                         NDR_PULL_ALLOC(ndr, r->info1005);
5603                                 } else {
5604                                         r->info1005 = NULL;
5605                                 }
5606                         break; }
5607
5608                         case 1006: {
5609                                 uint32_t _ptr_info1006;
5610                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1006));
5611                                 if (_ptr_info1006) {
5612                                         NDR_PULL_ALLOC(ndr, r->info1006);
5613                                 } else {
5614                                         r->info1006 = NULL;
5615                                 }
5616                         break; }
5617
5618                         case 1007: {
5619                                 uint32_t _ptr_info1007;
5620                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1007));
5621                                 if (_ptr_info1007) {
5622                                         NDR_PULL_ALLOC(ndr, r->info1007);
5623                                 } else {
5624                                         r->info1007 = NULL;
5625                                 }
5626                         break; }
5627
5628                         case 1501: {
5629                                 uint32_t _ptr_info1501;
5630                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1501));
5631                                 if (_ptr_info1501) {
5632                                         NDR_PULL_ALLOC(ndr, r->info1501);
5633                                 } else {
5634                                         r->info1501 = NULL;
5635                                 }
5636                         break; }
5637
5638                         default: {
5639                         break; }
5640
5641                 }
5642         }
5643         if (ndr_flags & NDR_BUFFERS) {
5644                 switch (level) {
5645                         case 0:
5646                                 if (r->info0) {
5647                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
5648                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
5649                                         NDR_CHECK(ndr_pull_srvsvc_NetShareInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
5650                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
5651                                 }
5652                         break;
5653
5654                         case 1:
5655                                 if (r->info1) {
5656                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5657                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
5658                                         NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
5659                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
5660                                 }
5661                         break;
5662
5663                         case 2:
5664                                 if (r->info2) {
5665                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
5666                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
5667                                         NDR_CHECK(ndr_pull_srvsvc_NetShareInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
5668                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
5669                                 }
5670                         break;
5671
5672                         case 501:
5673                                 if (r->info501) {
5674                                         _mem_save_info501_0 = NDR_PULL_GET_MEM_CTX(ndr);
5675                                         NDR_PULL_SET_MEM_CTX(ndr, r->info501, 0);
5676                                         NDR_CHECK(ndr_pull_srvsvc_NetShareInfo501(ndr, NDR_SCALARS|NDR_BUFFERS, r->info501));
5677                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info501_0, 0);
5678                                 }
5679                         break;
5680
5681                         case 502:
5682                                 if (r->info502) {
5683                                         _mem_save_info502_0 = NDR_PULL_GET_MEM_CTX(ndr);
5684                                         NDR_PULL_SET_MEM_CTX(ndr, r->info502, 0);
5685                                         NDR_CHECK(ndr_pull_srvsvc_NetShareInfo502(ndr, NDR_SCALARS|NDR_BUFFERS, r->info502));
5686                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info502_0, 0);
5687                                 }
5688                         break;
5689
5690                         case 1004:
5691                                 if (r->info1004) {
5692                                         _mem_save_info1004_0 = NDR_PULL_GET_MEM_CTX(ndr);
5693                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1004, 0);
5694                                         NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1004(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1004));
5695                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1004_0, 0);
5696                                 }
5697                         break;
5698
5699                         case 1005:
5700                                 if (r->info1005) {
5701                                         _mem_save_info1005_0 = NDR_PULL_GET_MEM_CTX(ndr);
5702                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1005, 0);
5703                                         NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1005(ndr, NDR_SCALARS, r->info1005));
5704                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1005_0, 0);
5705                                 }
5706                         break;
5707
5708                         case 1006:
5709                                 if (r->info1006) {
5710                                         _mem_save_info1006_0 = NDR_PULL_GET_MEM_CTX(ndr);
5711                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1006, 0);
5712                                         NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1006(ndr, NDR_SCALARS, r->info1006));
5713                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1006_0, 0);
5714                                 }
5715                         break;
5716
5717                         case 1007:
5718                                 if (r->info1007) {
5719                                         _mem_save_info1007_0 = NDR_PULL_GET_MEM_CTX(ndr);
5720                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1007, 0);
5721                                         NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1007(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1007));
5722                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1007_0, 0);
5723                                 }
5724                         break;
5725
5726                         case 1501:
5727                                 if (r->info1501) {
5728                                         _mem_save_info1501_0 = NDR_PULL_GET_MEM_CTX(ndr);
5729                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1501, 0);
5730                                         NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1501));
5731                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1501_0, 0);
5732                                 }
5733                         break;
5734
5735                         default:
5736                         break;
5737
5738                 }
5739         }
5740         return NDR_ERR_SUCCESS;
5741 }
5742
5743 _PUBLIC_ void ndr_print_srvsvc_NetShareInfo(struct ndr_print *ndr, const char *name, const union srvsvc_NetShareInfo *r)
5744 {
5745         int level;
5746         level = ndr_print_get_switch_value(ndr, r);
5747         ndr_print_union(ndr, name, level, "srvsvc_NetShareInfo");
5748         switch (level) {
5749                 case 0:
5750                         ndr_print_ptr(ndr, "info0", r->info0);
5751                         ndr->depth++;
5752                         if (r->info0) {
5753                                 ndr_print_srvsvc_NetShareInfo0(ndr, "info0", r->info0);
5754                         }
5755                         ndr->depth--;
5756                 break;
5757
5758                 case 1:
5759                         ndr_print_ptr(ndr, "info1", r->info1);
5760                         ndr->depth++;
5761                         if (r->info1) {
5762                                 ndr_print_srvsvc_NetShareInfo1(ndr, "info1", r->info1);
5763                         }
5764                         ndr->depth--;
5765                 break;
5766
5767                 case 2:
5768                         ndr_print_ptr(ndr, "info2", r->info2);
5769                         ndr->depth++;
5770                         if (r->info2) {
5771                                 ndr_print_srvsvc_NetShareInfo2(ndr, "info2", r->info2);
5772                         }
5773                         ndr->depth--;
5774                 break;
5775
5776                 case 501:
5777                         ndr_print_ptr(ndr, "info501", r->info501);
5778                         ndr->depth++;
5779                         if (r->info501) {
5780                                 ndr_print_srvsvc_NetShareInfo501(ndr, "info501", r->info501);
5781                         }
5782                         ndr->depth--;
5783                 break;
5784
5785                 case 502:
5786                         ndr_print_ptr(ndr, "info502", r->info502);
5787                         ndr->depth++;
5788                         if (r->info502) {
5789                                 ndr_print_srvsvc_NetShareInfo502(ndr, "info502", r->info502);
5790                         }
5791                         ndr->depth--;
5792                 break;
5793
5794                 case 1004:
5795                         ndr_print_ptr(ndr, "info1004", r->info1004);
5796                         ndr->depth++;
5797                         if (r->info1004) {
5798                                 ndr_print_srvsvc_NetShareInfo1004(ndr, "info1004", r->info1004);
5799                         }
5800                         ndr->depth--;
5801                 break;
5802
5803                 case 1005:
5804                         ndr_print_ptr(ndr, "info1005", r->info1005);
5805                         ndr->depth++;
5806                         if (r->info1005) {
5807                                 ndr_print_srvsvc_NetShareInfo1005(ndr, "info1005", r->info1005);
5808                         }
5809                         ndr->depth--;
5810                 break;
5811
5812                 case 1006:
5813                         ndr_print_ptr(ndr, "info1006", r->info1006);
5814                         ndr->depth++;
5815                         if (r->info1006) {
5816                                 ndr_print_srvsvc_NetShareInfo1006(ndr, "info1006", r->info1006);
5817                         }
5818                         ndr->depth--;
5819                 break;
5820
5821                 case 1007:
5822                         ndr_print_ptr(ndr, "info1007", r->info1007);
5823                         ndr->depth++;
5824                         if (r->info1007) {
5825                                 ndr_print_srvsvc_NetShareInfo1007(ndr, "info1007", r->info1007);
5826                         }
5827                         ndr->depth--;
5828                 break;
5829
5830                 case 1501:
5831                         ndr_print_ptr(ndr, "info1501", r->info1501);
5832                         ndr->depth++;
5833                         if (r->info1501) {
5834                                 ndr_print_sec_desc_buf(ndr, "info1501", r->info1501);
5835                         }
5836                         ndr->depth--;
5837                 break;
5838
5839                 default:
5840                 break;
5841
5842         }
5843 }
5844
5845 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetShareCtr *r)
5846 {
5847         if (ndr_flags & NDR_SCALARS) {
5848                 int level = ndr_push_get_switch_value(ndr, r);
5849                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5850                 switch (level) {
5851                         case 0: {
5852                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
5853                         break; }
5854
5855                         case 1: {
5856                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
5857                         break; }
5858
5859                         case 2: {
5860                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr2));
5861                         break; }
5862
5863                         case 501: {
5864                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr501));
5865                         break; }
5866
5867                         case 502: {
5868                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr502));
5869                         break; }
5870
5871                         case 1004: {
5872                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1004));
5873                         break; }
5874
5875                         case 1005: {
5876                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1005));
5877                         break; }
5878
5879                         case 1006: {
5880                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1006));
5881                         break; }
5882
5883                         case 1007: {
5884                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1007));
5885                         break; }
5886
5887                         case 1501: {
5888                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1501));
5889                         break; }
5890
5891                         default: {
5892                         break; }
5893
5894                 }
5895         }
5896         if (ndr_flags & NDR_BUFFERS) {
5897                 int level = ndr_push_get_switch_value(ndr, r);
5898                 switch (level) {
5899                         case 0:
5900                                 if (r->ctr0) {
5901                                         NDR_CHECK(ndr_push_srvsvc_NetShareCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
5902                                 }
5903                         break;
5904
5905                         case 1:
5906                                 if (r->ctr1) {
5907                                         NDR_CHECK(ndr_push_srvsvc_NetShareCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
5908                                 }
5909                         break;
5910
5911                         case 2:
5912                                 if (r->ctr2) {
5913                                         NDR_CHECK(ndr_push_srvsvc_NetShareCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
5914                                 }
5915                         break;
5916
5917                         case 501:
5918                                 if (r->ctr501) {
5919                                         NDR_CHECK(ndr_push_srvsvc_NetShareCtr501(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr501));
5920                                 }
5921                         break;
5922
5923                         case 502:
5924                                 if (r->ctr502) {
5925                                         NDR_CHECK(ndr_push_srvsvc_NetShareCtr502(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr502));
5926                                 }
5927                         break;
5928
5929                         case 1004:
5930                                 if (r->ctr1004) {
5931                                         NDR_CHECK(ndr_push_srvsvc_NetShareCtr1004(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1004));
5932                                 }
5933                         break;
5934
5935                         case 1005:
5936                                 if (r->ctr1005) {
5937                                         NDR_CHECK(ndr_push_srvsvc_NetShareCtr1005(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1005));
5938                                 }
5939                         break;
5940
5941                         case 1006:
5942                                 if (r->ctr1006) {
5943                                         NDR_CHECK(ndr_push_srvsvc_NetShareCtr1006(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1006));
5944                                 }
5945                         break;
5946
5947                         case 1007:
5948                                 if (r->ctr1007) {
5949                                         NDR_CHECK(ndr_push_srvsvc_NetShareCtr1007(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1007));
5950                                 }
5951                         break;
5952
5953                         case 1501:
5954                                 if (r->ctr1501) {
5955                                         NDR_CHECK(ndr_push_srvsvc_NetShareCtr1501(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1501));
5956                                 }
5957                         break;
5958
5959                         default:
5960                         break;
5961
5962                 }
5963         }
5964         return NDR_ERR_SUCCESS;
5965 }
5966
5967 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetShareCtr *r)
5968 {
5969         int level;
5970         uint32_t _level;
5971         TALLOC_CTX *_mem_save_ctr0_0;
5972         TALLOC_CTX *_mem_save_ctr1_0;
5973         TALLOC_CTX *_mem_save_ctr2_0;
5974         TALLOC_CTX *_mem_save_ctr501_0;
5975         TALLOC_CTX *_mem_save_ctr502_0;
5976         TALLOC_CTX *_mem_save_ctr1004_0;
5977         TALLOC_CTX *_mem_save_ctr1005_0;
5978         TALLOC_CTX *_mem_save_ctr1006_0;
5979         TALLOC_CTX *_mem_save_ctr1007_0;
5980         TALLOC_CTX *_mem_save_ctr1501_0;
5981         level = ndr_pull_get_switch_value(ndr, r);
5982         if (ndr_flags & NDR_SCALARS) {
5983                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5984                 if (_level != level) {
5985                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5986                 }
5987                 switch (level) {
5988                         case 0: {
5989                                 uint32_t _ptr_ctr0;
5990                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));
5991                                 if (_ptr_ctr0) {
5992                                         NDR_PULL_ALLOC(ndr, r->ctr0);
5993                                 } else {
5994                                         r->ctr0 = NULL;
5995                                 }
5996                         break; }
5997
5998                         case 1: {
5999                                 uint32_t _ptr_ctr1;
6000                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
6001                                 if (_ptr_ctr1) {
6002                                         NDR_PULL_ALLOC(ndr, r->ctr1);
6003                                 } else {
6004                                         r->ctr1 = NULL;
6005                                 }
6006                         break; }
6007
6008                         case 2: {
6009                                 uint32_t _ptr_ctr2;
6010                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr2));
6011                                 if (_ptr_ctr2) {
6012                                         NDR_PULL_ALLOC(ndr, r->ctr2);
6013                                 } else {
6014                                         r->ctr2 = NULL;
6015                                 }
6016                         break; }
6017
6018                         case 501: {
6019                                 uint32_t _ptr_ctr501;
6020                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr501));
6021                                 if (_ptr_ctr501) {
6022                                         NDR_PULL_ALLOC(ndr, r->ctr501);
6023                                 } else {
6024                                         r->ctr501 = NULL;
6025                                 }
6026                         break; }
6027
6028                         case 502: {
6029                                 uint32_t _ptr_ctr502;
6030                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr502));
6031                                 if (_ptr_ctr502) {
6032                                         NDR_PULL_ALLOC(ndr, r->ctr502);
6033                                 } else {
6034                                         r->ctr502 = NULL;
6035                                 }
6036                         break; }
6037
6038                         case 1004: {
6039                                 uint32_t _ptr_ctr1004;
6040                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1004));
6041                                 if (_ptr_ctr1004) {
6042                                         NDR_PULL_ALLOC(ndr, r->ctr1004);
6043                                 } else {
6044                                         r->ctr1004 = NULL;
6045                                 }
6046                         break; }
6047
6048                         case 1005: {
6049                                 uint32_t _ptr_ctr1005;
6050                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1005));
6051                                 if (_ptr_ctr1005) {
6052                                         NDR_PULL_ALLOC(ndr, r->ctr1005);
6053                                 } else {
6054                                         r->ctr1005 = NULL;
6055                                 }
6056                         break; }
6057
6058                         case 1006: {
6059                                 uint32_t _ptr_ctr1006;
6060                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1006));
6061                                 if (_ptr_ctr1006) {
6062                                         NDR_PULL_ALLOC(ndr, r->ctr1006);
6063                                 } else {
6064                                         r->ctr1006 = NULL;
6065                                 }
6066                         break; }
6067
6068                         case 1007: {
6069                                 uint32_t _ptr_ctr1007;
6070                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1007));
6071                                 if (_ptr_ctr1007) {
6072                                         NDR_PULL_ALLOC(ndr, r->ctr1007);
6073                                 } else {
6074                                         r->ctr1007 = NULL;
6075                                 }
6076                         break; }
6077
6078                         case 1501: {
6079                                 uint32_t _ptr_ctr1501;
6080                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1501));
6081                                 if (_ptr_ctr1501) {
6082                                         NDR_PULL_ALLOC(ndr, r->ctr1501);
6083                                 } else {
6084                                         r->ctr1501 = NULL;
6085                                 }
6086                         break; }
6087
6088                         default: {
6089                         break; }
6090
6091                 }
6092         }
6093         if (ndr_flags & NDR_BUFFERS) {
6094                 switch (level) {
6095                         case 0:
6096                                 if (r->ctr0) {
6097                                         _mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);
6098                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr0, 0);
6099                                         NDR_CHECK(ndr_pull_srvsvc_NetShareCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
6100                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);
6101                                 }
6102                         break;
6103
6104                         case 1:
6105                                 if (r->ctr1) {
6106                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6107                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
6108                                         NDR_CHECK(ndr_pull_srvsvc_NetShareCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
6109                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
6110                                 }
6111                         break;
6112
6113                         case 2:
6114                                 if (r->ctr2) {
6115                                         _mem_save_ctr2_0 = NDR_PULL_GET_MEM_CTX(ndr);
6116                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr2, 0);
6117                                         NDR_CHECK(ndr_pull_srvsvc_NetShareCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
6118                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr2_0, 0);
6119                                 }
6120                         break;
6121
6122                         case 501:
6123                                 if (r->ctr501) {
6124                                         _mem_save_ctr501_0 = NDR_PULL_GET_MEM_CTX(ndr);
6125                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr501, 0);
6126                                         NDR_CHECK(ndr_pull_srvsvc_NetShareCtr501(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr501));
6127                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr501_0, 0);
6128                                 }
6129                         break;
6130
6131                         case 502:
6132                                 if (r->ctr502) {
6133                                         _mem_save_ctr502_0 = NDR_PULL_GET_MEM_CTX(ndr);
6134                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr502, 0);
6135                                         NDR_CHECK(ndr_pull_srvsvc_NetShareCtr502(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr502));
6136                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr502_0, 0);
6137                                 }
6138                         break;
6139
6140                         case 1004:
6141                                 if (r->ctr1004) {
6142                                         _mem_save_ctr1004_0 = NDR_PULL_GET_MEM_CTX(ndr);
6143                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1004, 0);
6144                                         NDR_CHECK(ndr_pull_srvsvc_NetShareCtr1004(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1004));
6145                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1004_0, 0);
6146                                 }
6147                         break;
6148
6149                         case 1005:
6150                                 if (r->ctr1005) {
6151                                         _mem_save_ctr1005_0 = NDR_PULL_GET_MEM_CTX(ndr);
6152                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1005, 0);
6153                                         NDR_CHECK(ndr_pull_srvsvc_NetShareCtr1005(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1005));
6154                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1005_0, 0);
6155                                 }
6156                         break;
6157
6158                         case 1006:
6159                                 if (r->ctr1006) {
6160                                         _mem_save_ctr1006_0 = NDR_PULL_GET_MEM_CTX(ndr);
6161                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1006, 0);
6162                                         NDR_CHECK(ndr_pull_srvsvc_NetShareCtr1006(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1006));
6163                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1006_0, 0);
6164                                 }
6165                         break;
6166
6167                         case 1007:
6168                                 if (r->ctr1007) {
6169                                         _mem_save_ctr1007_0 = NDR_PULL_GET_MEM_CTX(ndr);
6170                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1007, 0);
6171                                         NDR_CHECK(ndr_pull_srvsvc_NetShareCtr1007(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1007));
6172                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1007_0, 0);
6173                                 }
6174                         break;
6175
6176                         case 1501:
6177                                 if (r->ctr1501) {
6178                                         _mem_save_ctr1501_0 = NDR_PULL_GET_MEM_CTX(ndr);
6179                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1501, 0);
6180                                         NDR_CHECK(ndr_pull_srvsvc_NetShareCtr1501(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1501));
6181                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1501_0, 0);
6182                                 }
6183                         break;
6184
6185                         default:
6186                         break;
6187
6188                 }
6189         }
6190         return NDR_ERR_SUCCESS;
6191 }
6192
6193 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr(struct ndr_print *ndr, const char *name, const union srvsvc_NetShareCtr *r)
6194 {
6195         int level;
6196         level = ndr_print_get_switch_value(ndr, r);
6197         ndr_print_union(ndr, name, level, "srvsvc_NetShareCtr");
6198         switch (level) {
6199                 case 0:
6200                         ndr_print_ptr(ndr, "ctr0", r->ctr0);
6201                         ndr->depth++;
6202                         if (r->ctr0) {
6203                                 ndr_print_srvsvc_NetShareCtr0(ndr, "ctr0", r->ctr0);
6204                         }
6205                         ndr->depth--;
6206                 break;
6207
6208                 case 1:
6209                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
6210                         ndr->depth++;
6211                         if (r->ctr1) {
6212                                 ndr_print_srvsvc_NetShareCtr1(ndr, "ctr1", r->ctr1);
6213                         }
6214                         ndr->depth--;
6215                 break;
6216
6217                 case 2:
6218                         ndr_print_ptr(ndr, "ctr2", r->ctr2);
6219                         ndr->depth++;
6220                         if (r->ctr2) {
6221                                 ndr_print_srvsvc_NetShareCtr2(ndr, "ctr2", r->ctr2);
6222                         }
6223                         ndr->depth--;
6224                 break;
6225
6226                 case 501:
6227                         ndr_print_ptr(ndr, "ctr501", r->ctr501);
6228                         ndr->depth++;
6229                         if (r->ctr501) {
6230                                 ndr_print_srvsvc_NetShareCtr501(ndr, "ctr501", r->ctr501);
6231                         }
6232                         ndr->depth--;
6233                 break;
6234
6235                 case 502:
6236                         ndr_print_ptr(ndr, "ctr502", r->ctr502);
6237                         ndr->depth++;
6238                         if (r->ctr502) {
6239                                 ndr_print_srvsvc_NetShareCtr502(ndr, "ctr502", r->ctr502);
6240                         }
6241                         ndr->depth--;
6242                 break;
6243
6244                 case 1004:
6245                         ndr_print_ptr(ndr, "ctr1004", r->ctr1004);
6246                         ndr->depth++;
6247                         if (r->ctr1004) {
6248                                 ndr_print_srvsvc_NetShareCtr1004(ndr, "ctr1004", r->ctr1004);
6249                         }
6250                         ndr->depth--;
6251                 break;
6252
6253                 case 1005:
6254                         ndr_print_ptr(ndr, "ctr1005", r->ctr1005);
6255                         ndr->depth++;
6256                         if (r->ctr1005) {
6257                                 ndr_print_srvsvc_NetShareCtr1005(ndr, "ctr1005", r->ctr1005);
6258                         }
6259                         ndr->depth--;
6260                 break;
6261
6262                 case 1006:
6263                         ndr_print_ptr(ndr, "ctr1006", r->ctr1006);
6264                         ndr->depth++;
6265                         if (r->ctr1006) {
6266                                 ndr_print_srvsvc_NetShareCtr1006(ndr, "ctr1006", r->ctr1006);
6267                         }
6268                         ndr->depth--;
6269                 break;
6270
6271                 case 1007:
6272                         ndr_print_ptr(ndr, "ctr1007", r->ctr1007);
6273                         ndr->depth++;
6274                         if (r->ctr1007) {
6275                                 ndr_print_srvsvc_NetShareCtr1007(ndr, "ctr1007", r->ctr1007);
6276                         }
6277                         ndr->depth--;
6278                 break;
6279
6280                 case 1501:
6281                         ndr_print_ptr(ndr, "ctr1501", r->ctr1501);
6282                         ndr->depth++;
6283                         if (r->ctr1501) {
6284                                 ndr_print_srvsvc_NetShareCtr1501(ndr, "ctr1501", r->ctr1501);
6285                         }
6286                         ndr->depth--;
6287                 break;
6288
6289                 default:
6290                 break;
6291
6292         }
6293 }
6294
6295 static enum ndr_err_code ndr_push_srvsvc_NetShareInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfoCtr *r)
6296 {
6297         if (ndr_flags & NDR_SCALARS) {
6298                 NDR_CHECK(ndr_push_align(ndr, 4));
6299                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
6300                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
6301                 NDR_CHECK(ndr_push_srvsvc_NetShareCtr(ndr, NDR_SCALARS, &r->ctr));
6302         }
6303         if (ndr_flags & NDR_BUFFERS) {
6304                 NDR_CHECK(ndr_push_srvsvc_NetShareCtr(ndr, NDR_BUFFERS, &r->ctr));
6305         }
6306         return NDR_ERR_SUCCESS;
6307 }
6308
6309 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfoCtr *r)
6310 {
6311         if (ndr_flags & NDR_SCALARS) {
6312                 NDR_CHECK(ndr_pull_align(ndr, 4));
6313                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
6314                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
6315                 NDR_CHECK(ndr_pull_srvsvc_NetShareCtr(ndr, NDR_SCALARS, &r->ctr));
6316         }
6317         if (ndr_flags & NDR_BUFFERS) {
6318                 NDR_CHECK(ndr_pull_srvsvc_NetShareCtr(ndr, NDR_BUFFERS, &r->ctr));
6319         }
6320         return NDR_ERR_SUCCESS;
6321 }
6322
6323 _PUBLIC_ void ndr_print_srvsvc_NetShareInfoCtr(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfoCtr *r)
6324 {
6325         ndr_print_struct(ndr, name, "srvsvc_NetShareInfoCtr");
6326         ndr->depth++;
6327         ndr_print_uint32(ndr, "level", r->level);
6328         ndr_print_set_switch_value(ndr, &r->ctr, r->level);
6329         ndr_print_srvsvc_NetShareCtr(ndr, "ctr", &r->ctr);
6330         ndr->depth--;
6331 }
6332
6333 _PUBLIC_ enum ndr_err_code ndr_push_srvsvc_PlatformId(struct ndr_push *ndr, int ndr_flags, enum srvsvc_PlatformId r)
6334 {
6335         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
6336         return NDR_ERR_SUCCESS;
6337 }
6338
6339 _PUBLIC_ enum ndr_err_code ndr_pull_srvsvc_PlatformId(struct ndr_pull *ndr, int ndr_flags, enum srvsvc_PlatformId *r)
6340 {
6341         uint32_t v;
6342         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
6343         *r = v;
6344         return NDR_ERR_SUCCESS;
6345 }
6346
6347 _PUBLIC_ void ndr_print_srvsvc_PlatformId(struct ndr_print *ndr, const char *name, enum srvsvc_PlatformId r)
6348 {
6349         const char *val = NULL;
6350
6351         switch (r) {
6352                 case PLATFORM_ID_DOS: val = "PLATFORM_ID_DOS"; break;
6353                 case PLATFORM_ID_OS2: val = "PLATFORM_ID_OS2"; break;
6354                 case PLATFORM_ID_NT: val = "PLATFORM_ID_NT"; break;
6355                 case PLATFORM_ID_OSF: val = "PLATFORM_ID_OSF"; break;
6356                 case PLATFORM_ID_VMS: val = "PLATFORM_ID_VMS"; break;
6357         }
6358         ndr_print_enum(ndr, name, "ENUM", val, r);
6359 }
6360
6361 _PUBLIC_ enum ndr_err_code ndr_push_srvsvc_NetSrvInfo100(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo100 *r)
6362 {
6363         if (ndr_flags & NDR_SCALARS) {
6364                 NDR_CHECK(ndr_push_align(ndr, 4));
6365                 NDR_CHECK(ndr_push_srvsvc_PlatformId(ndr, NDR_SCALARS, r->platform_id));
6366                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
6367         }
6368         if (ndr_flags & NDR_BUFFERS) {
6369                 if (r->server_name) {
6370                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
6371                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6372                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
6373                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6374                 }
6375         }
6376         return NDR_ERR_SUCCESS;
6377 }
6378
6379 _PUBLIC_ enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo100(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo100 *r)
6380 {
6381         uint32_t _ptr_server_name;
6382         TALLOC_CTX *_mem_save_server_name_0;
6383         if (ndr_flags & NDR_SCALARS) {
6384                 NDR_CHECK(ndr_pull_align(ndr, 4));
6385                 NDR_CHECK(ndr_pull_srvsvc_PlatformId(ndr, NDR_SCALARS, &r->platform_id));
6386                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6387                 if (_ptr_server_name) {
6388                         NDR_PULL_ALLOC(ndr, r->server_name);
6389                 } else {
6390                         r->server_name = NULL;
6391                 }
6392         }
6393         if (ndr_flags & NDR_BUFFERS) {
6394                 if (r->server_name) {
6395                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6396                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
6397                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
6398                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
6399                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
6400                                 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));
6401                         }
6402                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
6403                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
6404                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6405                 }
6406         }
6407         return NDR_ERR_SUCCESS;
6408 }
6409
6410 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo100(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo100 *r)
6411 {
6412         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo100");
6413         ndr->depth++;
6414         ndr_print_srvsvc_PlatformId(ndr, "platform_id", r->platform_id);
6415         ndr_print_ptr(ndr, "server_name", r->server_name);
6416         ndr->depth++;
6417         if (r->server_name) {
6418                 ndr_print_string(ndr, "server_name", r->server_name);
6419         }
6420         ndr->depth--;
6421         ndr->depth--;
6422 }
6423
6424 _PUBLIC_ enum ndr_err_code ndr_push_srvsvc_NetSrvInfo101(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo101 *r)
6425 {
6426         if (ndr_flags & NDR_SCALARS) {
6427                 NDR_CHECK(ndr_push_align(ndr, 4));
6428                 NDR_CHECK(ndr_push_srvsvc_PlatformId(ndr, NDR_SCALARS, r->platform_id));
6429                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
6430                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_major));
6431                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_minor));
6432                 NDR_CHECK(ndr_push_svcctl_ServerType(ndr, NDR_SCALARS, r->server_type));
6433                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6434         }
6435         if (ndr_flags & NDR_BUFFERS) {
6436                 if (r->server_name) {
6437                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
6438                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6439                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
6440                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6441                 }
6442                 if (r->comment) {
6443                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6444                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6445                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6446                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6447                 }
6448         }
6449         return NDR_ERR_SUCCESS;
6450 }
6451
6452 _PUBLIC_ enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo101(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo101 *r)
6453 {
6454         uint32_t _ptr_server_name;
6455         TALLOC_CTX *_mem_save_server_name_0;
6456         uint32_t _ptr_comment;
6457         TALLOC_CTX *_mem_save_comment_0;
6458         if (ndr_flags & NDR_SCALARS) {
6459                 NDR_CHECK(ndr_pull_align(ndr, 4));
6460                 NDR_CHECK(ndr_pull_srvsvc_PlatformId(ndr, NDR_SCALARS, &r->platform_id));
6461                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6462                 if (_ptr_server_name) {
6463                         NDR_PULL_ALLOC(ndr, r->server_name);
6464                 } else {
6465                         r->server_name = NULL;
6466                 }
6467                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_major));
6468                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_minor));
6469                 NDR_CHECK(ndr_pull_svcctl_ServerType(ndr, NDR_SCALARS, &r->server_type));
6470                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6471                 if (_ptr_comment) {
6472                         NDR_PULL_ALLOC(ndr, r->comment);
6473                 } else {
6474                         r->comment = NULL;
6475                 }
6476         }
6477         if (ndr_flags & NDR_BUFFERS) {
6478                 if (r->server_name) {
6479                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6480                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
6481                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
6482                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
6483                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
6484                                 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));
6485                         }
6486                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
6487                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
6488                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6489                 }
6490                 if (r->comment) {
6491                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6492                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6493                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6494                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6495                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6496                                 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));
6497                         }
6498                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6499                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6500                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6501                 }
6502         }
6503         return NDR_ERR_SUCCESS;
6504 }
6505
6506 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo101(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo101 *r)
6507 {
6508         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo101");
6509         ndr->depth++;
6510         ndr_print_srvsvc_PlatformId(ndr, "platform_id", r->platform_id);
6511         ndr_print_ptr(ndr, "server_name", r->server_name);
6512         ndr->depth++;
6513         if (r->server_name) {
6514                 ndr_print_string(ndr, "server_name", r->server_name);
6515         }
6516         ndr->depth--;
6517         ndr_print_uint32(ndr, "version_major", r->version_major);
6518         ndr_print_uint32(ndr, "version_minor", r->version_minor);
6519         ndr_print_svcctl_ServerType(ndr, "server_type", r->server_type);
6520         ndr_print_ptr(ndr, "comment", r->comment);
6521         ndr->depth++;
6522         if (r->comment) {
6523                 ndr_print_string(ndr, "comment", r->comment);
6524         }
6525         ndr->depth--;
6526         ndr->depth--;
6527 }
6528
6529 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo102(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo102 *r)
6530 {
6531         if (ndr_flags & NDR_SCALARS) {
6532                 NDR_CHECK(ndr_push_align(ndr, 4));
6533                 NDR_CHECK(ndr_push_srvsvc_PlatformId(ndr, NDR_SCALARS, r->platform_id));
6534                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
6535                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_major));
6536                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_minor));
6537                 NDR_CHECK(ndr_push_svcctl_ServerType(ndr, NDR_SCALARS, r->server_type));
6538                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6539                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->users));
6540                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->disc));
6541                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->hidden));
6542                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->announce));
6543                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->anndelta));
6544                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->licenses));
6545                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->userpath));
6546         }
6547         if (ndr_flags & NDR_BUFFERS) {
6548                 if (r->server_name) {
6549                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
6550                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6551                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
6552                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6553                 }
6554                 if (r->comment) {
6555                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6556                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6557                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6558                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6559                 }
6560                 if (r->userpath) {
6561                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->userpath, CH_UTF16)));
6562                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6563                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->userpath, CH_UTF16)));
6564                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->userpath, ndr_charset_length(r->userpath, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6565                 }
6566         }
6567         return NDR_ERR_SUCCESS;
6568 }
6569
6570 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo102(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo102 *r)
6571 {
6572         uint32_t _ptr_server_name;
6573         TALLOC_CTX *_mem_save_server_name_0;
6574         uint32_t _ptr_comment;
6575         TALLOC_CTX *_mem_save_comment_0;
6576         uint32_t _ptr_userpath;
6577         TALLOC_CTX *_mem_save_userpath_0;
6578         if (ndr_flags & NDR_SCALARS) {
6579                 NDR_CHECK(ndr_pull_align(ndr, 4));
6580                 NDR_CHECK(ndr_pull_srvsvc_PlatformId(ndr, NDR_SCALARS, &r->platform_id));
6581                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6582                 if (_ptr_server_name) {
6583                         NDR_PULL_ALLOC(ndr, r->server_name);
6584                 } else {
6585                         r->server_name = NULL;
6586                 }
6587                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_major));
6588                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_minor));
6589                 NDR_CHECK(ndr_pull_svcctl_ServerType(ndr, NDR_SCALARS, &r->server_type));
6590                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6591                 if (_ptr_comment) {
6592                         NDR_PULL_ALLOC(ndr, r->comment);
6593                 } else {
6594                         r->comment = NULL;
6595                 }
6596                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->users));
6597                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->disc));
6598                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->hidden));
6599                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->announce));
6600                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->anndelta));
6601                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->licenses));
6602                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_userpath));
6603                 if (_ptr_userpath) {
6604                         NDR_PULL_ALLOC(ndr, r->userpath);
6605                 } else {
6606                         r->userpath = NULL;
6607                 }
6608         }
6609         if (ndr_flags & NDR_BUFFERS) {
6610                 if (r->server_name) {
6611                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6612                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
6613                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
6614                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
6615                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
6616                                 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));
6617                         }
6618                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
6619                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
6620                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6621                 }
6622                 if (r->comment) {
6623                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6624                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6625                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6626                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6627                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6628                                 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));
6629                         }
6630                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6631                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6632                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6633                 }
6634                 if (r->userpath) {
6635                         _mem_save_userpath_0 = NDR_PULL_GET_MEM_CTX(ndr);
6636                         NDR_PULL_SET_MEM_CTX(ndr, r->userpath, 0);
6637                         NDR_CHECK(ndr_pull_array_size(ndr, &r->userpath));
6638                         NDR_CHECK(ndr_pull_array_length(ndr, &r->userpath));
6639                         if (ndr_get_array_length(ndr, &r->userpath) > ndr_get_array_size(ndr, &r->userpath)) {
6640                                 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));
6641                         }
6642                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->userpath), sizeof(uint16_t)));
6643                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->userpath, ndr_get_array_length(ndr, &r->userpath), sizeof(uint16_t), CH_UTF16));
6644                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userpath_0, 0);
6645                 }
6646         }
6647         return NDR_ERR_SUCCESS;
6648 }
6649
6650 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo102(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo102 *r)
6651 {
6652         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo102");
6653         ndr->depth++;
6654         ndr_print_srvsvc_PlatformId(ndr, "platform_id", r->platform_id);
6655         ndr_print_ptr(ndr, "server_name", r->server_name);
6656         ndr->depth++;
6657         if (r->server_name) {
6658                 ndr_print_string(ndr, "server_name", r->server_name);
6659         }
6660         ndr->depth--;
6661         ndr_print_uint32(ndr, "version_major", r->version_major);
6662         ndr_print_uint32(ndr, "version_minor", r->version_minor);
6663         ndr_print_svcctl_ServerType(ndr, "server_type", r->server_type);
6664         ndr_print_ptr(ndr, "comment", r->comment);
6665         ndr->depth++;
6666         if (r->comment) {
6667                 ndr_print_string(ndr, "comment", r->comment);
6668         }
6669         ndr->depth--;
6670         ndr_print_uint32(ndr, "users", r->users);
6671         ndr_print_uint32(ndr, "disc", r->disc);
6672         ndr_print_uint32(ndr, "hidden", r->hidden);
6673         ndr_print_uint32(ndr, "announce", r->announce);
6674         ndr_print_uint32(ndr, "anndelta", r->anndelta);
6675         ndr_print_uint32(ndr, "licenses", r->licenses);
6676         ndr_print_ptr(ndr, "userpath", r->userpath);
6677         ndr->depth++;
6678         if (r->userpath) {
6679                 ndr_print_string(ndr, "userpath", r->userpath);
6680         }
6681         ndr->depth--;
6682         ndr->depth--;
6683 }
6684
6685 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo402(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo402 *r)
6686 {
6687         if (ndr_flags & NDR_SCALARS) {
6688                 NDR_CHECK(ndr_push_align(ndr, 4));
6689                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ulist_mtime));
6690                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->glist_mtime));
6691                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alist_mtime));
6692                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->alerts));
6693                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->security));
6694                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numadmin));
6695                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lanmask));
6696                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guestaccount));
6697                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->chdevs));
6698                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->chdevqs));
6699                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->chdevjobs));
6700                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->connections));
6701                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->shares));
6702                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->openfiles));
6703                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessopen));
6704                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sesssvc));
6705                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessreqs));
6706                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->opensearch));
6707                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->activelocks));
6708                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numreqbufs));
6709                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sizereqbufs));
6710                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numbigbufs));
6711                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numfiletasks));
6712                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alertsched));
6713                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->erroralert));
6714                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->logonalert));
6715                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->accessalert));
6716                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->diskalert));
6717                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->netioalert));
6718                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxaudits));
6719                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->srvheuristics));
6720         }
6721         if (ndr_flags & NDR_BUFFERS) {
6722                 if (r->alerts) {
6723                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->alerts, CH_UTF16)));
6724                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6725                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->alerts, CH_UTF16)));
6726                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->alerts, ndr_charset_length(r->alerts, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6727                 }
6728                 if (r->guestaccount) {
6729                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guestaccount, CH_UTF16)));
6730                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6731                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guestaccount, CH_UTF16)));
6732                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guestaccount, ndr_charset_length(r->guestaccount, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6733                 }
6734                 if (r->srvheuristics) {
6735                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->srvheuristics, CH_UTF16)));
6736                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6737                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->srvheuristics, CH_UTF16)));
6738                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->srvheuristics, ndr_charset_length(r->srvheuristics, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6739                 }
6740         }
6741         return NDR_ERR_SUCCESS;
6742 }
6743
6744 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo402(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo402 *r)
6745 {
6746         uint32_t _ptr_alerts;
6747         TALLOC_CTX *_mem_save_alerts_0;
6748         uint32_t _ptr_guestaccount;
6749         TALLOC_CTX *_mem_save_guestaccount_0;
6750         uint32_t _ptr_srvheuristics;
6751         TALLOC_CTX *_mem_save_srvheuristics_0;
6752         if (ndr_flags & NDR_SCALARS) {
6753                 NDR_CHECK(ndr_pull_align(ndr, 4));
6754                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ulist_mtime));
6755                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->glist_mtime));
6756                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alist_mtime));
6757                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_alerts));
6758                 if (_ptr_alerts) {
6759                         NDR_PULL_ALLOC(ndr, r->alerts);
6760                 } else {
6761                         r->alerts = NULL;
6762                 }
6763                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->security));
6764                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numadmin));
6765                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lanmask));
6766                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guestaccount));
6767                 if (_ptr_guestaccount) {
6768                         NDR_PULL_ALLOC(ndr, r->guestaccount);
6769                 } else {
6770                         r->guestaccount = NULL;
6771                 }
6772                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->chdevs));
6773                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->chdevqs));
6774                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->chdevjobs));
6775                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->connections));
6776                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->shares));
6777                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->openfiles));
6778                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessopen));
6779                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sesssvc));
6780                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessreqs));
6781                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->opensearch));
6782                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->activelocks));
6783                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numreqbufs));
6784                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sizereqbufs));
6785                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numbigbufs));
6786                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numfiletasks));
6787                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alertsched));
6788                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->erroralert));
6789                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->logonalert));
6790                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->accessalert));
6791                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->diskalert));
6792                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->netioalert));
6793                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxaudits));
6794                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_srvheuristics));
6795                 if (_ptr_srvheuristics) {
6796                         NDR_PULL_ALLOC(ndr, r->srvheuristics);
6797                 } else {
6798                         r->srvheuristics = NULL;
6799                 }
6800         }
6801         if (ndr_flags & NDR_BUFFERS) {
6802                 if (r->alerts) {
6803                         _mem_save_alerts_0 = NDR_PULL_GET_MEM_CTX(ndr);
6804                         NDR_PULL_SET_MEM_CTX(ndr, r->alerts, 0);
6805                         NDR_CHECK(ndr_pull_array_size(ndr, &r->alerts));
6806                         NDR_CHECK(ndr_pull_array_length(ndr, &r->alerts));
6807                         if (ndr_get_array_length(ndr, &r->alerts) > ndr_get_array_size(ndr, &r->alerts)) {
6808                                 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));
6809                         }
6810                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->alerts), sizeof(uint16_t)));
6811                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->alerts, ndr_get_array_length(ndr, &r->alerts), sizeof(uint16_t), CH_UTF16));
6812                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alerts_0, 0);
6813                 }
6814                 if (r->guestaccount) {
6815                         _mem_save_guestaccount_0 = NDR_PULL_GET_MEM_CTX(ndr);
6816                         NDR_PULL_SET_MEM_CTX(ndr, r->guestaccount, 0);
6817                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guestaccount));
6818                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guestaccount));
6819                         if (ndr_get_array_length(ndr, &r->guestaccount) > ndr_get_array_size(ndr, &r->guestaccount)) {
6820                                 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));
6821                         }
6822                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guestaccount), sizeof(uint16_t)));
6823                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guestaccount, ndr_get_array_length(ndr, &r->guestaccount), sizeof(uint16_t), CH_UTF16));
6824                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guestaccount_0, 0);
6825                 }
6826                 if (r->srvheuristics) {
6827                         _mem_save_srvheuristics_0 = NDR_PULL_GET_MEM_CTX(ndr);
6828                         NDR_PULL_SET_MEM_CTX(ndr, r->srvheuristics, 0);
6829                         NDR_CHECK(ndr_pull_array_size(ndr, &r->srvheuristics));
6830                         NDR_CHECK(ndr_pull_array_length(ndr, &r->srvheuristics));
6831                         if (ndr_get_array_length(ndr, &r->srvheuristics) > ndr_get_array_size(ndr, &r->srvheuristics)) {
6832                                 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));
6833                         }
6834                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->srvheuristics), sizeof(uint16_t)));
6835                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->srvheuristics, ndr_get_array_length(ndr, &r->srvheuristics), sizeof(uint16_t), CH_UTF16));
6836                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_srvheuristics_0, 0);
6837                 }
6838         }
6839         return NDR_ERR_SUCCESS;
6840 }
6841
6842 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo402(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo402 *r)
6843 {
6844         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo402");
6845         ndr->depth++;
6846         ndr_print_uint32(ndr, "ulist_mtime", r->ulist_mtime);
6847         ndr_print_uint32(ndr, "glist_mtime", r->glist_mtime);
6848         ndr_print_uint32(ndr, "alist_mtime", r->alist_mtime);
6849         ndr_print_ptr(ndr, "alerts", r->alerts);
6850         ndr->depth++;
6851         if (r->alerts) {
6852                 ndr_print_string(ndr, "alerts", r->alerts);
6853         }
6854         ndr->depth--;
6855         ndr_print_uint32(ndr, "security", r->security);
6856         ndr_print_uint32(ndr, "numadmin", r->numadmin);
6857         ndr_print_uint32(ndr, "lanmask", r->lanmask);
6858         ndr_print_ptr(ndr, "guestaccount", r->guestaccount);
6859         ndr->depth++;
6860         if (r->guestaccount) {
6861                 ndr_print_string(ndr, "guestaccount", r->guestaccount);
6862         }
6863         ndr->depth--;
6864         ndr_print_uint32(ndr, "chdevs", r->chdevs);
6865         ndr_print_uint32(ndr, "chdevqs", r->chdevqs);
6866         ndr_print_uint32(ndr, "chdevjobs", r->chdevjobs);
6867         ndr_print_uint32(ndr, "connections", r->connections);
6868         ndr_print_uint32(ndr, "shares", r->shares);
6869         ndr_print_uint32(ndr, "openfiles", r->openfiles);
6870         ndr_print_uint32(ndr, "sessopen", r->sessopen);
6871         ndr_print_uint32(ndr, "sesssvc", r->sesssvc);
6872         ndr_print_uint32(ndr, "sessreqs", r->sessreqs);
6873         ndr_print_uint32(ndr, "opensearch", r->opensearch);
6874         ndr_print_uint32(ndr, "activelocks", r->activelocks);
6875         ndr_print_uint32(ndr, "numreqbufs", r->numreqbufs);
6876         ndr_print_uint32(ndr, "sizereqbufs", r->sizereqbufs);
6877         ndr_print_uint32(ndr, "numbigbufs", r->numbigbufs);
6878         ndr_print_uint32(ndr, "numfiletasks", r->numfiletasks);
6879         ndr_print_uint32(ndr, "alertsched", r->alertsched);
6880         ndr_print_uint32(ndr, "erroralert", r->erroralert);
6881         ndr_print_uint32(ndr, "logonalert", r->logonalert);
6882         ndr_print_uint32(ndr, "accessalert", r->accessalert);
6883         ndr_print_uint32(ndr, "diskalert", r->diskalert);
6884         ndr_print_uint32(ndr, "netioalert", r->netioalert);
6885         ndr_print_uint32(ndr, "maxaudits", r->maxaudits);
6886         ndr_print_ptr(ndr, "srvheuristics", r->srvheuristics);
6887         ndr->depth++;
6888         if (r->srvheuristics) {
6889                 ndr_print_string(ndr, "srvheuristics", r->srvheuristics);
6890         }
6891         ndr->depth--;
6892         ndr->depth--;
6893 }
6894
6895 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo403(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo403 *r)
6896 {
6897         if (ndr_flags & NDR_SCALARS) {
6898                 NDR_CHECK(ndr_push_align(ndr, 4));
6899                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ulist_mtime));
6900                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->glist_mtime));
6901                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alist_mtime));
6902                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->alerts));
6903                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->security));
6904                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numadmin));
6905                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lanmask));
6906                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guestaccount));
6907                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->chdevs));
6908                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->chdevqs));
6909                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->chdevjobs));
6910                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->connections));
6911                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->shares));
6912                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->openfiles));
6913                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessopen));
6914                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sesssvc));
6915                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessreqs));
6916                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->opensearch));
6917                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->activelocks));
6918                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numreqbufs));
6919                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sizereqbufs));
6920                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numbigbufs));
6921                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numfiletasks));
6922                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alertsched));
6923                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->erroralert));
6924                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->logonalert));
6925                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->accessalert));
6926                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->diskalert));
6927                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->netioalert));
6928                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxaudits));
6929                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->srvheuristics));
6930                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->auditedevents));
6931                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->auditprofile));
6932                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->autopath));
6933         }
6934         if (ndr_flags & NDR_BUFFERS) {
6935                 if (r->alerts) {
6936                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->alerts, CH_UTF16)));
6937                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6938                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->alerts, CH_UTF16)));
6939                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->alerts, ndr_charset_length(r->alerts, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6940                 }
6941                 if (r->guestaccount) {
6942                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guestaccount, CH_UTF16)));
6943                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6944                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guestaccount, CH_UTF16)));
6945                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guestaccount, ndr_charset_length(r->guestaccount, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6946                 }
6947                 if (r->srvheuristics) {
6948                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->srvheuristics, CH_UTF16)));
6949                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6950                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->srvheuristics, CH_UTF16)));
6951                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->srvheuristics, ndr_charset_length(r->srvheuristics, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6952                 }
6953                 if (r->autopath) {
6954                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->autopath, CH_UTF16)));
6955                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6956                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->autopath, CH_UTF16)));
6957                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->autopath, ndr_charset_length(r->autopath, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6958                 }
6959         }
6960         return NDR_ERR_SUCCESS;
6961 }
6962
6963 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo403(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo403 *r)
6964 {
6965         uint32_t _ptr_alerts;
6966         TALLOC_CTX *_mem_save_alerts_0;
6967         uint32_t _ptr_guestaccount;
6968         TALLOC_CTX *_mem_save_guestaccount_0;
6969         uint32_t _ptr_srvheuristics;
6970         TALLOC_CTX *_mem_save_srvheuristics_0;
6971         uint32_t _ptr_autopath;
6972         TALLOC_CTX *_mem_save_autopath_0;
6973         if (ndr_flags & NDR_SCALARS) {
6974                 NDR_CHECK(ndr_pull_align(ndr, 4));
6975                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ulist_mtime));
6976                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->glist_mtime));
6977                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alist_mtime));
6978                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_alerts));
6979                 if (_ptr_alerts) {
6980                         NDR_PULL_ALLOC(ndr, r->alerts);
6981                 } else {
6982                         r->alerts = NULL;
6983                 }
6984                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->security));
6985                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numadmin));
6986                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lanmask));
6987                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guestaccount));
6988                 if (_ptr_guestaccount) {
6989                         NDR_PULL_ALLOC(ndr, r->guestaccount);
6990                 } else {
6991                         r->guestaccount = NULL;
6992                 }
6993                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->chdevs));
6994                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->chdevqs));
6995                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->chdevjobs));
6996                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->connections));
6997                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->shares));
6998                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->openfiles));
6999                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessopen));
7000                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sesssvc));
7001                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessreqs));
7002                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->opensearch));
7003                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->activelocks));
7004                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numreqbufs));
7005                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sizereqbufs));
7006                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numbigbufs));
7007                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numfiletasks));
7008                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alertsched));
7009                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->erroralert));
7010                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->logonalert));
7011                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->accessalert));
7012                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->diskalert));
7013                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->netioalert));
7014                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxaudits));
7015                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_srvheuristics));
7016                 if (_ptr_srvheuristics) {
7017                         NDR_PULL_ALLOC(ndr, r->srvheuristics);
7018                 } else {
7019                         r->srvheuristics = NULL;
7020                 }
7021                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->auditedevents));
7022                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->auditprofile));
7023                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_autopath));
7024                 if (_ptr_autopath) {
7025                         NDR_PULL_ALLOC(ndr, r->autopath);
7026                 } else {
7027                         r->autopath = NULL;
7028                 }
7029         }
7030         if (ndr_flags & NDR_BUFFERS) {
7031                 if (r->alerts) {
7032                         _mem_save_alerts_0 = NDR_PULL_GET_MEM_CTX(ndr);
7033                         NDR_PULL_SET_MEM_CTX(ndr, r->alerts, 0);
7034                         NDR_CHECK(ndr_pull_array_size(ndr, &r->alerts));
7035                         NDR_CHECK(ndr_pull_array_length(ndr, &r->alerts));
7036                         if (ndr_get_array_length(ndr, &r->alerts) > ndr_get_array_size(ndr, &r->alerts)) {
7037                                 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));
7038                         }
7039                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->alerts), sizeof(uint16_t)));
7040                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->alerts, ndr_get_array_length(ndr, &r->alerts), sizeof(uint16_t), CH_UTF16));
7041                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alerts_0, 0);
7042                 }
7043                 if (r->guestaccount) {
7044                         _mem_save_guestaccount_0 = NDR_PULL_GET_MEM_CTX(ndr);
7045                         NDR_PULL_SET_MEM_CTX(ndr, r->guestaccount, 0);
7046                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guestaccount));
7047                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guestaccount));
7048                         if (ndr_get_array_length(ndr, &r->guestaccount) > ndr_get_array_size(ndr, &r->guestaccount)) {
7049                                 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));
7050                         }
7051                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guestaccount), sizeof(uint16_t)));
7052                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guestaccount, ndr_get_array_length(ndr, &r->guestaccount), sizeof(uint16_t), CH_UTF16));
7053                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guestaccount_0, 0);
7054                 }
7055                 if (r->srvheuristics) {
7056                         _mem_save_srvheuristics_0 = NDR_PULL_GET_MEM_CTX(ndr);
7057                         NDR_PULL_SET_MEM_CTX(ndr, r->srvheuristics, 0);
7058                         NDR_CHECK(ndr_pull_array_size(ndr, &r->srvheuristics));
7059                         NDR_CHECK(ndr_pull_array_length(ndr, &r->srvheuristics));
7060                         if (ndr_get_array_length(ndr, &r->srvheuristics) > ndr_get_array_size(ndr, &r->srvheuristics)) {
7061                                 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));
7062                         }
7063                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->srvheuristics), sizeof(uint16_t)));
7064                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->srvheuristics, ndr_get_array_length(ndr, &r->srvheuristics), sizeof(uint16_t), CH_UTF16));
7065                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_srvheuristics_0, 0);
7066                 }
7067                 if (r->autopath) {
7068                         _mem_save_autopath_0 = NDR_PULL_GET_MEM_CTX(ndr);
7069                         NDR_PULL_SET_MEM_CTX(ndr, r->autopath, 0);
7070                         NDR_CHECK(ndr_pull_array_size(ndr, &r->autopath));
7071                         NDR_CHECK(ndr_pull_array_length(ndr, &r->autopath));
7072                         if (ndr_get_array_length(ndr, &r->autopath) > ndr_get_array_size(ndr, &r->autopath)) {
7073                                 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));
7074                         }
7075                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->autopath), sizeof(uint16_t)));
7076                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->autopath, ndr_get_array_length(ndr, &r->autopath), sizeof(uint16_t), CH_UTF16));
7077                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_autopath_0, 0);
7078                 }
7079         }
7080         return NDR_ERR_SUCCESS;
7081 }
7082
7083 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo403(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo403 *r)
7084 {
7085         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo403");
7086         ndr->depth++;
7087         ndr_print_uint32(ndr, "ulist_mtime", r->ulist_mtime);
7088         ndr_print_uint32(ndr, "glist_mtime", r->glist_mtime);
7089         ndr_print_uint32(ndr, "alist_mtime", r->alist_mtime);
7090         ndr_print_ptr(ndr, "alerts", r->alerts);
7091         ndr->depth++;
7092         if (r->alerts) {
7093                 ndr_print_string(ndr, "alerts", r->alerts);
7094         }
7095         ndr->depth--;
7096         ndr_print_uint32(ndr, "security", r->security);
7097         ndr_print_uint32(ndr, "numadmin", r->numadmin);
7098         ndr_print_uint32(ndr, "lanmask", r->lanmask);
7099         ndr_print_ptr(ndr, "guestaccount", r->guestaccount);
7100         ndr->depth++;
7101         if (r->guestaccount) {
7102                 ndr_print_string(ndr, "guestaccount", r->guestaccount);
7103         }
7104         ndr->depth--;
7105         ndr_print_uint32(ndr, "chdevs", r->chdevs);
7106         ndr_print_uint32(ndr, "chdevqs", r->chdevqs);
7107         ndr_print_uint32(ndr, "chdevjobs", r->chdevjobs);
7108         ndr_print_uint32(ndr, "connections", r->connections);
7109         ndr_print_uint32(ndr, "shares", r->shares);
7110         ndr_print_uint32(ndr, "openfiles", r->openfiles);
7111         ndr_print_uint32(ndr, "sessopen", r->sessopen);
7112         ndr_print_uint32(ndr, "sesssvc", r->sesssvc);
7113         ndr_print_uint32(ndr, "sessreqs", r->sessreqs);
7114         ndr_print_uint32(ndr, "opensearch", r->opensearch);
7115         ndr_print_uint32(ndr, "activelocks", r->activelocks);
7116         ndr_print_uint32(ndr, "numreqbufs", r->numreqbufs);
7117         ndr_print_uint32(ndr, "sizereqbufs", r->sizereqbufs);
7118         ndr_print_uint32(ndr, "numbigbufs", r->numbigbufs);
7119         ndr_print_uint32(ndr, "numfiletasks", r->numfiletasks);
7120         ndr_print_uint32(ndr, "alertsched", r->alertsched);
7121         ndr_print_uint32(ndr, "erroralert", r->erroralert);
7122         ndr_print_uint32(ndr, "logonalert", r->logonalert);
7123         ndr_print_uint32(ndr, "accessalert", r->accessalert);
7124         ndr_print_uint32(ndr, "diskalert", r->diskalert);
7125         ndr_print_uint32(ndr, "netioalert", r->netioalert);
7126         ndr_print_uint32(ndr, "maxaudits", r->maxaudits);
7127         ndr_print_ptr(ndr, "srvheuristics", r->srvheuristics);
7128         ndr->depth++;
7129         if (r->srvheuristics) {
7130                 ndr_print_string(ndr, "srvheuristics", r->srvheuristics);
7131         }
7132         ndr->depth--;
7133         ndr_print_uint32(ndr, "auditedevents", r->auditedevents);
7134         ndr_print_uint32(ndr, "auditprofile", r->auditprofile);
7135         ndr_print_ptr(ndr, "autopath", r->autopath);
7136         ndr->depth++;
7137         if (r->autopath) {
7138                 ndr_print_string(ndr, "autopath", r->autopath);
7139         }
7140         ndr->depth--;
7141         ndr->depth--;
7142 }
7143
7144 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo502(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo502 *r)
7145 {
7146         if (ndr_flags & NDR_SCALARS) {
7147                 NDR_CHECK(ndr_push_align(ndr, 4));
7148                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessopen));
7149                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sesssvc));
7150                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->opensearch));
7151                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sizereqbufs));
7152                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initworkitems));
7153                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxworkitems));
7154                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rawworkitems));
7155                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->irpstacksize));
7156                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxrawbuflen));
7157                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessusers));
7158                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessconns));
7159                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxpagedmemoryusage));
7160                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxnonpagedmemoryusage));
7161                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablesoftcompat));
7162                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableforcedlogoff));
7163                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->timesource));
7164                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->acceptdownlevelapis));
7165                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lmannounce));
7166         }
7167         if (ndr_flags & NDR_BUFFERS) {
7168         }
7169         return NDR_ERR_SUCCESS;
7170 }
7171
7172 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo502(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo502 *r)
7173 {
7174         if (ndr_flags & NDR_SCALARS) {
7175                 NDR_CHECK(ndr_pull_align(ndr, 4));
7176                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessopen));
7177                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sesssvc));
7178                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->opensearch));
7179                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sizereqbufs));
7180                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initworkitems));
7181                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxworkitems));
7182                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rawworkitems));
7183                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->irpstacksize));
7184                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxrawbuflen));
7185                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessusers));
7186                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessconns));
7187                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxpagedmemoryusage));
7188                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxnonpagedmemoryusage));
7189                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablesoftcompat));
7190                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableforcedlogoff));
7191                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->timesource));
7192                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->acceptdownlevelapis));
7193                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lmannounce));
7194         }
7195         if (ndr_flags & NDR_BUFFERS) {
7196         }
7197         return NDR_ERR_SUCCESS;
7198 }
7199
7200 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo502(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo502 *r)
7201 {
7202         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo502");
7203         ndr->depth++;
7204         ndr_print_uint32(ndr, "sessopen", r->sessopen);
7205         ndr_print_uint32(ndr, "sesssvc", r->sesssvc);
7206         ndr_print_uint32(ndr, "opensearch", r->opensearch);
7207         ndr_print_uint32(ndr, "sizereqbufs", r->sizereqbufs);
7208         ndr_print_uint32(ndr, "initworkitems", r->initworkitems);
7209         ndr_print_uint32(ndr, "maxworkitems", r->maxworkitems);
7210         ndr_print_uint32(ndr, "rawworkitems", r->rawworkitems);
7211         ndr_print_uint32(ndr, "irpstacksize", r->irpstacksize);
7212         ndr_print_uint32(ndr, "maxrawbuflen", r->maxrawbuflen);
7213         ndr_print_uint32(ndr, "sessusers", r->sessusers);
7214         ndr_print_uint32(ndr, "sessconns", r->sessconns);
7215         ndr_print_uint32(ndr, "maxpagedmemoryusage", r->maxpagedmemoryusage);
7216         ndr_print_uint32(ndr, "maxnonpagedmemoryusage", r->maxnonpagedmemoryusage);
7217         ndr_print_uint32(ndr, "enablesoftcompat", r->enablesoftcompat);
7218         ndr_print_uint32(ndr, "enableforcedlogoff", r->enableforcedlogoff);
7219         ndr_print_uint32(ndr, "timesource", r->timesource);
7220         ndr_print_uint32(ndr, "acceptdownlevelapis", r->acceptdownlevelapis);
7221         ndr_print_uint32(ndr, "lmannounce", r->lmannounce);
7222         ndr->depth--;
7223 }
7224
7225 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo503(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo503 *r)
7226 {
7227         if (ndr_flags & NDR_SCALARS) {
7228                 NDR_CHECK(ndr_push_align(ndr, 4));
7229                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessopen));
7230                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sesssvc));
7231                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->opensearch));
7232                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sizereqbufs));
7233                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initworkitems));
7234                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxworkitems));
7235                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rawworkitems));
7236                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->irpstacksize));
7237                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxrawbuflen));
7238                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessusers));
7239                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessconns));
7240                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxpagedmemoryusage));
7241                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxnonpagedmemoryusage));
7242                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablesoftcompat));
7243                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableforcedlogoff));
7244                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->timesource));
7245                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->acceptdownlevelapis));
7246                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lmannounce));
7247                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
7248                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxcopyreadlen));
7249                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxcopywritelen));
7250                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minkeepsearch));
7251                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxkeepsearch));
7252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minkeepcomplsearch));
7253                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxkeepcomplsearch));
7254                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->threadcountadd));
7255                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numlockthreads));
7256                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->scavtimeout));
7257                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minrcvqueue));
7258                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minfreeworkitems));
7259                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->xactmemsize));
7260                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->threadpriority));
7261                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxmpxct));
7262                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->oplockbreakwait));
7263                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->oplockbreakresponsewait));
7264                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableoplocks));
7265                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableoplockforceclose));
7266                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablefcbopens));
7267                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableraw));
7268                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablesharednetdrives));
7269                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minfreeconnections));
7270                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxfreeconnections));
7271         }
7272         if (ndr_flags & NDR_BUFFERS) {
7273                 if (r->domain) {
7274                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
7275                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7276                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
7277                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain, ndr_charset_length(r->domain, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7278                 }
7279         }
7280         return NDR_ERR_SUCCESS;
7281 }
7282
7283 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo503(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo503 *r)
7284 {
7285         uint32_t _ptr_domain;
7286         TALLOC_CTX *_mem_save_domain_0;
7287         if (ndr_flags & NDR_SCALARS) {
7288                 NDR_CHECK(ndr_pull_align(ndr, 4));
7289                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessopen));
7290                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sesssvc));
7291                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->opensearch));
7292                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sizereqbufs));
7293                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initworkitems));
7294                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxworkitems));
7295                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rawworkitems));
7296                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->irpstacksize));
7297                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxrawbuflen));
7298                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessusers));
7299                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessconns));
7300                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxpagedmemoryusage));
7301                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxnonpagedmemoryusage));
7302                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablesoftcompat));
7303                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableforcedlogoff));
7304                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->timesource));
7305                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->acceptdownlevelapis));
7306                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lmannounce));
7307                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
7308                 if (_ptr_domain) {
7309                         NDR_PULL_ALLOC(ndr, r->domain);
7310                 } else {
7311                         r->domain = NULL;
7312                 }
7313                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxcopyreadlen));
7314                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxcopywritelen));
7315                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minkeepsearch));
7316                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxkeepsearch));
7317                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minkeepcomplsearch));
7318                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxkeepcomplsearch));
7319                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->threadcountadd));
7320                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numlockthreads));
7321                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->scavtimeout));
7322                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minrcvqueue));
7323                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minfreeworkitems));
7324                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->xactmemsize));
7325                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->threadpriority));
7326                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxmpxct));
7327                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->oplockbreakwait));
7328                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->oplockbreakresponsewait));
7329                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableoplocks));
7330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableoplockforceclose));
7331                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablefcbopens));
7332                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableraw));
7333                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablesharednetdrives));
7334                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minfreeconnections));
7335                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxfreeconnections));
7336         }
7337         if (ndr_flags & NDR_BUFFERS) {
7338                 if (r->domain) {
7339                         _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
7340                         NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);
7341                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain));
7342                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain));
7343                         if (ndr_get_array_length(ndr, &r->domain) > ndr_get_array_size(ndr, &r->domain)) {
7344                                 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));
7345                         }
7346                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t)));
7347                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t), CH_UTF16));
7348                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);
7349                 }
7350         }
7351         return NDR_ERR_SUCCESS;
7352 }
7353
7354 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo503(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo503 *r)
7355 {
7356         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo503");
7357         ndr->depth++;
7358         ndr_print_uint32(ndr, "sessopen", r->sessopen);
7359         ndr_print_uint32(ndr, "sesssvc", r->sesssvc);
7360         ndr_print_uint32(ndr, "opensearch", r->opensearch);
7361         ndr_print_uint32(ndr, "sizereqbufs", r->sizereqbufs);
7362         ndr_print_uint32(ndr, "initworkitems", r->initworkitems);
7363         ndr_print_uint32(ndr, "maxworkitems", r->maxworkitems);
7364         ndr_print_uint32(ndr, "rawworkitems", r->rawworkitems);
7365         ndr_print_uint32(ndr, "irpstacksize", r->irpstacksize);
7366         ndr_print_uint32(ndr, "maxrawbuflen", r->maxrawbuflen);
7367         ndr_print_uint32(ndr, "sessusers", r->sessusers);
7368         ndr_print_uint32(ndr, "sessconns", r->sessconns);
7369         ndr_print_uint32(ndr, "maxpagedmemoryusage", r->maxpagedmemoryusage);
7370         ndr_print_uint32(ndr, "maxnonpagedmemoryusage", r->maxnonpagedmemoryusage);
7371         ndr_print_uint32(ndr, "enablesoftcompat", r->enablesoftcompat);
7372         ndr_print_uint32(ndr, "enableforcedlogoff", r->enableforcedlogoff);
7373         ndr_print_uint32(ndr, "timesource", r->timesource);
7374         ndr_print_uint32(ndr, "acceptdownlevelapis", r->acceptdownlevelapis);
7375         ndr_print_uint32(ndr, "lmannounce", r->lmannounce);
7376         ndr_print_ptr(ndr, "domain", r->domain);
7377         ndr->depth++;
7378         if (r->domain) {
7379                 ndr_print_string(ndr, "domain", r->domain);
7380         }
7381         ndr->depth--;
7382         ndr_print_uint32(ndr, "maxcopyreadlen", r->maxcopyreadlen);
7383         ndr_print_uint32(ndr, "maxcopywritelen", r->maxcopywritelen);
7384         ndr_print_uint32(ndr, "minkeepsearch", r->minkeepsearch);
7385         ndr_print_uint32(ndr, "maxkeepsearch", r->maxkeepsearch);
7386         ndr_print_uint32(ndr, "minkeepcomplsearch", r->minkeepcomplsearch);
7387         ndr_print_uint32(ndr, "maxkeepcomplsearch", r->maxkeepcomplsearch);
7388         ndr_print_uint32(ndr, "threadcountadd", r->threadcountadd);
7389         ndr_print_uint32(ndr, "numlockthreads", r->numlockthreads);
7390         ndr_print_uint32(ndr, "scavtimeout", r->scavtimeout);
7391         ndr_print_uint32(ndr, "minrcvqueue", r->minrcvqueue);
7392         ndr_print_uint32(ndr, "minfreeworkitems", r->minfreeworkitems);
7393         ndr_print_uint32(ndr, "xactmemsize", r->xactmemsize);
7394         ndr_print_uint32(ndr, "threadpriority", r->threadpriority);
7395         ndr_print_uint32(ndr, "maxmpxct", r->maxmpxct);
7396         ndr_print_uint32(ndr, "oplockbreakwait", r->oplockbreakwait);
7397         ndr_print_uint32(ndr, "oplockbreakresponsewait", r->oplockbreakresponsewait);
7398         ndr_print_uint32(ndr, "enableoplocks", r->enableoplocks);
7399         ndr_print_uint32(ndr, "enableoplockforceclose", r->enableoplockforceclose);
7400         ndr_print_uint32(ndr, "enablefcbopens", r->enablefcbopens);
7401         ndr_print_uint32(ndr, "enableraw", r->enableraw);
7402         ndr_print_uint32(ndr, "enablesharednetdrives", r->enablesharednetdrives);
7403         ndr_print_uint32(ndr, "minfreeconnections", r->minfreeconnections);
7404         ndr_print_uint32(ndr, "maxfreeconnections", r->maxfreeconnections);
7405         ndr->depth--;
7406 }
7407
7408 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo599(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo599 *r)
7409 {
7410         if (ndr_flags & NDR_SCALARS) {
7411                 NDR_CHECK(ndr_push_align(ndr, 4));
7412                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessopen));
7413                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sesssvc));
7414                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->opensearch));
7415                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sizereqbufs));
7416                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initworkitems));
7417                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxworkitems));
7418                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rawworkitems));
7419                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->irpstacksize));
7420                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxrawbuflen));
7421                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessusers));
7422                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessconns));
7423                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxpagedmemoryusage));
7424                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxnonpagedmemoryusage));
7425                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablesoftcompat));
7426                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableforcedlogoff));
7427                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->timesource));
7428                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->acceptdownlevelapis));
7429                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lmannounce));
7430                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
7431                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxcopyreadlen));
7432                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxcopywritelen));
7433                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minkeepsearch));
7434                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minkeepcomplsearch));
7435                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxkeepcomplsearch));
7436                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->threadcountadd));
7437                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numlockthreads));
7438                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->scavtimeout));
7439                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minrcvqueue));
7440                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minfreeworkitems));
7441                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->xactmemsize));
7442                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->threadpriority));
7443                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxmpxct));
7444                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->oplockbreakwait));
7445                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->oplockbreakresponsewait));
7446                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableoplocks));
7447                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableoplockforceclose));
7448                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablefcbopens));
7449                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableraw));
7450                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablesharednetdrives));
7451                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minfreeconnections));
7452                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxfreeconnections));
7453                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initsesstable));
7454                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initconntable));
7455                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initfiletable));
7456                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initsearchtable));
7457                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alertsched));
7458                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->errortreshold));
7459                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->networkerrortreshold));
7460                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->diskspacetreshold));
7461                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
7462                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxlinkdelay));
7463                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minlinkthroughput));
7464                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->linkinfovalidtime));
7465                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->scavqosinfoupdatetime));
7466                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxworkitemidletime));
7467         }
7468         if (ndr_flags & NDR_BUFFERS) {
7469                 if (r->domain) {
7470                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
7471                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7472                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
7473                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain, ndr_charset_length(r->domain, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7474                 }
7475         }
7476         return NDR_ERR_SUCCESS;
7477 }
7478
7479 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo599(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo599 *r)
7480 {
7481         uint32_t _ptr_domain;
7482         TALLOC_CTX *_mem_save_domain_0;
7483         if (ndr_flags & NDR_SCALARS) {
7484                 NDR_CHECK(ndr_pull_align(ndr, 4));
7485                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessopen));
7486                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sesssvc));
7487                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->opensearch));
7488                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sizereqbufs));
7489                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initworkitems));
7490                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxworkitems));
7491                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rawworkitems));
7492                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->irpstacksize));
7493                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxrawbuflen));
7494                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessusers));
7495                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessconns));
7496                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxpagedmemoryusage));
7497                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxnonpagedmemoryusage));
7498                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablesoftcompat));
7499                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableforcedlogoff));
7500                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->timesource));
7501                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->acceptdownlevelapis));
7502                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lmannounce));
7503                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
7504                 if (_ptr_domain) {
7505                         NDR_PULL_ALLOC(ndr, r->domain);
7506                 } else {
7507                         r->domain = NULL;
7508                 }
7509                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxcopyreadlen));
7510                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxcopywritelen));
7511                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minkeepsearch));
7512                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minkeepcomplsearch));
7513                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxkeepcomplsearch));
7514                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->threadcountadd));
7515                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numlockthreads));
7516                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->scavtimeout));
7517                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minrcvqueue));
7518                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minfreeworkitems));
7519                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->xactmemsize));
7520                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->threadpriority));
7521                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxmpxct));
7522                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->oplockbreakwait));
7523                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->oplockbreakresponsewait));
7524                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableoplocks));
7525                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableoplockforceclose));
7526                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablefcbopens));
7527                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableraw));
7528                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablesharednetdrives));
7529                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minfreeconnections));
7530                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxfreeconnections));
7531                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initsesstable));
7532                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initconntable));
7533                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initfiletable));
7534                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initsearchtable));
7535                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alertsched));
7536                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->errortreshold));
7537                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->networkerrortreshold));
7538                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->diskspacetreshold));
7539                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
7540                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxlinkdelay));
7541                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minlinkthroughput));
7542                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->linkinfovalidtime));
7543                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->scavqosinfoupdatetime));
7544                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxworkitemidletime));
7545         }
7546         if (ndr_flags & NDR_BUFFERS) {
7547                 if (r->domain) {
7548                         _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
7549                         NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);
7550                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain));
7551                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain));
7552                         if (ndr_get_array_length(ndr, &r->domain) > ndr_get_array_size(ndr, &r->domain)) {
7553                                 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));
7554                         }
7555                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t)));
7556                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t), CH_UTF16));
7557                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);
7558                 }
7559         }
7560         return NDR_ERR_SUCCESS;
7561 }
7562
7563 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo599(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo599 *r)
7564 {
7565         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo599");
7566         ndr->depth++;
7567         ndr_print_uint32(ndr, "sessopen", r->sessopen);
7568         ndr_print_uint32(ndr, "sesssvc", r->sesssvc);
7569         ndr_print_uint32(ndr, "opensearch", r->opensearch);
7570         ndr_print_uint32(ndr, "sizereqbufs", r->sizereqbufs);
7571         ndr_print_uint32(ndr, "initworkitems", r->initworkitems);
7572         ndr_print_uint32(ndr, "maxworkitems", r->maxworkitems);
7573         ndr_print_uint32(ndr, "rawworkitems", r->rawworkitems);
7574         ndr_print_uint32(ndr, "irpstacksize", r->irpstacksize);
7575         ndr_print_uint32(ndr, "maxrawbuflen", r->maxrawbuflen);
7576         ndr_print_uint32(ndr, "sessusers", r->sessusers);
7577         ndr_print_uint32(ndr, "sessconns", r->sessconns);
7578         ndr_print_uint32(ndr, "maxpagedmemoryusage", r->maxpagedmemoryusage);
7579         ndr_print_uint32(ndr, "maxnonpagedmemoryusage", r->maxnonpagedmemoryusage);
7580         ndr_print_uint32(ndr, "enablesoftcompat", r->enablesoftcompat);
7581         ndr_print_uint32(ndr, "enableforcedlogoff", r->enableforcedlogoff);
7582         ndr_print_uint32(ndr, "timesource", r->timesource);
7583         ndr_print_uint32(ndr, "acceptdownlevelapis", r->acceptdownlevelapis);
7584         ndr_print_uint32(ndr, "lmannounce", r->lmannounce);
7585         ndr_print_ptr(ndr, "domain", r->domain);
7586         ndr->depth++;
7587         if (r->domain) {
7588                 ndr_print_string(ndr, "domain", r->domain);
7589         }
7590         ndr->depth--;
7591         ndr_print_uint32(ndr, "maxcopyreadlen", r->maxcopyreadlen);
7592         ndr_print_uint32(ndr, "maxcopywritelen", r->maxcopywritelen);
7593         ndr_print_uint32(ndr, "minkeepsearch", r->minkeepsearch);
7594         ndr_print_uint32(ndr, "minkeepcomplsearch", r->minkeepcomplsearch);
7595         ndr_print_uint32(ndr, "maxkeepcomplsearch", r->maxkeepcomplsearch);
7596         ndr_print_uint32(ndr, "threadcountadd", r->threadcountadd);
7597         ndr_print_uint32(ndr, "numlockthreads", r->numlockthreads);
7598         ndr_print_uint32(ndr, "scavtimeout", r->scavtimeout);
7599         ndr_print_uint32(ndr, "minrcvqueue", r->minrcvqueue);
7600         ndr_print_uint32(ndr, "minfreeworkitems", r->minfreeworkitems);
7601         ndr_print_uint32(ndr, "xactmemsize", r->xactmemsize);
7602         ndr_print_uint32(ndr, "threadpriority", r->threadpriority);
7603         ndr_print_uint32(ndr, "maxmpxct", r->maxmpxct);
7604         ndr_print_uint32(ndr, "oplockbreakwait", r->oplockbreakwait);
7605         ndr_print_uint32(ndr, "oplockbreakresponsewait", r->oplockbreakresponsewait);
7606         ndr_print_uint32(ndr, "enableoplocks", r->enableoplocks);
7607         ndr_print_uint32(ndr, "enableoplockforceclose", r->enableoplockforceclose);
7608         ndr_print_uint32(ndr, "enablefcbopens", r->enablefcbopens);
7609         ndr_print_uint32(ndr, "enableraw", r->enableraw);
7610         ndr_print_uint32(ndr, "enablesharednetdrives", r->enablesharednetdrives);
7611         ndr_print_uint32(ndr, "minfreeconnections", r->minfreeconnections);
7612         ndr_print_uint32(ndr, "maxfreeconnections", r->maxfreeconnections);
7613         ndr_print_uint32(ndr, "initsesstable", r->initsesstable);
7614         ndr_print_uint32(ndr, "initconntable", r->initconntable);
7615         ndr_print_uint32(ndr, "initfiletable", r->initfiletable);
7616         ndr_print_uint32(ndr, "initsearchtable", r->initsearchtable);
7617         ndr_print_uint32(ndr, "alertsched", r->alertsched);
7618         ndr_print_uint32(ndr, "errortreshold", r->errortreshold);
7619         ndr_print_uint32(ndr, "networkerrortreshold", r->networkerrortreshold);
7620         ndr_print_uint32(ndr, "diskspacetreshold", r->diskspacetreshold);
7621         ndr_print_uint32(ndr, "reserved", r->reserved);
7622         ndr_print_uint32(ndr, "maxlinkdelay", r->maxlinkdelay);
7623         ndr_print_uint32(ndr, "minlinkthroughput", r->minlinkthroughput);
7624         ndr_print_uint32(ndr, "linkinfovalidtime", r->linkinfovalidtime);
7625         ndr_print_uint32(ndr, "scavqosinfoupdatetime", r->scavqosinfoupdatetime);
7626         ndr_print_uint32(ndr, "maxworkitemidletime", r->maxworkitemidletime);
7627         ndr->depth--;
7628 }
7629
7630 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1005(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1005 *r)
7631 {
7632         if (ndr_flags & NDR_SCALARS) {
7633                 NDR_CHECK(ndr_push_align(ndr, 4));
7634                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
7635         }
7636         if (ndr_flags & NDR_BUFFERS) {
7637                 if (r->comment) {
7638                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
7639                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7640                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
7641                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7642                 }
7643         }
7644         return NDR_ERR_SUCCESS;
7645 }
7646
7647 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1005(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1005 *r)
7648 {
7649         uint32_t _ptr_comment;
7650         TALLOC_CTX *_mem_save_comment_0;
7651         if (ndr_flags & NDR_SCALARS) {
7652                 NDR_CHECK(ndr_pull_align(ndr, 4));
7653                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
7654                 if (_ptr_comment) {
7655                         NDR_PULL_ALLOC(ndr, r->comment);
7656                 } else {
7657                         r->comment = NULL;
7658                 }
7659         }
7660         if (ndr_flags & NDR_BUFFERS) {
7661                 if (r->comment) {
7662                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
7663                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
7664                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
7665                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
7666                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
7667                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
7668                         }
7669                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
7670                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
7671                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
7672                 }
7673         }
7674         return NDR_ERR_SUCCESS;
7675 }
7676
7677 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1005(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1005 *r)
7678 {
7679         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1005");
7680         ndr->depth++;
7681         ndr_print_ptr(ndr, "comment", r->comment);
7682         ndr->depth++;
7683         if (r->comment) {
7684                 ndr_print_string(ndr, "comment", r->comment);
7685         }
7686         ndr->depth--;
7687         ndr->depth--;
7688 }
7689
7690 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1010(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1010 *r)
7691 {
7692         if (ndr_flags & NDR_SCALARS) {
7693                 NDR_CHECK(ndr_push_align(ndr, 4));
7694                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->disc));
7695         }
7696         if (ndr_flags & NDR_BUFFERS) {
7697         }
7698         return NDR_ERR_SUCCESS;
7699 }
7700
7701 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1010(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1010 *r)
7702 {
7703         if (ndr_flags & NDR_SCALARS) {
7704                 NDR_CHECK(ndr_pull_align(ndr, 4));
7705                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->disc));
7706         }
7707         if (ndr_flags & NDR_BUFFERS) {
7708         }
7709         return NDR_ERR_SUCCESS;
7710 }
7711
7712 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1010(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1010 *r)
7713 {
7714         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1010");
7715         ndr->depth++;
7716         ndr_print_uint32(ndr, "disc", r->disc);
7717         ndr->depth--;
7718 }
7719
7720 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1016(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1016 *r)
7721 {
7722         if (ndr_flags & NDR_SCALARS) {
7723                 NDR_CHECK(ndr_push_align(ndr, 4));
7724                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->hidden));
7725         }
7726         if (ndr_flags & NDR_BUFFERS) {
7727         }
7728         return NDR_ERR_SUCCESS;
7729 }
7730
7731 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1016(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1016 *r)
7732 {
7733         if (ndr_flags & NDR_SCALARS) {
7734                 NDR_CHECK(ndr_pull_align(ndr, 4));
7735                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->hidden));
7736         }
7737         if (ndr_flags & NDR_BUFFERS) {
7738         }
7739         return NDR_ERR_SUCCESS;
7740 }
7741
7742 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1016(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1016 *r)
7743 {
7744         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1016");
7745         ndr->depth++;
7746         ndr_print_uint32(ndr, "hidden", r->hidden);
7747         ndr->depth--;
7748 }
7749
7750 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1017(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1017 *r)
7751 {
7752         if (ndr_flags & NDR_SCALARS) {
7753                 NDR_CHECK(ndr_push_align(ndr, 4));
7754                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->announce));
7755         }
7756         if (ndr_flags & NDR_BUFFERS) {
7757         }
7758         return NDR_ERR_SUCCESS;
7759 }
7760
7761 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1017(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1017 *r)
7762 {
7763         if (ndr_flags & NDR_SCALARS) {
7764                 NDR_CHECK(ndr_pull_align(ndr, 4));
7765                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->announce));
7766         }
7767         if (ndr_flags & NDR_BUFFERS) {
7768         }
7769         return NDR_ERR_SUCCESS;
7770 }
7771
7772 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1017(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1017 *r)
7773 {
7774         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1017");
7775         ndr->depth++;
7776         ndr_print_uint32(ndr, "announce", r->announce);
7777         ndr->depth--;
7778 }
7779
7780 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1018(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1018 *r)
7781 {
7782         if (ndr_flags & NDR_SCALARS) {
7783                 NDR_CHECK(ndr_push_align(ndr, 4));
7784                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->anndelta));
7785         }
7786         if (ndr_flags & NDR_BUFFERS) {
7787         }
7788         return NDR_ERR_SUCCESS;
7789 }
7790
7791 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1018(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1018 *r)
7792 {
7793         if (ndr_flags & NDR_SCALARS) {
7794                 NDR_CHECK(ndr_pull_align(ndr, 4));
7795                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->anndelta));
7796         }
7797         if (ndr_flags & NDR_BUFFERS) {
7798         }
7799         return NDR_ERR_SUCCESS;
7800 }
7801
7802 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1018(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1018 *r)
7803 {
7804         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1018");
7805         ndr->depth++;
7806         ndr_print_uint32(ndr, "anndelta", r->anndelta);
7807         ndr->depth--;
7808 }
7809
7810 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1107(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1107 *r)
7811 {
7812         if (ndr_flags & NDR_SCALARS) {
7813                 NDR_CHECK(ndr_push_align(ndr, 4));
7814                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->users));
7815         }
7816         if (ndr_flags & NDR_BUFFERS) {
7817         }
7818         return NDR_ERR_SUCCESS;
7819 }
7820
7821 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1107(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1107 *r)
7822 {
7823         if (ndr_flags & NDR_SCALARS) {
7824                 NDR_CHECK(ndr_pull_align(ndr, 4));
7825                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->users));
7826         }
7827         if (ndr_flags & NDR_BUFFERS) {
7828         }
7829         return NDR_ERR_SUCCESS;
7830 }
7831
7832 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1107(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1107 *r)
7833 {
7834         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1107");
7835         ndr->depth++;
7836         ndr_print_uint32(ndr, "users", r->users);
7837         ndr->depth--;
7838 }
7839
7840 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1501(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1501 *r)
7841 {
7842         if (ndr_flags & NDR_SCALARS) {
7843                 NDR_CHECK(ndr_push_align(ndr, 4));
7844                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessopens));
7845         }
7846         if (ndr_flags & NDR_BUFFERS) {
7847         }
7848         return NDR_ERR_SUCCESS;
7849 }
7850
7851 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1501(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1501 *r)
7852 {
7853         if (ndr_flags & NDR_SCALARS) {
7854                 NDR_CHECK(ndr_pull_align(ndr, 4));
7855                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessopens));
7856         }
7857         if (ndr_flags & NDR_BUFFERS) {
7858         }
7859         return NDR_ERR_SUCCESS;
7860 }
7861
7862 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1501(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1501 *r)
7863 {
7864         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1501");
7865         ndr->depth++;
7866         ndr_print_uint32(ndr, "sessopens", r->sessopens);
7867         ndr->depth--;
7868 }
7869
7870 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1502(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1502 *r)
7871 {
7872         if (ndr_flags & NDR_SCALARS) {
7873                 NDR_CHECK(ndr_push_align(ndr, 4));
7874                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessvcs));
7875         }
7876         if (ndr_flags & NDR_BUFFERS) {
7877         }
7878         return NDR_ERR_SUCCESS;
7879 }
7880
7881 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1502(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1502 *r)
7882 {
7883         if (ndr_flags & NDR_SCALARS) {
7884                 NDR_CHECK(ndr_pull_align(ndr, 4));
7885                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessvcs));
7886         }
7887         if (ndr_flags & NDR_BUFFERS) {
7888         }
7889         return NDR_ERR_SUCCESS;
7890 }
7891
7892 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1502(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1502 *r)
7893 {
7894         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1502");
7895         ndr->depth++;
7896         ndr_print_uint32(ndr, "sessvcs", r->sessvcs);
7897         ndr->depth--;
7898 }
7899
7900 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1503(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1503 *r)
7901 {
7902         if (ndr_flags & NDR_SCALARS) {
7903                 NDR_CHECK(ndr_push_align(ndr, 4));
7904                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->opensearch));
7905         }
7906         if (ndr_flags & NDR_BUFFERS) {
7907         }
7908         return NDR_ERR_SUCCESS;
7909 }
7910
7911 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1503(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1503 *r)
7912 {
7913         if (ndr_flags & NDR_SCALARS) {
7914                 NDR_CHECK(ndr_pull_align(ndr, 4));
7915                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->opensearch));
7916         }
7917         if (ndr_flags & NDR_BUFFERS) {
7918         }
7919         return NDR_ERR_SUCCESS;
7920 }
7921
7922 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1503(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1503 *r)
7923 {
7924         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1503");
7925         ndr->depth++;
7926         ndr_print_uint32(ndr, "opensearch", r->opensearch);
7927         ndr->depth--;
7928 }
7929
7930 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1506(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1506 *r)
7931 {
7932         if (ndr_flags & NDR_SCALARS) {
7933                 NDR_CHECK(ndr_push_align(ndr, 4));
7934                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxworkitems));
7935         }
7936         if (ndr_flags & NDR_BUFFERS) {
7937         }
7938         return NDR_ERR_SUCCESS;
7939 }
7940
7941 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1506(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1506 *r)
7942 {
7943         if (ndr_flags & NDR_SCALARS) {
7944                 NDR_CHECK(ndr_pull_align(ndr, 4));
7945                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxworkitems));
7946         }
7947         if (ndr_flags & NDR_BUFFERS) {
7948         }
7949         return NDR_ERR_SUCCESS;
7950 }
7951
7952 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1506(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1506 *r)
7953 {
7954         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1506");
7955         ndr->depth++;
7956         ndr_print_uint32(ndr, "maxworkitems", r->maxworkitems);
7957         ndr->depth--;
7958 }
7959
7960 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1509(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1509 *r)
7961 {
7962         if (ndr_flags & NDR_SCALARS) {
7963                 NDR_CHECK(ndr_push_align(ndr, 4));
7964                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxrawbuflen));
7965         }
7966         if (ndr_flags & NDR_BUFFERS) {
7967         }
7968         return NDR_ERR_SUCCESS;
7969 }
7970
7971 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1509(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1509 *r)
7972 {
7973         if (ndr_flags & NDR_SCALARS) {
7974                 NDR_CHECK(ndr_pull_align(ndr, 4));
7975                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxrawbuflen));
7976         }
7977         if (ndr_flags & NDR_BUFFERS) {
7978         }
7979         return NDR_ERR_SUCCESS;
7980 }
7981
7982 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1509(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1509 *r)
7983 {
7984         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1509");
7985         ndr->depth++;
7986         ndr_print_uint32(ndr, "maxrawbuflen", r->maxrawbuflen);
7987         ndr->depth--;
7988 }
7989
7990 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1510(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1510 *r)
7991 {
7992         if (ndr_flags & NDR_SCALARS) {
7993                 NDR_CHECK(ndr_push_align(ndr, 4));
7994                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessusers));
7995         }
7996         if (ndr_flags & NDR_BUFFERS) {
7997         }
7998         return NDR_ERR_SUCCESS;
7999 }
8000
8001 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1510(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1510 *r)
8002 {
8003         if (ndr_flags & NDR_SCALARS) {
8004                 NDR_CHECK(ndr_pull_align(ndr, 4));
8005                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessusers));
8006         }
8007         if (ndr_flags & NDR_BUFFERS) {
8008         }
8009         return NDR_ERR_SUCCESS;
8010 }
8011
8012 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1510(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1510 *r)
8013 {
8014         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1510");
8015         ndr->depth++;
8016         ndr_print_uint32(ndr, "sessusers", r->sessusers);
8017         ndr->depth--;
8018 }
8019
8020 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1511(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1511 *r)
8021 {
8022         if (ndr_flags & NDR_SCALARS) {
8023                 NDR_CHECK(ndr_push_align(ndr, 4));
8024                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sesscons));
8025         }
8026         if (ndr_flags & NDR_BUFFERS) {
8027         }
8028         return NDR_ERR_SUCCESS;
8029 }
8030
8031 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1511(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1511 *r)
8032 {
8033         if (ndr_flags & NDR_SCALARS) {
8034                 NDR_CHECK(ndr_pull_align(ndr, 4));
8035                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sesscons));
8036         }
8037         if (ndr_flags & NDR_BUFFERS) {
8038         }
8039         return NDR_ERR_SUCCESS;
8040 }
8041
8042 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1511(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1511 *r)
8043 {
8044         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1511");
8045         ndr->depth++;
8046         ndr_print_uint32(ndr, "sesscons", r->sesscons);
8047         ndr->depth--;
8048 }
8049
8050 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1512(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1512 *r)
8051 {
8052         if (ndr_flags & NDR_SCALARS) {
8053                 NDR_CHECK(ndr_push_align(ndr, 4));
8054                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxnonpagedmemoryusage));
8055         }
8056         if (ndr_flags & NDR_BUFFERS) {
8057         }
8058         return NDR_ERR_SUCCESS;
8059 }
8060
8061 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1512(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1512 *r)
8062 {
8063         if (ndr_flags & NDR_SCALARS) {
8064                 NDR_CHECK(ndr_pull_align(ndr, 4));
8065                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxnonpagedmemoryusage));
8066         }
8067         if (ndr_flags & NDR_BUFFERS) {
8068         }
8069         return NDR_ERR_SUCCESS;
8070 }
8071
8072 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1512(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1512 *r)
8073 {
8074         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1512");
8075         ndr->depth++;
8076         ndr_print_uint32(ndr, "maxnonpagedmemoryusage", r->maxnonpagedmemoryusage);
8077         ndr->depth--;
8078 }
8079
8080 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1513(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1513 *r)
8081 {
8082         if (ndr_flags & NDR_SCALARS) {
8083                 NDR_CHECK(ndr_push_align(ndr, 4));
8084                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxpagedmemoryusage));
8085         }
8086         if (ndr_flags & NDR_BUFFERS) {
8087         }
8088         return NDR_ERR_SUCCESS;
8089 }
8090
8091 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1513(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1513 *r)
8092 {
8093         if (ndr_flags & NDR_SCALARS) {
8094                 NDR_CHECK(ndr_pull_align(ndr, 4));
8095                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxpagedmemoryusage));
8096         }
8097         if (ndr_flags & NDR_BUFFERS) {
8098         }
8099         return NDR_ERR_SUCCESS;
8100 }
8101
8102 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1513(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1513 *r)
8103 {
8104         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1513");
8105         ndr->depth++;
8106         ndr_print_uint32(ndr, "maxpagedmemoryusage", r->maxpagedmemoryusage);
8107         ndr->depth--;
8108 }
8109
8110 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1514(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1514 *r)
8111 {
8112         if (ndr_flags & NDR_SCALARS) {
8113                 NDR_CHECK(ndr_push_align(ndr, 4));
8114                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablesoftcompat));
8115         }
8116         if (ndr_flags & NDR_BUFFERS) {
8117         }
8118         return NDR_ERR_SUCCESS;
8119 }
8120
8121 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1514(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1514 *r)
8122 {
8123         if (ndr_flags & NDR_SCALARS) {
8124                 NDR_CHECK(ndr_pull_align(ndr, 4));
8125                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablesoftcompat));
8126         }
8127         if (ndr_flags & NDR_BUFFERS) {
8128         }
8129         return NDR_ERR_SUCCESS;
8130 }
8131
8132 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1514(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1514 *r)
8133 {
8134         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1514");
8135         ndr->depth++;
8136         ndr_print_uint32(ndr, "enablesoftcompat", r->enablesoftcompat);
8137         ndr->depth--;
8138 }
8139
8140 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1515(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1515 *r)
8141 {
8142         if (ndr_flags & NDR_SCALARS) {
8143                 NDR_CHECK(ndr_push_align(ndr, 4));
8144                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableforcedlogoff));
8145         }
8146         if (ndr_flags & NDR_BUFFERS) {
8147         }
8148         return NDR_ERR_SUCCESS;
8149 }
8150
8151 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1515(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1515 *r)
8152 {
8153         if (ndr_flags & NDR_SCALARS) {
8154                 NDR_CHECK(ndr_pull_align(ndr, 4));
8155                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableforcedlogoff));
8156         }
8157         if (ndr_flags & NDR_BUFFERS) {
8158         }
8159         return NDR_ERR_SUCCESS;
8160 }
8161
8162 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1515(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1515 *r)
8163 {
8164         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1515");
8165         ndr->depth++;
8166         ndr_print_uint32(ndr, "enableforcedlogoff", r->enableforcedlogoff);
8167         ndr->depth--;
8168 }
8169
8170 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1516(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1516 *r)
8171 {
8172         if (ndr_flags & NDR_SCALARS) {
8173                 NDR_CHECK(ndr_push_align(ndr, 4));
8174                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->timesource));
8175         }
8176         if (ndr_flags & NDR_BUFFERS) {
8177         }
8178         return NDR_ERR_SUCCESS;
8179 }
8180
8181 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1516(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1516 *r)
8182 {
8183         if (ndr_flags & NDR_SCALARS) {
8184                 NDR_CHECK(ndr_pull_align(ndr, 4));
8185                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->timesource));
8186         }
8187         if (ndr_flags & NDR_BUFFERS) {
8188         }
8189         return NDR_ERR_SUCCESS;
8190 }
8191
8192 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1516(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1516 *r)
8193 {
8194         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1516");
8195         ndr->depth++;
8196         ndr_print_uint32(ndr, "timesource", r->timesource);
8197         ndr->depth--;
8198 }
8199
8200 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1518(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1518 *r)
8201 {
8202         if (ndr_flags & NDR_SCALARS) {
8203                 NDR_CHECK(ndr_push_align(ndr, 4));
8204                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lmannounce));
8205         }
8206         if (ndr_flags & NDR_BUFFERS) {
8207         }
8208         return NDR_ERR_SUCCESS;
8209 }
8210
8211 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1518(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1518 *r)
8212 {
8213         if (ndr_flags & NDR_SCALARS) {
8214                 NDR_CHECK(ndr_pull_align(ndr, 4));
8215                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lmannounce));
8216         }
8217         if (ndr_flags & NDR_BUFFERS) {
8218         }
8219         return NDR_ERR_SUCCESS;
8220 }
8221
8222 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1518(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1518 *r)
8223 {
8224         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1518");
8225         ndr->depth++;
8226         ndr_print_uint32(ndr, "lmannounce", r->lmannounce);
8227         ndr->depth--;
8228 }
8229
8230 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1520(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1520 *r)
8231 {
8232         if (ndr_flags & NDR_SCALARS) {
8233                 NDR_CHECK(ndr_push_align(ndr, 4));
8234                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxcopyreadlen));
8235         }
8236         if (ndr_flags & NDR_BUFFERS) {
8237         }
8238         return NDR_ERR_SUCCESS;
8239 }
8240
8241 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1520(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1520 *r)
8242 {
8243         if (ndr_flags & NDR_SCALARS) {
8244                 NDR_CHECK(ndr_pull_align(ndr, 4));
8245                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxcopyreadlen));
8246         }
8247         if (ndr_flags & NDR_BUFFERS) {
8248         }
8249         return NDR_ERR_SUCCESS;
8250 }
8251
8252 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1520(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1520 *r)
8253 {
8254         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1520");
8255         ndr->depth++;
8256         ndr_print_uint32(ndr, "maxcopyreadlen", r->maxcopyreadlen);
8257         ndr->depth--;
8258 }
8259
8260 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1521(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1521 *r)
8261 {
8262         if (ndr_flags & NDR_SCALARS) {
8263                 NDR_CHECK(ndr_push_align(ndr, 4));
8264                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxcopywritelen));
8265         }
8266         if (ndr_flags & NDR_BUFFERS) {
8267         }
8268         return NDR_ERR_SUCCESS;
8269 }
8270
8271 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1521(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1521 *r)
8272 {
8273         if (ndr_flags & NDR_SCALARS) {
8274                 NDR_CHECK(ndr_pull_align(ndr, 4));
8275                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxcopywritelen));
8276         }
8277         if (ndr_flags & NDR_BUFFERS) {
8278         }
8279         return NDR_ERR_SUCCESS;
8280 }
8281
8282 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1521(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1521 *r)
8283 {
8284         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1521");
8285         ndr->depth++;
8286         ndr_print_uint32(ndr, "maxcopywritelen", r->maxcopywritelen);
8287         ndr->depth--;
8288 }
8289
8290 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1522(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1522 *r)
8291 {
8292         if (ndr_flags & NDR_SCALARS) {
8293                 NDR_CHECK(ndr_push_align(ndr, 4));
8294                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minkeepsearch));
8295         }
8296         if (ndr_flags & NDR_BUFFERS) {
8297         }
8298         return NDR_ERR_SUCCESS;
8299 }
8300
8301 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1522(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1522 *r)
8302 {
8303         if (ndr_flags & NDR_SCALARS) {
8304                 NDR_CHECK(ndr_pull_align(ndr, 4));
8305                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minkeepsearch));
8306         }
8307         if (ndr_flags & NDR_BUFFERS) {
8308         }
8309         return NDR_ERR_SUCCESS;
8310 }
8311
8312 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1522(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1522 *r)
8313 {
8314         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1522");
8315         ndr->depth++;
8316         ndr_print_uint32(ndr, "minkeepsearch", r->minkeepsearch);
8317         ndr->depth--;
8318 }
8319
8320 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1523(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1523 *r)
8321 {
8322         if (ndr_flags & NDR_SCALARS) {
8323                 NDR_CHECK(ndr_push_align(ndr, 4));
8324                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxkeepsearch));
8325         }
8326         if (ndr_flags & NDR_BUFFERS) {
8327         }
8328         return NDR_ERR_SUCCESS;
8329 }
8330
8331 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1523(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1523 *r)
8332 {
8333         if (ndr_flags & NDR_SCALARS) {
8334                 NDR_CHECK(ndr_pull_align(ndr, 4));
8335                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxkeepsearch));
8336         }
8337         if (ndr_flags & NDR_BUFFERS) {
8338         }
8339         return NDR_ERR_SUCCESS;
8340 }
8341
8342 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1523(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1523 *r)
8343 {
8344         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1523");
8345         ndr->depth++;
8346         ndr_print_uint32(ndr, "maxkeepsearch", r->maxkeepsearch);
8347         ndr->depth--;
8348 }
8349
8350 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1524(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1524 *r)
8351 {
8352         if (ndr_flags & NDR_SCALARS) {
8353                 NDR_CHECK(ndr_push_align(ndr, 4));
8354                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minkeepcomplsearch));
8355         }
8356         if (ndr_flags & NDR_BUFFERS) {
8357         }
8358         return NDR_ERR_SUCCESS;
8359 }
8360
8361 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1524(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1524 *r)
8362 {
8363         if (ndr_flags & NDR_SCALARS) {
8364                 NDR_CHECK(ndr_pull_align(ndr, 4));
8365                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minkeepcomplsearch));
8366         }
8367         if (ndr_flags & NDR_BUFFERS) {
8368         }
8369         return NDR_ERR_SUCCESS;
8370 }
8371
8372 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1524(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1524 *r)
8373 {
8374         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1524");
8375         ndr->depth++;
8376         ndr_print_uint32(ndr, "minkeepcomplsearch", r->minkeepcomplsearch);
8377         ndr->depth--;
8378 }
8379
8380 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1525(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1525 *r)
8381 {
8382         if (ndr_flags & NDR_SCALARS) {
8383                 NDR_CHECK(ndr_push_align(ndr, 4));
8384                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxkeepcomplsearch));
8385         }
8386         if (ndr_flags & NDR_BUFFERS) {
8387         }
8388         return NDR_ERR_SUCCESS;
8389 }
8390
8391 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1525(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1525 *r)
8392 {
8393         if (ndr_flags & NDR_SCALARS) {
8394                 NDR_CHECK(ndr_pull_align(ndr, 4));
8395                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxkeepcomplsearch));
8396         }
8397         if (ndr_flags & NDR_BUFFERS) {
8398         }
8399         return NDR_ERR_SUCCESS;
8400 }
8401
8402 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1525(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1525 *r)
8403 {
8404         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1525");
8405         ndr->depth++;
8406         ndr_print_uint32(ndr, "maxkeepcomplsearch", r->maxkeepcomplsearch);
8407         ndr->depth--;
8408 }
8409
8410 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1528(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1528 *r)
8411 {
8412         if (ndr_flags & NDR_SCALARS) {
8413                 NDR_CHECK(ndr_push_align(ndr, 4));
8414                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->scavtimeout));
8415         }
8416         if (ndr_flags & NDR_BUFFERS) {
8417         }
8418         return NDR_ERR_SUCCESS;
8419 }
8420
8421 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1528(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1528 *r)
8422 {
8423         if (ndr_flags & NDR_SCALARS) {
8424                 NDR_CHECK(ndr_pull_align(ndr, 4));
8425                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->scavtimeout));
8426         }
8427         if (ndr_flags & NDR_BUFFERS) {
8428         }
8429         return NDR_ERR_SUCCESS;
8430 }
8431
8432 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1528(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1528 *r)
8433 {
8434         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1528");
8435         ndr->depth++;
8436         ndr_print_uint32(ndr, "scavtimeout", r->scavtimeout);
8437         ndr->depth--;
8438 }
8439
8440 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1529(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1529 *r)
8441 {
8442         if (ndr_flags & NDR_SCALARS) {
8443                 NDR_CHECK(ndr_push_align(ndr, 4));
8444                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minrcvqueue));
8445         }
8446         if (ndr_flags & NDR_BUFFERS) {
8447         }
8448         return NDR_ERR_SUCCESS;
8449 }
8450
8451 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1529(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1529 *r)
8452 {
8453         if (ndr_flags & NDR_SCALARS) {
8454                 NDR_CHECK(ndr_pull_align(ndr, 4));
8455                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minrcvqueue));
8456         }
8457         if (ndr_flags & NDR_BUFFERS) {
8458         }
8459         return NDR_ERR_SUCCESS;
8460 }
8461
8462 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1529(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1529 *r)
8463 {
8464         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1529");
8465         ndr->depth++;
8466         ndr_print_uint32(ndr, "minrcvqueue", r->minrcvqueue);
8467         ndr->depth--;
8468 }
8469
8470 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1530(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1530 *r)
8471 {
8472         if (ndr_flags & NDR_SCALARS) {
8473                 NDR_CHECK(ndr_push_align(ndr, 4));
8474                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minfreeworkitems));
8475         }
8476         if (ndr_flags & NDR_BUFFERS) {
8477         }
8478         return NDR_ERR_SUCCESS;
8479 }
8480
8481 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1530(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1530 *r)
8482 {
8483         if (ndr_flags & NDR_SCALARS) {
8484                 NDR_CHECK(ndr_pull_align(ndr, 4));
8485                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minfreeworkitems));
8486         }
8487         if (ndr_flags & NDR_BUFFERS) {
8488         }
8489         return NDR_ERR_SUCCESS;
8490 }
8491
8492 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1530(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1530 *r)
8493 {
8494         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1530");
8495         ndr->depth++;
8496         ndr_print_uint32(ndr, "minfreeworkitems", r->minfreeworkitems);
8497         ndr->depth--;
8498 }
8499
8500 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1533(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1533 *r)
8501 {
8502         if (ndr_flags & NDR_SCALARS) {
8503                 NDR_CHECK(ndr_push_align(ndr, 4));
8504                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxmpxct));
8505         }
8506         if (ndr_flags & NDR_BUFFERS) {
8507         }
8508         return NDR_ERR_SUCCESS;
8509 }
8510
8511 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1533(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1533 *r)
8512 {
8513         if (ndr_flags & NDR_SCALARS) {
8514                 NDR_CHECK(ndr_pull_align(ndr, 4));
8515                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxmpxct));
8516         }
8517         if (ndr_flags & NDR_BUFFERS) {
8518         }
8519         return NDR_ERR_SUCCESS;
8520 }
8521
8522 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1533(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1533 *r)
8523 {
8524         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1533");
8525         ndr->depth++;
8526         ndr_print_uint32(ndr, "maxmpxct", r->maxmpxct);
8527         ndr->depth--;
8528 }
8529
8530 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1534(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1534 *r)
8531 {
8532         if (ndr_flags & NDR_SCALARS) {
8533                 NDR_CHECK(ndr_push_align(ndr, 4));
8534                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->oplockbreakwait));
8535         }
8536         if (ndr_flags & NDR_BUFFERS) {
8537         }
8538         return NDR_ERR_SUCCESS;
8539 }
8540
8541 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1534(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1534 *r)
8542 {
8543         if (ndr_flags & NDR_SCALARS) {
8544                 NDR_CHECK(ndr_pull_align(ndr, 4));
8545                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->oplockbreakwait));
8546         }
8547         if (ndr_flags & NDR_BUFFERS) {
8548         }
8549         return NDR_ERR_SUCCESS;
8550 }
8551
8552 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1534(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1534 *r)
8553 {
8554         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1534");
8555         ndr->depth++;
8556         ndr_print_uint32(ndr, "oplockbreakwait", r->oplockbreakwait);
8557         ndr->depth--;
8558 }
8559
8560 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1535(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1535 *r)
8561 {
8562         if (ndr_flags & NDR_SCALARS) {
8563                 NDR_CHECK(ndr_push_align(ndr, 4));
8564                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->oplockbreakresponsewait));
8565         }
8566         if (ndr_flags & NDR_BUFFERS) {
8567         }
8568         return NDR_ERR_SUCCESS;
8569 }
8570
8571 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1535(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1535 *r)
8572 {
8573         if (ndr_flags & NDR_SCALARS) {
8574                 NDR_CHECK(ndr_pull_align(ndr, 4));
8575                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->oplockbreakresponsewait));
8576         }
8577         if (ndr_flags & NDR_BUFFERS) {
8578         }
8579         return NDR_ERR_SUCCESS;
8580 }
8581
8582 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1535(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1535 *r)
8583 {
8584         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1535");
8585         ndr->depth++;
8586         ndr_print_uint32(ndr, "oplockbreakresponsewait", r->oplockbreakresponsewait);
8587         ndr->depth--;
8588 }
8589
8590 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1536(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1536 *r)
8591 {
8592         if (ndr_flags & NDR_SCALARS) {
8593                 NDR_CHECK(ndr_push_align(ndr, 4));
8594                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableoplocks));
8595         }
8596         if (ndr_flags & NDR_BUFFERS) {
8597         }
8598         return NDR_ERR_SUCCESS;
8599 }
8600
8601 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1536(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1536 *r)
8602 {
8603         if (ndr_flags & NDR_SCALARS) {
8604                 NDR_CHECK(ndr_pull_align(ndr, 4));
8605                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableoplocks));
8606         }
8607         if (ndr_flags & NDR_BUFFERS) {
8608         }
8609         return NDR_ERR_SUCCESS;
8610 }
8611
8612 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1536(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1536 *r)
8613 {
8614         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1536");
8615         ndr->depth++;
8616         ndr_print_uint32(ndr, "enableoplocks", r->enableoplocks);
8617         ndr->depth--;
8618 }
8619
8620 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1537(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1537 *r)
8621 {
8622         if (ndr_flags & NDR_SCALARS) {
8623                 NDR_CHECK(ndr_push_align(ndr, 4));
8624                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableoplockforceclose));
8625         }
8626         if (ndr_flags & NDR_BUFFERS) {
8627         }
8628         return NDR_ERR_SUCCESS;
8629 }
8630
8631 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1537(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1537 *r)
8632 {
8633         if (ndr_flags & NDR_SCALARS) {
8634                 NDR_CHECK(ndr_pull_align(ndr, 4));
8635                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableoplockforceclose));
8636         }
8637         if (ndr_flags & NDR_BUFFERS) {
8638         }
8639         return NDR_ERR_SUCCESS;
8640 }
8641
8642 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1537(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1537 *r)
8643 {
8644         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1537");
8645         ndr->depth++;
8646         ndr_print_uint32(ndr, "enableoplockforceclose", r->enableoplockforceclose);
8647         ndr->depth--;
8648 }
8649
8650 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1538(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1538 *r)
8651 {
8652         if (ndr_flags & NDR_SCALARS) {
8653                 NDR_CHECK(ndr_push_align(ndr, 4));
8654                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablefcbopens));
8655         }
8656         if (ndr_flags & NDR_BUFFERS) {
8657         }
8658         return NDR_ERR_SUCCESS;
8659 }
8660
8661 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1538(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1538 *r)
8662 {
8663         if (ndr_flags & NDR_SCALARS) {
8664                 NDR_CHECK(ndr_pull_align(ndr, 4));
8665                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablefcbopens));
8666         }
8667         if (ndr_flags & NDR_BUFFERS) {
8668         }
8669         return NDR_ERR_SUCCESS;
8670 }
8671
8672 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1538(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1538 *r)
8673 {
8674         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1538");
8675         ndr->depth++;
8676         ndr_print_uint32(ndr, "enablefcbopens", r->enablefcbopens);
8677         ndr->depth--;
8678 }
8679
8680 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1539(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1539 *r)
8681 {
8682         if (ndr_flags & NDR_SCALARS) {
8683                 NDR_CHECK(ndr_push_align(ndr, 4));
8684                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableraw));
8685         }
8686         if (ndr_flags & NDR_BUFFERS) {
8687         }
8688         return NDR_ERR_SUCCESS;
8689 }
8690
8691 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1539(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1539 *r)
8692 {
8693         if (ndr_flags & NDR_SCALARS) {
8694                 NDR_CHECK(ndr_pull_align(ndr, 4));
8695                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableraw));
8696         }
8697         if (ndr_flags & NDR_BUFFERS) {
8698         }
8699         return NDR_ERR_SUCCESS;
8700 }
8701
8702 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1539(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1539 *r)
8703 {
8704         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1539");
8705         ndr->depth++;
8706         ndr_print_uint32(ndr, "enableraw", r->enableraw);
8707         ndr->depth--;
8708 }
8709
8710 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1540(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1540 *r)
8711 {
8712         if (ndr_flags & NDR_SCALARS) {
8713                 NDR_CHECK(ndr_push_align(ndr, 4));
8714                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablesharednetdrives));
8715         }
8716         if (ndr_flags & NDR_BUFFERS) {
8717         }
8718         return NDR_ERR_SUCCESS;
8719 }
8720
8721 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1540(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1540 *r)
8722 {
8723         if (ndr_flags & NDR_SCALARS) {
8724                 NDR_CHECK(ndr_pull_align(ndr, 4));
8725                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablesharednetdrives));
8726         }
8727         if (ndr_flags & NDR_BUFFERS) {
8728         }
8729         return NDR_ERR_SUCCESS;
8730 }
8731
8732 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1540(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1540 *r)
8733 {
8734         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1540");
8735         ndr->depth++;
8736         ndr_print_uint32(ndr, "enablesharednetdrives", r->enablesharednetdrives);
8737         ndr->depth--;
8738 }
8739
8740 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1541(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1541 *r)
8741 {
8742         if (ndr_flags & NDR_SCALARS) {
8743                 NDR_CHECK(ndr_push_align(ndr, 4));
8744                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minfreeconnections));
8745         }
8746         if (ndr_flags & NDR_BUFFERS) {
8747         }
8748         return NDR_ERR_SUCCESS;
8749 }
8750
8751 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1541(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1541 *r)
8752 {
8753         if (ndr_flags & NDR_SCALARS) {
8754                 NDR_CHECK(ndr_pull_align(ndr, 4));
8755                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minfreeconnections));
8756         }
8757         if (ndr_flags & NDR_BUFFERS) {
8758         }
8759         return NDR_ERR_SUCCESS;
8760 }
8761
8762 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1541(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1541 *r)
8763 {
8764         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1541");
8765         ndr->depth++;
8766         ndr_print_uint32(ndr, "minfreeconnections", r->minfreeconnections);
8767         ndr->depth--;
8768 }
8769
8770 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1542(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1542 *r)
8771 {
8772         if (ndr_flags & NDR_SCALARS) {
8773                 NDR_CHECK(ndr_push_align(ndr, 4));
8774                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxfreeconnections));
8775         }
8776         if (ndr_flags & NDR_BUFFERS) {
8777         }
8778         return NDR_ERR_SUCCESS;
8779 }
8780
8781 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1542(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1542 *r)
8782 {
8783         if (ndr_flags & NDR_SCALARS) {
8784                 NDR_CHECK(ndr_pull_align(ndr, 4));
8785                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxfreeconnections));
8786         }
8787         if (ndr_flags & NDR_BUFFERS) {
8788         }
8789         return NDR_ERR_SUCCESS;
8790 }
8791
8792 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1542(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1542 *r)
8793 {
8794         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1542");
8795         ndr->depth++;
8796         ndr_print_uint32(ndr, "maxfreeconnections", r->maxfreeconnections);
8797         ndr->depth--;
8798 }
8799
8800 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1543(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1543 *r)
8801 {
8802         if (ndr_flags & NDR_SCALARS) {
8803                 NDR_CHECK(ndr_push_align(ndr, 4));
8804                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initsesstable));
8805         }
8806         if (ndr_flags & NDR_BUFFERS) {
8807         }
8808         return NDR_ERR_SUCCESS;
8809 }
8810
8811 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1543(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1543 *r)
8812 {
8813         if (ndr_flags & NDR_SCALARS) {
8814                 NDR_CHECK(ndr_pull_align(ndr, 4));
8815                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initsesstable));
8816         }
8817         if (ndr_flags & NDR_BUFFERS) {
8818         }
8819         return NDR_ERR_SUCCESS;
8820 }
8821
8822 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1543(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1543 *r)
8823 {
8824         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1543");
8825         ndr->depth++;
8826         ndr_print_uint32(ndr, "initsesstable", r->initsesstable);
8827         ndr->depth--;
8828 }
8829
8830 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1544(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1544 *r)
8831 {
8832         if (ndr_flags & NDR_SCALARS) {
8833                 NDR_CHECK(ndr_push_align(ndr, 4));
8834                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initconntable));
8835         }
8836         if (ndr_flags & NDR_BUFFERS) {
8837         }
8838         return NDR_ERR_SUCCESS;
8839 }
8840
8841 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1544(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1544 *r)
8842 {
8843         if (ndr_flags & NDR_SCALARS) {
8844                 NDR_CHECK(ndr_pull_align(ndr, 4));
8845                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initconntable));
8846         }
8847         if (ndr_flags & NDR_BUFFERS) {
8848         }
8849         return NDR_ERR_SUCCESS;
8850 }
8851
8852 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1544(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1544 *r)
8853 {
8854         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1544");
8855         ndr->depth++;
8856         ndr_print_uint32(ndr, "initconntable", r->initconntable);
8857         ndr->depth--;
8858 }
8859
8860 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1545(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1545 *r)
8861 {
8862         if (ndr_flags & NDR_SCALARS) {
8863                 NDR_CHECK(ndr_push_align(ndr, 4));
8864                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initfiletable));
8865         }
8866         if (ndr_flags & NDR_BUFFERS) {
8867         }
8868         return NDR_ERR_SUCCESS;
8869 }
8870
8871 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1545(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1545 *r)
8872 {
8873         if (ndr_flags & NDR_SCALARS) {
8874                 NDR_CHECK(ndr_pull_align(ndr, 4));
8875                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initfiletable));
8876         }
8877         if (ndr_flags & NDR_BUFFERS) {
8878         }
8879         return NDR_ERR_SUCCESS;
8880 }
8881
8882 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1545(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1545 *r)
8883 {
8884         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1545");
8885         ndr->depth++;
8886         ndr_print_uint32(ndr, "initfiletable", r->initfiletable);
8887         ndr->depth--;
8888 }
8889
8890 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1546(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1546 *r)
8891 {
8892         if (ndr_flags & NDR_SCALARS) {
8893                 NDR_CHECK(ndr_push_align(ndr, 4));
8894                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initsearchtable));
8895         }
8896         if (ndr_flags & NDR_BUFFERS) {
8897         }
8898         return NDR_ERR_SUCCESS;
8899 }
8900
8901 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1546(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1546 *r)
8902 {
8903         if (ndr_flags & NDR_SCALARS) {
8904                 NDR_CHECK(ndr_pull_align(ndr, 4));
8905                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initsearchtable));
8906         }
8907         if (ndr_flags & NDR_BUFFERS) {
8908         }
8909         return NDR_ERR_SUCCESS;
8910 }
8911
8912 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1546(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1546 *r)
8913 {
8914         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1546");
8915         ndr->depth++;
8916         ndr_print_uint32(ndr, "initsearchtable", r->initsearchtable);
8917         ndr->depth--;
8918 }
8919
8920 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1547(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1547 *r)
8921 {
8922         if (ndr_flags & NDR_SCALARS) {
8923                 NDR_CHECK(ndr_push_align(ndr, 4));
8924                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alertsched));
8925         }
8926         if (ndr_flags & NDR_BUFFERS) {
8927         }
8928         return NDR_ERR_SUCCESS;
8929 }
8930
8931 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1547(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1547 *r)
8932 {
8933         if (ndr_flags & NDR_SCALARS) {
8934                 NDR_CHECK(ndr_pull_align(ndr, 4));
8935                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alertsched));
8936         }
8937         if (ndr_flags & NDR_BUFFERS) {
8938         }
8939         return NDR_ERR_SUCCESS;
8940 }
8941
8942 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1547(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1547 *r)
8943 {
8944         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1547");
8945         ndr->depth++;
8946         ndr_print_uint32(ndr, "alertsched", r->alertsched);
8947         ndr->depth--;
8948 }
8949
8950 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1548(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1548 *r)
8951 {
8952         if (ndr_flags & NDR_SCALARS) {
8953                 NDR_CHECK(ndr_push_align(ndr, 4));
8954                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->errortreshold));
8955         }
8956         if (ndr_flags & NDR_BUFFERS) {
8957         }
8958         return NDR_ERR_SUCCESS;
8959 }
8960
8961 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1548(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1548 *r)
8962 {
8963         if (ndr_flags & NDR_SCALARS) {
8964                 NDR_CHECK(ndr_pull_align(ndr, 4));
8965                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->errortreshold));
8966         }
8967         if (ndr_flags & NDR_BUFFERS) {
8968         }
8969         return NDR_ERR_SUCCESS;
8970 }
8971
8972 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1548(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1548 *r)
8973 {
8974         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1548");
8975         ndr->depth++;
8976         ndr_print_uint32(ndr, "errortreshold", r->errortreshold);
8977         ndr->depth--;
8978 }
8979
8980 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1549(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1549 *r)
8981 {
8982         if (ndr_flags & NDR_SCALARS) {
8983                 NDR_CHECK(ndr_push_align(ndr, 4));
8984                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->networkerrortreshold));
8985         }
8986         if (ndr_flags & NDR_BUFFERS) {
8987         }
8988         return NDR_ERR_SUCCESS;
8989 }
8990
8991 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1549(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1549 *r)
8992 {
8993         if (ndr_flags & NDR_SCALARS) {
8994                 NDR_CHECK(ndr_pull_align(ndr, 4));
8995                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->networkerrortreshold));
8996         }
8997         if (ndr_flags & NDR_BUFFERS) {
8998         }
8999         return NDR_ERR_SUCCESS;
9000 }
9001
9002 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1549(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1549 *r)
9003 {
9004         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1549");
9005         ndr->depth++;
9006         ndr_print_uint32(ndr, "networkerrortreshold", r->networkerrortreshold);
9007         ndr->depth--;
9008 }
9009
9010 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1550(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1550 *r)
9011 {
9012         if (ndr_flags & NDR_SCALARS) {
9013                 NDR_CHECK(ndr_push_align(ndr, 4));
9014                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->diskspacetreshold));
9015         }
9016         if (ndr_flags & NDR_BUFFERS) {
9017         }
9018         return NDR_ERR_SUCCESS;
9019 }
9020
9021 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1550(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1550 *r)
9022 {
9023         if (ndr_flags & NDR_SCALARS) {
9024                 NDR_CHECK(ndr_pull_align(ndr, 4));
9025                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->diskspacetreshold));
9026         }
9027         if (ndr_flags & NDR_BUFFERS) {
9028         }
9029         return NDR_ERR_SUCCESS;
9030 }
9031
9032 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1550(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1550 *r)
9033 {
9034         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1550");
9035         ndr->depth++;
9036         ndr_print_uint32(ndr, "diskspacetreshold", r->diskspacetreshold);
9037         ndr->depth--;
9038 }
9039
9040 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1552(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1552 *r)
9041 {
9042         if (ndr_flags & NDR_SCALARS) {
9043                 NDR_CHECK(ndr_push_align(ndr, 4));
9044                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxlinkdelay));
9045         }
9046         if (ndr_flags & NDR_BUFFERS) {
9047         }
9048         return NDR_ERR_SUCCESS;
9049 }
9050
9051 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1552(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1552 *r)
9052 {
9053         if (ndr_flags & NDR_SCALARS) {
9054                 NDR_CHECK(ndr_pull_align(ndr, 4));
9055                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxlinkdelay));
9056         }
9057         if (ndr_flags & NDR_BUFFERS) {
9058         }
9059         return NDR_ERR_SUCCESS;
9060 }
9061
9062 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1552(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1552 *r)
9063 {
9064         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1552");
9065         ndr->depth++;
9066         ndr_print_uint32(ndr, "maxlinkdelay", r->maxlinkdelay);
9067         ndr->depth--;
9068 }
9069
9070 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1553(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1553 *r)
9071 {
9072         if (ndr_flags & NDR_SCALARS) {
9073                 NDR_CHECK(ndr_push_align(ndr, 4));
9074                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minlinkthroughput));
9075         }
9076         if (ndr_flags & NDR_BUFFERS) {
9077         }
9078         return NDR_ERR_SUCCESS;
9079 }
9080
9081 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1553(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1553 *r)
9082 {
9083         if (ndr_flags & NDR_SCALARS) {
9084                 NDR_CHECK(ndr_pull_align(ndr, 4));
9085                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minlinkthroughput));
9086         }
9087         if (ndr_flags & NDR_BUFFERS) {
9088         }
9089         return NDR_ERR_SUCCESS;
9090 }
9091
9092 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1553(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1553 *r)
9093 {
9094         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1553");
9095         ndr->depth++;
9096         ndr_print_uint32(ndr, "minlinkthroughput", r->minlinkthroughput);
9097         ndr->depth--;
9098 }
9099
9100 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1554(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1554 *r)
9101 {
9102         if (ndr_flags & NDR_SCALARS) {
9103                 NDR_CHECK(ndr_push_align(ndr, 4));
9104                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->linkinfovalidtime));
9105         }
9106         if (ndr_flags & NDR_BUFFERS) {
9107         }
9108         return NDR_ERR_SUCCESS;
9109 }
9110
9111 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1554(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1554 *r)
9112 {
9113         if (ndr_flags & NDR_SCALARS) {
9114                 NDR_CHECK(ndr_pull_align(ndr, 4));
9115                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->linkinfovalidtime));
9116         }
9117         if (ndr_flags & NDR_BUFFERS) {
9118         }
9119         return NDR_ERR_SUCCESS;
9120 }
9121
9122 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1554(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1554 *r)
9123 {
9124         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1554");
9125         ndr->depth++;
9126         ndr_print_uint32(ndr, "linkinfovalidtime", r->linkinfovalidtime);
9127         ndr->depth--;
9128 }
9129
9130 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1555(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1555 *r)
9131 {
9132         if (ndr_flags & NDR_SCALARS) {
9133                 NDR_CHECK(ndr_push_align(ndr, 4));
9134                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->scavqosinfoupdatetime));
9135         }
9136         if (ndr_flags & NDR_BUFFERS) {
9137         }
9138         return NDR_ERR_SUCCESS;
9139 }
9140
9141 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1555(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1555 *r)
9142 {
9143         if (ndr_flags & NDR_SCALARS) {
9144                 NDR_CHECK(ndr_pull_align(ndr, 4));
9145                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->scavqosinfoupdatetime));
9146         }
9147         if (ndr_flags & NDR_BUFFERS) {
9148         }
9149         return NDR_ERR_SUCCESS;
9150 }
9151
9152 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1555(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1555 *r)
9153 {
9154         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1555");
9155         ndr->depth++;
9156         ndr_print_uint32(ndr, "scavqosinfoupdatetime", r->scavqosinfoupdatetime);
9157         ndr->depth--;
9158 }
9159
9160 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1556(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1556 *r)
9161 {
9162         if (ndr_flags & NDR_SCALARS) {
9163                 NDR_CHECK(ndr_push_align(ndr, 4));
9164                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxworkitemidletime));
9165         }
9166         if (ndr_flags & NDR_BUFFERS) {
9167         }
9168         return NDR_ERR_SUCCESS;
9169 }
9170
9171 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1556(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1556 *r)
9172 {
9173         if (ndr_flags & NDR_SCALARS) {
9174                 NDR_CHECK(ndr_pull_align(ndr, 4));
9175                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxworkitemidletime));
9176         }
9177         if (ndr_flags & NDR_BUFFERS) {
9178         }
9179         return NDR_ERR_SUCCESS;
9180 }
9181
9182 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1556(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1556 *r)
9183 {
9184         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1556");
9185         ndr->depth++;
9186         ndr_print_uint32(ndr, "maxworkitemidletime", r->maxworkitemidletime);
9187         ndr->depth--;
9188 }
9189
9190 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetSrvInfo *r)
9191 {
9192         if (ndr_flags & NDR_SCALARS) {
9193                 int level = ndr_push_get_switch_value(ndr, r);
9194                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
9195                 switch (level) {
9196                         case 100: {
9197                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info100));
9198                         break; }
9199
9200                         case 101: {
9201                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info101));
9202                         break; }
9203
9204                         case 102: {
9205                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info102));
9206                         break; }
9207
9208                         case 402: {
9209                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info402));
9210                         break; }
9211
9212                         case 403: {
9213                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info403));
9214                         break; }
9215
9216                         case 502: {
9217                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info502));
9218                         break; }
9219
9220                         case 503: {
9221                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info503));
9222                         break; }
9223
9224                         case 599: {
9225                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info599));
9226                         break; }
9227
9228                         case 1005: {
9229                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1005));
9230                         break; }
9231
9232                         case 1010: {
9233                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1010));
9234                         break; }
9235
9236                         case 1016: {
9237                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1016));
9238                         break; }
9239
9240                         case 1017: {
9241                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1017));
9242                         break; }
9243
9244                         case 1018: {
9245                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1018));
9246                         break; }
9247
9248                         case 1107: {
9249                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1107));
9250                         break; }
9251
9252                         case 1501: {
9253                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1501));
9254                         break; }
9255
9256                         case 1502: {
9257                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1502));
9258                         break; }
9259
9260                         case 1503: {
9261                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1503));
9262                         break; }
9263
9264                         case 1506: {
9265                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1506));
9266                         break; }
9267
9268                         case 1509: {
9269                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1509));
9270                         break; }
9271
9272                         case 1510: {
9273                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1510));
9274                         break; }
9275
9276                         case 1511: {
9277                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1511));
9278                         break; }
9279
9280                         case 1512: {
9281                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1512));
9282                         break; }
9283
9284                         case 1513: {
9285                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1513));
9286                         break; }
9287
9288                         case 1514: {
9289                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1514));
9290                         break; }
9291
9292                         case 1515: {
9293                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1515));
9294                         break; }
9295
9296                         case 1516: {
9297                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1516));
9298                         break; }
9299
9300                         case 1518: {
9301                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1518));
9302                         break; }
9303
9304                         case 1520: {
9305                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1520));
9306                         break; }
9307
9308                         case 1521: {
9309                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1521));
9310                         break; }
9311
9312                         case 1522: {
9313                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1522));
9314                         break; }
9315
9316                         case 1523: {
9317                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1523));
9318                         break; }
9319
9320                         case 1524: {
9321                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1524));
9322                         break; }
9323
9324                         case 1525: {
9325                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1525));
9326                         break; }
9327
9328                         case 1528: {
9329                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1528));
9330                         break; }
9331
9332                         case 1529: {
9333                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1529));
9334                         break; }
9335
9336                         case 1530: {
9337                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1530));
9338                         break; }
9339
9340                         case 1533: {
9341                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1533));
9342                         break; }
9343
9344                         case 1534: {
9345                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1534));
9346                         break; }
9347
9348                         case 1535: {
9349                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1535));
9350                         break; }
9351
9352                         case 1536: {
9353                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1536));
9354                         break; }
9355
9356                         case 1537: {
9357                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1537));
9358                         break; }
9359
9360                         case 1538: {
9361                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1538));
9362                         break; }
9363
9364                         case 1539: {
9365                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1539));
9366                         break; }
9367
9368                         case 1540: {
9369                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1540));
9370                         break; }
9371
9372                         case 1541: {
9373                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1541));
9374                         break; }
9375
9376                         case 1542: {
9377                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1542));
9378                         break; }
9379
9380                         case 1543: {
9381                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1543));
9382                         break; }
9383
9384                         case 1544: {
9385                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1544));
9386                         break; }
9387
9388                         case 1545: {
9389                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1545));
9390                         break; }
9391
9392                         case 1546: {
9393                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1546));
9394                         break; }
9395
9396                         case 1547: {
9397                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1547));
9398                         break; }
9399
9400                         case 1548: {
9401                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1548));
9402                         break; }
9403
9404                         case 1549: {
9405                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1549));
9406                         break; }
9407
9408                         case 1550: {
9409                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1550));
9410                         break; }
9411
9412                         case 1552: {
9413                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1552));
9414                         break; }
9415
9416                         case 1553: {
9417                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1553));
9418                         break; }
9419
9420                         case 1554: {
9421                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1554));
9422                         break; }
9423
9424                         case 1555: {
9425                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1555));
9426                         break; }
9427
9428                         case 1556: {
9429                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1556));
9430                         break; }
9431
9432                         default: {
9433                         break; }
9434
9435                 }
9436         }
9437         if (ndr_flags & NDR_BUFFERS) {
9438                 int level = ndr_push_get_switch_value(ndr, r);
9439                 switch (level) {
9440                         case 100:
9441                                 if (r->info100) {
9442                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo100(ndr, NDR_SCALARS|NDR_BUFFERS, r->info100));
9443                                 }
9444                         break;
9445
9446                         case 101:
9447                                 if (r->info101) {
9448                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info101));
9449                                 }
9450                         break;
9451
9452                         case 102:
9453                                 if (r->info102) {
9454                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo102(ndr, NDR_SCALARS|NDR_BUFFERS, r->info102));
9455                                 }
9456                         break;
9457
9458                         case 402:
9459                                 if (r->info402) {
9460                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo402(ndr, NDR_SCALARS|NDR_BUFFERS, r->info402));
9461                                 }
9462                         break;
9463
9464                         case 403:
9465                                 if (r->info403) {
9466                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo403(ndr, NDR_SCALARS|NDR_BUFFERS, r->info403));
9467                                 }
9468                         break;
9469
9470                         case 502:
9471                                 if (r->info502) {
9472                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo502(ndr, NDR_SCALARS, r->info502));
9473                                 }
9474                         break;
9475
9476                         case 503:
9477                                 if (r->info503) {
9478                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo503(ndr, NDR_SCALARS|NDR_BUFFERS, r->info503));
9479                                 }
9480                         break;
9481
9482                         case 599:
9483                                 if (r->info599) {
9484                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo599(ndr, NDR_SCALARS|NDR_BUFFERS, r->info599));
9485                                 }
9486                         break;
9487
9488                         case 1005:
9489                                 if (r->info1005) {
9490                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1005(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1005));
9491                                 }
9492                         break;
9493
9494                         case 1010:
9495                                 if (r->info1010) {
9496                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1010(ndr, NDR_SCALARS, r->info1010));
9497                                 }
9498                         break;
9499
9500                         case 1016:
9501                                 if (r->info1016) {
9502                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1016(ndr, NDR_SCALARS, r->info1016));
9503                                 }
9504                         break;
9505
9506                         case 1017:
9507                                 if (r->info1017) {
9508                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1017(ndr, NDR_SCALARS, r->info1017));
9509                                 }
9510                         break;
9511
9512                         case 1018:
9513                                 if (r->info1018) {
9514                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1018(ndr, NDR_SCALARS, r->info1018));
9515                                 }
9516                         break;
9517
9518                         case 1107:
9519                                 if (r->info1107) {
9520                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1107(ndr, NDR_SCALARS, r->info1107));
9521                                 }
9522                         break;
9523
9524                         case 1501:
9525                                 if (r->info1501) {
9526                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1501(ndr, NDR_SCALARS, r->info1501));
9527                                 }
9528                         break;
9529
9530                         case 1502:
9531                                 if (r->info1502) {
9532                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1502(ndr, NDR_SCALARS, r->info1502));
9533                                 }
9534                         break;
9535
9536                         case 1503:
9537                                 if (r->info1503) {
9538                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1503(ndr, NDR_SCALARS, r->info1503));
9539                                 }
9540                         break;
9541
9542                         case 1506:
9543                                 if (r->info1506) {
9544                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1506(ndr, NDR_SCALARS, r->info1506));
9545                                 }
9546                         break;
9547
9548                         case 1509:
9549                                 if (r->info1509) {
9550                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1509(ndr, NDR_SCALARS, r->info1509));
9551                                 }
9552                         break;
9553
9554                         case 1510:
9555                                 if (r->info1510) {
9556                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1510(ndr, NDR_SCALARS, r->info1510));
9557                                 }
9558                         break;
9559
9560                         case 1511:
9561                                 if (r->info1511) {
9562                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1511(ndr, NDR_SCALARS, r->info1511));
9563                                 }
9564                         break;
9565
9566                         case 1512:
9567                                 if (r->info1512) {
9568                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1512(ndr, NDR_SCALARS, r->info1512));
9569                                 }
9570                         break;
9571
9572                         case 1513:
9573                                 if (r->info1513) {
9574                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1513(ndr, NDR_SCALARS, r->info1513));
9575                                 }
9576                         break;
9577
9578                         case 1514:
9579                                 if (r->info1514) {
9580                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1514(ndr, NDR_SCALARS, r->info1514));
9581                                 }
9582                         break;
9583
9584                         case 1515:
9585                                 if (r->info1515) {
9586                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1515(ndr, NDR_SCALARS, r->info1515));
9587                                 }
9588                         break;
9589
9590                         case 1516:
9591                                 if (r->info1516) {
9592                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1516(ndr, NDR_SCALARS, r->info1516));
9593                                 }
9594                         break;
9595
9596                         case 1518:
9597                                 if (r->info1518) {
9598                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1518(ndr, NDR_SCALARS, r->info1518));
9599                                 }
9600                         break;
9601
9602                         case 1520:
9603                                 if (r->info1520) {
9604                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1520(ndr, NDR_SCALARS, r->info1520));
9605                                 }
9606                         break;
9607
9608                         case 1521:
9609                                 if (r->info1521) {
9610                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1521(ndr, NDR_SCALARS, r->info1521));
9611                                 }
9612                         break;
9613
9614                         case 1522:
9615                                 if (r->info1522) {
9616                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1522(ndr, NDR_SCALARS, r->info1522));
9617                                 }
9618                         break;
9619
9620                         case 1523:
9621                                 if (r->info1523) {
9622                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1523(ndr, NDR_SCALARS, r->info1523));
9623                                 }
9624                         break;
9625
9626                         case 1524:
9627                                 if (r->info1524) {
9628                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1524(ndr, NDR_SCALARS, r->info1524));
9629                                 }
9630                         break;
9631
9632                         case 1525:
9633                                 if (r->info1525) {
9634                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1525(ndr, NDR_SCALARS, r->info1525));
9635                                 }
9636                         break;
9637
9638                         case 1528:
9639                                 if (r->info1528) {
9640                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1528(ndr, NDR_SCALARS, r->info1528));
9641                                 }
9642                         break;
9643
9644                         case 1529:
9645                                 if (r->info1529) {
9646                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1529(ndr, NDR_SCALARS, r->info1529));
9647                                 }
9648                         break;
9649
9650                         case 1530:
9651                                 if (r->info1530) {
9652                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1530(ndr, NDR_SCALARS, r->info1530));
9653                                 }
9654                         break;
9655
9656                         case 1533:
9657                                 if (r->info1533) {
9658                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1533(ndr, NDR_SCALARS, r->info1533));
9659                                 }
9660                         break;
9661
9662                         case 1534:
9663                                 if (r->info1534) {
9664                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1534(ndr, NDR_SCALARS, r->info1534));
9665                                 }
9666                         break;
9667
9668                         case 1535:
9669                                 if (r->info1535) {
9670                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1535(ndr, NDR_SCALARS, r->info1535));
9671                                 }
9672                         break;
9673
9674                         case 1536:
9675                                 if (r->info1536) {
9676                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1536(ndr, NDR_SCALARS, r->info1536));
9677                                 }
9678                         break;
9679
9680                         case 1537:
9681                                 if (r->info1537) {
9682                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1537(ndr, NDR_SCALARS, r->info1537));
9683                                 }
9684                         break;
9685
9686                         case 1538:
9687                                 if (r->info1538) {
9688                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1538(ndr, NDR_SCALARS, r->info1538));
9689                                 }
9690                         break;
9691
9692                         case 1539:
9693                                 if (r->info1539) {
9694                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1539(ndr, NDR_SCALARS, r->info1539));
9695                                 }
9696                         break;
9697
9698                         case 1540:
9699                                 if (r->info1540) {
9700                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1540(ndr, NDR_SCALARS, r->info1540));
9701                                 }
9702                         break;
9703
9704                         case 1541:
9705                                 if (r->info1541) {
9706                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1541(ndr, NDR_SCALARS, r->info1541));
9707                                 }
9708                         break;
9709
9710                         case 1542:
9711                                 if (r->info1542) {
9712                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1542(ndr, NDR_SCALARS, r->info1542));
9713                                 }
9714                         break;
9715
9716                         case 1543:
9717                                 if (r->info1543) {
9718                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1543(ndr, NDR_SCALARS, r->info1543));
9719                                 }
9720                         break;
9721
9722                         case 1544:
9723                                 if (r->info1544) {
9724                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1544(ndr, NDR_SCALARS, r->info1544));
9725                                 }
9726                         break;
9727
9728                         case 1545:
9729                                 if (r->info1545) {
9730                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1545(ndr, NDR_SCALARS, r->info1545));
9731                                 }
9732                         break;
9733
9734                         case 1546:
9735                                 if (r->info1546) {
9736                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1546(ndr, NDR_SCALARS, r->info1546));
9737                                 }
9738                         break;
9739
9740                         case 1547:
9741                                 if (r->info1547) {
9742                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1547(ndr, NDR_SCALARS, r->info1547));
9743                                 }
9744                         break;
9745
9746                         case 1548:
9747                                 if (r->info1548) {
9748                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1548(ndr, NDR_SCALARS, r->info1548));
9749                                 }
9750                         break;
9751
9752                         case 1549:
9753                                 if (r->info1549) {
9754                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1549(ndr, NDR_SCALARS, r->info1549));
9755                                 }
9756                         break;
9757
9758                         case 1550:
9759                                 if (r->info1550) {
9760                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1550(ndr, NDR_SCALARS, r->info1550));
9761                                 }
9762                         break;
9763
9764                         case 1552:
9765                                 if (r->info1552) {
9766                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1552(ndr, NDR_SCALARS, r->info1552));
9767                                 }
9768                         break;
9769
9770                         case 1553:
9771                                 if (r->info1553) {
9772                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1553(ndr, NDR_SCALARS, r->info1553));
9773                                 }
9774                         break;
9775
9776                         case 1554:
9777                                 if (r->info1554) {
9778                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1554(ndr, NDR_SCALARS, r->info1554));
9779                                 }
9780                         break;
9781
9782                         case 1555:
9783                                 if (r->info1555) {
9784                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1555(ndr, NDR_SCALARS, r->info1555));
9785                                 }
9786                         break;
9787
9788                         case 1556:
9789                                 if (r->info1556) {
9790                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1556(ndr, NDR_SCALARS, r->info1556));
9791                                 }
9792                         break;
9793
9794                         default:
9795                         break;
9796
9797                 }
9798         }
9799         return NDR_ERR_SUCCESS;
9800 }
9801
9802 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetSrvInfo *r)
9803 {
9804         int level;
9805         uint32_t _level;
9806         TALLOC_CTX *_mem_save_info100_0;
9807         TALLOC_CTX *_mem_save_info101_0;
9808         TALLOC_CTX *_mem_save_info102_0;
9809         TALLOC_CTX *_mem_save_info402_0;
9810         TALLOC_CTX *_mem_save_info403_0;
9811         TALLOC_CTX *_mem_save_info502_0;
9812         TALLOC_CTX *_mem_save_info503_0;
9813         TALLOC_CTX *_mem_save_info599_0;
9814         TALLOC_CTX *_mem_save_info1005_0;
9815         TALLOC_CTX *_mem_save_info1010_0;
9816         TALLOC_CTX *_mem_save_info1016_0;
9817         TALLOC_CTX *_mem_save_info1017_0;
9818         TALLOC_CTX *_mem_save_info1018_0;
9819         TALLOC_CTX *_mem_save_info1107_0;
9820         TALLOC_CTX *_mem_save_info1501_0;
9821         TALLOC_CTX *_mem_save_info1502_0;
9822         TALLOC_CTX *_mem_save_info1503_0;
9823         TALLOC_CTX *_mem_save_info1506_0;
9824         TALLOC_CTX *_mem_save_info1509_0;
9825         TALLOC_CTX *_mem_save_info1510_0;
9826         TALLOC_CTX *_mem_save_info1511_0;
9827         TALLOC_CTX *_mem_save_info1512_0;
9828         TALLOC_CTX *_mem_save_info1513_0;
9829         TALLOC_CTX *_mem_save_info1514_0;
9830         TALLOC_CTX *_mem_save_info1515_0;
9831         TALLOC_CTX *_mem_save_info1516_0;
9832         TALLOC_CTX *_mem_save_info1518_0;
9833         TALLOC_CTX *_mem_save_info1520_0;
9834         TALLOC_CTX *_mem_save_info1521_0;
9835         TALLOC_CTX *_mem_save_info1522_0;
9836         TALLOC_CTX *_mem_save_info1523_0;
9837         TALLOC_CTX *_mem_save_info1524_0;
9838         TALLOC_CTX *_mem_save_info1525_0;
9839         TALLOC_CTX *_mem_save_info1528_0;
9840         TALLOC_CTX *_mem_save_info1529_0;
9841         TALLOC_CTX *_mem_save_info1530_0;
9842         TALLOC_CTX *_mem_save_info1533_0;
9843         TALLOC_CTX *_mem_save_info1534_0;
9844         TALLOC_CTX *_mem_save_info1535_0;
9845         TALLOC_CTX *_mem_save_info1536_0;
9846         TALLOC_CTX *_mem_save_info1537_0;
9847         TALLOC_CTX *_mem_save_info1538_0;
9848         TALLOC_CTX *_mem_save_info1539_0;
9849         TALLOC_CTX *_mem_save_info1540_0;
9850         TALLOC_CTX *_mem_save_info1541_0;
9851         TALLOC_CTX *_mem_save_info1542_0;
9852         TALLOC_CTX *_mem_save_info1543_0;
9853         TALLOC_CTX *_mem_save_info1544_0;
9854         TALLOC_CTX *_mem_save_info1545_0;
9855         TALLOC_CTX *_mem_save_info1546_0;
9856         TALLOC_CTX *_mem_save_info1547_0;
9857         TALLOC_CTX *_mem_save_info1548_0;
9858         TALLOC_CTX *_mem_save_info1549_0;
9859         TALLOC_CTX *_mem_save_info1550_0;
9860         TALLOC_CTX *_mem_save_info1552_0;
9861         TALLOC_CTX *_mem_save_info1553_0;
9862         TALLOC_CTX *_mem_save_info1554_0;
9863         TALLOC_CTX *_mem_save_info1555_0;
9864         TALLOC_CTX *_mem_save_info1556_0;
9865         level = ndr_pull_get_switch_value(ndr, r);
9866         if (ndr_flags & NDR_SCALARS) {
9867                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9868                 if (_level != level) {
9869                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
9870                 }
9871                 switch (level) {
9872                         case 100: {
9873                                 uint32_t _ptr_info100;
9874                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info100));
9875                                 if (_ptr_info100) {
9876                                         NDR_PULL_ALLOC(ndr, r->info100);
9877                                 } else {
9878                                         r->info100 = NULL;
9879                                 }
9880                         break; }
9881
9882                         case 101: {
9883                                 uint32_t _ptr_info101;
9884                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info101));
9885                                 if (_ptr_info101) {
9886                                         NDR_PULL_ALLOC(ndr, r->info101);
9887                                 } else {
9888                                         r->info101 = NULL;
9889                                 }
9890                         break; }
9891
9892                         case 102: {
9893                                 uint32_t _ptr_info102;
9894                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info102));
9895                                 if (_ptr_info102) {
9896                                         NDR_PULL_ALLOC(ndr, r->info102);
9897                                 } else {
9898                                         r->info102 = NULL;
9899                                 }
9900                         break; }
9901
9902                         case 402: {
9903                                 uint32_t _ptr_info402;
9904                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info402));
9905                                 if (_ptr_info402) {
9906                                         NDR_PULL_ALLOC(ndr, r->info402);
9907                                 } else {
9908                                         r->info402 = NULL;
9909                                 }
9910                         break; }
9911
9912                         case 403: {
9913                                 uint32_t _ptr_info403;
9914                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info403));
9915                                 if (_ptr_info403) {
9916                                         NDR_PULL_ALLOC(ndr, r->info403);
9917                                 } else {
9918                                         r->info403 = NULL;
9919                                 }
9920                         break; }
9921
9922                         case 502: {
9923                                 uint32_t _ptr_info502;
9924                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info502));
9925                                 if (_ptr_info502) {
9926                                         NDR_PULL_ALLOC(ndr, r->info502);
9927                                 } else {
9928                                         r->info502 = NULL;
9929                                 }
9930                         break; }
9931
9932                         case 503: {
9933                                 uint32_t _ptr_info503;
9934                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info503));
9935                                 if (_ptr_info503) {
9936                                         NDR_PULL_ALLOC(ndr, r->info503);
9937                                 } else {
9938                                         r->info503 = NULL;
9939                                 }
9940                         break; }
9941
9942                         case 599: {
9943                                 uint32_t _ptr_info599;
9944                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info599));
9945                                 if (_ptr_info599) {
9946                                         NDR_PULL_ALLOC(ndr, r->info599);
9947                                 } else {
9948                                         r->info599 = NULL;
9949                                 }
9950                         break; }
9951
9952                         case 1005: {
9953                                 uint32_t _ptr_info1005;
9954                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1005));
9955                                 if (_ptr_info1005) {
9956                                         NDR_PULL_ALLOC(ndr, r->info1005);
9957                                 } else {
9958                                         r->info1005 = NULL;
9959                                 }
9960                         break; }
9961
9962                         case 1010: {
9963                                 uint32_t _ptr_info1010;
9964                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1010));
9965                                 if (_ptr_info1010) {
9966                                         NDR_PULL_ALLOC(ndr, r->info1010);
9967                                 } else {
9968                                         r->info1010 = NULL;
9969                                 }
9970                         break; }
9971
9972                         case 1016: {
9973                                 uint32_t _ptr_info1016;
9974                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1016));
9975                                 if (_ptr_info1016) {
9976                                         NDR_PULL_ALLOC(ndr, r->info1016);
9977                                 } else {
9978                                         r->info1016 = NULL;
9979                                 }
9980                         break; }
9981
9982                         case 1017: {
9983                                 uint32_t _ptr_info1017;
9984                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1017));
9985                                 if (_ptr_info1017) {
9986                                         NDR_PULL_ALLOC(ndr, r->info1017);
9987                                 } else {
9988                                         r->info1017 = NULL;
9989                                 }
9990                         break; }
9991
9992                         case 1018: {
9993                                 uint32_t _ptr_info1018;
9994                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1018));
9995                                 if (_ptr_info1018) {
9996                                         NDR_PULL_ALLOC(ndr, r->info1018);
9997                                 } else {
9998                                         r->info1018 = NULL;
9999                                 }
10000                         break; }
10001
10002                         case 1107: {
10003                                 uint32_t _ptr_info1107;
10004                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1107));
10005                                 if (_ptr_info1107) {
10006                                         NDR_PULL_ALLOC(ndr, r->info1107);
10007                                 } else {
10008                                         r->info1107 = NULL;
10009                                 }
10010                         break; }
10011
10012                         case 1501: {
10013                                 uint32_t _ptr_info1501;
10014                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1501));
10015                                 if (_ptr_info1501) {
10016                                         NDR_PULL_ALLOC(ndr, r->info1501);
10017                                 } else {
10018                                         r->info1501 = NULL;
10019                                 }
10020                         break; }
10021
10022                         case 1502: {
10023                                 uint32_t _ptr_info1502;
10024                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1502));
10025                                 if (_ptr_info1502) {
10026                                         NDR_PULL_ALLOC(ndr, r->info1502);
10027                                 } else {
10028                                         r->info1502 = NULL;
10029                                 }
10030                         break; }
10031
10032                         case 1503: {
10033                                 uint32_t _ptr_info1503;
10034                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1503));
10035                                 if (_ptr_info1503) {
10036                                         NDR_PULL_ALLOC(ndr, r->info1503);
10037                                 } else {
10038                                         r->info1503 = NULL;
10039                                 }
10040                         break; }
10041
10042                         case 1506: {
10043                                 uint32_t _ptr_info1506;
10044                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1506));
10045                                 if (_ptr_info1506) {
10046                                         NDR_PULL_ALLOC(ndr, r->info1506);
10047                                 } else {
10048                                         r->info1506 = NULL;
10049                                 }
10050                         break; }
10051
10052                         case 1509: {
10053                                 uint32_t _ptr_info1509;
10054                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1509));
10055                                 if (_ptr_info1509) {
10056                                         NDR_PULL_ALLOC(ndr, r->info1509);
10057                                 } else {
10058                                         r->info1509 = NULL;
10059                                 }
10060                         break; }
10061
10062                         case 1510: {
10063                                 uint32_t _ptr_info1510;
10064                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1510));
10065                                 if (_ptr_info1510) {
10066                                         NDR_PULL_ALLOC(ndr, r->info1510);
10067                                 } else {
10068                                         r->info1510 = NULL;
10069                                 }
10070                         break; }
10071
10072                         case 1511: {
10073                                 uint32_t _ptr_info1511;
10074                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1511));
10075                                 if (_ptr_info1511) {
10076                                         NDR_PULL_ALLOC(ndr, r->info1511);
10077                                 } else {
10078                                         r->info1511 = NULL;
10079                                 }
10080                         break; }
10081
10082                         case 1512: {
10083                                 uint32_t _ptr_info1512;
10084                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1512));
10085                                 if (_ptr_info1512) {
10086                                         NDR_PULL_ALLOC(ndr, r->info1512);
10087                                 } else {
10088                                         r->info1512 = NULL;
10089                                 }
10090                         break; }
10091
10092                         case 1513: {
10093                                 uint32_t _ptr_info1513;
10094                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1513));
10095                                 if (_ptr_info1513) {
10096                                         NDR_PULL_ALLOC(ndr, r->info1513);
10097                                 } else {
10098                                         r->info1513 = NULL;
10099                                 }
10100                         break; }
10101
10102                         case 1514: {
10103                                 uint32_t _ptr_info1514;
10104                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1514));
10105                                 if (_ptr_info1514) {
10106                                         NDR_PULL_ALLOC(ndr, r->info1514);
10107                                 } else {
10108                                         r->info1514 = NULL;
10109                                 }
10110                         break; }
10111
10112                         case 1515: {
10113                                 uint32_t _ptr_info1515;
10114                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1515));
10115                                 if (_ptr_info1515) {
10116                                         NDR_PULL_ALLOC(ndr, r->info1515);
10117                                 } else {
10118                                         r->info1515 = NULL;
10119                                 }
10120                         break; }
10121
10122                         case 1516: {
10123                                 uint32_t _ptr_info1516;
10124                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1516));
10125                                 if (_ptr_info1516) {
10126                                         NDR_PULL_ALLOC(ndr, r->info1516);
10127                                 } else {
10128                                         r->info1516 = NULL;
10129                                 }
10130                         break; }
10131
10132                         case 1518: {
10133                                 uint32_t _ptr_info1518;
10134                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1518));
10135                                 if (_ptr_info1518) {
10136                                         NDR_PULL_ALLOC(ndr, r->info1518);
10137                                 } else {
10138                                         r->info1518 = NULL;
10139                                 }
10140                         break; }
10141
10142                         case 1520: {
10143                                 uint32_t _ptr_info1520;
10144                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1520));
10145                                 if (_ptr_info1520) {
10146                                         NDR_PULL_ALLOC(ndr, r->info1520);
10147                                 } else {
10148                                         r->info1520 = NULL;
10149                                 }
10150                         break; }
10151
10152                         case 1521: {
10153                                 uint32_t _ptr_info1521;
10154                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1521));
10155                                 if (_ptr_info1521) {
10156                                         NDR_PULL_ALLOC(ndr, r->info1521);
10157                                 } else {
10158                                         r->info1521 = NULL;
10159                                 }
10160                         break; }
10161
10162                         case 1522: {
10163                                 uint32_t _ptr_info1522;
10164                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1522));
10165                                 if (_ptr_info1522) {
10166                                         NDR_PULL_ALLOC(ndr, r->info1522);
10167                                 } else {
10168                                         r->info1522 = NULL;
10169                                 }
10170                         break; }
10171
10172                         case 1523: {
10173                                 uint32_t _ptr_info1523;
10174                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1523));
10175                                 if (_ptr_info1523) {
10176                                         NDR_PULL_ALLOC(ndr, r->info1523);
10177                                 } else {
10178                                         r->info1523 = NULL;
10179                                 }
10180                         break; }
10181
10182                         case 1524: {
10183                                 uint32_t _ptr_info1524;
10184                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1524));
10185                                 if (_ptr_info1524) {
10186                                         NDR_PULL_ALLOC(ndr, r->info1524);
10187                                 } else {
10188                                         r->info1524 = NULL;
10189                                 }
10190                         break; }
10191
10192                         case 1525: {
10193                                 uint32_t _ptr_info1525;
10194                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1525));
10195                                 if (_ptr_info1525) {
10196                                         NDR_PULL_ALLOC(ndr, r->info1525);
10197                                 } else {
10198                                         r->info1525 = NULL;
10199                                 }
10200                         break; }
10201
10202                         case 1528: {
10203                                 uint32_t _ptr_info1528;
10204                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1528));
10205                                 if (_ptr_info1528) {
10206                                         NDR_PULL_ALLOC(ndr, r->info1528);
10207                                 } else {
10208                                         r->info1528 = NULL;
10209                                 }
10210                         break; }
10211
10212                         case 1529: {
10213                                 uint32_t _ptr_info1529;
10214                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1529));
10215                                 if (_ptr_info1529) {
10216                                         NDR_PULL_ALLOC(ndr, r->info1529);
10217                                 } else {
10218                                         r->info1529 = NULL;
10219                                 }
10220                         break; }
10221
10222                         case 1530: {
10223                                 uint32_t _ptr_info1530;
10224                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1530));
10225                                 if (_ptr_info1530) {
10226                                         NDR_PULL_ALLOC(ndr, r->info1530);
10227                                 } else {
10228                                         r->info1530 = NULL;
10229                                 }
10230                         break; }
10231
10232                         case 1533: {
10233                                 uint32_t _ptr_info1533;
10234                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1533));
10235                                 if (_ptr_info1533) {
10236                                         NDR_PULL_ALLOC(ndr, r->info1533);
10237                                 } else {
10238                                         r->info1533 = NULL;
10239                                 }
10240                         break; }
10241
10242                         case 1534: {
10243                                 uint32_t _ptr_info1534;
10244                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1534));
10245                                 if (_ptr_info1534) {
10246                                         NDR_PULL_ALLOC(ndr, r->info1534);
10247                                 } else {
10248                                         r->info1534 = NULL;
10249                                 }
10250                         break; }
10251
10252                         case 1535: {
10253                                 uint32_t _ptr_info1535;
10254                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1535));
10255                                 if (_ptr_info1535) {
10256                                         NDR_PULL_ALLOC(ndr, r->info1535);
10257                                 } else {
10258                                         r->info1535 = NULL;
10259                                 }
10260                         break; }
10261
10262                         case 1536: {
10263                                 uint32_t _ptr_info1536;
10264                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1536));
10265                                 if (_ptr_info1536) {
10266                                         NDR_PULL_ALLOC(ndr, r->info1536);
10267                                 } else {
10268                                         r->info1536 = NULL;
10269                                 }
10270                         break; }
10271
10272                         case 1537: {
10273                                 uint32_t _ptr_info1537;
10274                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1537));
10275                                 if (_ptr_info1537) {
10276                                         NDR_PULL_ALLOC(ndr, r->info1537);
10277                                 } else {
10278                                         r->info1537 = NULL;
10279                                 }
10280                         break; }
10281
10282                         case 1538: {
10283                                 uint32_t _ptr_info1538;
10284                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1538));
10285                                 if (_ptr_info1538) {
10286                                         NDR_PULL_ALLOC(ndr, r->info1538);
10287                                 } else {
10288                                         r->info1538 = NULL;
10289                                 }
10290                         break; }
10291
10292                         case 1539: {
10293                                 uint32_t _ptr_info1539;
10294                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1539));
10295                                 if (_ptr_info1539) {
10296                                         NDR_PULL_ALLOC(ndr, r->info1539);
10297                                 } else {
10298                                         r->info1539 = NULL;
10299                                 }
10300                         break; }
10301
10302                         case 1540: {
10303                                 uint32_t _ptr_info1540;
10304                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1540));
10305                                 if (_ptr_info1540) {
10306                                         NDR_PULL_ALLOC(ndr, r->info1540);
10307                                 } else {
10308                                         r->info1540 = NULL;
10309                                 }
10310                         break; }
10311
10312                         case 1541: {
10313                                 uint32_t _ptr_info1541;
10314                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1541));
10315                                 if (_ptr_info1541) {
10316                                         NDR_PULL_ALLOC(ndr, r->info1541);
10317                                 } else {
10318                                         r->info1541 = NULL;
10319                                 }
10320                         break; }
10321
10322                         case 1542: {
10323                                 uint32_t _ptr_info1542;
10324                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1542));
10325                                 if (_ptr_info1542) {
10326                                         NDR_PULL_ALLOC(ndr, r->info1542);
10327                                 } else {
10328                                         r->info1542 = NULL;
10329                                 }
10330                         break; }
10331
10332                         case 1543: {
10333                                 uint32_t _ptr_info1543;
10334                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1543));
10335                                 if (_ptr_info1543) {
10336                                         NDR_PULL_ALLOC(ndr, r->info1543);
10337                                 } else {
10338                                         r->info1543 = NULL;
10339                                 }
10340                         break; }
10341
10342                         case 1544: {
10343                                 uint32_t _ptr_info1544;
10344                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1544));
10345                                 if (_ptr_info1544) {
10346                                         NDR_PULL_ALLOC(ndr, r->info1544);
10347                                 } else {
10348                                         r->info1544 = NULL;
10349                                 }
10350                         break; }
10351
10352                         case 1545: {
10353                                 uint32_t _ptr_info1545;
10354                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1545));
10355                                 if (_ptr_info1545) {
10356                                         NDR_PULL_ALLOC(ndr, r->info1545);
10357                                 } else {
10358                                         r->info1545 = NULL;
10359                                 }
10360                         break; }
10361
10362                         case 1546: {
10363                                 uint32_t _ptr_info1546;
10364                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1546));
10365                                 if (_ptr_info1546) {
10366                                         NDR_PULL_ALLOC(ndr, r->info1546);
10367                                 } else {
10368                                         r->info1546 = NULL;
10369                                 }
10370                         break; }
10371
10372                         case 1547: {
10373                                 uint32_t _ptr_info1547;
10374                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1547));
10375                                 if (_ptr_info1547) {
10376                                         NDR_PULL_ALLOC(ndr, r->info1547);
10377                                 } else {
10378                                         r->info1547 = NULL;
10379                                 }
10380                         break; }
10381
10382                         case 1548: {
10383                                 uint32_t _ptr_info1548;
10384                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1548));
10385                                 if (_ptr_info1548) {
10386                                         NDR_PULL_ALLOC(ndr, r->info1548);
10387                                 } else {
10388                                         r->info1548 = NULL;
10389                                 }
10390                         break; }
10391
10392                         case 1549: {
10393                                 uint32_t _ptr_info1549;
10394                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1549));
10395                                 if (_ptr_info1549) {
10396                                         NDR_PULL_ALLOC(ndr, r->info1549);
10397                                 } else {
10398                                         r->info1549 = NULL;
10399                                 }
10400                         break; }
10401
10402                         case 1550: {
10403                                 uint32_t _ptr_info1550;
10404                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1550));
10405                                 if (_ptr_info1550) {
10406                                         NDR_PULL_ALLOC(ndr, r->info1550);
10407                                 } else {
10408                                         r->info1550 = NULL;
10409                                 }
10410                         break; }
10411
10412                         case 1552: {
10413                                 uint32_t _ptr_info1552;
10414                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1552));
10415                                 if (_ptr_info1552) {
10416                                         NDR_PULL_ALLOC(ndr, r->info1552);
10417                                 } else {
10418                                         r->info1552 = NULL;
10419                                 }
10420                         break; }
10421
10422                         case 1553: {
10423                                 uint32_t _ptr_info1553;
10424                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1553));
10425                                 if (_ptr_info1553) {
10426                                         NDR_PULL_ALLOC(ndr, r->info1553);
10427                                 } else {
10428                                         r->info1553 = NULL;
10429                                 }
10430                         break; }
10431
10432                         case 1554: {
10433                                 uint32_t _ptr_info1554;
10434                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1554));
10435                                 if (_ptr_info1554) {
10436                                         NDR_PULL_ALLOC(ndr, r->info1554);
10437                                 } else {
10438                                         r->info1554 = NULL;
10439                                 }
10440                         break; }
10441
10442                         case 1555: {
10443                                 uint32_t _ptr_info1555;
10444                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1555));
10445                                 if (_ptr_info1555) {
10446                                         NDR_PULL_ALLOC(ndr, r->info1555);
10447                                 } else {
10448                                         r->info1555 = NULL;
10449                                 }
10450                         break; }
10451
10452                         case 1556: {
10453                                 uint32_t _ptr_info1556;
10454                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1556));
10455                                 if (_ptr_info1556) {
10456                                         NDR_PULL_ALLOC(ndr, r->info1556);
10457                                 } else {
10458                                         r->info1556 = NULL;
10459                                 }
10460                         break; }
10461
10462                         default: {
10463                         break; }
10464
10465                 }
10466         }
10467         if (ndr_flags & NDR_BUFFERS) {
10468                 switch (level) {
10469                         case 100:
10470                                 if (r->info100) {
10471                                         _mem_save_info100_0 = NDR_PULL_GET_MEM_CTX(ndr);
10472                                         NDR_PULL_SET_MEM_CTX(ndr, r->info100, 0);
10473                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo100(ndr, NDR_SCALARS|NDR_BUFFERS, r->info100));
10474                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info100_0, 0);
10475                                 }
10476                         break;
10477
10478                         case 101:
10479                                 if (r->info101) {
10480                                         _mem_save_info101_0 = NDR_PULL_GET_MEM_CTX(ndr);
10481                                         NDR_PULL_SET_MEM_CTX(ndr, r->info101, 0);
10482                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info101));
10483                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info101_0, 0);
10484                                 }
10485                         break;
10486
10487                         case 102:
10488                                 if (r->info102) {
10489                                         _mem_save_info102_0 = NDR_PULL_GET_MEM_CTX(ndr);
10490                                         NDR_PULL_SET_MEM_CTX(ndr, r->info102, 0);
10491                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo102(ndr, NDR_SCALARS|NDR_BUFFERS, r->info102));
10492                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info102_0, 0);
10493                                 }
10494                         break;
10495
10496                         case 402:
10497                                 if (r->info402) {
10498                                         _mem_save_info402_0 = NDR_PULL_GET_MEM_CTX(ndr);
10499                                         NDR_PULL_SET_MEM_CTX(ndr, r->info402, 0);
10500                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo402(ndr, NDR_SCALARS|NDR_BUFFERS, r->info402));
10501                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info402_0, 0);
10502                                 }
10503                         break;
10504
10505                         case 403:
10506                                 if (r->info403) {
10507                                         _mem_save_info403_0 = NDR_PULL_GET_MEM_CTX(ndr);
10508                                         NDR_PULL_SET_MEM_CTX(ndr, r->info403, 0);
10509                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo403(ndr, NDR_SCALARS|NDR_BUFFERS, r->info403));
10510                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info403_0, 0);
10511                                 }
10512                         break;
10513
10514                         case 502:
10515                                 if (r->info502) {
10516                                         _mem_save_info502_0 = NDR_PULL_GET_MEM_CTX(ndr);
10517                                         NDR_PULL_SET_MEM_CTX(ndr, r->info502, 0);
10518                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo502(ndr, NDR_SCALARS, r->info502));
10519                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info502_0, 0);
10520                                 }
10521                         break;
10522
10523                         case 503:
10524                                 if (r->info503) {
10525                                         _mem_save_info503_0 = NDR_PULL_GET_MEM_CTX(ndr);
10526                                         NDR_PULL_SET_MEM_CTX(ndr, r->info503, 0);
10527                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo503(ndr, NDR_SCALARS|NDR_BUFFERS, r->info503));
10528                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info503_0, 0);
10529                                 }
10530                         break;
10531
10532                         case 599:
10533                                 if (r->info599) {
10534                                         _mem_save_info599_0 = NDR_PULL_GET_MEM_CTX(ndr);
10535                                         NDR_PULL_SET_MEM_CTX(ndr, r->info599, 0);
10536                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo599(ndr, NDR_SCALARS|NDR_BUFFERS, r->info599));
10537                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info599_0, 0);
10538                                 }
10539                         break;
10540
10541                         case 1005:
10542                                 if (r->info1005) {
10543                                         _mem_save_info1005_0 = NDR_PULL_GET_MEM_CTX(ndr);
10544                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1005, 0);
10545                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1005(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1005));
10546                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1005_0, 0);
10547                                 }
10548                         break;
10549
10550                         case 1010:
10551                                 if (r->info1010) {
10552                                         _mem_save_info1010_0 = NDR_PULL_GET_MEM_CTX(ndr);
10553                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1010, 0);
10554                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1010(ndr, NDR_SCALARS, r->info1010));
10555                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1010_0, 0);
10556                                 }
10557                         break;
10558
10559                         case 1016:
10560                                 if (r->info1016) {
10561                                         _mem_save_info1016_0 = NDR_PULL_GET_MEM_CTX(ndr);
10562                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1016, 0);
10563                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1016(ndr, NDR_SCALARS, r->info1016));
10564                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1016_0, 0);
10565                                 }
10566                         break;
10567
10568                         case 1017:
10569                                 if (r->info1017) {
10570                                         _mem_save_info1017_0 = NDR_PULL_GET_MEM_CTX(ndr);
10571                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1017, 0);
10572                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1017(ndr, NDR_SCALARS, r->info1017));
10573                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1017_0, 0);
10574                                 }
10575                         break;
10576
10577                         case 1018:
10578                                 if (r->info1018) {
10579                                         _mem_save_info1018_0 = NDR_PULL_GET_MEM_CTX(ndr);
10580                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1018, 0);
10581                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1018(ndr, NDR_SCALARS, r->info1018));
10582                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1018_0, 0);
10583                                 }
10584                         break;
10585
10586                         case 1107:
10587                                 if (r->info1107) {
10588                                         _mem_save_info1107_0 = NDR_PULL_GET_MEM_CTX(ndr);
10589                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1107, 0);
10590                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1107(ndr, NDR_SCALARS, r->info1107));
10591                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1107_0, 0);
10592                                 }
10593                         break;
10594
10595                         case 1501:
10596                                 if (r->info1501) {
10597                                         _mem_save_info1501_0 = NDR_PULL_GET_MEM_CTX(ndr);
10598                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1501, 0);
10599                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1501(ndr, NDR_SCALARS, r->info1501));
10600                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1501_0, 0);
10601                                 }
10602                         break;
10603
10604                         case 1502:
10605                                 if (r->info1502) {
10606                                         _mem_save_info1502_0 = NDR_PULL_GET_MEM_CTX(ndr);
10607                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1502, 0);
10608                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1502(ndr, NDR_SCALARS, r->info1502));
10609                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1502_0, 0);
10610                                 }
10611                         break;
10612
10613                         case 1503:
10614                                 if (r->info1503) {
10615                                         _mem_save_info1503_0 = NDR_PULL_GET_MEM_CTX(ndr);
10616                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1503, 0);
10617                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1503(ndr, NDR_SCALARS, r->info1503));
10618                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1503_0, 0);
10619                                 }
10620                         break;
10621
10622                         case 1506:
10623                                 if (r->info1506) {
10624                                         _mem_save_info1506_0 = NDR_PULL_GET_MEM_CTX(ndr);
10625                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1506, 0);
10626                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1506(ndr, NDR_SCALARS, r->info1506));
10627                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1506_0, 0);
10628                                 }
10629                         break;
10630
10631                         case 1509:
10632                                 if (r->info1509) {
10633                                         _mem_save_info1509_0 = NDR_PULL_GET_MEM_CTX(ndr);
10634                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1509, 0);
10635                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1509(ndr, NDR_SCALARS, r->info1509));
10636                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1509_0, 0);
10637                                 }
10638                         break;
10639
10640                         case 1510:
10641                                 if (r->info1510) {
10642                                         _mem_save_info1510_0 = NDR_PULL_GET_MEM_CTX(ndr);
10643                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1510, 0);
10644                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1510(ndr, NDR_SCALARS, r->info1510));
10645                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1510_0, 0);
10646                                 }
10647                         break;
10648
10649                         case 1511:
10650                                 if (r->info1511) {
10651                                         _mem_save_info1511_0 = NDR_PULL_GET_MEM_CTX(ndr);
10652                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1511, 0);
10653                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1511(ndr, NDR_SCALARS, r->info1511));
10654                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1511_0, 0);
10655                                 }
10656                         break;
10657
10658                         case 1512:
10659                                 if (r->info1512) {
10660                                         _mem_save_info1512_0 = NDR_PULL_GET_MEM_CTX(ndr);
10661                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1512, 0);
10662                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1512(ndr, NDR_SCALARS, r->info1512));
10663                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1512_0, 0);
10664                                 }
10665                         break;
10666
10667                         case 1513:
10668                                 if (r->info1513) {
10669                                         _mem_save_info1513_0 = NDR_PULL_GET_MEM_CTX(ndr);
10670                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1513, 0);
10671                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1513(ndr, NDR_SCALARS, r->info1513));
10672                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1513_0, 0);
10673                                 }
10674                         break;
10675
10676                         case 1514:
10677                                 if (r->info1514) {
10678                                         _mem_save_info1514_0 = NDR_PULL_GET_MEM_CTX(ndr);
10679                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1514, 0);
10680                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1514(ndr, NDR_SCALARS, r->info1514));
10681                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1514_0, 0);
10682                                 }
10683                         break;
10684
10685                         case 1515:
10686                                 if (r->info1515) {
10687                                         _mem_save_info1515_0 = NDR_PULL_GET_MEM_CTX(ndr);
10688                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1515, 0);
10689                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1515(ndr, NDR_SCALARS, r->info1515));
10690                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1515_0, 0);
10691                                 }
10692                         break;
10693
10694                         case 1516:
10695                                 if (r->info1516) {
10696                                         _mem_save_info1516_0 = NDR_PULL_GET_MEM_CTX(ndr);
10697                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1516, 0);
10698                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1516(ndr, NDR_SCALARS, r->info1516));
10699                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1516_0, 0);
10700                                 }
10701                         break;
10702
10703                         case 1518:
10704                                 if (r->info1518) {
10705                                         _mem_save_info1518_0 = NDR_PULL_GET_MEM_CTX(ndr);
10706                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1518, 0);
10707                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1518(ndr, NDR_SCALARS, r->info1518));
10708                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1518_0, 0);
10709                                 }
10710                         break;
10711
10712                         case 1520:
10713                                 if (r->info1520) {
10714                                         _mem_save_info1520_0 = NDR_PULL_GET_MEM_CTX(ndr);
10715                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1520, 0);
10716                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1520(ndr, NDR_SCALARS, r->info1520));
10717                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1520_0, 0);
10718                                 }
10719                         break;
10720
10721                         case 1521:
10722                                 if (r->info1521) {
10723                                         _mem_save_info1521_0 = NDR_PULL_GET_MEM_CTX(ndr);
10724                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1521, 0);
10725                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1521(ndr, NDR_SCALARS, r->info1521));
10726                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1521_0, 0);
10727                                 }
10728                         break;
10729
10730                         case 1522:
10731                                 if (r->info1522) {
10732                                         _mem_save_info1522_0 = NDR_PULL_GET_MEM_CTX(ndr);
10733                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1522, 0);
10734                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1522(ndr, NDR_SCALARS, r->info1522));
10735                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1522_0, 0);
10736                                 }
10737                         break;
10738
10739                         case 1523:
10740                                 if (r->info1523) {
10741                                         _mem_save_info1523_0 = NDR_PULL_GET_MEM_CTX(ndr);
10742                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1523, 0);
10743                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1523(ndr, NDR_SCALARS, r->info1523));
10744                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1523_0, 0);
10745                                 }
10746                         break;
10747
10748                         case 1524:
10749                                 if (r->info1524) {
10750                                         _mem_save_info1524_0 = NDR_PULL_GET_MEM_CTX(ndr);
10751                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1524, 0);
10752                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1524(ndr, NDR_SCALARS, r->info1524));
10753                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1524_0, 0);
10754                                 }
10755                         break;
10756
10757                         case 1525:
10758                                 if (r->info1525) {
10759                                         _mem_save_info1525_0 = NDR_PULL_GET_MEM_CTX(ndr);
10760                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1525, 0);
10761                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1525(ndr, NDR_SCALARS, r->info1525));
10762                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1525_0, 0);
10763                                 }
10764                         break;
10765
10766                         case 1528:
10767                                 if (r->info1528) {
10768                                         _mem_save_info1528_0 = NDR_PULL_GET_MEM_CTX(ndr);
10769                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1528, 0);
10770                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1528(ndr, NDR_SCALARS, r->info1528));
10771                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1528_0, 0);
10772                                 }
10773                         break;
10774
10775                         case 1529:
10776                                 if (r->info1529) {
10777                                         _mem_save_info1529_0 = NDR_PULL_GET_MEM_CTX(ndr);
10778                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1529, 0);
10779                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1529(ndr, NDR_SCALARS, r->info1529));
10780                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1529_0, 0);
10781                                 }
10782                         break;
10783
10784                         case 1530:
10785                                 if (r->info1530) {
10786                                         _mem_save_info1530_0 = NDR_PULL_GET_MEM_CTX(ndr);
10787                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1530, 0);
10788                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1530(ndr, NDR_SCALARS, r->info1530));
10789                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1530_0, 0);
10790                                 }
10791                         break;
10792
10793                         case 1533:
10794                                 if (r->info1533) {
10795                                         _mem_save_info1533_0 = NDR_PULL_GET_MEM_CTX(ndr);
10796                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1533, 0);
10797                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1533(ndr, NDR_SCALARS, r->info1533));
10798                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1533_0, 0);
10799                                 }
10800                         break;
10801
10802                         case 1534:
10803                                 if (r->info1534) {
10804                                         _mem_save_info1534_0 = NDR_PULL_GET_MEM_CTX(ndr);
10805                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1534, 0);
10806                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1534(ndr, NDR_SCALARS, r->info1534));
10807                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1534_0, 0);
10808                                 }
10809                         break;
10810
10811                         case 1535:
10812                                 if (r->info1535) {
10813                                         _mem_save_info1535_0 = NDR_PULL_GET_MEM_CTX(ndr);
10814                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1535, 0);
10815                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1535(ndr, NDR_SCALARS, r->info1535));
10816                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1535_0, 0);
10817                                 }
10818                         break;
10819
10820                         case 1536:
10821                                 if (r->info1536) {
10822                                         _mem_save_info1536_0 = NDR_PULL_GET_MEM_CTX(ndr);
10823                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1536, 0);
10824                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1536(ndr, NDR_SCALARS, r->info1536));
10825                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1536_0, 0);
10826                                 }
10827                         break;
10828
10829                         case 1537:
10830                                 if (r->info1537) {
10831                                         _mem_save_info1537_0 = NDR_PULL_GET_MEM_CTX(ndr);
10832                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1537, 0);
10833                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1537(ndr, NDR_SCALARS, r->info1537));
10834                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1537_0, 0);
10835                                 }
10836                         break;
10837
10838                         case 1538:
10839                                 if (r->info1538) {
10840                                         _mem_save_info1538_0 = NDR_PULL_GET_MEM_CTX(ndr);
10841                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1538, 0);
10842                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1538(ndr, NDR_SCALARS, r->info1538));
10843                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1538_0, 0);
10844                                 }
10845                         break;
10846
10847                         case 1539:
10848                                 if (r->info1539) {
10849                                         _mem_save_info1539_0 = NDR_PULL_GET_MEM_CTX(ndr);
10850                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1539, 0);
10851                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1539(ndr, NDR_SCALARS, r->info1539));
10852                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1539_0, 0);
10853                                 }
10854                         break;
10855
10856                         case 1540:
10857                                 if (r->info1540) {
10858                                         _mem_save_info1540_0 = NDR_PULL_GET_MEM_CTX(ndr);
10859                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1540, 0);
10860                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1540(ndr, NDR_SCALARS, r->info1540));
10861                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1540_0, 0);
10862                                 }
10863                         break;
10864
10865                         case 1541:
10866                                 if (r->info1541) {
10867                                         _mem_save_info1541_0 = NDR_PULL_GET_MEM_CTX(ndr);
10868                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1541, 0);
10869                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1541(ndr, NDR_SCALARS, r->info1541));
10870                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1541_0, 0);
10871                                 }
10872                         break;
10873
10874                         case 1542:
10875                                 if (r->info1542) {
10876                                         _mem_save_info1542_0 = NDR_PULL_GET_MEM_CTX(ndr);
10877                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1542, 0);
10878                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1542(ndr, NDR_SCALARS, r->info1542));
10879                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1542_0, 0);
10880                                 }
10881                         break;
10882
10883                         case 1543:
10884                                 if (r->info1543) {
10885                                         _mem_save_info1543_0 = NDR_PULL_GET_MEM_CTX(ndr);
10886                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1543, 0);
10887                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1543(ndr, NDR_SCALARS, r->info1543));
10888                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1543_0, 0);
10889                                 }
10890                         break;
10891
10892                         case 1544:
10893                                 if (r->info1544) {
10894                                         _mem_save_info1544_0 = NDR_PULL_GET_MEM_CTX(ndr);
10895                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1544, 0);
10896                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1544(ndr, NDR_SCALARS, r->info1544));
10897                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1544_0, 0);
10898                                 }
10899                         break;
10900
10901                         case 1545:
10902                                 if (r->info1545) {
10903                                         _mem_save_info1545_0 = NDR_PULL_GET_MEM_CTX(ndr);
10904                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1545, 0);
10905                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1545(ndr, NDR_SCALARS, r->info1545));
10906                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1545_0, 0);
10907                                 }
10908                         break;
10909
10910                         case 1546:
10911                                 if (r->info1546) {
10912                                         _mem_save_info1546_0 = NDR_PULL_GET_MEM_CTX(ndr);
10913                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1546, 0);
10914                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1546(ndr, NDR_SCALARS, r->info1546));
10915                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1546_0, 0);
10916                                 }
10917                         break;
10918
10919                         case 1547:
10920                                 if (r->info1547) {
10921                                         _mem_save_info1547_0 = NDR_PULL_GET_MEM_CTX(ndr);
10922                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1547, 0);
10923                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1547(ndr, NDR_SCALARS, r->info1547));
10924                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1547_0, 0);
10925                                 }
10926                         break;
10927
10928                         case 1548:
10929                                 if (r->info1548) {
10930                                         _mem_save_info1548_0 = NDR_PULL_GET_MEM_CTX(ndr);
10931                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1548, 0);
10932                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1548(ndr, NDR_SCALARS, r->info1548));
10933                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1548_0, 0);
10934                                 }
10935                         break;
10936
10937                         case 1549:
10938                                 if (r->info1549) {
10939                                         _mem_save_info1549_0 = NDR_PULL_GET_MEM_CTX(ndr);
10940                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1549, 0);
10941                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1549(ndr, NDR_SCALARS, r->info1549));
10942                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1549_0, 0);
10943                                 }
10944                         break;
10945
10946                         case 1550:
10947                                 if (r->info1550) {
10948                                         _mem_save_info1550_0 = NDR_PULL_GET_MEM_CTX(ndr);
10949                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1550, 0);
10950                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1550(ndr, NDR_SCALARS, r->info1550));
10951                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1550_0, 0);
10952                                 }
10953                         break;
10954
10955                         case 1552:
10956                                 if (r->info1552) {
10957                                         _mem_save_info1552_0 = NDR_PULL_GET_MEM_CTX(ndr);
10958                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1552, 0);
10959                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1552(ndr, NDR_SCALARS, r->info1552));
10960                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1552_0, 0);
10961                                 }
10962                         break;
10963
10964                         case 1553:
10965                                 if (r->info1553) {
10966                                         _mem_save_info1553_0 = NDR_PULL_GET_MEM_CTX(ndr);
10967                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1553, 0);
10968                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1553(ndr, NDR_SCALARS, r->info1553));
10969                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1553_0, 0);
10970                                 }
10971                         break;
10972
10973                         case 1554:
10974                                 if (r->info1554) {
10975                                         _mem_save_info1554_0 = NDR_PULL_GET_MEM_CTX(ndr);
10976                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1554, 0);
10977                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1554(ndr, NDR_SCALARS, r->info1554));
10978                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1554_0, 0);
10979                                 }
10980                         break;
10981
10982                         case 1555:
10983                                 if (r->info1555) {
10984                                         _mem_save_info1555_0 = NDR_PULL_GET_MEM_CTX(ndr);
10985                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1555, 0);
10986                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1555(ndr, NDR_SCALARS, r->info1555));
10987                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1555_0, 0);
10988                                 }
10989                         break;
10990
10991                         case 1556:
10992                                 if (r->info1556) {
10993                                         _mem_save_info1556_0 = NDR_PULL_GET_MEM_CTX(ndr);
10994                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1556, 0);
10995                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1556(ndr, NDR_SCALARS, r->info1556));
10996                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1556_0, 0);
10997                                 }
10998                         break;
10999
11000                         default:
11001                         break;
11002
11003                 }
11004         }
11005         return NDR_ERR_SUCCESS;
11006 }
11007
11008 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo(struct ndr_print *ndr, const char *name, const union srvsvc_NetSrvInfo *r)
11009 {
11010         int level;
11011         level = ndr_print_get_switch_value(ndr, r);
11012         ndr_print_union(ndr, name, level, "srvsvc_NetSrvInfo");
11013         switch (level) {
11014                 case 100:
11015                         ndr_print_ptr(ndr, "info100", r->info100);
11016                         ndr->depth++;
11017                         if (r->info100) {
11018                                 ndr_print_srvsvc_NetSrvInfo100(ndr, "info100", r->info100);
11019                         }
11020                         ndr->depth--;
11021                 break;
11022
11023                 case 101:
11024                         ndr_print_ptr(ndr, "info101", r->info101);
11025                         ndr->depth++;
11026                         if (r->info101) {
11027                                 ndr_print_srvsvc_NetSrvInfo101(ndr, "info101", r->info101);
11028                         }
11029                         ndr->depth--;
11030                 break;
11031
11032                 case 102:
11033                         ndr_print_ptr(ndr, "info102", r->info102);
11034                         ndr->depth++;
11035                         if (r->info102) {
11036                                 ndr_print_srvsvc_NetSrvInfo102(ndr, "info102", r->info102);
11037                         }
11038                         ndr->depth--;
11039                 break;
11040
11041                 case 402:
11042                         ndr_print_ptr(ndr, "info402", r->info402);
11043                         ndr->depth++;
11044                         if (r->info402) {
11045                                 ndr_print_srvsvc_NetSrvInfo402(ndr, "info402", r->info402);
11046                         }
11047                         ndr->depth--;
11048                 break;
11049
11050                 case 403:
11051                         ndr_print_ptr(ndr, "info403", r->info403);
11052                         ndr->depth++;
11053                         if (r->info403) {
11054                                 ndr_print_srvsvc_NetSrvInfo403(ndr, "info403", r->info403);
11055                         }
11056                         ndr->depth--;
11057                 break;
11058
11059                 case 502:
11060                         ndr_print_ptr(ndr, "info502", r->info502);
11061                         ndr->depth++;
11062                         if (r->info502) {
11063                                 ndr_print_srvsvc_NetSrvInfo502(ndr, "info502", r->info502);
11064                         }
11065                         ndr->depth--;
11066                 break;
11067
11068                 case 503:
11069                         ndr_print_ptr(ndr, "info503", r->info503);
11070                         ndr->depth++;
11071                         if (r->info503) {
11072                                 ndr_print_srvsvc_NetSrvInfo503(ndr, "info503", r->info503);
11073                         }
11074                         ndr->depth--;
11075                 break;
11076
11077                 case 599:
11078                         ndr_print_ptr(ndr, "info599", r->info599);
11079                         ndr->depth++;
11080                         if (r->info599) {
11081                                 ndr_print_srvsvc_NetSrvInfo599(ndr, "info599", r->info599);
11082                         }
11083                         ndr->depth--;
11084                 break;
11085
11086                 case 1005:
11087                         ndr_print_ptr(ndr, "info1005", r->info1005);
11088                         ndr->depth++;
11089                         if (r->info1005) {
11090                                 ndr_print_srvsvc_NetSrvInfo1005(ndr, "info1005", r->info1005);
11091                         }
11092                         ndr->depth--;
11093                 break;
11094
11095                 case 1010:
11096                         ndr_print_ptr(ndr, "info1010", r->info1010);
11097                         ndr->depth++;
11098                         if (r->info1010) {
11099                                 ndr_print_srvsvc_NetSrvInfo1010(ndr, "info1010", r->info1010);
11100                         }
11101                         ndr->depth--;
11102                 break;
11103
11104                 case 1016:
11105                         ndr_print_ptr(ndr, "info1016", r->info1016);
11106                         ndr->depth++;
11107                         if (r->info1016) {
11108                                 ndr_print_srvsvc_NetSrvInfo1016(ndr, "info1016", r->info1016);
11109                         }
11110                         ndr->depth--;
11111                 break;
11112
11113                 case 1017:
11114                         ndr_print_ptr(ndr, "info1017", r->info1017);
11115                         ndr->depth++;
11116                         if (r->info1017) {
11117                                 ndr_print_srvsvc_NetSrvInfo1017(ndr, "info1017", r->info1017);
11118                         }
11119                         ndr->depth--;
11120                 break;
11121
11122                 case 1018:
11123                         ndr_print_ptr(ndr, "info1018", r->info1018);
11124                         ndr->depth++;
11125                         if (r->info1018) {
11126                                 ndr_print_srvsvc_NetSrvInfo1018(ndr, "info1018", r->info1018);
11127                         }
11128                         ndr->depth--;
11129                 break;
11130
11131                 case 1107:
11132                         ndr_print_ptr(ndr, "info1107", r->info1107);
11133                         ndr->depth++;
11134                         if (r->info1107) {
11135                                 ndr_print_srvsvc_NetSrvInfo1107(ndr, "info1107", r->info1107);
11136                         }
11137                         ndr->depth--;
11138                 break;
11139
11140                 case 1501:
11141                         ndr_print_ptr(ndr, "info1501", r->info1501);
11142                         ndr->depth++;
11143                         if (r->info1501) {
11144                                 ndr_print_srvsvc_NetSrvInfo1501(ndr, "info1501", r->info1501);
11145                         }
11146                         ndr->depth--;
11147                 break;
11148
11149                 case 1502:
11150                         ndr_print_ptr(ndr, "info1502", r->info1502);
11151                         ndr->depth++;
11152                         if (r->info1502) {
11153                                 ndr_print_srvsvc_NetSrvInfo1502(ndr, "info1502", r->info1502);
11154                         }
11155                         ndr->depth--;
11156                 break;
11157
11158                 case 1503:
11159                         ndr_print_ptr(ndr, "info1503", r->info1503);
11160                         ndr->depth++;
11161                         if (r->info1503) {
11162                                 ndr_print_srvsvc_NetSrvInfo1503(ndr, "info1503", r->info1503);
11163                         }
11164                         ndr->depth--;
11165                 break;
11166
11167                 case 1506:
11168                         ndr_print_ptr(ndr, "info1506", r->info1506);
11169                         ndr->depth++;
11170                         if (r->info1506) {
11171                                 ndr_print_srvsvc_NetSrvInfo1506(ndr, "info1506", r->info1506);
11172                         }
11173                         ndr->depth--;
11174                 break;
11175
11176                 case 1509:
11177                         ndr_print_ptr(ndr, "info1509", r->info1509);
11178                         ndr->depth++;
11179                         if (r->info1509) {
11180                                 ndr_print_srvsvc_NetSrvInfo1509(ndr, "info1509", r->info1509);
11181                         }
11182                         ndr->depth--;
11183                 break;
11184
11185                 case 1510:
11186                         ndr_print_ptr(ndr, "info1510", r->info1510);
11187                         ndr->depth++;
11188                         if (r->info1510) {
11189                                 ndr_print_srvsvc_NetSrvInfo1510(ndr, "info1510", r->info1510);
11190                         }
11191                         ndr->depth--;
11192                 break;
11193
11194                 case 1511:
11195                         ndr_print_ptr(ndr, "info1511", r->info1511);
11196                         ndr->depth++;
11197                         if (r->info1511) {
11198                                 ndr_print_srvsvc_NetSrvInfo1511(ndr, "info1511", r->info1511);
11199                         }
11200                         ndr->depth--;
11201                 break;
11202
11203                 case 1512:
11204                         ndr_print_ptr(ndr, "info1512", r->info1512);
11205                         ndr->depth++;
11206                         if (r->info1512) {
11207                                 ndr_print_srvsvc_NetSrvInfo1512(ndr, "info1512", r->info1512);
11208                         }
11209                         ndr->depth--;
11210                 break;
11211
11212                 case 1513:
11213                         ndr_print_ptr(ndr, "info1513", r->info1513);
11214                         ndr->depth++;
11215                         if (r->info1513) {
11216                                 ndr_print_srvsvc_NetSrvInfo1513(ndr, "info1513", r->info1513);
11217                         }
11218                         ndr->depth--;
11219                 break;
11220
11221                 case 1514:
11222                         ndr_print_ptr(ndr, "info1514", r->info1514);
11223                         ndr->depth++;
11224                         if (r->info1514) {
11225                                 ndr_print_srvsvc_NetSrvInfo1514(ndr, "info1514", r->info1514);
11226                         }
11227                         ndr->depth--;
11228                 break;
11229
11230                 case 1515:
11231                         ndr_print_ptr(ndr, "info1515", r->info1515);
11232                         ndr->depth++;
11233                         if (r->info1515) {
11234                                 ndr_print_srvsvc_NetSrvInfo1515(ndr, "info1515", r->info1515);
11235                         }
11236                         ndr->depth--;
11237                 break;
11238
11239                 case 1516:
11240                         ndr_print_ptr(ndr, "info1516", r->info1516);
11241                         ndr->depth++;
11242                         if (r->info1516) {
11243                                 ndr_print_srvsvc_NetSrvInfo1516(ndr, "info1516", r->info1516);
11244                         }
11245                         ndr->depth--;
11246                 break;
11247
11248                 case 1518:
11249                         ndr_print_ptr(ndr, "info1518", r->info1518);
11250                         ndr->depth++;
11251                         if (r->info1518) {
11252                                 ndr_print_srvsvc_NetSrvInfo1518(ndr, "info1518", r->info1518);
11253                         }
11254                         ndr->depth--;
11255                 break;
11256
11257                 case 1520:
11258                         ndr_print_ptr(ndr, "info1520", r->info1520);
11259                         ndr->depth++;
11260                         if (r->info1520) {
11261                                 ndr_print_srvsvc_NetSrvInfo1520(ndr, "info1520", r->info1520);
11262                         }
11263                         ndr->depth--;
11264                 break;
11265
11266                 case 1521:
11267                         ndr_print_ptr(ndr, "info1521", r->info1521);
11268                         ndr->depth++;
11269                         if (r->info1521) {
11270                                 ndr_print_srvsvc_NetSrvInfo1521(ndr, "info1521", r->info1521);
11271                         }
11272                         ndr->depth--;
11273                 break;
11274
11275                 case 1522:
11276                         ndr_print_ptr(ndr, "info1522", r->info1522);
11277                         ndr->depth++;
11278                         if (r->info1522) {
11279                                 ndr_print_srvsvc_NetSrvInfo1522(ndr, "info1522", r->info1522);
11280                         }
11281                         ndr->depth--;
11282                 break;
11283
11284                 case 1523:
11285                         ndr_print_ptr(ndr, "info1523", r->info1523);
11286                         ndr->depth++;
11287                         if (r->info1523) {
11288                                 ndr_print_srvsvc_NetSrvInfo1523(ndr, "info1523", r->info1523);
11289                         }
11290                         ndr->depth--;
11291                 break;
11292
11293                 case 1524:
11294                         ndr_print_ptr(ndr, "info1524", r->info1524);
11295                         ndr->depth++;
11296                         if (r->info1524) {
11297                                 ndr_print_srvsvc_NetSrvInfo1524(ndr, "info1524", r->info1524);
11298                         }
11299                         ndr->depth--;
11300                 break;
11301
11302                 case 1525:
11303                         ndr_print_ptr(ndr, "info1525", r->info1525);
11304                         ndr->depth++;
11305                         if (r->info1525) {
11306                                 ndr_print_srvsvc_NetSrvInfo1525(ndr, "info1525", r->info1525);
11307                         }
11308                         ndr->depth--;
11309                 break;
11310
11311                 case 1528:
11312                         ndr_print_ptr(ndr, "info1528", r->info1528);
11313                         ndr->depth++;
11314                         if (r->info1528) {
11315                                 ndr_print_srvsvc_NetSrvInfo1528(ndr, "info1528", r->info1528);
11316                         }
11317                         ndr->depth--;
11318                 break;
11319
11320                 case 1529:
11321                         ndr_print_ptr(ndr, "info1529", r->info1529);
11322                         ndr->depth++;
11323                         if (r->info1529) {
11324                                 ndr_print_srvsvc_NetSrvInfo1529(ndr, "info1529", r->info1529);
11325                         }
11326                         ndr->depth--;
11327                 break;
11328
11329                 case 1530:
11330                         ndr_print_ptr(ndr, "info1530", r->info1530);
11331                         ndr->depth++;
11332                         if (r->info1530) {
11333                                 ndr_print_srvsvc_NetSrvInfo1530(ndr, "info1530", r->info1530);
11334                         }
11335                         ndr->depth--;
11336                 break;
11337
11338                 case 1533:
11339                         ndr_print_ptr(ndr, "info1533", r->info1533);
11340                         ndr->depth++;
11341                         if (r->info1533) {
11342                                 ndr_print_srvsvc_NetSrvInfo1533(ndr, "info1533", r->info1533);
11343                         }
11344                         ndr->depth--;
11345                 break;
11346
11347                 case 1534:
11348                         ndr_print_ptr(ndr, "info1534", r->info1534);
11349                         ndr->depth++;
11350                         if (r->info1534) {
11351                                 ndr_print_srvsvc_NetSrvInfo1534(ndr, "info1534", r->info1534);
11352                         }
11353                         ndr->depth--;
11354                 break;
11355
11356                 case 1535:
11357                         ndr_print_ptr(ndr, "info1535", r->info1535);
11358                         ndr->depth++;
11359                         if (r->info1535) {
11360                                 ndr_print_srvsvc_NetSrvInfo1535(ndr, "info1535", r->info1535);
11361                         }
11362                         ndr->depth--;
11363                 break;
11364
11365                 case 1536:
11366                         ndr_print_ptr(ndr, "info1536", r->info1536);
11367                         ndr->depth++;
11368                         if (r->info1536) {
11369                                 ndr_print_srvsvc_NetSrvInfo1536(ndr, "info1536", r->info1536);
11370                         }
11371                         ndr->depth--;
11372                 break;
11373
11374                 case 1537:
11375                         ndr_print_ptr(ndr, "info1537", r->info1537);
11376                         ndr->depth++;
11377                         if (r->info1537) {
11378                                 ndr_print_srvsvc_NetSrvInfo1537(ndr, "info1537", r->info1537);
11379                         }
11380                         ndr->depth--;
11381                 break;
11382
11383                 case 1538:
11384                         ndr_print_ptr(ndr, "info1538", r->info1538);
11385                         ndr->depth++;
11386                         if (r->info1538) {
11387                                 ndr_print_srvsvc_NetSrvInfo1538(ndr, "info1538", r->info1538);
11388                         }
11389                         ndr->depth--;
11390                 break;
11391
11392                 case 1539:
11393                         ndr_print_ptr(ndr, "info1539", r->info1539);
11394                         ndr->depth++;
11395                         if (r->info1539) {
11396                                 ndr_print_srvsvc_NetSrvInfo1539(ndr, "info1539", r->info1539);
11397                         }
11398                         ndr->depth--;
11399                 break;
11400
11401                 case 1540:
11402                         ndr_print_ptr(ndr, "info1540", r->info1540);
11403                         ndr->depth++;
11404                         if (r->info1540) {
11405                                 ndr_print_srvsvc_NetSrvInfo1540(ndr, "info1540", r->info1540);
11406                         }
11407                         ndr->depth--;
11408                 break;
11409
11410                 case 1541:
11411                         ndr_print_ptr(ndr, "info1541", r->info1541);
11412                         ndr->depth++;
11413                         if (r->info1541) {
11414                                 ndr_print_srvsvc_NetSrvInfo1541(ndr, "info1541", r->info1541);
11415                         }
11416                         ndr->depth--;
11417                 break;
11418
11419                 case 1542:
11420                         ndr_print_ptr(ndr, "info1542", r->info1542);
11421                         ndr->depth++;
11422                         if (r->info1542) {
11423                                 ndr_print_srvsvc_NetSrvInfo1542(ndr, "info1542", r->info1542);
11424                         }
11425                         ndr->depth--;
11426                 break;
11427
11428                 case 1543:
11429                         ndr_print_ptr(ndr, "info1543", r->info1543);
11430                         ndr->depth++;
11431                         if (r->info1543) {
11432                                 ndr_print_srvsvc_NetSrvInfo1543(ndr, "info1543", r->info1543);
11433                         }
11434                         ndr->depth--;
11435                 break;
11436
11437                 case 1544:
11438                         ndr_print_ptr(ndr, "info1544", r->info1544);
11439                         ndr->depth++;
11440                         if (r->info1544) {
11441                                 ndr_print_srvsvc_NetSrvInfo1544(ndr, "info1544", r->info1544);
11442                         }
11443                         ndr->depth--;
11444                 break;
11445
11446                 case 1545:
11447                         ndr_print_ptr(ndr, "info1545", r->info1545);
11448                         ndr->depth++;
11449                         if (r->info1545) {
11450                                 ndr_print_srvsvc_NetSrvInfo1545(ndr, "info1545", r->info1545);
11451                         }
11452                         ndr->depth--;
11453                 break;
11454
11455                 case 1546:
11456                         ndr_print_ptr(ndr, "info1546", r->info1546);
11457                         ndr->depth++;
11458                         if (r->info1546) {
11459                                 ndr_print_srvsvc_NetSrvInfo1546(ndr, "info1546", r->info1546);
11460                         }
11461                         ndr->depth--;
11462                 break;
11463
11464                 case 1547:
11465                         ndr_print_ptr(ndr, "info1547", r->info1547);
11466                         ndr->depth++;
11467                         if (r->info1547) {
11468                                 ndr_print_srvsvc_NetSrvInfo1547(ndr, "info1547", r->info1547);
11469                         }
11470                         ndr->depth--;
11471                 break;
11472
11473                 case 1548:
11474                         ndr_print_ptr(ndr, "info1548", r->info1548);
11475                         ndr->depth++;
11476                         if (r->info1548) {
11477                                 ndr_print_srvsvc_NetSrvInfo1548(ndr, "info1548", r->info1548);
11478                         }
11479                         ndr->depth--;
11480                 break;
11481
11482                 case 1549:
11483                         ndr_print_ptr(ndr, "info1549", r->info1549);
11484                         ndr->depth++;
11485                         if (r->info1549) {
11486                                 ndr_print_srvsvc_NetSrvInfo1549(ndr, "info1549", r->info1549);
11487                         }
11488                         ndr->depth--;
11489                 break;
11490
11491                 case 1550:
11492                         ndr_print_ptr(ndr, "info1550", r->info1550);
11493                         ndr->depth++;
11494                         if (r->info1550) {
11495                                 ndr_print_srvsvc_NetSrvInfo1550(ndr, "info1550", r->info1550);
11496                         }
11497                         ndr->depth--;
11498                 break;
11499
11500                 case 1552:
11501                         ndr_print_ptr(ndr, "info1552", r->info1552);
11502                         ndr->depth++;
11503                         if (r->info1552) {
11504                                 ndr_print_srvsvc_NetSrvInfo1552(ndr, "info1552", r->info1552);
11505                         }
11506                         ndr->depth--;
11507                 break;
11508
11509                 case 1553:
11510                         ndr_print_ptr(ndr, "info1553", r->info1553);
11511                         ndr->depth++;
11512                         if (r->info1553) {
11513                                 ndr_print_srvsvc_NetSrvInfo1553(ndr, "info1553", r->info1553);
11514                         }
11515                         ndr->depth--;
11516                 break;
11517
11518                 case 1554:
11519                         ndr_print_ptr(ndr, "info1554", r->info1554);
11520                         ndr->depth++;
11521                         if (r->info1554) {
11522                                 ndr_print_srvsvc_NetSrvInfo1554(ndr, "info1554", r->info1554);
11523                         }
11524                         ndr->depth--;
11525                 break;
11526
11527                 case 1555:
11528                         ndr_print_ptr(ndr, "info1555", r->info1555);
11529                         ndr->depth++;
11530                         if (r->info1555) {
11531                                 ndr_print_srvsvc_NetSrvInfo1555(ndr, "info1555", r->info1555);
11532                         }
11533                         ndr->depth--;
11534                 break;
11535
11536                 case 1556:
11537                         ndr_print_ptr(ndr, "info1556", r->info1556);
11538                         ndr->depth++;
11539                         if (r->info1556) {
11540                                 ndr_print_srvsvc_NetSrvInfo1556(ndr, "info1556", r->info1556);
11541                         }
11542                         ndr->depth--;
11543                 break;
11544
11545                 default:
11546                 break;
11547
11548         }
11549 }
11550
11551 static enum ndr_err_code ndr_push_srvsvc_NetDiskInfo0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetDiskInfo0 *r)
11552 {
11553         if (ndr_flags & NDR_SCALARS) {
11554                 NDR_CHECK(ndr_push_align(ndr, 4));
11555                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11556                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen(r->disk) + 1));
11557                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->disk, strlen(r->disk) + 1, sizeof(uint16_t), CH_UTF16));
11558         }
11559         if (ndr_flags & NDR_BUFFERS) {
11560         }
11561         return NDR_ERR_SUCCESS;
11562 }
11563
11564 static enum ndr_err_code ndr_pull_srvsvc_NetDiskInfo0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetDiskInfo0 *r)
11565 {
11566         if (ndr_flags & NDR_SCALARS) {
11567                 NDR_CHECK(ndr_pull_align(ndr, 4));
11568                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__disk_offset));
11569                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__disk_length));
11570                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->disk, r->__disk_length, sizeof(uint16_t), CH_UTF16));
11571         }
11572         if (ndr_flags & NDR_BUFFERS) {
11573         }
11574         return NDR_ERR_SUCCESS;
11575 }
11576
11577 _PUBLIC_ void ndr_print_srvsvc_NetDiskInfo0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetDiskInfo0 *r)
11578 {
11579         ndr_print_struct(ndr, name, "srvsvc_NetDiskInfo0");
11580         ndr->depth++;
11581         ndr_print_uint32(ndr, "__disk_offset", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->__disk_offset);
11582         ndr_print_uint32(ndr, "__disk_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen(r->disk) + 1:r->__disk_length);
11583         ndr_print_string(ndr, "disk", r->disk);
11584         ndr->depth--;
11585 }
11586
11587 static enum ndr_err_code ndr_push_srvsvc_NetDiskInfo(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetDiskInfo *r)
11588 {
11589         uint32_t cntr_disks_1;
11590         if (ndr_flags & NDR_SCALARS) {
11591                 NDR_CHECK(ndr_push_align(ndr, 4));
11592                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11593                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->disks));
11594         }
11595         if (ndr_flags & NDR_BUFFERS) {
11596                 if (r->disks) {
11597                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11598                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11599                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11600                         for (cntr_disks_1 = 0; cntr_disks_1 < r->count; cntr_disks_1++) {
11601                                 NDR_CHECK(ndr_push_srvsvc_NetDiskInfo0(ndr, NDR_SCALARS, &r->disks[cntr_disks_1]));
11602                         }
11603                 }
11604         }
11605         return NDR_ERR_SUCCESS;
11606 }
11607
11608 static enum ndr_err_code ndr_pull_srvsvc_NetDiskInfo(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetDiskInfo *r)
11609 {
11610         uint32_t _ptr_disks;
11611         uint32_t cntr_disks_1;
11612         TALLOC_CTX *_mem_save_disks_0;
11613         TALLOC_CTX *_mem_save_disks_1;
11614         if (ndr_flags & NDR_SCALARS) {
11615                 NDR_CHECK(ndr_pull_align(ndr, 4));
11616                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11617                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_disks));
11618                 if (_ptr_disks) {
11619                         NDR_PULL_ALLOC(ndr, r->disks);
11620                 } else {
11621                         r->disks = NULL;
11622                 }
11623         }
11624         if (ndr_flags & NDR_BUFFERS) {
11625                 if (r->disks) {
11626                         _mem_save_disks_0 = NDR_PULL_GET_MEM_CTX(ndr);
11627                         NDR_PULL_SET_MEM_CTX(ndr, r->disks, 0);
11628                         NDR_CHECK(ndr_pull_array_size(ndr, &r->disks));
11629                         NDR_CHECK(ndr_pull_array_length(ndr, &r->disks));
11630                         if (ndr_get_array_length(ndr, &r->disks) > ndr_get_array_size(ndr, &r->disks)) {
11631                                 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));
11632                         }
11633                         NDR_PULL_ALLOC_N(ndr, r->disks, ndr_get_array_size(ndr, &r->disks));
11634                         _mem_save_disks_1 = NDR_PULL_GET_MEM_CTX(ndr);
11635                         NDR_PULL_SET_MEM_CTX(ndr, r->disks, 0);
11636                         for (cntr_disks_1 = 0; cntr_disks_1 < r->count; cntr_disks_1++) {
11637                                 NDR_CHECK(ndr_pull_srvsvc_NetDiskInfo0(ndr, NDR_SCALARS, &r->disks[cntr_disks_1]));
11638                         }
11639                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_disks_1, 0);
11640                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_disks_0, 0);
11641                 }
11642                 if (r->disks) {
11643                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->disks, r->count));
11644                 }
11645                 if (r->disks) {
11646                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->disks, r->count));
11647                 }
11648         }
11649         return NDR_ERR_SUCCESS;
11650 }
11651
11652 _PUBLIC_ void ndr_print_srvsvc_NetDiskInfo(struct ndr_print *ndr, const char *name, const struct srvsvc_NetDiskInfo *r)
11653 {
11654         uint32_t cntr_disks_1;
11655         ndr_print_struct(ndr, name, "srvsvc_NetDiskInfo");
11656         ndr->depth++;
11657         ndr_print_uint32(ndr, "count", r->count);
11658         ndr_print_ptr(ndr, "disks", r->disks);
11659         ndr->depth++;
11660         if (r->disks) {
11661                 ndr->print(ndr, "%s: ARRAY(%d)", "disks", (int)r->count);
11662                 ndr->depth++;
11663                 for (cntr_disks_1=0;cntr_disks_1<r->count;cntr_disks_1++) {
11664                         char *idx_1=NULL;
11665                         if (asprintf(&idx_1, "[%d]", cntr_disks_1) != -1) {
11666                                 ndr_print_srvsvc_NetDiskInfo0(ndr, "disks", &r->disks[cntr_disks_1]);
11667                                 free(idx_1);
11668                         }
11669                 }
11670                 ndr->depth--;
11671         }
11672         ndr->depth--;
11673         ndr->depth--;
11674 }
11675
11676 static enum ndr_err_code ndr_push_srvsvc_Statistics(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_Statistics *r)
11677 {
11678         if (ndr_flags & NDR_SCALARS) {
11679                 NDR_CHECK(ndr_push_align(ndr, 4));
11680                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start));
11681                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->fopens));
11682                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->devopens));
11683                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->jobsqueued));
11684                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sopens));
11685                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->stimeouts));
11686                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->serrorout));
11687                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pwerrors));
11688                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->permerrors));
11689                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->syserrors));
11690                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bytessent_low));
11691                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bytessent_high));
11692                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bytesrcvd_low));
11693                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bytesrcvd_high));
11694                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->avresponse));
11695                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reqbufneed));
11696                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bigbufneed));
11697         }
11698         if (ndr_flags & NDR_BUFFERS) {
11699         }
11700         return NDR_ERR_SUCCESS;
11701 }
11702
11703 static enum ndr_err_code ndr_pull_srvsvc_Statistics(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_Statistics *r)
11704 {
11705         if (ndr_flags & NDR_SCALARS) {
11706                 NDR_CHECK(ndr_pull_align(ndr, 4));
11707                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start));
11708                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->fopens));
11709                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->devopens));
11710                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->jobsqueued));
11711                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sopens));
11712                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->stimeouts));
11713                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->serrorout));
11714                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pwerrors));
11715                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->permerrors));
11716                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->syserrors));
11717                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bytessent_low));
11718                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bytessent_high));
11719                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bytesrcvd_low));
11720                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bytesrcvd_high));
11721                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->avresponse));
11722                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reqbufneed));
11723                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bigbufneed));
11724         }
11725         if (ndr_flags & NDR_BUFFERS) {
11726         }
11727         return NDR_ERR_SUCCESS;
11728 }
11729
11730 _PUBLIC_ void ndr_print_srvsvc_Statistics(struct ndr_print *ndr, const char *name, const struct srvsvc_Statistics *r)
11731 {
11732         ndr_print_struct(ndr, name, "srvsvc_Statistics");
11733         ndr->depth++;
11734         ndr_print_uint32(ndr, "start", r->start);
11735         ndr_print_uint32(ndr, "fopens", r->fopens);
11736         ndr_print_uint32(ndr, "devopens", r->devopens);
11737         ndr_print_uint32(ndr, "jobsqueued", r->jobsqueued);
11738         ndr_print_uint32(ndr, "sopens", r->sopens);
11739         ndr_print_uint32(ndr, "stimeouts", r->stimeouts);
11740         ndr_print_uint32(ndr, "serrorout", r->serrorout);
11741         ndr_print_uint32(ndr, "pwerrors", r->pwerrors);
11742         ndr_print_uint32(ndr, "permerrors", r->permerrors);
11743         ndr_print_uint32(ndr, "syserrors", r->syserrors);
11744         ndr_print_uint32(ndr, "bytessent_low", r->bytessent_low);
11745         ndr_print_uint32(ndr, "bytessent_high", r->bytessent_high);
11746         ndr_print_uint32(ndr, "bytesrcvd_low", r->bytesrcvd_low);
11747         ndr_print_uint32(ndr, "bytesrcvd_high", r->bytesrcvd_high);
11748         ndr_print_uint32(ndr, "avresponse", r->avresponse);
11749         ndr_print_uint32(ndr, "reqbufneed", r->reqbufneed);
11750         ndr_print_uint32(ndr, "bigbufneed", r->bigbufneed);
11751         ndr->depth--;
11752 }
11753
11754 static enum ndr_err_code ndr_push_srvsvc_NetTransportInfo0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportInfo0 *r)
11755 {
11756         if (ndr_flags & NDR_SCALARS) {
11757                 NDR_CHECK(ndr_push_align(ndr, 4));
11758                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->vcs));
11759                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
11760                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->addr));
11761                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->addr_len));
11762                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->net_addr));
11763         }
11764         if (ndr_flags & NDR_BUFFERS) {
11765                 if (r->name) {
11766                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
11767                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11768                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
11769                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11770                 }
11771                 if (r->addr) {
11772                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->addr_len));
11773                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->addr, r->addr_len));
11774                 }
11775                 if (r->net_addr) {
11776                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->net_addr, CH_UTF16)));
11777                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11778                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->net_addr, CH_UTF16)));
11779                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->net_addr, ndr_charset_length(r->net_addr, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11780                 }
11781         }
11782         return NDR_ERR_SUCCESS;
11783 }
11784
11785 static enum ndr_err_code ndr_pull_srvsvc_NetTransportInfo0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportInfo0 *r)
11786 {
11787         uint32_t _ptr_name;
11788         TALLOC_CTX *_mem_save_name_0;
11789         uint32_t _ptr_addr;
11790         TALLOC_CTX *_mem_save_addr_0;
11791         uint32_t _ptr_net_addr;
11792         TALLOC_CTX *_mem_save_net_addr_0;
11793         if (ndr_flags & NDR_SCALARS) {
11794                 NDR_CHECK(ndr_pull_align(ndr, 4));
11795                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->vcs));
11796                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
11797                 if (_ptr_name) {
11798                         NDR_PULL_ALLOC(ndr, r->name);
11799                 } else {
11800                         r->name = NULL;
11801                 }
11802                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_addr));
11803                 if (_ptr_addr) {
11804                         NDR_PULL_ALLOC(ndr, r->addr);
11805                 } else {
11806                         r->addr = NULL;
11807                 }
11808                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->addr_len));
11809                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_net_addr));
11810                 if (_ptr_net_addr) {
11811                         NDR_PULL_ALLOC(ndr, r->net_addr);
11812                 } else {
11813                         r->net_addr = NULL;
11814                 }
11815         }
11816         if (ndr_flags & NDR_BUFFERS) {
11817                 if (r->name) {
11818                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11819                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
11820                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
11821                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
11822                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
11823                                 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));
11824                         }
11825                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
11826                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
11827                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
11828                 }
11829                 if (r->addr) {
11830                         _mem_save_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);
11831                         NDR_PULL_SET_MEM_CTX(ndr, r->addr, 0);
11832                         NDR_CHECK(ndr_pull_array_size(ndr, &r->addr));
11833                         NDR_PULL_ALLOC_N(ndr, r->addr, ndr_get_array_size(ndr, &r->addr));
11834                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->addr, ndr_get_array_size(ndr, &r->addr)));
11835                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_addr_0, 0);
11836                 }
11837                 if (r->net_addr) {
11838                         _mem_save_net_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);
11839                         NDR_PULL_SET_MEM_CTX(ndr, r->net_addr, 0);
11840                         NDR_CHECK(ndr_pull_array_size(ndr, &r->net_addr));
11841                         NDR_CHECK(ndr_pull_array_length(ndr, &r->net_addr));
11842                         if (ndr_get_array_length(ndr, &r->net_addr) > ndr_get_array_size(ndr, &r->net_addr)) {
11843                                 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));
11844                         }
11845                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->net_addr), sizeof(uint16_t)));
11846                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->net_addr, ndr_get_array_length(ndr, &r->net_addr), sizeof(uint16_t), CH_UTF16));
11847                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_net_addr_0, 0);
11848                 }
11849                 if (r->addr) {
11850                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->addr, r->addr_len));
11851                 }
11852         }
11853         return NDR_ERR_SUCCESS;
11854 }
11855
11856 _PUBLIC_ void ndr_print_srvsvc_NetTransportInfo0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportInfo0 *r)
11857 {
11858         ndr_print_struct(ndr, name, "srvsvc_NetTransportInfo0");
11859         ndr->depth++;
11860         ndr_print_uint32(ndr, "vcs", r->vcs);
11861         ndr_print_ptr(ndr, "name", r->name);
11862         ndr->depth++;
11863         if (r->name) {
11864                 ndr_print_string(ndr, "name", r->name);
11865         }
11866         ndr->depth--;
11867         ndr_print_ptr(ndr, "addr", r->addr);
11868         ndr->depth++;
11869         if (r->addr) {
11870                 ndr_print_array_uint8(ndr, "addr", r->addr, r->addr_len);
11871         }
11872         ndr->depth--;
11873         ndr_print_uint32(ndr, "addr_len", r->addr_len);
11874         ndr_print_ptr(ndr, "net_addr", r->net_addr);
11875         ndr->depth++;
11876         if (r->net_addr) {
11877                 ndr_print_string(ndr, "net_addr", r->net_addr);
11878         }
11879         ndr->depth--;
11880         ndr->depth--;
11881 }
11882
11883 static enum ndr_err_code ndr_push_srvsvc_NetTransportCtr0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportCtr0 *r)
11884 {
11885         uint32_t cntr_array_1;
11886         if (ndr_flags & NDR_SCALARS) {
11887                 NDR_CHECK(ndr_push_align(ndr, 4));
11888                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11889                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
11890         }
11891         if (ndr_flags & NDR_BUFFERS) {
11892                 if (r->array) {
11893                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11894                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
11895                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
11896                         }
11897                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
11898                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
11899                         }
11900                 }
11901         }
11902         return NDR_ERR_SUCCESS;
11903 }
11904
11905 static enum ndr_err_code ndr_pull_srvsvc_NetTransportCtr0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportCtr0 *r)
11906 {
11907         uint32_t _ptr_array;
11908         uint32_t cntr_array_1;
11909         TALLOC_CTX *_mem_save_array_0;
11910         TALLOC_CTX *_mem_save_array_1;
11911         if (ndr_flags & NDR_SCALARS) {
11912                 NDR_CHECK(ndr_pull_align(ndr, 4));
11913                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11914                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
11915                 if (_ptr_array) {
11916                         NDR_PULL_ALLOC(ndr, r->array);
11917                 } else {
11918                         r->array = NULL;
11919                 }
11920         }
11921         if (ndr_flags & NDR_BUFFERS) {
11922                 if (r->array) {
11923                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11924                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11925                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11926                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11927                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
11928                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11929                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
11930                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
11931                         }
11932                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
11933                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
11934                         }
11935                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
11936                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11937                 }
11938                 if (r->array) {
11939                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11940                 }
11941         }
11942         return NDR_ERR_SUCCESS;
11943 }
11944
11945 _PUBLIC_ void ndr_print_srvsvc_NetTransportCtr0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportCtr0 *r)
11946 {
11947         uint32_t cntr_array_1;
11948         ndr_print_struct(ndr, name, "srvsvc_NetTransportCtr0");
11949         ndr->depth++;
11950         ndr_print_uint32(ndr, "count", r->count);
11951         ndr_print_ptr(ndr, "array", r->array);
11952         ndr->depth++;
11953         if (r->array) {
11954                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11955                 ndr->depth++;
11956                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
11957                         char *idx_1=NULL;
11958                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
11959                                 ndr_print_srvsvc_NetTransportInfo0(ndr, "array", &r->array[cntr_array_1]);
11960                                 free(idx_1);
11961                         }
11962                 }
11963                 ndr->depth--;
11964         }
11965         ndr->depth--;
11966         ndr->depth--;
11967 }
11968
11969 static enum ndr_err_code ndr_push_srvsvc_NetTransportInfo1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportInfo1 *r)
11970 {
11971         if (ndr_flags & NDR_SCALARS) {
11972                 NDR_CHECK(ndr_push_align(ndr, 4));
11973                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->vcs));
11974                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
11975                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->addr));
11976                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->addr_len));
11977                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->net_addr));
11978                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
11979         }
11980         if (ndr_flags & NDR_BUFFERS) {
11981                 if (r->name) {
11982                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
11983                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11984                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
11985                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11986                 }
11987                 if (r->addr) {
11988                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->addr_len));
11989                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->addr, r->addr_len));
11990                 }
11991                 if (r->net_addr) {
11992                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->net_addr, CH_UTF16)));
11993                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11994                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->net_addr, CH_UTF16)));
11995                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->net_addr, ndr_charset_length(r->net_addr, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11996                 }
11997                 if (r->domain) {
11998                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
11999                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12000                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
12001                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain, ndr_charset_length(r->domain, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12002                 }
12003         }
12004         return NDR_ERR_SUCCESS;
12005 }
12006
12007 static enum ndr_err_code ndr_pull_srvsvc_NetTransportInfo1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportInfo1 *r)
12008 {
12009         uint32_t _ptr_name;
12010         TALLOC_CTX *_mem_save_name_0;
12011         uint32_t _ptr_addr;
12012         TALLOC_CTX *_mem_save_addr_0;
12013         uint32_t _ptr_net_addr;
12014         TALLOC_CTX *_mem_save_net_addr_0;
12015         uint32_t _ptr_domain;
12016         TALLOC_CTX *_mem_save_domain_0;
12017         if (ndr_flags & NDR_SCALARS) {
12018                 NDR_CHECK(ndr_pull_align(ndr, 4));
12019                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->vcs));
12020                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
12021                 if (_ptr_name) {
12022                         NDR_PULL_ALLOC(ndr, r->name);
12023                 } else {
12024                         r->name = NULL;
12025                 }
12026                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_addr));
12027                 if (_ptr_addr) {
12028                         NDR_PULL_ALLOC(ndr, r->addr);
12029                 } else {
12030                         r->addr = NULL;
12031                 }
12032                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->addr_len));
12033                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_net_addr));
12034                 if (_ptr_net_addr) {
12035                         NDR_PULL_ALLOC(ndr, r->net_addr);
12036                 } else {
12037                         r->net_addr = NULL;
12038                 }
12039                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
12040                 if (_ptr_domain) {
12041                         NDR_PULL_ALLOC(ndr, r->domain);
12042                 } else {
12043                         r->domain = NULL;
12044                 }
12045         }
12046         if (ndr_flags & NDR_BUFFERS) {
12047                 if (r->name) {
12048                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12049                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
12050                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
12051                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
12052                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
12053                                 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));
12054                         }
12055                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
12056                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
12057                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
12058                 }
12059                 if (r->addr) {
12060                         _mem_save_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);
12061                         NDR_PULL_SET_MEM_CTX(ndr, r->addr, 0);
12062                         NDR_CHECK(ndr_pull_array_size(ndr, &r->addr));
12063                         NDR_PULL_ALLOC_N(ndr, r->addr, ndr_get_array_size(ndr, &r->addr));
12064                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->addr, ndr_get_array_size(ndr, &r->addr)));
12065                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_addr_0, 0);
12066                 }
12067                 if (r->net_addr) {
12068                         _mem_save_net_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);
12069                         NDR_PULL_SET_MEM_CTX(ndr, r->net_addr, 0);
12070                         NDR_CHECK(ndr_pull_array_size(ndr, &r->net_addr));
12071                         NDR_CHECK(ndr_pull_array_length(ndr, &r->net_addr));
12072                         if (ndr_get_array_length(ndr, &r->net_addr) > ndr_get_array_size(ndr, &r->net_addr)) {
12073                                 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));
12074                         }
12075                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->net_addr), sizeof(uint16_t)));
12076                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->net_addr, ndr_get_array_length(ndr, &r->net_addr), sizeof(uint16_t), CH_UTF16));
12077                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_net_addr_0, 0);
12078                 }
12079                 if (r->domain) {
12080                         _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
12081                         NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);
12082                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain));
12083                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain));
12084                         if (ndr_get_array_length(ndr, &r->domain) > ndr_get_array_size(ndr, &r->domain)) {
12085                                 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));
12086                         }
12087                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t)));
12088                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t), CH_UTF16));
12089                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);
12090                 }
12091                 if (r->addr) {
12092                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->addr, r->addr_len));
12093                 }
12094         }
12095         return NDR_ERR_SUCCESS;
12096 }
12097
12098 _PUBLIC_ void ndr_print_srvsvc_NetTransportInfo1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportInfo1 *r)
12099 {
12100         ndr_print_struct(ndr, name, "srvsvc_NetTransportInfo1");
12101         ndr->depth++;
12102         ndr_print_uint32(ndr, "vcs", r->vcs);
12103         ndr_print_ptr(ndr, "name", r->name);
12104         ndr->depth++;
12105         if (r->name) {
12106                 ndr_print_string(ndr, "name", r->name);
12107         }
12108         ndr->depth--;
12109         ndr_print_ptr(ndr, "addr", r->addr);
12110         ndr->depth++;
12111         if (r->addr) {
12112                 ndr_print_array_uint8(ndr, "addr", r->addr, r->addr_len);
12113         }
12114         ndr->depth--;
12115         ndr_print_uint32(ndr, "addr_len", r->addr_len);
12116         ndr_print_ptr(ndr, "net_addr", r->net_addr);
12117         ndr->depth++;
12118         if (r->net_addr) {
12119                 ndr_print_string(ndr, "net_addr", r->net_addr);
12120         }
12121         ndr->depth--;
12122         ndr_print_ptr(ndr, "domain", r->domain);
12123         ndr->depth++;
12124         if (r->domain) {
12125                 ndr_print_string(ndr, "domain", r->domain);
12126         }
12127         ndr->depth--;
12128         ndr->depth--;
12129 }
12130
12131 static enum ndr_err_code ndr_push_srvsvc_NetTransportCtr1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportCtr1 *r)
12132 {
12133         uint32_t cntr_array_1;
12134         if (ndr_flags & NDR_SCALARS) {
12135                 NDR_CHECK(ndr_push_align(ndr, 4));
12136                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
12137                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
12138         }
12139         if (ndr_flags & NDR_BUFFERS) {
12140                 if (r->array) {
12141                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
12142                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
12143                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
12144                         }
12145                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
12146                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
12147                         }
12148                 }
12149         }
12150         return NDR_ERR_SUCCESS;
12151 }
12152
12153 static enum ndr_err_code ndr_pull_srvsvc_NetTransportCtr1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportCtr1 *r)
12154 {
12155         uint32_t _ptr_array;
12156         uint32_t cntr_array_1;
12157         TALLOC_CTX *_mem_save_array_0;
12158         TALLOC_CTX *_mem_save_array_1;
12159         if (ndr_flags & NDR_SCALARS) {
12160                 NDR_CHECK(ndr_pull_align(ndr, 4));
12161                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
12162                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
12163                 if (_ptr_array) {
12164                         NDR_PULL_ALLOC(ndr, r->array);
12165                 } else {
12166                         r->array = NULL;
12167                 }
12168         }
12169         if (ndr_flags & NDR_BUFFERS) {
12170                 if (r->array) {
12171                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12172                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
12173                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
12174                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
12175                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
12176                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
12177                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
12178                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
12179                         }
12180                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
12181                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
12182                         }
12183                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
12184                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
12185                 }
12186                 if (r->array) {
12187                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
12188                 }
12189         }
12190         return NDR_ERR_SUCCESS;
12191 }
12192
12193 _PUBLIC_ void ndr_print_srvsvc_NetTransportCtr1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportCtr1 *r)
12194 {
12195         uint32_t cntr_array_1;
12196         ndr_print_struct(ndr, name, "srvsvc_NetTransportCtr1");
12197         ndr->depth++;
12198         ndr_print_uint32(ndr, "count", r->count);
12199         ndr_print_ptr(ndr, "array", r->array);
12200         ndr->depth++;
12201         if (r->array) {
12202                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
12203                 ndr->depth++;
12204                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
12205                         char *idx_1=NULL;
12206                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
12207                                 ndr_print_srvsvc_NetTransportInfo1(ndr, "array", &r->array[cntr_array_1]);
12208                                 free(idx_1);
12209                         }
12210                 }
12211                 ndr->depth--;
12212         }
12213         ndr->depth--;
12214         ndr->depth--;
12215 }
12216
12217 static enum ndr_err_code ndr_push_srvsvc_NetTransportInfo2(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportInfo2 *r)
12218 {
12219         if (ndr_flags & NDR_SCALARS) {
12220                 NDR_CHECK(ndr_push_align(ndr, 4));
12221                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->vcs));
12222                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
12223                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->addr));
12224                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->addr_len));
12225                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->net_addr));
12226                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
12227                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
12228         }
12229         if (ndr_flags & NDR_BUFFERS) {
12230                 if (r->name) {
12231                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
12232                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12233                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
12234                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12235                 }
12236                 if (r->addr) {
12237                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->addr_len));
12238                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->addr, r->addr_len));
12239                 }
12240                 if (r->net_addr) {
12241                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->net_addr, CH_UTF16)));
12242                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12243                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->net_addr, CH_UTF16)));
12244                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->net_addr, ndr_charset_length(r->net_addr, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12245                 }
12246                 if (r->domain) {
12247                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
12248                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12249                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
12250                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain, ndr_charset_length(r->domain, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12251                 }
12252         }
12253         return NDR_ERR_SUCCESS;
12254 }
12255
12256 static enum ndr_err_code ndr_pull_srvsvc_NetTransportInfo2(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportInfo2 *r)
12257 {
12258         uint32_t _ptr_name;
12259         TALLOC_CTX *_mem_save_name_0;
12260         uint32_t _ptr_addr;
12261         TALLOC_CTX *_mem_save_addr_0;
12262         uint32_t _ptr_net_addr;
12263         TALLOC_CTX *_mem_save_net_addr_0;
12264         uint32_t _ptr_domain;
12265         TALLOC_CTX *_mem_save_domain_0;
12266         if (ndr_flags & NDR_SCALARS) {
12267                 NDR_CHECK(ndr_pull_align(ndr, 4));
12268                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->vcs));
12269                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
12270                 if (_ptr_name) {
12271                         NDR_PULL_ALLOC(ndr, r->name);
12272                 } else {
12273                         r->name = NULL;
12274                 }
12275                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_addr));
12276                 if (_ptr_addr) {
12277                         NDR_PULL_ALLOC(ndr, r->addr);
12278                 } else {
12279                         r->addr = NULL;
12280                 }
12281                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->addr_len));
12282                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_net_addr));
12283                 if (_ptr_net_addr) {
12284                         NDR_PULL_ALLOC(ndr, r->net_addr);
12285                 } else {
12286                         r->net_addr = NULL;
12287                 }
12288                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
12289                 if (_ptr_domain) {
12290                         NDR_PULL_ALLOC(ndr, r->domain);
12291                 } else {
12292                         r->domain = NULL;
12293                 }
12294                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
12295         }
12296         if (ndr_flags & NDR_BUFFERS) {
12297                 if (r->name) {
12298                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12299                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
12300                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
12301                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
12302                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
12303                                 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));
12304                         }
12305                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
12306                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
12307                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
12308                 }
12309                 if (r->addr) {
12310                         _mem_save_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);
12311                         NDR_PULL_SET_MEM_CTX(ndr, r->addr, 0);
12312                         NDR_CHECK(ndr_pull_array_size(ndr, &r->addr));
12313                         NDR_PULL_ALLOC_N(ndr, r->addr, ndr_get_array_size(ndr, &r->addr));
12314                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->addr, ndr_get_array_size(ndr, &r->addr)));
12315                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_addr_0, 0);
12316                 }
12317                 if (r->net_addr) {
12318                         _mem_save_net_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);
12319                         NDR_PULL_SET_MEM_CTX(ndr, r->net_addr, 0);
12320                         NDR_CHECK(ndr_pull_array_size(ndr, &r->net_addr));
12321                         NDR_CHECK(ndr_pull_array_length(ndr, &r->net_addr));
12322                         if (ndr_get_array_length(ndr, &r->net_addr) > ndr_get_array_size(ndr, &r->net_addr)) {
12323                                 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));
12324                         }
12325                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->net_addr), sizeof(uint16_t)));
12326                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->net_addr, ndr_get_array_length(ndr, &r->net_addr), sizeof(uint16_t), CH_UTF16));
12327                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_net_addr_0, 0);
12328                 }
12329                 if (r->domain) {
12330                         _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
12331                         NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);
12332                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain));
12333                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain));
12334                         if (ndr_get_array_length(ndr, &r->domain) > ndr_get_array_size(ndr, &r->domain)) {
12335                                 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));
12336                         }
12337                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t)));
12338                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t), CH_UTF16));
12339                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);
12340                 }
12341                 if (r->addr) {
12342                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->addr, r->addr_len));
12343                 }
12344         }
12345         return NDR_ERR_SUCCESS;
12346 }
12347
12348 _PUBLIC_ void ndr_print_srvsvc_NetTransportInfo2(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportInfo2 *r)
12349 {
12350         ndr_print_struct(ndr, name, "srvsvc_NetTransportInfo2");
12351         ndr->depth++;
12352         ndr_print_uint32(ndr, "vcs", r->vcs);
12353         ndr_print_ptr(ndr, "name", r->name);
12354         ndr->depth++;
12355         if (r->name) {
12356                 ndr_print_string(ndr, "name", r->name);
12357         }
12358         ndr->depth--;
12359         ndr_print_ptr(ndr, "addr", r->addr);
12360         ndr->depth++;
12361         if (r->addr) {
12362                 ndr_print_array_uint8(ndr, "addr", r->addr, r->addr_len);
12363         }
12364         ndr->depth--;
12365         ndr_print_uint32(ndr, "addr_len", r->addr_len);
12366         ndr_print_ptr(ndr, "net_addr", r->net_addr);
12367         ndr->depth++;
12368         if (r->net_addr) {
12369                 ndr_print_string(ndr, "net_addr", r->net_addr);
12370         }
12371         ndr->depth--;
12372         ndr_print_ptr(ndr, "domain", r->domain);
12373         ndr->depth++;
12374         if (r->domain) {
12375                 ndr_print_string(ndr, "domain", r->domain);
12376         }
12377         ndr->depth--;
12378         ndr_print_uint32(ndr, "unknown", r->unknown);
12379         ndr->depth--;
12380 }
12381
12382 static enum ndr_err_code ndr_push_srvsvc_NetTransportCtr2(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportCtr2 *r)
12383 {
12384         uint32_t cntr_array_1;
12385         if (ndr_flags & NDR_SCALARS) {
12386                 NDR_CHECK(ndr_push_align(ndr, 4));
12387                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
12388                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
12389         }
12390         if (ndr_flags & NDR_BUFFERS) {
12391                 if (r->array) {
12392                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
12393                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
12394                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
12395                         }
12396                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
12397                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
12398                         }
12399                 }
12400         }
12401         return NDR_ERR_SUCCESS;
12402 }
12403
12404 static enum ndr_err_code ndr_pull_srvsvc_NetTransportCtr2(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportCtr2 *r)
12405 {
12406         uint32_t _ptr_array;
12407         uint32_t cntr_array_1;
12408         TALLOC_CTX *_mem_save_array_0;
12409         TALLOC_CTX *_mem_save_array_1;
12410         if (ndr_flags & NDR_SCALARS) {
12411                 NDR_CHECK(ndr_pull_align(ndr, 4));
12412                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
12413                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
12414                 if (_ptr_array) {
12415                         NDR_PULL_ALLOC(ndr, r->array);
12416                 } else {
12417                         r->array = NULL;
12418                 }
12419         }
12420         if (ndr_flags & NDR_BUFFERS) {
12421                 if (r->array) {
12422                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12423                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
12424                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
12425                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
12426                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
12427                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
12428                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
12429                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
12430                         }
12431                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
12432                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
12433                         }
12434                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
12435                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
12436                 }
12437                 if (r->array) {
12438                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
12439                 }
12440         }
12441         return NDR_ERR_SUCCESS;
12442 }
12443
12444 _PUBLIC_ void ndr_print_srvsvc_NetTransportCtr2(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportCtr2 *r)
12445 {
12446         uint32_t cntr_array_1;
12447         ndr_print_struct(ndr, name, "srvsvc_NetTransportCtr2");
12448         ndr->depth++;
12449         ndr_print_uint32(ndr, "count", r->count);
12450         ndr_print_ptr(ndr, "array", r->array);
12451         ndr->depth++;
12452         if (r->array) {
12453                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
12454                 ndr->depth++;
12455                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
12456                         char *idx_1=NULL;
12457                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
12458                                 ndr_print_srvsvc_NetTransportInfo2(ndr, "array", &r->array[cntr_array_1]);
12459                                 free(idx_1);
12460                         }
12461                 }
12462                 ndr->depth--;
12463         }
12464         ndr->depth--;
12465         ndr->depth--;
12466 }
12467
12468 static enum ndr_err_code ndr_push_srvsvc_NetTransportInfo3(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportInfo3 *r)
12469 {
12470         if (ndr_flags & NDR_SCALARS) {
12471                 NDR_CHECK(ndr_push_align(ndr, 4));
12472                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->vcs));
12473                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
12474                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->addr));
12475                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->addr_len));
12476                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->net_addr));
12477                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
12478                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
12479                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
12480                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->unknown3, 256));
12481         }
12482         if (ndr_flags & NDR_BUFFERS) {
12483                 if (r->name) {
12484                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
12485                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12486                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
12487                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12488                 }
12489                 if (r->addr) {
12490                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->addr_len));
12491                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->addr, r->addr_len));
12492                 }
12493                 if (r->net_addr) {
12494                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->net_addr, CH_UTF16)));
12495                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12496                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->net_addr, CH_UTF16)));
12497                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->net_addr, ndr_charset_length(r->net_addr, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12498                 }
12499                 if (r->domain) {
12500                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
12501                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12502                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
12503                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain, ndr_charset_length(r->domain, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12504                 }
12505         }
12506         return NDR_ERR_SUCCESS;
12507 }
12508
12509 static enum ndr_err_code ndr_pull_srvsvc_NetTransportInfo3(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportInfo3 *r)
12510 {
12511         uint32_t _ptr_name;
12512         TALLOC_CTX *_mem_save_name_0;
12513         uint32_t _ptr_addr;
12514         TALLOC_CTX *_mem_save_addr_0;
12515         uint32_t _ptr_net_addr;
12516         TALLOC_CTX *_mem_save_net_addr_0;
12517         uint32_t _ptr_domain;
12518         TALLOC_CTX *_mem_save_domain_0;
12519         if (ndr_flags & NDR_SCALARS) {
12520                 NDR_CHECK(ndr_pull_align(ndr, 4));
12521                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->vcs));
12522                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
12523                 if (_ptr_name) {
12524                         NDR_PULL_ALLOC(ndr, r->name);
12525                 } else {
12526                         r->name = NULL;
12527                 }
12528                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_addr));
12529                 if (_ptr_addr) {
12530                         NDR_PULL_ALLOC(ndr, r->addr);
12531                 } else {
12532                         r->addr = NULL;
12533                 }
12534                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->addr_len));
12535                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_net_addr));
12536                 if (_ptr_net_addr) {
12537                         NDR_PULL_ALLOC(ndr, r->net_addr);
12538                 } else {
12539                         r->net_addr = NULL;
12540                 }
12541                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
12542                 if (_ptr_domain) {
12543                         NDR_PULL_ALLOC(ndr, r->domain);
12544                 } else {
12545                         r->domain = NULL;
12546                 }
12547                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
12548                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
12549                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->unknown3, 256));
12550         }
12551         if (ndr_flags & NDR_BUFFERS) {
12552                 if (r->name) {
12553                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12554                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
12555                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
12556                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
12557                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
12558                                 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));
12559                         }
12560                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
12561                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
12562                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
12563                 }
12564                 if (r->addr) {
12565                         _mem_save_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);
12566                         NDR_PULL_SET_MEM_CTX(ndr, r->addr, 0);
12567                         NDR_CHECK(ndr_pull_array_size(ndr, &r->addr));
12568                         NDR_PULL_ALLOC_N(ndr, r->addr, ndr_get_array_size(ndr, &r->addr));
12569                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->addr, ndr_get_array_size(ndr, &r->addr)));
12570                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_addr_0, 0);
12571                 }
12572                 if (r->net_addr) {
12573                         _mem_save_net_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);
12574                         NDR_PULL_SET_MEM_CTX(ndr, r->net_addr, 0);
12575                         NDR_CHECK(ndr_pull_array_size(ndr, &r->net_addr));
12576                         NDR_CHECK(ndr_pull_array_length(ndr, &r->net_addr));
12577                         if (ndr_get_array_length(ndr, &r->net_addr) > ndr_get_array_size(ndr, &r->net_addr)) {
12578                                 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));
12579                         }
12580                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->net_addr), sizeof(uint16_t)));
12581                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->net_addr, ndr_get_array_length(ndr, &r->net_addr), sizeof(uint16_t), CH_UTF16));
12582                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_net_addr_0, 0);
12583                 }
12584                 if (r->domain) {
12585                         _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
12586                         NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);
12587                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain));
12588                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain));
12589                         if (ndr_get_array_length(ndr, &r->domain) > ndr_get_array_size(ndr, &r->domain)) {
12590                                 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));
12591                         }
12592                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t)));
12593                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t), CH_UTF16));
12594                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);
12595                 }
12596                 if (r->addr) {
12597                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->addr, r->addr_len));
12598                 }
12599         }
12600         return NDR_ERR_SUCCESS;
12601 }
12602
12603 _PUBLIC_ void ndr_print_srvsvc_NetTransportInfo3(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportInfo3 *r)
12604 {
12605         ndr_print_struct(ndr, name, "srvsvc_NetTransportInfo3");
12606         ndr->depth++;
12607         ndr_print_uint32(ndr, "vcs", r->vcs);
12608         ndr_print_ptr(ndr, "name", r->name);
12609         ndr->depth++;
12610         if (r->name) {
12611                 ndr_print_string(ndr, "name", r->name);
12612         }
12613         ndr->depth--;
12614         ndr_print_ptr(ndr, "addr", r->addr);
12615         ndr->depth++;
12616         if (r->addr) {
12617                 ndr_print_array_uint8(ndr, "addr", r->addr, r->addr_len);
12618         }
12619         ndr->depth--;
12620         ndr_print_uint32(ndr, "addr_len", r->addr_len);
12621         ndr_print_ptr(ndr, "net_addr", r->net_addr);
12622         ndr->depth++;
12623         if (r->net_addr) {
12624                 ndr_print_string(ndr, "net_addr", r->net_addr);
12625         }
12626         ndr->depth--;
12627         ndr_print_ptr(ndr, "domain", r->domain);
12628         ndr->depth++;
12629         if (r->domain) {
12630                 ndr_print_string(ndr, "domain", r->domain);
12631         }
12632         ndr->depth--;
12633         ndr_print_uint32(ndr, "unknown1", r->unknown1);
12634         ndr_print_uint32(ndr, "unknown2", r->unknown2);
12635         ndr_print_array_uint8(ndr, "unknown3", r->unknown3, 256);
12636         ndr->depth--;
12637 }
12638
12639 static enum ndr_err_code ndr_push_srvsvc_NetTransportCtr3(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportCtr3 *r)
12640 {
12641         uint32_t cntr_array_1;
12642         if (ndr_flags & NDR_SCALARS) {
12643                 NDR_CHECK(ndr_push_align(ndr, 4));
12644                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
12645                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
12646         }
12647         if (ndr_flags & NDR_BUFFERS) {
12648                 if (r->array) {
12649                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
12650                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
12651                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
12652                         }
12653                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
12654                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
12655                         }
12656                 }
12657         }
12658         return NDR_ERR_SUCCESS;
12659 }
12660
12661 static enum ndr_err_code ndr_pull_srvsvc_NetTransportCtr3(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportCtr3 *r)
12662 {
12663         uint32_t _ptr_array;
12664         uint32_t cntr_array_1;
12665         TALLOC_CTX *_mem_save_array_0;
12666         TALLOC_CTX *_mem_save_array_1;
12667         if (ndr_flags & NDR_SCALARS) {
12668                 NDR_CHECK(ndr_pull_align(ndr, 4));
12669                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
12670                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
12671                 if (_ptr_array) {
12672                         NDR_PULL_ALLOC(ndr, r->array);
12673                 } else {
12674                         r->array = NULL;
12675                 }
12676         }
12677         if (ndr_flags & NDR_BUFFERS) {
12678                 if (r->array) {
12679                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12680                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
12681                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
12682                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
12683                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
12684                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
12685                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
12686                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
12687                         }
12688                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
12689                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
12690                         }
12691                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
12692                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
12693                 }
12694                 if (r->array) {
12695                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
12696                 }
12697         }
12698         return NDR_ERR_SUCCESS;
12699 }
12700
12701 _PUBLIC_ void ndr_print_srvsvc_NetTransportCtr3(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportCtr3 *r)
12702 {
12703         uint32_t cntr_array_1;
12704         ndr_print_struct(ndr, name, "srvsvc_NetTransportCtr3");
12705         ndr->depth++;
12706         ndr_print_uint32(ndr, "count", r->count);
12707         ndr_print_ptr(ndr, "array", r->array);
12708         ndr->depth++;
12709         if (r->array) {
12710                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
12711                 ndr->depth++;
12712                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
12713                         char *idx_1=NULL;
12714                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
12715                                 ndr_print_srvsvc_NetTransportInfo3(ndr, "array", &r->array[cntr_array_1]);
12716                                 free(idx_1);
12717                         }
12718                 }
12719                 ndr->depth--;
12720         }
12721         ndr->depth--;
12722         ndr->depth--;
12723 }
12724
12725 static enum ndr_err_code ndr_push_srvsvc_NetTransportCtr(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetTransportCtr *r)
12726 {
12727         if (ndr_flags & NDR_SCALARS) {
12728                 int level = ndr_push_get_switch_value(ndr, r);
12729                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
12730                 switch (level) {
12731                         case 0: {
12732                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
12733                         break; }
12734
12735                         case 1: {
12736                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
12737                         break; }
12738
12739                         case 2: {
12740                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr2));
12741                         break; }
12742
12743                         case 3: {
12744                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr3));
12745                         break; }
12746
12747                         default: {
12748                         break; }
12749
12750                 }
12751         }
12752         if (ndr_flags & NDR_BUFFERS) {
12753                 int level = ndr_push_get_switch_value(ndr, r);
12754                 switch (level) {
12755                         case 0:
12756                                 if (r->ctr0) {
12757                                         NDR_CHECK(ndr_push_srvsvc_NetTransportCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
12758                                 }
12759                         break;
12760
12761                         case 1:
12762                                 if (r->ctr1) {
12763                                         NDR_CHECK(ndr_push_srvsvc_NetTransportCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
12764                                 }
12765                         break;
12766
12767                         case 2:
12768                                 if (r->ctr2) {
12769                                         NDR_CHECK(ndr_push_srvsvc_NetTransportCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
12770                                 }
12771                         break;
12772
12773                         case 3:
12774                                 if (r->ctr3) {
12775                                         NDR_CHECK(ndr_push_srvsvc_NetTransportCtr3(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr3));
12776                                 }
12777                         break;
12778
12779                         default:
12780                         break;
12781
12782                 }
12783         }
12784         return NDR_ERR_SUCCESS;
12785 }
12786
12787 static enum ndr_err_code ndr_pull_srvsvc_NetTransportCtr(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetTransportCtr *r)
12788 {
12789         int level;
12790         uint32_t _level;
12791         TALLOC_CTX *_mem_save_ctr0_0;
12792         TALLOC_CTX *_mem_save_ctr1_0;
12793         TALLOC_CTX *_mem_save_ctr2_0;
12794         TALLOC_CTX *_mem_save_ctr3_0;
12795         level = ndr_pull_get_switch_value(ndr, r);
12796         if (ndr_flags & NDR_SCALARS) {
12797                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
12798                 if (_level != level) {
12799                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
12800                 }
12801                 switch (level) {
12802                         case 0: {
12803                                 uint32_t _ptr_ctr0;
12804                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));
12805                                 if (_ptr_ctr0) {
12806                                         NDR_PULL_ALLOC(ndr, r->ctr0);
12807                                 } else {
12808                                         r->ctr0 = NULL;
12809                                 }
12810                         break; }
12811
12812                         case 1: {
12813                                 uint32_t _ptr_ctr1;
12814                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
12815                                 if (_ptr_ctr1) {
12816                                         NDR_PULL_ALLOC(ndr, r->ctr1);
12817                                 } else {
12818                                         r->ctr1 = NULL;
12819                                 }
12820                         break; }
12821
12822                         case 2: {
12823                                 uint32_t _ptr_ctr2;
12824                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr2));
12825                                 if (_ptr_ctr2) {
12826                                         NDR_PULL_ALLOC(ndr, r->ctr2);
12827                                 } else {
12828                                         r->ctr2 = NULL;
12829                                 }
12830                         break; }
12831
12832                         case 3: {
12833                                 uint32_t _ptr_ctr3;
12834                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr3));
12835                                 if (_ptr_ctr3) {
12836                                         NDR_PULL_ALLOC(ndr, r->ctr3);
12837                                 } else {
12838                                         r->ctr3 = NULL;
12839                                 }
12840                         break; }
12841
12842                         default: {
12843                         break; }
12844
12845                 }
12846         }
12847         if (ndr_flags & NDR_BUFFERS) {
12848                 switch (level) {
12849                         case 0:
12850                                 if (r->ctr0) {
12851                                         _mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);
12852                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr0, 0);
12853                                         NDR_CHECK(ndr_pull_srvsvc_NetTransportCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
12854                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);
12855                                 }
12856                         break;
12857
12858                         case 1:
12859                                 if (r->ctr1) {
12860                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
12861                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
12862                                         NDR_CHECK(ndr_pull_srvsvc_NetTransportCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
12863                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
12864                                 }
12865                         break;
12866
12867                         case 2:
12868                                 if (r->ctr2) {
12869                                         _mem_save_ctr2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12870                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr2, 0);
12871                                         NDR_CHECK(ndr_pull_srvsvc_NetTransportCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
12872                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr2_0, 0);
12873                                 }
12874                         break;
12875
12876                         case 3:
12877                                 if (r->ctr3) {
12878                                         _mem_save_ctr3_0 = NDR_PULL_GET_MEM_CTX(ndr);
12879                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr3, 0);
12880                                         NDR_CHECK(ndr_pull_srvsvc_NetTransportCtr3(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr3));
12881                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr3_0, 0);
12882                                 }
12883                         break;
12884
12885                         default:
12886                         break;
12887
12888                 }
12889         }
12890         return NDR_ERR_SUCCESS;
12891 }
12892
12893 _PUBLIC_ void ndr_print_srvsvc_NetTransportCtr(struct ndr_print *ndr, const char *name, const union srvsvc_NetTransportCtr *r)
12894 {
12895         int level;
12896         level = ndr_print_get_switch_value(ndr, r);
12897         ndr_print_union(ndr, name, level, "srvsvc_NetTransportCtr");
12898         switch (level) {
12899                 case 0:
12900                         ndr_print_ptr(ndr, "ctr0", r->ctr0);
12901                         ndr->depth++;
12902                         if (r->ctr0) {
12903                                 ndr_print_srvsvc_NetTransportCtr0(ndr, "ctr0", r->ctr0);
12904                         }
12905                         ndr->depth--;
12906                 break;
12907
12908                 case 1:
12909                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
12910                         ndr->depth++;
12911                         if (r->ctr1) {
12912                                 ndr_print_srvsvc_NetTransportCtr1(ndr, "ctr1", r->ctr1);
12913                         }
12914                         ndr->depth--;
12915                 break;
12916
12917                 case 2:
12918                         ndr_print_ptr(ndr, "ctr2", r->ctr2);
12919                         ndr->depth++;
12920                         if (r->ctr2) {
12921                                 ndr_print_srvsvc_NetTransportCtr2(ndr, "ctr2", r->ctr2);
12922                         }
12923                         ndr->depth--;
12924                 break;
12925
12926                 case 3:
12927                         ndr_print_ptr(ndr, "ctr3", r->ctr3);
12928                         ndr->depth++;
12929                         if (r->ctr3) {
12930                                 ndr_print_srvsvc_NetTransportCtr3(ndr, "ctr3", r->ctr3);
12931                         }
12932                         ndr->depth--;
12933                 break;
12934
12935                 default:
12936                 break;
12937
12938         }
12939 }
12940
12941 static enum ndr_err_code ndr_push_srvsvc_NetTransportInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportInfoCtr *r)
12942 {
12943         if (ndr_flags & NDR_SCALARS) {
12944                 NDR_CHECK(ndr_push_align(ndr, 4));
12945                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
12946                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
12947                 NDR_CHECK(ndr_push_srvsvc_NetTransportCtr(ndr, NDR_SCALARS, &r->ctr));
12948         }
12949         if (ndr_flags & NDR_BUFFERS) {
12950                 NDR_CHECK(ndr_push_srvsvc_NetTransportCtr(ndr, NDR_BUFFERS, &r->ctr));
12951         }
12952         return NDR_ERR_SUCCESS;
12953 }
12954
12955 static enum ndr_err_code ndr_pull_srvsvc_NetTransportInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportInfoCtr *r)
12956 {
12957         if (ndr_flags & NDR_SCALARS) {
12958                 NDR_CHECK(ndr_pull_align(ndr, 4));
12959                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
12960                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
12961                 NDR_CHECK(ndr_pull_srvsvc_NetTransportCtr(ndr, NDR_SCALARS, &r->ctr));
12962         }
12963         if (ndr_flags & NDR_BUFFERS) {
12964                 NDR_CHECK(ndr_pull_srvsvc_NetTransportCtr(ndr, NDR_BUFFERS, &r->ctr));
12965         }
12966         return NDR_ERR_SUCCESS;
12967 }
12968
12969 _PUBLIC_ void ndr_print_srvsvc_NetTransportInfoCtr(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportInfoCtr *r)
12970 {
12971         ndr_print_struct(ndr, name, "srvsvc_NetTransportInfoCtr");
12972         ndr->depth++;
12973         ndr_print_uint32(ndr, "level", r->level);
12974         ndr_print_set_switch_value(ndr, &r->ctr, r->level);
12975         ndr_print_srvsvc_NetTransportCtr(ndr, "ctr", &r->ctr);
12976         ndr->depth--;
12977 }
12978
12979 static enum ndr_err_code ndr_push_srvsvc_NetRemoteTODInfo(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetRemoteTODInfo *r)
12980 {
12981         if (ndr_flags & NDR_SCALARS) {
12982                 NDR_CHECK(ndr_push_align(ndr, 4));
12983                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->elapsed));
12984                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->msecs));
12985                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->hours));
12986                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->mins));
12987                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->secs));
12988                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->hunds));
12989                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->timezone));
12990                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->tinterval));
12991                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->day));
12992                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->month));
12993                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->year));
12994                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->weekday));
12995         }
12996         if (ndr_flags & NDR_BUFFERS) {
12997         }
12998         return NDR_ERR_SUCCESS;
12999 }
13000
13001 static enum ndr_err_code ndr_pull_srvsvc_NetRemoteTODInfo(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetRemoteTODInfo *r)
13002 {
13003         if (ndr_flags & NDR_SCALARS) {
13004                 NDR_CHECK(ndr_pull_align(ndr, 4));
13005                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->elapsed));
13006                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->msecs));
13007                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->hours));
13008                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->mins));
13009                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->secs));
13010                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->hunds));
13011                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->timezone));
13012                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->tinterval));
13013                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->day));
13014                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->month));
13015                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->year));
13016                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->weekday));
13017         }
13018         if (ndr_flags & NDR_BUFFERS) {
13019         }
13020         return NDR_ERR_SUCCESS;
13021 }
13022
13023 _PUBLIC_ void ndr_print_srvsvc_NetRemoteTODInfo(struct ndr_print *ndr, const char *name, const struct srvsvc_NetRemoteTODInfo *r)
13024 {
13025         ndr_print_struct(ndr, name, "srvsvc_NetRemoteTODInfo");
13026         ndr->depth++;
13027         ndr_print_uint32(ndr, "elapsed", r->elapsed);
13028         ndr_print_uint32(ndr, "msecs", r->msecs);
13029         ndr_print_uint32(ndr, "hours", r->hours);
13030         ndr_print_uint32(ndr, "mins", r->mins);
13031         ndr_print_uint32(ndr, "secs", r->secs);
13032         ndr_print_uint32(ndr, "hunds", r->hunds);
13033         ndr_print_int32(ndr, "timezone", r->timezone);
13034         ndr_print_uint32(ndr, "tinterval", r->tinterval);
13035         ndr_print_uint32(ndr, "day", r->day);
13036         ndr_print_uint32(ndr, "month", r->month);
13037         ndr_print_uint32(ndr, "year", r->year);
13038         ndr_print_uint32(ndr, "weekday", r->weekday);
13039         ndr->depth--;
13040 }
13041
13042 static enum ndr_err_code ndr_push_srvsvc_NetTransportInfo(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetTransportInfo *r)
13043 {
13044         if (ndr_flags & NDR_SCALARS) {
13045                 int level = ndr_push_get_switch_value(ndr, r);
13046                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
13047                 switch (level) {
13048                         case 0: {
13049                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo0(ndr, NDR_SCALARS, &r->info0));
13050                         break; }
13051
13052                         case 1: {
13053                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo1(ndr, NDR_SCALARS, &r->info1));
13054                         break; }
13055
13056                         case 2: {
13057                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo2(ndr, NDR_SCALARS, &r->info2));
13058                         break; }
13059
13060                         case 3: {
13061                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo3(ndr, NDR_SCALARS, &r->info3));
13062                         break; }
13063
13064                         default:
13065                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13066                 }
13067         }
13068         if (ndr_flags & NDR_BUFFERS) {
13069                 int level = ndr_push_get_switch_value(ndr, r);
13070                 switch (level) {
13071                         case 0:
13072                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo0(ndr, NDR_BUFFERS, &r->info0));
13073                         break;
13074
13075                         case 1:
13076                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo1(ndr, NDR_BUFFERS, &r->info1));
13077                         break;
13078
13079                         case 2:
13080                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo2(ndr, NDR_BUFFERS, &r->info2));
13081                         break;
13082
13083                         case 3:
13084                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo3(ndr, NDR_BUFFERS, &r->info3));
13085                         break;
13086
13087                         default:
13088                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13089                 }
13090         }
13091         return NDR_ERR_SUCCESS;
13092 }
13093
13094 static enum ndr_err_code ndr_pull_srvsvc_NetTransportInfo(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetTransportInfo *r)
13095 {
13096         int level;
13097         uint32_t _level;
13098         level = ndr_pull_get_switch_value(ndr, r);
13099         if (ndr_flags & NDR_SCALARS) {
13100                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
13101                 if (_level != level) {
13102                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
13103                 }
13104                 switch (level) {
13105                         case 0: {
13106                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo0(ndr, NDR_SCALARS, &r->info0));
13107                         break; }
13108
13109                         case 1: {
13110                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo1(ndr, NDR_SCALARS, &r->info1));
13111                         break; }
13112
13113                         case 2: {
13114                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo2(ndr, NDR_SCALARS, &r->info2));
13115                         break; }
13116
13117                         case 3: {
13118                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo3(ndr, NDR_SCALARS, &r->info3));
13119                         break; }
13120
13121                         default:
13122                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13123                 }
13124         }
13125         if (ndr_flags & NDR_BUFFERS) {
13126                 switch (level) {
13127                         case 0:
13128                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo0(ndr, NDR_BUFFERS, &r->info0));
13129                         break;
13130
13131                         case 1:
13132                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo1(ndr, NDR_BUFFERS, &r->info1));
13133                         break;
13134
13135                         case 2:
13136                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo2(ndr, NDR_BUFFERS, &r->info2));
13137                         break;
13138
13139                         case 3:
13140                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo3(ndr, NDR_BUFFERS, &r->info3));
13141                         break;
13142
13143                         default:
13144                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13145                 }
13146         }
13147         return NDR_ERR_SUCCESS;
13148 }
13149
13150 _PUBLIC_ void ndr_print_srvsvc_NetTransportInfo(struct ndr_print *ndr, const char *name, const union srvsvc_NetTransportInfo *r)
13151 {
13152         int level;
13153         level = ndr_print_get_switch_value(ndr, r);
13154         ndr_print_union(ndr, name, level, "srvsvc_NetTransportInfo");
13155         switch (level) {
13156                 case 0:
13157                         ndr_print_srvsvc_NetTransportInfo0(ndr, "info0", &r->info0);
13158                 break;
13159
13160                 case 1:
13161                         ndr_print_srvsvc_NetTransportInfo1(ndr, "info1", &r->info1);
13162                 break;
13163
13164                 case 2:
13165                         ndr_print_srvsvc_NetTransportInfo2(ndr, "info2", &r->info2);
13166                 break;
13167
13168                 case 3:
13169                         ndr_print_srvsvc_NetTransportInfo3(ndr, "info3", &r->info3);
13170                 break;
13171
13172                 default:
13173                         ndr_print_bad_level(ndr, name, level);
13174         }
13175 }
13176
13177 static enum ndr_err_code ndr_push_srvsvc_NetCharDevEnum(struct ndr_push *ndr, int flags, const struct srvsvc_NetCharDevEnum *r)
13178 {
13179         if (flags & NDR_IN) {
13180                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
13181                 if (r->in.server_unc) {
13182                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
13183                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13184                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
13185                         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));
13186                 }
13187                 if (r->in.info_ctr == NULL) {
13188                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13189                 }
13190                 NDR_CHECK(ndr_push_srvsvc_NetCharDevInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
13191                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));
13192                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
13193                 if (r->in.resume_handle) {
13194                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
13195                 }
13196         }
13197         if (flags & NDR_OUT) {
13198                 if (r->out.info_ctr == NULL) {
13199                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13200                 }
13201                 NDR_CHECK(ndr_push_srvsvc_NetCharDevInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));
13202                 if (r->out.totalentries == NULL) {
13203                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13204                 }
13205                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
13206                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
13207                 if (r->out.resume_handle) {
13208                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
13209                 }
13210                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13211         }
13212         return NDR_ERR_SUCCESS;
13213 }
13214
13215 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevEnum(struct ndr_pull *ndr, int flags, struct srvsvc_NetCharDevEnum *r)
13216 {
13217         uint32_t _ptr_server_unc;
13218         uint32_t _ptr_resume_handle;
13219         TALLOC_CTX *_mem_save_server_unc_0;
13220         TALLOC_CTX *_mem_save_info_ctr_0;
13221         TALLOC_CTX *_mem_save_totalentries_0;
13222         TALLOC_CTX *_mem_save_resume_handle_0;
13223         if (flags & NDR_IN) {
13224                 ZERO_STRUCT(r->out);
13225
13226                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
13227                 if (_ptr_server_unc) {
13228                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
13229                 } else {
13230                         r->in.server_unc = NULL;
13231                 }
13232                 if (r->in.server_unc) {
13233                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
13234                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
13235                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
13236                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
13237                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
13238                                 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));
13239                         }
13240                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
13241                         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));
13242                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
13243                 }
13244                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13245                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
13246                 }
13247                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13248                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
13249                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
13250                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13251                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));
13252                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
13253                 if (_ptr_resume_handle) {
13254                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
13255                 } else {
13256                         r->in.resume_handle = NULL;
13257                 }
13258                 if (r->in.resume_handle) {
13259                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13260                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
13261                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
13262                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
13263                 }
13264                 NDR_PULL_ALLOC(ndr, r->out.info_ctr);
13265                 *r->out.info_ctr = *r->in.info_ctr;
13266                 NDR_PULL_ALLOC(ndr, r->out.totalentries);
13267                 ZERO_STRUCTP(r->out.totalentries);
13268         }
13269         if (flags & NDR_OUT) {
13270                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13271                         NDR_PULL_ALLOC(ndr, r->out.info_ctr);
13272                 }
13273                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13274                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_ctr, LIBNDR_FLAG_REF_ALLOC);
13275                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));
13276                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13277                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13278                         NDR_PULL_ALLOC(ndr, r->out.totalentries);
13279                 }
13280                 _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
13281                 NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);
13282                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
13283                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);
13284                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
13285                 if (_ptr_resume_handle) {
13286                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
13287                 } else {
13288                         r->out.resume_handle = NULL;
13289                 }
13290                 if (r->out.resume_handle) {
13291                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13292                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
13293                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
13294                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
13295                 }
13296                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13297         }
13298         return NDR_ERR_SUCCESS;
13299 }
13300
13301 _PUBLIC_ void ndr_print_srvsvc_NetCharDevEnum(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetCharDevEnum *r)
13302 {
13303         ndr_print_struct(ndr, name, "srvsvc_NetCharDevEnum");
13304         ndr->depth++;
13305         if (flags & NDR_SET_VALUES) {
13306                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13307         }
13308         if (flags & NDR_IN) {
13309                 ndr_print_struct(ndr, "in", "srvsvc_NetCharDevEnum");
13310                 ndr->depth++;
13311                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
13312                 ndr->depth++;
13313                 if (r->in.server_unc) {
13314                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
13315                 }
13316                 ndr->depth--;
13317                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
13318                 ndr->depth++;
13319                 ndr_print_srvsvc_NetCharDevInfoCtr(ndr, "info_ctr", r->in.info_ctr);
13320                 ndr->depth--;
13321                 ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);
13322                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
13323                 ndr->depth++;
13324                 if (r->in.resume_handle) {
13325                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
13326                 }
13327                 ndr->depth--;
13328                 ndr->depth--;
13329         }
13330         if (flags & NDR_OUT) {
13331                 ndr_print_struct(ndr, "out", "srvsvc_NetCharDevEnum");
13332                 ndr->depth++;
13333                 ndr_print_ptr(ndr, "info_ctr", r->out.info_ctr);
13334                 ndr->depth++;
13335                 ndr_print_srvsvc_NetCharDevInfoCtr(ndr, "info_ctr", r->out.info_ctr);
13336                 ndr->depth--;
13337                 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
13338                 ndr->depth++;
13339                 ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
13340                 ndr->depth--;
13341                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
13342                 ndr->depth++;
13343                 if (r->out.resume_handle) {
13344                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
13345                 }
13346                 ndr->depth--;
13347                 ndr_print_WERROR(ndr, "result", r->out.result);
13348                 ndr->depth--;
13349         }
13350         ndr->depth--;
13351 }
13352
13353 static enum ndr_err_code ndr_push_srvsvc_NetCharDevGetInfo(struct ndr_push *ndr, int flags, const struct srvsvc_NetCharDevGetInfo *r)
13354 {
13355         if (flags & NDR_IN) {
13356                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
13357                 if (r->in.server_unc) {
13358                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
13359                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13360                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
13361                         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));
13362                 }
13363                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.device_name, CH_UTF16)));
13364                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13365                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.device_name, CH_UTF16)));
13366                 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));
13367                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13368         }
13369         if (flags & NDR_OUT) {
13370                 if (r->out.info == NULL) {
13371                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13372                 }
13373                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
13374                 NDR_CHECK(ndr_push_srvsvc_NetCharDevInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
13375                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13376         }
13377         return NDR_ERR_SUCCESS;
13378 }
13379
13380 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevGetInfo(struct ndr_pull *ndr, int flags, struct srvsvc_NetCharDevGetInfo *r)
13381 {
13382         uint32_t _ptr_server_unc;
13383         TALLOC_CTX *_mem_save_server_unc_0;
13384         TALLOC_CTX *_mem_save_info_0;
13385         if (flags & NDR_IN) {
13386                 ZERO_STRUCT(r->out);
13387
13388                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
13389                 if (_ptr_server_unc) {
13390                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
13391                 } else {
13392                         r->in.server_unc = NULL;
13393                 }
13394                 if (r->in.server_unc) {
13395                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
13396                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
13397                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
13398                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
13399                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
13400                                 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));
13401                         }
13402                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
13403                         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));
13404                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
13405                 }
13406                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.device_name));
13407                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.device_name));
13408                 if (ndr_get_array_length(ndr, &r->in.device_name) > ndr_get_array_size(ndr, &r->in.device_name)) {
13409                         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));
13410                 }
13411                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.device_name), sizeof(uint16_t)));
13412                 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));
13413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13414                 NDR_PULL_ALLOC(ndr, r->out.info);
13415                 ZERO_STRUCTP(r->out.info);
13416         }
13417         if (flags & NDR_OUT) {
13418                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13419                         NDR_PULL_ALLOC(ndr, r->out.info);
13420                 }
13421                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13422                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
13423                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
13424                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
13425                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
13426                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13427         }
13428         return NDR_ERR_SUCCESS;
13429 }
13430
13431 _PUBLIC_ void ndr_print_srvsvc_NetCharDevGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetCharDevGetInfo *r)
13432 {
13433         ndr_print_struct(ndr, name, "srvsvc_NetCharDevGetInfo");
13434         ndr->depth++;
13435         if (flags & NDR_SET_VALUES) {
13436                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13437         }
13438         if (flags & NDR_IN) {
13439                 ndr_print_struct(ndr, "in", "srvsvc_NetCharDevGetInfo");
13440                 ndr->depth++;
13441                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
13442                 ndr->depth++;
13443                 if (r->in.server_unc) {
13444                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
13445                 }
13446                 ndr->depth--;
13447                 ndr_print_string(ndr, "device_name", r->in.device_name);
13448                 ndr_print_uint32(ndr, "level", r->in.level);
13449                 ndr->depth--;
13450         }
13451         if (flags & NDR_OUT) {
13452                 ndr_print_struct(ndr, "out", "srvsvc_NetCharDevGetInfo");
13453                 ndr->depth++;
13454                 ndr_print_ptr(ndr, "info", r->out.info);
13455                 ndr->depth++;
13456                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
13457                 ndr_print_srvsvc_NetCharDevInfo(ndr, "info", r->out.info);
13458                 ndr->depth--;
13459                 ndr_print_WERROR(ndr, "result", r->out.result);
13460                 ndr->depth--;
13461         }
13462         ndr->depth--;
13463 }
13464
13465 static enum ndr_err_code ndr_push_srvsvc_NetCharDevControl(struct ndr_push *ndr, int flags, const struct srvsvc_NetCharDevControl *r)
13466 {
13467         if (flags & NDR_IN) {
13468                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
13469                 if (r->in.server_unc) {
13470                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
13471                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13472                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
13473                         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));
13474                 }
13475                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.device_name, CH_UTF16)));
13476                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13477                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.device_name, CH_UTF16)));
13478                 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));
13479                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.opcode));
13480         }
13481         if (flags & NDR_OUT) {
13482                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13483         }
13484         return NDR_ERR_SUCCESS;
13485 }
13486
13487 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevControl(struct ndr_pull *ndr, int flags, struct srvsvc_NetCharDevControl *r)
13488 {
13489         uint32_t _ptr_server_unc;
13490         TALLOC_CTX *_mem_save_server_unc_0;
13491         if (flags & NDR_IN) {
13492                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
13493                 if (_ptr_server_unc) {
13494                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
13495                 } else {
13496                         r->in.server_unc = NULL;
13497                 }
13498                 if (r->in.server_unc) {
13499                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
13500                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
13501                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
13502                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
13503                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
13504                                 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));
13505                         }
13506                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
13507                         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));
13508                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
13509                 }
13510                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.device_name));
13511                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.device_name));
13512                 if (ndr_get_array_length(ndr, &r->in.device_name) > ndr_get_array_size(ndr, &r->in.device_name)) {
13513                         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));
13514                 }
13515                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.device_name), sizeof(uint16_t)));
13516                 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));
13517                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.opcode));
13518         }
13519         if (flags & NDR_OUT) {
13520                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13521         }
13522         return NDR_ERR_SUCCESS;
13523 }
13524
13525 _PUBLIC_ void ndr_print_srvsvc_NetCharDevControl(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetCharDevControl *r)
13526 {
13527         ndr_print_struct(ndr, name, "srvsvc_NetCharDevControl");
13528         ndr->depth++;
13529         if (flags & NDR_SET_VALUES) {
13530                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13531         }
13532         if (flags & NDR_IN) {
13533                 ndr_print_struct(ndr, "in", "srvsvc_NetCharDevControl");
13534                 ndr->depth++;
13535                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
13536                 ndr->depth++;
13537                 if (r->in.server_unc) {
13538                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
13539                 }
13540                 ndr->depth--;
13541                 ndr_print_string(ndr, "device_name", r->in.device_name);
13542                 ndr_print_uint32(ndr, "opcode", r->in.opcode);
13543                 ndr->depth--;
13544         }
13545         if (flags & NDR_OUT) {
13546                 ndr_print_struct(ndr, "out", "srvsvc_NetCharDevControl");
13547                 ndr->depth++;
13548                 ndr_print_WERROR(ndr, "result", r->out.result);
13549                 ndr->depth--;
13550         }
13551         ndr->depth--;
13552 }
13553
13554 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQEnum(struct ndr_push *ndr, int flags, const struct srvsvc_NetCharDevQEnum *r)
13555 {
13556         if (flags & NDR_IN) {
13557                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
13558                 if (r->in.server_unc) {
13559                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
13560                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13561                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
13562                         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));
13563                 }
13564                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.user));
13565                 if (r->in.user) {
13566                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));
13567                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13568                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));
13569                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.user, ndr_charset_length(r->in.user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13570                 }
13571                 if (r->in.info_ctr == NULL) {
13572                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13573                 }
13574                 NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
13575                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));
13576                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
13577                 if (r->in.resume_handle) {
13578                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
13579                 }
13580         }
13581         if (flags & NDR_OUT) {
13582                 if (r->out.info_ctr == NULL) {
13583                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13584                 }
13585                 NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));
13586                 if (r->out.totalentries == NULL) {
13587                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13588                 }
13589                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
13590                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
13591                 if (r->out.resume_handle) {
13592                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
13593                 }
13594                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13595         }
13596         return NDR_ERR_SUCCESS;
13597 }
13598
13599 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQEnum(struct ndr_pull *ndr, int flags, struct srvsvc_NetCharDevQEnum *r)
13600 {
13601         uint32_t _ptr_server_unc;
13602         uint32_t _ptr_user;
13603         uint32_t _ptr_resume_handle;
13604         TALLOC_CTX *_mem_save_server_unc_0;
13605         TALLOC_CTX *_mem_save_user_0;
13606         TALLOC_CTX *_mem_save_info_ctr_0;
13607         TALLOC_CTX *_mem_save_totalentries_0;
13608         TALLOC_CTX *_mem_save_resume_handle_0;
13609         if (flags & NDR_IN) {
13610                 ZERO_STRUCT(r->out);
13611
13612                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
13613                 if (_ptr_server_unc) {
13614                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
13615                 } else {
13616                         r->in.server_unc = NULL;
13617                 }
13618                 if (r->in.server_unc) {
13619                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
13620                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
13621                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
13622                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
13623                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
13624                                 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));
13625                         }
13626                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
13627                         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));
13628                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
13629                 }
13630                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
13631                 if (_ptr_user) {
13632                         NDR_PULL_ALLOC(ndr, r->in.user);
13633                 } else {
13634                         r->in.user = NULL;
13635                 }
13636                 if (r->in.user) {
13637                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
13638                         NDR_PULL_SET_MEM_CTX(ndr, r->in.user, 0);
13639                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.user));
13640                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.user));
13641                         if (ndr_get_array_length(ndr, &r->in.user) > ndr_get_array_size(ndr, &r->in.user)) {
13642                                 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));
13643                         }
13644                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.user), sizeof(uint16_t)));
13645                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.user, ndr_get_array_length(ndr, &r->in.user), sizeof(uint16_t), CH_UTF16));
13646                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
13647                 }
13648                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13649                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
13650                 }
13651                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13652                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
13653                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
13654                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13655                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));
13656                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
13657                 if (_ptr_resume_handle) {
13658                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
13659                 } else {
13660                         r->in.resume_handle = NULL;
13661                 }
13662                 if (r->in.resume_handle) {
13663                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13664                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
13665                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
13666                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
13667                 }
13668                 NDR_PULL_ALLOC(ndr, r->out.info_ctr);
13669                 *r->out.info_ctr = *r->in.info_ctr;
13670                 NDR_PULL_ALLOC(ndr, r->out.totalentries);
13671                 ZERO_STRUCTP(r->out.totalentries);
13672         }
13673         if (flags & NDR_OUT) {
13674                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13675                         NDR_PULL_ALLOC(ndr, r->out.info_ctr);
13676                 }
13677                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13678                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_ctr, LIBNDR_FLAG_REF_ALLOC);
13679                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));
13680                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13681                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13682                         NDR_PULL_ALLOC(ndr, r->out.totalentries);
13683                 }
13684                 _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
13685                 NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);
13686                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
13687                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);
13688                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
13689                 if (_ptr_resume_handle) {
13690                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
13691                 } else {
13692                         r->out.resume_handle = NULL;
13693                 }
13694                 if (r->out.resume_handle) {
13695                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13696                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
13697                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
13698                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
13699                 }
13700                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13701         }
13702         return NDR_ERR_SUCCESS;
13703 }
13704
13705 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQEnum(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetCharDevQEnum *r)
13706 {
13707         ndr_print_struct(ndr, name, "srvsvc_NetCharDevQEnum");
13708         ndr->depth++;
13709         if (flags & NDR_SET_VALUES) {
13710                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13711         }
13712         if (flags & NDR_IN) {
13713                 ndr_print_struct(ndr, "in", "srvsvc_NetCharDevQEnum");
13714                 ndr->depth++;
13715                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
13716                 ndr->depth++;
13717                 if (r->in.server_unc) {
13718                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
13719                 }
13720                 ndr->depth--;
13721                 ndr_print_ptr(ndr, "user", r->in.user);
13722                 ndr->depth++;
13723                 if (r->in.user) {
13724                         ndr_print_string(ndr, "user", r->in.user);
13725                 }
13726                 ndr->depth--;
13727                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
13728                 ndr->depth++;
13729                 ndr_print_srvsvc_NetCharDevQInfoCtr(ndr, "info_ctr", r->in.info_ctr);
13730                 ndr->depth--;
13731                 ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);
13732                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
13733                 ndr->depth++;
13734                 if (r->in.resume_handle) {
13735                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
13736                 }
13737                 ndr->depth--;
13738                 ndr->depth--;
13739         }
13740         if (flags & NDR_OUT) {
13741                 ndr_print_struct(ndr, "out", "srvsvc_NetCharDevQEnum");
13742                 ndr->depth++;
13743                 ndr_print_ptr(ndr, "info_ctr", r->out.info_ctr);
13744                 ndr->depth++;
13745                 ndr_print_srvsvc_NetCharDevQInfoCtr(ndr, "info_ctr", r->out.info_ctr);
13746                 ndr->depth--;
13747                 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
13748                 ndr->depth++;
13749                 ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
13750                 ndr->depth--;
13751                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
13752                 ndr->depth++;
13753                 if (r->out.resume_handle) {
13754                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
13755                 }
13756                 ndr->depth--;
13757                 ndr_print_WERROR(ndr, "result", r->out.result);
13758                 ndr->depth--;
13759         }
13760         ndr->depth--;
13761 }
13762
13763 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQGetInfo(struct ndr_push *ndr, int flags, const struct srvsvc_NetCharDevQGetInfo *r)
13764 {
13765         if (flags & NDR_IN) {
13766                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
13767                 if (r->in.server_unc) {
13768                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
13769                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13770                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
13771                         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));
13772                 }
13773                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.queue_name, CH_UTF16)));
13774                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13775                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.queue_name, CH_UTF16)));
13776                 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));
13777                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, 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.user, CH_UTF16)));
13780                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.user, ndr_charset_length(r->in.user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13781                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13782         }
13783         if (flags & NDR_OUT) {
13784                 if (r->out.info == NULL) {
13785                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13786                 }
13787                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
13788                 NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
13789                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13790         }
13791         return NDR_ERR_SUCCESS;
13792 }
13793
13794 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQGetInfo(struct ndr_pull *ndr, int flags, struct srvsvc_NetCharDevQGetInfo *r)
13795 {
13796         uint32_t _ptr_server_unc;
13797         TALLOC_CTX *_mem_save_server_unc_0;
13798         TALLOC_CTX *_mem_save_info_0;
13799         if (flags & NDR_IN) {
13800                 ZERO_STRUCT(r->out);
13801
13802                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
13803                 if (_ptr_server_unc) {
13804                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
13805                 } else {
13806                         r->in.server_unc = NULL;
13807                 }
13808                 if (r->in.server_unc) {
13809                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
13810                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
13811                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
13812                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
13813                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
13814                                 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));
13815                         }
13816                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
13817                         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));
13818                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
13819                 }
13820                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.queue_name));
13821                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.queue_name));
13822                 if (ndr_get_array_length(ndr, &r->in.queue_name) > ndr_get_array_size(ndr, &r->in.queue_name)) {
13823                         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));
13824                 }
13825                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.queue_name), sizeof(uint16_t)));
13826                 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));
13827                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.user));
13828                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.user));
13829                 if (ndr_get_array_length(ndr, &r->in.user) > ndr_get_array_size(ndr, &r->in.user)) {
13830                         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));
13831                 }
13832                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.user), sizeof(uint16_t)));
13833                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.user, ndr_get_array_length(ndr, &r->in.user), sizeof(uint16_t), CH_UTF16));
13834                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13835                 NDR_PULL_ALLOC(ndr, r->out.info);
13836                 ZERO_STRUCTP(r->out.info);
13837         }
13838         if (flags & NDR_OUT) {
13839                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13840                         NDR_PULL_ALLOC(ndr, r->out.info);
13841                 }
13842                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13843                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
13844                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
13845                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
13846                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
13847                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13848         }
13849         return NDR_ERR_SUCCESS;
13850 }
13851
13852 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetCharDevQGetInfo *r)
13853 {
13854         ndr_print_struct(ndr, name, "srvsvc_NetCharDevQGetInfo");
13855         ndr->depth++;
13856         if (flags & NDR_SET_VALUES) {
13857                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13858         }
13859         if (flags & NDR_IN) {
13860                 ndr_print_struct(ndr, "in", "srvsvc_NetCharDevQGetInfo");
13861                 ndr->depth++;
13862                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
13863                 ndr->depth++;
13864                 if (r->in.server_unc) {
13865                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
13866                 }
13867                 ndr->depth--;
13868                 ndr_print_string(ndr, "queue_name", r->in.queue_name);
13869                 ndr_print_string(ndr, "user", r->in.user);
13870                 ndr_print_uint32(ndr, "level", r->in.level);
13871                 ndr->depth--;
13872         }
13873         if (flags & NDR_OUT) {
13874                 ndr_print_struct(ndr, "out", "srvsvc_NetCharDevQGetInfo");
13875                 ndr->depth++;
13876                 ndr_print_ptr(ndr, "info", r->out.info);
13877                 ndr->depth++;
13878                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
13879                 ndr_print_srvsvc_NetCharDevQInfo(ndr, "info", r->out.info);
13880                 ndr->depth--;
13881                 ndr_print_WERROR(ndr, "result", r->out.result);
13882                 ndr->depth--;
13883         }
13884         ndr->depth--;
13885 }
13886
13887 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQSetInfo(struct ndr_push *ndr, int flags, const struct srvsvc_NetCharDevQSetInfo *r)
13888 {
13889         if (flags & NDR_IN) {
13890                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
13891                 if (r->in.server_unc) {
13892                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
13893                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13894                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
13895                         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));
13896                 }
13897                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.queue_name, CH_UTF16)));
13898                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13899                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.queue_name, CH_UTF16)));
13900                 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));
13901                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13902                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
13903                 NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
13904                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_error));
13905                 if (r->in.parm_error) {
13906                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_error));
13907                 }
13908         }
13909         if (flags & NDR_OUT) {
13910                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_error));
13911                 if (r->out.parm_error) {
13912                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_error));
13913                 }
13914                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13915         }
13916         return NDR_ERR_SUCCESS;
13917 }
13918
13919 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQSetInfo(struct ndr_pull *ndr, int flags, struct srvsvc_NetCharDevQSetInfo *r)
13920 {
13921         uint32_t _ptr_server_unc;
13922         uint32_t _ptr_parm_error;
13923         TALLOC_CTX *_mem_save_server_unc_0;
13924         TALLOC_CTX *_mem_save_parm_error_0;
13925         if (flags & NDR_IN) {
13926                 ZERO_STRUCT(r->out);
13927
13928                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
13929                 if (_ptr_server_unc) {
13930                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
13931                 } else {
13932                         r->in.server_unc = NULL;
13933                 }
13934                 if (r->in.server_unc) {
13935                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
13936                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
13937                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
13938                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
13939                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
13940                                 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));
13941                         }
13942                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
13943                         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));
13944                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
13945                 }
13946                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.queue_name));
13947                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.queue_name));
13948                 if (ndr_get_array_length(ndr, &r->in.queue_name) > ndr_get_array_size(ndr, &r->in.queue_name)) {
13949                         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));
13950                 }
13951                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.queue_name), sizeof(uint16_t)));
13952                 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));
13953                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13954                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
13955                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
13956                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_error));
13957                 if (_ptr_parm_error) {
13958                         NDR_PULL_ALLOC(ndr, r->in.parm_error);
13959                 } else {
13960                         r->in.parm_error = NULL;
13961                 }
13962                 if (r->in.parm_error) {
13963                         _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
13964                         NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_error, 0);
13965                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_error));
13966                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, 0);
13967                 }
13968         }
13969         if (flags & NDR_OUT) {
13970                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_error));
13971                 if (_ptr_parm_error) {
13972                         NDR_PULL_ALLOC(ndr, r->out.parm_error);
13973                 } else {
13974                         r->out.parm_error = NULL;
13975                 }
13976                 if (r->out.parm_error) {
13977                         _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
13978                         NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_error, 0);
13979                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_error));
13980                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, 0);
13981                 }
13982                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13983         }
13984         return NDR_ERR_SUCCESS;
13985 }
13986
13987 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQSetInfo(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetCharDevQSetInfo *r)
13988 {
13989         ndr_print_struct(ndr, name, "srvsvc_NetCharDevQSetInfo");
13990         ndr->depth++;
13991         if (flags & NDR_SET_VALUES) {
13992                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13993         }
13994         if (flags & NDR_IN) {
13995                 ndr_print_struct(ndr, "in", "srvsvc_NetCharDevQSetInfo");
13996                 ndr->depth++;
13997                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
13998                 ndr->depth++;
13999                 if (r->in.server_unc) {
14000                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
14001                 }
14002                 ndr->depth--;
14003                 ndr_print_string(ndr, "queue_name", r->in.queue_name);
14004                 ndr_print_uint32(ndr, "level", r->in.level);
14005                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
14006                 ndr_print_srvsvc_NetCharDevQInfo(ndr, "info", &r->in.info);
14007                 ndr_print_ptr(ndr, "parm_error", r->in.parm_error);
14008                 ndr->depth++;
14009                 if (r->in.parm_error) {
14010                         ndr_print_uint32(ndr, "parm_error", *r->in.parm_error);
14011                 }
14012                 ndr->depth--;
14013                 ndr->depth--;
14014         }
14015         if (flags & NDR_OUT) {
14016                 ndr_print_struct(ndr, "out", "srvsvc_NetCharDevQSetInfo");
14017                 ndr->depth++;
14018                 ndr_print_ptr(ndr, "parm_error", r->out.parm_error);
14019                 ndr->depth++;
14020                 if (r->out.parm_error) {
14021                         ndr_print_uint32(ndr, "parm_error", *r->out.parm_error);
14022                 }
14023                 ndr->depth--;
14024                 ndr_print_WERROR(ndr, "result", r->out.result);
14025                 ndr->depth--;
14026         }
14027         ndr->depth--;
14028 }
14029
14030 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQPurge(struct ndr_push *ndr, int flags, const struct srvsvc_NetCharDevQPurge *r)
14031 {
14032         if (flags & NDR_IN) {
14033                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
14034                 if (r->in.server_unc) {
14035                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14036                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14037                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14038                         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));
14039                 }
14040                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.queue_name, CH_UTF16)));
14041                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14042                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.queue_name, CH_UTF16)));
14043                 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));
14044         }
14045         if (flags & NDR_OUT) {
14046                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14047         }
14048         return NDR_ERR_SUCCESS;
14049 }
14050
14051 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQPurge(struct ndr_pull *ndr, int flags, struct srvsvc_NetCharDevQPurge *r)
14052 {
14053         uint32_t _ptr_server_unc;
14054         TALLOC_CTX *_mem_save_server_unc_0;
14055         if (flags & NDR_IN) {
14056                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
14057                 if (_ptr_server_unc) {
14058                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
14059                 } else {
14060                         r->in.server_unc = NULL;
14061                 }
14062                 if (r->in.server_unc) {
14063                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
14064                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
14065                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
14066                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
14067                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
14068                                 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));
14069                         }
14070                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
14071                         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));
14072                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
14073                 }
14074                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.queue_name));
14075                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.queue_name));
14076                 if (ndr_get_array_length(ndr, &r->in.queue_name) > ndr_get_array_size(ndr, &r->in.queue_name)) {
14077                         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));
14078                 }
14079                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.queue_name), sizeof(uint16_t)));
14080                 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));
14081         }
14082         if (flags & NDR_OUT) {
14083                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14084         }
14085         return NDR_ERR_SUCCESS;
14086 }
14087
14088 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQPurge(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetCharDevQPurge *r)
14089 {
14090         ndr_print_struct(ndr, name, "srvsvc_NetCharDevQPurge");
14091         ndr->depth++;
14092         if (flags & NDR_SET_VALUES) {
14093                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14094         }
14095         if (flags & NDR_IN) {
14096                 ndr_print_struct(ndr, "in", "srvsvc_NetCharDevQPurge");
14097                 ndr->depth++;
14098                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
14099                 ndr->depth++;
14100                 if (r->in.server_unc) {
14101                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
14102                 }
14103                 ndr->depth--;
14104                 ndr_print_string(ndr, "queue_name", r->in.queue_name);
14105                 ndr->depth--;
14106         }
14107         if (flags & NDR_OUT) {
14108                 ndr_print_struct(ndr, "out", "srvsvc_NetCharDevQPurge");
14109                 ndr->depth++;
14110                 ndr_print_WERROR(ndr, "result", r->out.result);
14111                 ndr->depth--;
14112         }
14113         ndr->depth--;
14114 }
14115
14116 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQPurgeSelf(struct ndr_push *ndr, int flags, const struct srvsvc_NetCharDevQPurgeSelf *r)
14117 {
14118         if (flags & NDR_IN) {
14119                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
14120                 if (r->in.server_unc) {
14121                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14122                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14123                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14124                         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));
14125                 }
14126                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.queue_name, CH_UTF16)));
14127                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14128                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.queue_name, CH_UTF16)));
14129                 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));
14130                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.computer_name, CH_UTF16)));
14131                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14132                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.computer_name, CH_UTF16)));
14133                 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));
14134         }
14135         if (flags & NDR_OUT) {
14136                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14137         }
14138         return NDR_ERR_SUCCESS;
14139 }
14140
14141 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQPurgeSelf(struct ndr_pull *ndr, int flags, struct srvsvc_NetCharDevQPurgeSelf *r)
14142 {
14143         uint32_t _ptr_server_unc;
14144         TALLOC_CTX *_mem_save_server_unc_0;
14145         if (flags & NDR_IN) {
14146                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
14147                 if (_ptr_server_unc) {
14148                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
14149                 } else {
14150                         r->in.server_unc = NULL;
14151                 }
14152                 if (r->in.server_unc) {
14153                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
14154                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
14155                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
14156                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
14157                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
14158                                 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));
14159                         }
14160                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
14161                         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));
14162                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
14163                 }
14164                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.queue_name));
14165                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.queue_name));
14166                 if (ndr_get_array_length(ndr, &r->in.queue_name) > ndr_get_array_size(ndr, &r->in.queue_name)) {
14167                         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));
14168                 }
14169                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.queue_name), sizeof(uint16_t)));
14170                 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));
14171                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.computer_name));
14172                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.computer_name));
14173                 if (ndr_get_array_length(ndr, &r->in.computer_name) > ndr_get_array_size(ndr, &r->in.computer_name)) {
14174                         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));
14175                 }
14176                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.computer_name), sizeof(uint16_t)));
14177                 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));
14178         }
14179         if (flags & NDR_OUT) {
14180                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14181         }
14182         return NDR_ERR_SUCCESS;
14183 }
14184
14185 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQPurgeSelf(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetCharDevQPurgeSelf *r)
14186 {
14187         ndr_print_struct(ndr, name, "srvsvc_NetCharDevQPurgeSelf");
14188         ndr->depth++;
14189         if (flags & NDR_SET_VALUES) {
14190                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14191         }
14192         if (flags & NDR_IN) {
14193                 ndr_print_struct(ndr, "in", "srvsvc_NetCharDevQPurgeSelf");
14194                 ndr->depth++;
14195                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
14196                 ndr->depth++;
14197                 if (r->in.server_unc) {
14198                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
14199                 }
14200                 ndr->depth--;
14201                 ndr_print_string(ndr, "queue_name", r->in.queue_name);
14202                 ndr_print_string(ndr, "computer_name", r->in.computer_name);
14203                 ndr->depth--;
14204         }
14205         if (flags & NDR_OUT) {
14206                 ndr_print_struct(ndr, "out", "srvsvc_NetCharDevQPurgeSelf");
14207                 ndr->depth++;
14208                 ndr_print_WERROR(ndr, "result", r->out.result);
14209                 ndr->depth--;
14210         }
14211         ndr->depth--;
14212 }
14213
14214 static enum ndr_err_code ndr_push_srvsvc_NetConnEnum(struct ndr_push *ndr, int flags, const struct srvsvc_NetConnEnum *r)
14215 {
14216         if (flags & NDR_IN) {
14217                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
14218                 if (r->in.server_unc) {
14219                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14220                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14221                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14222                         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));
14223                 }
14224                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.path));
14225                 if (r->in.path) {
14226                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));
14227                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14228                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));
14229                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.path, ndr_charset_length(r->in.path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14230                 }
14231                 if (r->in.info_ctr == NULL) {
14232                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14233                 }
14234                 NDR_CHECK(ndr_push_srvsvc_NetConnInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
14235                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));
14236                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
14237                 if (r->in.resume_handle) {
14238                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
14239                 }
14240         }
14241         if (flags & NDR_OUT) {
14242                 if (r->out.info_ctr == NULL) {
14243                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14244                 }
14245                 NDR_CHECK(ndr_push_srvsvc_NetConnInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));
14246                 if (r->out.totalentries == NULL) {
14247                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14248                 }
14249                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
14250                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
14251                 if (r->out.resume_handle) {
14252                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
14253                 }
14254                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14255         }
14256         return NDR_ERR_SUCCESS;
14257 }
14258
14259 static enum ndr_err_code ndr_pull_srvsvc_NetConnEnum(struct ndr_pull *ndr, int flags, struct srvsvc_NetConnEnum *r)
14260 {
14261         uint32_t _ptr_server_unc;
14262         uint32_t _ptr_path;
14263         uint32_t _ptr_resume_handle;
14264         TALLOC_CTX *_mem_save_server_unc_0;
14265         TALLOC_CTX *_mem_save_path_0;
14266         TALLOC_CTX *_mem_save_info_ctr_0;
14267         TALLOC_CTX *_mem_save_totalentries_0;
14268         TALLOC_CTX *_mem_save_resume_handle_0;
14269         if (flags & NDR_IN) {
14270                 ZERO_STRUCT(r->out);
14271
14272                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
14273                 if (_ptr_server_unc) {
14274                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
14275                 } else {
14276                         r->in.server_unc = NULL;
14277                 }
14278                 if (r->in.server_unc) {
14279                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
14280                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
14281                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
14282                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
14283                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
14284                                 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));
14285                         }
14286                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
14287                         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));
14288                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
14289                 }
14290                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_path));
14291                 if (_ptr_path) {
14292                         NDR_PULL_ALLOC(ndr, r->in.path);
14293                 } else {
14294                         r->in.path = NULL;
14295                 }
14296                 if (r->in.path) {
14297                         _mem_save_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
14298                         NDR_PULL_SET_MEM_CTX(ndr, r->in.path, 0);
14299                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path));
14300                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path));
14301                         if (ndr_get_array_length(ndr, &r->in.path) > ndr_get_array_size(ndr, &r->in.path)) {
14302                                 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));
14303                         }
14304                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path), sizeof(uint16_t)));
14305                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.path, ndr_get_array_length(ndr, &r->in.path), sizeof(uint16_t), CH_UTF16));
14306                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_path_0, 0);
14307                 }
14308                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14309                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
14310                 }
14311                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14312                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
14313                 NDR_CHECK(ndr_pull_srvsvc_NetConnInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
14314                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14315                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));
14316                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
14317                 if (_ptr_resume_handle) {
14318                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
14319                 } else {
14320                         r->in.resume_handle = NULL;
14321                 }
14322                 if (r->in.resume_handle) {
14323                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14324                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
14325                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
14326                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
14327                 }
14328                 NDR_PULL_ALLOC(ndr, r->out.info_ctr);
14329                 *r->out.info_ctr = *r->in.info_ctr;
14330                 NDR_PULL_ALLOC(ndr, r->out.totalentries);
14331                 ZERO_STRUCTP(r->out.totalentries);
14332         }
14333         if (flags & NDR_OUT) {
14334                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14335                         NDR_PULL_ALLOC(ndr, r->out.info_ctr);
14336                 }
14337                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14338                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_ctr, LIBNDR_FLAG_REF_ALLOC);
14339                 NDR_CHECK(ndr_pull_srvsvc_NetConnInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));
14340                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14341                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14342                         NDR_PULL_ALLOC(ndr, r->out.totalentries);
14343                 }
14344                 _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
14345                 NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);
14346                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
14347                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);
14348                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
14349                 if (_ptr_resume_handle) {
14350                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
14351                 } else {
14352                         r->out.resume_handle = NULL;
14353                 }
14354                 if (r->out.resume_handle) {
14355                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14356                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
14357                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
14358                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
14359                 }
14360                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14361         }
14362         return NDR_ERR_SUCCESS;
14363 }
14364
14365 _PUBLIC_ void ndr_print_srvsvc_NetConnEnum(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetConnEnum *r)
14366 {
14367         ndr_print_struct(ndr, name, "srvsvc_NetConnEnum");
14368         ndr->depth++;
14369         if (flags & NDR_SET_VALUES) {
14370                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14371         }
14372         if (flags & NDR_IN) {
14373                 ndr_print_struct(ndr, "in", "srvsvc_NetConnEnum");
14374                 ndr->depth++;
14375                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
14376                 ndr->depth++;
14377                 if (r->in.server_unc) {
14378                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
14379                 }
14380                 ndr->depth--;
14381                 ndr_print_ptr(ndr, "path", r->in.path);
14382                 ndr->depth++;
14383                 if (r->in.path) {
14384                         ndr_print_string(ndr, "path", r->in.path);
14385                 }
14386                 ndr->depth--;
14387                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
14388                 ndr->depth++;
14389                 ndr_print_srvsvc_NetConnInfoCtr(ndr, "info_ctr", r->in.info_ctr);
14390                 ndr->depth--;
14391                 ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);
14392                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
14393                 ndr->depth++;
14394                 if (r->in.resume_handle) {
14395                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
14396                 }
14397                 ndr->depth--;
14398                 ndr->depth--;
14399         }
14400         if (flags & NDR_OUT) {
14401                 ndr_print_struct(ndr, "out", "srvsvc_NetConnEnum");
14402                 ndr->depth++;
14403                 ndr_print_ptr(ndr, "info_ctr", r->out.info_ctr);
14404                 ndr->depth++;
14405                 ndr_print_srvsvc_NetConnInfoCtr(ndr, "info_ctr", r->out.info_ctr);
14406                 ndr->depth--;
14407                 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
14408                 ndr->depth++;
14409                 ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
14410                 ndr->depth--;
14411                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
14412                 ndr->depth++;
14413                 if (r->out.resume_handle) {
14414                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
14415                 }
14416                 ndr->depth--;
14417                 ndr_print_WERROR(ndr, "result", r->out.result);
14418                 ndr->depth--;
14419         }
14420         ndr->depth--;
14421 }
14422
14423 static enum ndr_err_code ndr_push_srvsvc_NetFileEnum(struct ndr_push *ndr, int flags, const struct srvsvc_NetFileEnum *r)
14424 {
14425         if (flags & NDR_IN) {
14426                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
14427                 if (r->in.server_unc) {
14428                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14429                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14430                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14431                         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));
14432                 }
14433                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.path));
14434                 if (r->in.path) {
14435                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));
14436                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14437                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));
14438                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.path, ndr_charset_length(r->in.path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14439                 }
14440                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.user));
14441                 if (r->in.user) {
14442                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));
14443                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14444                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));
14445                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.user, ndr_charset_length(r->in.user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14446                 }
14447                 if (r->in.info_ctr == NULL) {
14448                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14449                 }
14450                 NDR_CHECK(ndr_push_srvsvc_NetFileInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
14451                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));
14452                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
14453                 if (r->in.resume_handle) {
14454                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
14455                 }
14456         }
14457         if (flags & NDR_OUT) {
14458                 if (r->out.info_ctr == NULL) {
14459                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14460                 }
14461                 NDR_CHECK(ndr_push_srvsvc_NetFileInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));
14462                 if (r->out.totalentries == NULL) {
14463                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14464                 }
14465                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
14466                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
14467                 if (r->out.resume_handle) {
14468                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
14469                 }
14470                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14471         }
14472         return NDR_ERR_SUCCESS;
14473 }
14474
14475 static enum ndr_err_code ndr_pull_srvsvc_NetFileEnum(struct ndr_pull *ndr, int flags, struct srvsvc_NetFileEnum *r)
14476 {
14477         uint32_t _ptr_server_unc;
14478         uint32_t _ptr_path;
14479         uint32_t _ptr_user;
14480         uint32_t _ptr_resume_handle;
14481         TALLOC_CTX *_mem_save_server_unc_0;
14482         TALLOC_CTX *_mem_save_path_0;
14483         TALLOC_CTX *_mem_save_user_0;
14484         TALLOC_CTX *_mem_save_info_ctr_0;
14485         TALLOC_CTX *_mem_save_totalentries_0;
14486         TALLOC_CTX *_mem_save_resume_handle_0;
14487         if (flags & NDR_IN) {
14488                 ZERO_STRUCT(r->out);
14489
14490                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
14491                 if (_ptr_server_unc) {
14492                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
14493                 } else {
14494                         r->in.server_unc = NULL;
14495                 }
14496                 if (r->in.server_unc) {
14497                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
14498                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
14499                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
14500                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
14501                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
14502                                 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));
14503                         }
14504                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
14505                         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));
14506                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
14507                 }
14508                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_path));
14509                 if (_ptr_path) {
14510                         NDR_PULL_ALLOC(ndr, r->in.path);
14511                 } else {
14512                         r->in.path = NULL;
14513                 }
14514                 if (r->in.path) {
14515                         _mem_save_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
14516                         NDR_PULL_SET_MEM_CTX(ndr, r->in.path, 0);
14517                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path));
14518                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path));
14519                         if (ndr_get_array_length(ndr, &r->in.path) > ndr_get_array_size(ndr, &r->in.path)) {
14520                                 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));
14521                         }
14522                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path), sizeof(uint16_t)));
14523                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.path, ndr_get_array_length(ndr, &r->in.path), sizeof(uint16_t), CH_UTF16));
14524                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_path_0, 0);
14525                 }
14526                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
14527                 if (_ptr_user) {
14528                         NDR_PULL_ALLOC(ndr, r->in.user);
14529                 } else {
14530                         r->in.user = NULL;
14531                 }
14532                 if (r->in.user) {
14533                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
14534                         NDR_PULL_SET_MEM_CTX(ndr, r->in.user, 0);
14535                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.user));
14536                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.user));
14537                         if (ndr_get_array_length(ndr, &r->in.user) > ndr_get_array_size(ndr, &r->in.user)) {
14538                                 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));
14539                         }
14540                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.user), sizeof(uint16_t)));
14541                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.user, ndr_get_array_length(ndr, &r->in.user), sizeof(uint16_t), CH_UTF16));
14542                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
14543                 }
14544                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14545                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
14546                 }
14547                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14548                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
14549                 NDR_CHECK(ndr_pull_srvsvc_NetFileInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
14550                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14551                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));
14552                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
14553                 if (_ptr_resume_handle) {
14554                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
14555                 } else {
14556                         r->in.resume_handle = NULL;
14557                 }
14558                 if (r->in.resume_handle) {
14559                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14560                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
14561                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
14562                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
14563                 }
14564                 NDR_PULL_ALLOC(ndr, r->out.info_ctr);
14565                 *r->out.info_ctr = *r->in.info_ctr;
14566                 NDR_PULL_ALLOC(ndr, r->out.totalentries);
14567                 ZERO_STRUCTP(r->out.totalentries);
14568         }
14569         if (flags & NDR_OUT) {
14570                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14571                         NDR_PULL_ALLOC(ndr, r->out.info_ctr);
14572                 }
14573                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14574                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_ctr, LIBNDR_FLAG_REF_ALLOC);
14575                 NDR_CHECK(ndr_pull_srvsvc_NetFileInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));
14576                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14577                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14578                         NDR_PULL_ALLOC(ndr, r->out.totalentries);
14579                 }
14580                 _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
14581                 NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);
14582                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
14583                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);
14584                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
14585                 if (_ptr_resume_handle) {
14586                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
14587                 } else {
14588                         r->out.resume_handle = NULL;
14589                 }
14590                 if (r->out.resume_handle) {
14591                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14592                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
14593                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
14594                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
14595                 }
14596                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14597         }
14598         return NDR_ERR_SUCCESS;
14599 }
14600
14601 _PUBLIC_ void ndr_print_srvsvc_NetFileEnum(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetFileEnum *r)
14602 {
14603         ndr_print_struct(ndr, name, "srvsvc_NetFileEnum");
14604         ndr->depth++;
14605         if (flags & NDR_SET_VALUES) {
14606                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14607         }
14608         if (flags & NDR_IN) {
14609                 ndr_print_struct(ndr, "in", "srvsvc_NetFileEnum");
14610                 ndr->depth++;
14611                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
14612                 ndr->depth++;
14613                 if (r->in.server_unc) {
14614                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
14615                 }
14616                 ndr->depth--;
14617                 ndr_print_ptr(ndr, "path", r->in.path);
14618                 ndr->depth++;
14619                 if (r->in.path) {
14620                         ndr_print_string(ndr, "path", r->in.path);
14621                 }
14622                 ndr->depth--;
14623                 ndr_print_ptr(ndr, "user", r->in.user);
14624                 ndr->depth++;
14625                 if (r->in.user) {
14626                         ndr_print_string(ndr, "user", r->in.user);
14627                 }
14628                 ndr->depth--;
14629                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
14630                 ndr->depth++;
14631                 ndr_print_srvsvc_NetFileInfoCtr(ndr, "info_ctr", r->in.info_ctr);
14632                 ndr->depth--;
14633                 ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);
14634                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
14635                 ndr->depth++;
14636                 if (r->in.resume_handle) {
14637                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
14638                 }
14639                 ndr->depth--;
14640                 ndr->depth--;
14641         }
14642         if (flags & NDR_OUT) {
14643                 ndr_print_struct(ndr, "out", "srvsvc_NetFileEnum");
14644                 ndr->depth++;
14645                 ndr_print_ptr(ndr, "info_ctr", r->out.info_ctr);
14646                 ndr->depth++;
14647                 ndr_print_srvsvc_NetFileInfoCtr(ndr, "info_ctr", r->out.info_ctr);
14648                 ndr->depth--;
14649                 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
14650                 ndr->depth++;
14651                 ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
14652                 ndr->depth--;
14653                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
14654                 ndr->depth++;
14655                 if (r->out.resume_handle) {
14656                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
14657                 }
14658                 ndr->depth--;
14659                 ndr_print_WERROR(ndr, "result", r->out.result);
14660                 ndr->depth--;
14661         }
14662         ndr->depth--;
14663 }
14664
14665 static enum ndr_err_code ndr_push_srvsvc_NetFileGetInfo(struct ndr_push *ndr, int flags, const struct srvsvc_NetFileGetInfo *r)
14666 {
14667         if (flags & NDR_IN) {
14668                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
14669                 if (r->in.server_unc) {
14670                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14671                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14672                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14673                         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));
14674                 }
14675                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.fid));
14676                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14677         }
14678         if (flags & NDR_OUT) {
14679                 if (r->out.info == NULL) {
14680                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14681                 }
14682                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
14683                 NDR_CHECK(ndr_push_srvsvc_NetFileInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14684                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14685         }
14686         return NDR_ERR_SUCCESS;
14687 }
14688
14689 static enum ndr_err_code ndr_pull_srvsvc_NetFileGetInfo(struct ndr_pull *ndr, int flags, struct srvsvc_NetFileGetInfo *r)
14690 {
14691         uint32_t _ptr_server_unc;
14692         TALLOC_CTX *_mem_save_server_unc_0;
14693         TALLOC_CTX *_mem_save_info_0;
14694         if (flags & NDR_IN) {
14695                 ZERO_STRUCT(r->out);
14696
14697                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
14698                 if (_ptr_server_unc) {
14699                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
14700                 } else {
14701                         r->in.server_unc = NULL;
14702                 }
14703                 if (r->in.server_unc) {
14704                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
14705                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
14706                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
14707                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
14708                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
14709                                 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));
14710                         }
14711                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
14712                         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));
14713                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
14714                 }
14715                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.fid));
14716                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14717                 NDR_PULL_ALLOC(ndr, r->out.info);
14718                 ZERO_STRUCTP(r->out.info);
14719         }
14720         if (flags & NDR_OUT) {
14721                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14722                         NDR_PULL_ALLOC(ndr, r->out.info);
14723                 }
14724                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14725                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
14726                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
14727                 NDR_CHECK(ndr_pull_srvsvc_NetFileInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14728                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
14729                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14730         }
14731         return NDR_ERR_SUCCESS;
14732 }
14733
14734 _PUBLIC_ void ndr_print_srvsvc_NetFileGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetFileGetInfo *r)
14735 {
14736         ndr_print_struct(ndr, name, "srvsvc_NetFileGetInfo");
14737         ndr->depth++;
14738         if (flags & NDR_SET_VALUES) {
14739                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14740         }
14741         if (flags & NDR_IN) {
14742                 ndr_print_struct(ndr, "in", "srvsvc_NetFileGetInfo");
14743                 ndr->depth++;
14744                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
14745                 ndr->depth++;
14746                 if (r->in.server_unc) {
14747                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
14748                 }
14749                 ndr->depth--;
14750                 ndr_print_uint32(ndr, "fid", r->in.fid);
14751                 ndr_print_uint32(ndr, "level", r->in.level);
14752                 ndr->depth--;
14753         }
14754         if (flags & NDR_OUT) {
14755                 ndr_print_struct(ndr, "out", "srvsvc_NetFileGetInfo");
14756                 ndr->depth++;
14757                 ndr_print_ptr(ndr, "info", r->out.info);
14758                 ndr->depth++;
14759                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
14760                 ndr_print_srvsvc_NetFileInfo(ndr, "info", r->out.info);
14761                 ndr->depth--;
14762                 ndr_print_WERROR(ndr, "result", r->out.result);
14763                 ndr->depth--;
14764         }
14765         ndr->depth--;
14766 }
14767
14768 static enum ndr_err_code ndr_push_srvsvc_NetFileClose(struct ndr_push *ndr, int flags, const struct srvsvc_NetFileClose *r)
14769 {
14770         if (flags & NDR_IN) {
14771                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
14772                 if (r->in.server_unc) {
14773                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14774                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14775                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14776                         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));
14777                 }
14778                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.fid));
14779         }
14780         if (flags & NDR_OUT) {
14781                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14782         }
14783         return NDR_ERR_SUCCESS;
14784 }
14785
14786 static enum ndr_err_code ndr_pull_srvsvc_NetFileClose(struct ndr_pull *ndr, int flags, struct srvsvc_NetFileClose *r)
14787 {
14788         uint32_t _ptr_server_unc;
14789         TALLOC_CTX *_mem_save_server_unc_0;
14790         if (flags & NDR_IN) {
14791                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
14792                 if (_ptr_server_unc) {
14793                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
14794                 } else {
14795                         r->in.server_unc = NULL;
14796                 }
14797                 if (r->in.server_unc) {
14798                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
14799                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
14800                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
14801                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
14802                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
14803                                 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));
14804                         }
14805                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
14806                         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));
14807                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
14808                 }
14809                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.fid));
14810         }
14811         if (flags & NDR_OUT) {
14812                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14813         }
14814         return NDR_ERR_SUCCESS;
14815 }
14816
14817 _PUBLIC_ void ndr_print_srvsvc_NetFileClose(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetFileClose *r)
14818 {
14819         ndr_print_struct(ndr, name, "srvsvc_NetFileClose");
14820         ndr->depth++;
14821         if (flags & NDR_SET_VALUES) {
14822                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14823         }
14824         if (flags & NDR_IN) {
14825                 ndr_print_struct(ndr, "in", "srvsvc_NetFileClose");
14826                 ndr->depth++;
14827                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
14828                 ndr->depth++;
14829                 if (r->in.server_unc) {
14830                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
14831                 }
14832                 ndr->depth--;
14833                 ndr_print_uint32(ndr, "fid", r->in.fid);
14834                 ndr->depth--;
14835         }
14836         if (flags & NDR_OUT) {
14837                 ndr_print_struct(ndr, "out", "srvsvc_NetFileClose");
14838                 ndr->depth++;
14839                 ndr_print_WERROR(ndr, "result", r->out.result);
14840                 ndr->depth--;
14841         }
14842         ndr->depth--;
14843 }
14844
14845 static enum ndr_err_code ndr_push_srvsvc_NetSessEnum(struct ndr_push *ndr, int flags, const struct srvsvc_NetSessEnum *r)
14846 {
14847         if (flags & NDR_IN) {
14848                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
14849                 if (r->in.server_unc) {
14850                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14851                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14852                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14853                         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));
14854                 }
14855                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.client));
14856                 if (r->in.client) {
14857                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.client, CH_UTF16)));
14858                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14859                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.client, CH_UTF16)));
14860                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.client, ndr_charset_length(r->in.client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14861                 }
14862                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.user));
14863                 if (r->in.user) {
14864                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));
14865                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14866                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));
14867                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.user, ndr_charset_length(r->in.user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14868                 }
14869                 if (r->in.info_ctr == NULL) {
14870                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14871                 }
14872                 NDR_CHECK(ndr_push_srvsvc_NetSessInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
14873                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));
14874                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
14875                 if (r->in.resume_handle) {
14876                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
14877                 }
14878         }
14879         if (flags & NDR_OUT) {
14880                 if (r->out.info_ctr == NULL) {
14881                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14882                 }
14883                 NDR_CHECK(ndr_push_srvsvc_NetSessInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));
14884                 if (r->out.totalentries == NULL) {
14885                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14886                 }
14887                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
14888                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
14889                 if (r->out.resume_handle) {
14890                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
14891                 }
14892                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14893         }
14894         return NDR_ERR_SUCCESS;
14895 }
14896
14897 static enum ndr_err_code ndr_pull_srvsvc_NetSessEnum(struct ndr_pull *ndr, int flags, struct srvsvc_NetSessEnum *r)
14898 {
14899         uint32_t _ptr_server_unc;
14900         uint32_t _ptr_client;
14901         uint32_t _ptr_user;
14902         uint32_t _ptr_resume_handle;
14903         TALLOC_CTX *_mem_save_server_unc_0;
14904         TALLOC_CTX *_mem_save_client_0;
14905         TALLOC_CTX *_mem_save_user_0;
14906         TALLOC_CTX *_mem_save_info_ctr_0;
14907         TALLOC_CTX *_mem_save_totalentries_0;
14908         TALLOC_CTX *_mem_save_resume_handle_0;
14909         if (flags & NDR_IN) {
14910                 ZERO_STRUCT(r->out);
14911
14912                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
14913                 if (_ptr_server_unc) {
14914                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
14915                 } else {
14916                         r->in.server_unc = NULL;
14917                 }
14918                 if (r->in.server_unc) {
14919                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
14920                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
14921                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
14922                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
14923                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
14924                                 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));
14925                         }
14926                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
14927                         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));
14928                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
14929                 }
14930                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
14931                 if (_ptr_client) {
14932                         NDR_PULL_ALLOC(ndr, r->in.client);
14933                 } else {
14934                         r->in.client = NULL;
14935                 }
14936                 if (r->in.client) {
14937                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
14938                         NDR_PULL_SET_MEM_CTX(ndr, r->in.client, 0);
14939                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.client));
14940                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.client));
14941                         if (ndr_get_array_length(ndr, &r->in.client) > ndr_get_array_size(ndr, &r->in.client)) {
14942                                 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));
14943                         }
14944                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.client), sizeof(uint16_t)));
14945                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.client, ndr_get_array_length(ndr, &r->in.client), sizeof(uint16_t), CH_UTF16));
14946                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
14947                 }
14948                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
14949                 if (_ptr_user) {
14950                         NDR_PULL_ALLOC(ndr, r->in.user);
14951                 } else {
14952                         r->in.user = NULL;
14953                 }
14954                 if (r->in.user) {
14955                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
14956                         NDR_PULL_SET_MEM_CTX(ndr, r->in.user, 0);
14957                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.user));
14958                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.user));
14959                         if (ndr_get_array_length(ndr, &r->in.user) > ndr_get_array_size(ndr, &r->in.user)) {
14960                                 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));
14961                         }
14962                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.user), sizeof(uint16_t)));
14963                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.user, ndr_get_array_length(ndr, &r->in.user), sizeof(uint16_t), CH_UTF16));
14964                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
14965                 }
14966                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14967                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
14968                 }
14969                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14970                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
14971                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
14972                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14973                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));
14974                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
14975                 if (_ptr_resume_handle) {
14976                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
14977                 } else {
14978                         r->in.resume_handle = NULL;
14979                 }
14980                 if (r->in.resume_handle) {
14981                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14982                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
14983                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
14984                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
14985                 }
14986                 NDR_PULL_ALLOC(ndr, r->out.info_ctr);
14987                 *r->out.info_ctr = *r->in.info_ctr;
14988                 NDR_PULL_ALLOC(ndr, r->out.totalentries);
14989                 ZERO_STRUCTP(r->out.totalentries);
14990         }
14991         if (flags & NDR_OUT) {
14992                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14993                         NDR_PULL_ALLOC(ndr, r->out.info_ctr);
14994                 }
14995                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14996                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_ctr, LIBNDR_FLAG_REF_ALLOC);
14997                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));
14998                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14999                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15000                         NDR_PULL_ALLOC(ndr, r->out.totalentries);
15001                 }
15002                 _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
15003                 NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);
15004                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
15005                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);
15006                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
15007                 if (_ptr_resume_handle) {
15008                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
15009                 } else {
15010                         r->out.resume_handle = NULL;
15011                 }
15012                 if (r->out.resume_handle) {
15013                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15014                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
15015                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
15016                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
15017                 }
15018                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15019         }
15020         return NDR_ERR_SUCCESS;
15021 }
15022
15023 _PUBLIC_ void ndr_print_srvsvc_NetSessEnum(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetSessEnum *r)
15024 {
15025         ndr_print_struct(ndr, name, "srvsvc_NetSessEnum");
15026         ndr->depth++;
15027         if (flags & NDR_SET_VALUES) {
15028                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15029         }
15030         if (flags & NDR_IN) {
15031                 ndr_print_struct(ndr, "in", "srvsvc_NetSessEnum");
15032                 ndr->depth++;
15033                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
15034                 ndr->depth++;
15035                 if (r->in.server_unc) {
15036                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
15037                 }
15038                 ndr->depth--;
15039                 ndr_print_ptr(ndr, "client", r->in.client);
15040                 ndr->depth++;
15041                 if (r->in.client) {
15042                         ndr_print_string(ndr, "client", r->in.client);
15043                 }
15044                 ndr->depth--;
15045                 ndr_print_ptr(ndr, "user", r->in.user);
15046                 ndr->depth++;
15047                 if (r->in.user) {
15048                         ndr_print_string(ndr, "user", r->in.user);
15049                 }
15050                 ndr->depth--;
15051                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
15052                 ndr->depth++;
15053                 ndr_print_srvsvc_NetSessInfoCtr(ndr, "info_ctr", r->in.info_ctr);
15054                 ndr->depth--;
15055                 ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);
15056                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
15057                 ndr->depth++;
15058                 if (r->in.resume_handle) {
15059                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
15060                 }
15061                 ndr->depth--;
15062                 ndr->depth--;
15063         }
15064         if (flags & NDR_OUT) {
15065                 ndr_print_struct(ndr, "out", "srvsvc_NetSessEnum");
15066                 ndr->depth++;
15067                 ndr_print_ptr(ndr, "info_ctr", r->out.info_ctr);
15068                 ndr->depth++;
15069                 ndr_print_srvsvc_NetSessInfoCtr(ndr, "info_ctr", r->out.info_ctr);
15070                 ndr->depth--;
15071                 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
15072                 ndr->depth++;
15073                 ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
15074                 ndr->depth--;
15075                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
15076                 ndr->depth++;
15077                 if (r->out.resume_handle) {
15078                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
15079                 }
15080                 ndr->depth--;
15081                 ndr_print_WERROR(ndr, "result", r->out.result);
15082                 ndr->depth--;
15083         }
15084         ndr->depth--;
15085 }
15086
15087 static enum ndr_err_code ndr_push_srvsvc_NetSessDel(struct ndr_push *ndr, int flags, const struct srvsvc_NetSessDel *r)
15088 {
15089         if (flags & NDR_IN) {
15090                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
15091                 if (r->in.server_unc) {
15092                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15093                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15094                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15095                         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));
15096                 }
15097                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.client));
15098                 if (r->in.client) {
15099                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.client, CH_UTF16)));
15100                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15101                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.client, CH_UTF16)));
15102                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.client, ndr_charset_length(r->in.client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15103                 }
15104                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.user));
15105                 if (r->in.user) {
15106                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));
15107                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15108                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));
15109                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.user, ndr_charset_length(r->in.user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15110                 }
15111         }
15112         if (flags & NDR_OUT) {
15113                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15114         }
15115         return NDR_ERR_SUCCESS;
15116 }
15117
15118 static enum ndr_err_code ndr_pull_srvsvc_NetSessDel(struct ndr_pull *ndr, int flags, struct srvsvc_NetSessDel *r)
15119 {
15120         uint32_t _ptr_server_unc;
15121         uint32_t _ptr_client;
15122         uint32_t _ptr_user;
15123         TALLOC_CTX *_mem_save_server_unc_0;
15124         TALLOC_CTX *_mem_save_client_0;
15125         TALLOC_CTX *_mem_save_user_0;
15126         if (flags & NDR_IN) {
15127                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
15128                 if (_ptr_server_unc) {
15129                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
15130                 } else {
15131                         r->in.server_unc = NULL;
15132                 }
15133                 if (r->in.server_unc) {
15134                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
15135                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
15136                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
15137                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
15138                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
15139                                 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));
15140                         }
15141                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
15142                         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));
15143                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
15144                 }
15145                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
15146                 if (_ptr_client) {
15147                         NDR_PULL_ALLOC(ndr, r->in.client);
15148                 } else {
15149                         r->in.client = NULL;
15150                 }
15151                 if (r->in.client) {
15152                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
15153                         NDR_PULL_SET_MEM_CTX(ndr, r->in.client, 0);
15154                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.client));
15155                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.client));
15156                         if (ndr_get_array_length(ndr, &r->in.client) > ndr_get_array_size(ndr, &r->in.client)) {
15157                                 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));
15158                         }
15159                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.client), sizeof(uint16_t)));
15160                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.client, ndr_get_array_length(ndr, &r->in.client), sizeof(uint16_t), CH_UTF16));
15161                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
15162                 }
15163                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
15164                 if (_ptr_user) {
15165                         NDR_PULL_ALLOC(ndr, r->in.user);
15166                 } else {
15167                         r->in.user = NULL;
15168                 }
15169                 if (r->in.user) {
15170                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
15171                         NDR_PULL_SET_MEM_CTX(ndr, r->in.user, 0);
15172                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.user));
15173                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.user));
15174                         if (ndr_get_array_length(ndr, &r->in.user) > ndr_get_array_size(ndr, &r->in.user)) {
15175                                 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));
15176                         }
15177                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.user), sizeof(uint16_t)));
15178                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.user, ndr_get_array_length(ndr, &r->in.user), sizeof(uint16_t), CH_UTF16));
15179                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
15180                 }
15181         }
15182         if (flags & NDR_OUT) {
15183                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15184         }
15185         return NDR_ERR_SUCCESS;
15186 }
15187
15188 _PUBLIC_ void ndr_print_srvsvc_NetSessDel(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetSessDel *r)
15189 {
15190         ndr_print_struct(ndr, name, "srvsvc_NetSessDel");
15191         ndr->depth++;
15192         if (flags & NDR_SET_VALUES) {
15193                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15194         }
15195         if (flags & NDR_IN) {
15196                 ndr_print_struct(ndr, "in", "srvsvc_NetSessDel");
15197                 ndr->depth++;
15198                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
15199                 ndr->depth++;
15200                 if (r->in.server_unc) {
15201                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
15202                 }
15203                 ndr->depth--;
15204                 ndr_print_ptr(ndr, "client", r->in.client);
15205                 ndr->depth++;
15206                 if (r->in.client) {
15207                         ndr_print_string(ndr, "client", r->in.client);
15208                 }
15209                 ndr->depth--;
15210                 ndr_print_ptr(ndr, "user", r->in.user);
15211                 ndr->depth++;
15212                 if (r->in.user) {
15213                         ndr_print_string(ndr, "user", r->in.user);
15214                 }
15215                 ndr->depth--;
15216                 ndr->depth--;
15217         }
15218         if (flags & NDR_OUT) {
15219                 ndr_print_struct(ndr, "out", "srvsvc_NetSessDel");
15220                 ndr->depth++;
15221                 ndr_print_WERROR(ndr, "result", r->out.result);
15222                 ndr->depth--;
15223         }
15224         ndr->depth--;
15225 }
15226
15227 static enum ndr_err_code ndr_push_srvsvc_NetShareAdd(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareAdd *r)
15228 {
15229         if (flags & NDR_IN) {
15230                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
15231                 if (r->in.server_unc) {
15232                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15233                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15234                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15235                         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));
15236                 }
15237                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15238                 if (r->in.info == NULL) {
15239                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15240                 }
15241                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
15242                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
15243                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_error));
15244                 if (r->in.parm_error) {
15245                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_error));
15246                 }
15247         }
15248         if (flags & NDR_OUT) {
15249                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_error));
15250                 if (r->out.parm_error) {
15251                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_error));
15252                 }
15253                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15254         }
15255         return NDR_ERR_SUCCESS;
15256 }
15257
15258 static enum ndr_err_code ndr_pull_srvsvc_NetShareAdd(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareAdd *r)
15259 {
15260         uint32_t _ptr_server_unc;
15261         uint32_t _ptr_parm_error;
15262         TALLOC_CTX *_mem_save_server_unc_0;
15263         TALLOC_CTX *_mem_save_info_0;
15264         TALLOC_CTX *_mem_save_parm_error_0;
15265         if (flags & NDR_IN) {
15266                 ZERO_STRUCT(r->out);
15267
15268                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
15269                 if (_ptr_server_unc) {
15270                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
15271                 } else {
15272                         r->in.server_unc = NULL;
15273                 }
15274                 if (r->in.server_unc) {
15275                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
15276                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
15277                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
15278                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
15279                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
15280                                 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));
15281                         }
15282                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
15283                         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));
15284                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
15285                 }
15286                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15287                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15288                         NDR_PULL_ALLOC(ndr, r->in.info);
15289                 }
15290                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15291                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
15292                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
15293                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
15294                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
15295                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_error));
15296                 if (_ptr_parm_error) {
15297                         NDR_PULL_ALLOC(ndr, r->in.parm_error);
15298                 } else {
15299                         r->in.parm_error = NULL;
15300                 }
15301                 if (r->in.parm_error) {
15302                         _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
15303                         NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_error, 0);
15304                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_error));
15305                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, 0);
15306                 }
15307         }
15308         if (flags & NDR_OUT) {
15309                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_error));
15310                 if (_ptr_parm_error) {
15311                         NDR_PULL_ALLOC(ndr, r->out.parm_error);
15312                 } else {
15313                         r->out.parm_error = NULL;
15314                 }
15315                 if (r->out.parm_error) {
15316                         _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
15317                         NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_error, 0);
15318                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_error));
15319                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, 0);
15320                 }
15321                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15322         }
15323         return NDR_ERR_SUCCESS;
15324 }
15325
15326 _PUBLIC_ void ndr_print_srvsvc_NetShareAdd(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareAdd *r)
15327 {
15328         ndr_print_struct(ndr, name, "srvsvc_NetShareAdd");
15329         ndr->depth++;
15330         if (flags & NDR_SET_VALUES) {
15331                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15332         }
15333         if (flags & NDR_IN) {
15334                 ndr_print_struct(ndr, "in", "srvsvc_NetShareAdd");
15335                 ndr->depth++;
15336                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
15337                 ndr->depth++;
15338                 if (r->in.server_unc) {
15339                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
15340                 }
15341                 ndr->depth--;
15342                 ndr_print_uint32(ndr, "level", r->in.level);
15343                 ndr_print_ptr(ndr, "info", r->in.info);
15344                 ndr->depth++;
15345                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
15346                 ndr_print_srvsvc_NetShareInfo(ndr, "info", r->in.info);
15347                 ndr->depth--;
15348                 ndr_print_ptr(ndr, "parm_error", r->in.parm_error);
15349                 ndr->depth++;
15350                 if (r->in.parm_error) {
15351                         ndr_print_uint32(ndr, "parm_error", *r->in.parm_error);
15352                 }
15353                 ndr->depth--;
15354                 ndr->depth--;
15355         }
15356         if (flags & NDR_OUT) {
15357                 ndr_print_struct(ndr, "out", "srvsvc_NetShareAdd");
15358                 ndr->depth++;
15359                 ndr_print_ptr(ndr, "parm_error", r->out.parm_error);
15360                 ndr->depth++;
15361                 if (r->out.parm_error) {
15362                         ndr_print_uint32(ndr, "parm_error", *r->out.parm_error);
15363                 }
15364                 ndr->depth--;
15365                 ndr_print_WERROR(ndr, "result", r->out.result);
15366                 ndr->depth--;
15367         }
15368         ndr->depth--;
15369 }
15370
15371 static enum ndr_err_code ndr_push_srvsvc_NetShareEnumAll(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareEnumAll *r)
15372 {
15373         if (flags & NDR_IN) {
15374                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
15375                 if (r->in.server_unc) {
15376                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15377                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15378                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15379                         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));
15380                 }
15381                 if (r->in.info_ctr == NULL) {
15382                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15383                 }
15384                 NDR_CHECK(ndr_push_srvsvc_NetShareInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
15385                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));
15386                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
15387                 if (r->in.resume_handle) {
15388                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
15389                 }
15390         }
15391         if (flags & NDR_OUT) {
15392                 if (r->out.info_ctr == NULL) {
15393                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15394                 }
15395                 NDR_CHECK(ndr_push_srvsvc_NetShareInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));
15396                 if (r->out.totalentries == NULL) {
15397                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15398                 }
15399                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
15400                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
15401                 if (r->out.resume_handle) {
15402                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
15403                 }
15404                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15405         }
15406         return NDR_ERR_SUCCESS;
15407 }
15408
15409 static enum ndr_err_code ndr_pull_srvsvc_NetShareEnumAll(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareEnumAll *r)
15410 {
15411         uint32_t _ptr_server_unc;
15412         uint32_t _ptr_resume_handle;
15413         TALLOC_CTX *_mem_save_server_unc_0;
15414         TALLOC_CTX *_mem_save_info_ctr_0;
15415         TALLOC_CTX *_mem_save_totalentries_0;
15416         TALLOC_CTX *_mem_save_resume_handle_0;
15417         if (flags & NDR_IN) {
15418                 ZERO_STRUCT(r->out);
15419
15420                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
15421                 if (_ptr_server_unc) {
15422                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
15423                 } else {
15424                         r->in.server_unc = NULL;
15425                 }
15426                 if (r->in.server_unc) {
15427                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
15428                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
15429                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
15430                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
15431                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
15432                                 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));
15433                         }
15434                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
15435                         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));
15436                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
15437                 }
15438                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15439                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
15440                 }
15441                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15442                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
15443                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
15444                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15445                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));
15446                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
15447                 if (_ptr_resume_handle) {
15448                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
15449                 } else {
15450                         r->in.resume_handle = NULL;
15451                 }
15452                 if (r->in.resume_handle) {
15453                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15454                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
15455                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
15456                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
15457                 }
15458                 NDR_PULL_ALLOC(ndr, r->out.info_ctr);
15459                 *r->out.info_ctr = *r->in.info_ctr;
15460                 NDR_PULL_ALLOC(ndr, r->out.totalentries);
15461                 ZERO_STRUCTP(r->out.totalentries);
15462         }
15463         if (flags & NDR_OUT) {
15464                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15465                         NDR_PULL_ALLOC(ndr, r->out.info_ctr);
15466                 }
15467                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15468                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_ctr, LIBNDR_FLAG_REF_ALLOC);
15469                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));
15470                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15471                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15472                         NDR_PULL_ALLOC(ndr, r->out.totalentries);
15473                 }
15474                 _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
15475                 NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);
15476                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
15477                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);
15478                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
15479                 if (_ptr_resume_handle) {
15480                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
15481                 } else {
15482                         r->out.resume_handle = NULL;
15483                 }
15484                 if (r->out.resume_handle) {
15485                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15486                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
15487                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
15488                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
15489                 }
15490                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15491         }
15492         return NDR_ERR_SUCCESS;
15493 }
15494
15495 _PUBLIC_ void ndr_print_srvsvc_NetShareEnumAll(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareEnumAll *r)
15496 {
15497         ndr_print_struct(ndr, name, "srvsvc_NetShareEnumAll");
15498         ndr->depth++;
15499         if (flags & NDR_SET_VALUES) {
15500                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15501         }
15502         if (flags & NDR_IN) {
15503                 ndr_print_struct(ndr, "in", "srvsvc_NetShareEnumAll");
15504                 ndr->depth++;
15505                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
15506                 ndr->depth++;
15507                 if (r->in.server_unc) {
15508                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
15509                 }
15510                 ndr->depth--;
15511                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
15512                 ndr->depth++;
15513                 ndr_print_srvsvc_NetShareInfoCtr(ndr, "info_ctr", r->in.info_ctr);
15514                 ndr->depth--;
15515                 ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);
15516                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
15517                 ndr->depth++;
15518                 if (r->in.resume_handle) {
15519                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
15520                 }
15521                 ndr->depth--;
15522                 ndr->depth--;
15523         }
15524         if (flags & NDR_OUT) {
15525                 ndr_print_struct(ndr, "out", "srvsvc_NetShareEnumAll");
15526                 ndr->depth++;
15527                 ndr_print_ptr(ndr, "info_ctr", r->out.info_ctr);
15528                 ndr->depth++;
15529                 ndr_print_srvsvc_NetShareInfoCtr(ndr, "info_ctr", r->out.info_ctr);
15530                 ndr->depth--;
15531                 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
15532                 ndr->depth++;
15533                 ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
15534                 ndr->depth--;
15535                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
15536                 ndr->depth++;
15537                 if (r->out.resume_handle) {
15538                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
15539                 }
15540                 ndr->depth--;
15541                 ndr_print_WERROR(ndr, "result", r->out.result);
15542                 ndr->depth--;
15543         }
15544         ndr->depth--;
15545 }
15546
15547 static enum ndr_err_code ndr_push_srvsvc_NetShareGetInfo(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareGetInfo *r)
15548 {
15549         if (flags & NDR_IN) {
15550                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
15551                 if (r->in.server_unc) {
15552                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15553                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15554                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15555                         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));
15556                 }
15557                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share_name, CH_UTF16)));
15558                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15559                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share_name, CH_UTF16)));
15560                 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));
15561                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15562         }
15563         if (flags & NDR_OUT) {
15564                 if (r->out.info == NULL) {
15565                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15566                 }
15567                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
15568                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15569                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15570         }
15571         return NDR_ERR_SUCCESS;
15572 }
15573
15574 static enum ndr_err_code ndr_pull_srvsvc_NetShareGetInfo(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareGetInfo *r)
15575 {
15576         uint32_t _ptr_server_unc;
15577         TALLOC_CTX *_mem_save_server_unc_0;
15578         TALLOC_CTX *_mem_save_info_0;
15579         if (flags & NDR_IN) {
15580                 ZERO_STRUCT(r->out);
15581
15582                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
15583                 if (_ptr_server_unc) {
15584                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
15585                 } else {
15586                         r->in.server_unc = NULL;
15587                 }
15588                 if (r->in.server_unc) {
15589                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
15590                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
15591                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
15592                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
15593                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
15594                                 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));
15595                         }
15596                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
15597                         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));
15598                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
15599                 }
15600                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.share_name));
15601                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.share_name));
15602                 if (ndr_get_array_length(ndr, &r->in.share_name) > ndr_get_array_size(ndr, &r->in.share_name)) {
15603                         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));
15604                 }
15605                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.share_name), sizeof(uint16_t)));
15606                 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));
15607                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15608                 NDR_PULL_ALLOC(ndr, r->out.info);
15609                 ZERO_STRUCTP(r->out.info);
15610         }
15611         if (flags & NDR_OUT) {
15612                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15613                         NDR_PULL_ALLOC(ndr, r->out.info);
15614                 }
15615                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15616                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
15617                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
15618                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15619                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
15620                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15621         }
15622         return NDR_ERR_SUCCESS;
15623 }
15624
15625 _PUBLIC_ void ndr_print_srvsvc_NetShareGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareGetInfo *r)
15626 {
15627         ndr_print_struct(ndr, name, "srvsvc_NetShareGetInfo");
15628         ndr->depth++;
15629         if (flags & NDR_SET_VALUES) {
15630                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15631         }
15632         if (flags & NDR_IN) {
15633                 ndr_print_struct(ndr, "in", "srvsvc_NetShareGetInfo");
15634                 ndr->depth++;
15635                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
15636                 ndr->depth++;
15637                 if (r->in.server_unc) {
15638                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
15639                 }
15640                 ndr->depth--;
15641                 ndr_print_string(ndr, "share_name", r->in.share_name);
15642                 ndr_print_uint32(ndr, "level", r->in.level);
15643                 ndr->depth--;
15644         }
15645         if (flags & NDR_OUT) {
15646                 ndr_print_struct(ndr, "out", "srvsvc_NetShareGetInfo");
15647                 ndr->depth++;
15648                 ndr_print_ptr(ndr, "info", r->out.info);
15649                 ndr->depth++;
15650                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
15651                 ndr_print_srvsvc_NetShareInfo(ndr, "info", r->out.info);
15652                 ndr->depth--;
15653                 ndr_print_WERROR(ndr, "result", r->out.result);
15654                 ndr->depth--;
15655         }
15656         ndr->depth--;
15657 }
15658
15659 static enum ndr_err_code ndr_push_srvsvc_NetShareSetInfo(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareSetInfo *r)
15660 {
15661         if (flags & NDR_IN) {
15662                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
15663                 if (r->in.server_unc) {
15664                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15665                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15666                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15667                         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));
15668                 }
15669                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share_name, CH_UTF16)));
15670                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15671                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share_name, CH_UTF16)));
15672                 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));
15673                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15674                 if (r->in.info == NULL) {
15675                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15676                 }
15677                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
15678                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
15679                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_error));
15680                 if (r->in.parm_error) {
15681                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_error));
15682                 }
15683         }
15684         if (flags & NDR_OUT) {
15685                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_error));
15686                 if (r->out.parm_error) {
15687                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_error));
15688                 }
15689                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15690         }
15691         return NDR_ERR_SUCCESS;
15692 }
15693
15694 static enum ndr_err_code ndr_pull_srvsvc_NetShareSetInfo(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareSetInfo *r)
15695 {
15696         uint32_t _ptr_server_unc;
15697         uint32_t _ptr_parm_error;
15698         TALLOC_CTX *_mem_save_server_unc_0;
15699         TALLOC_CTX *_mem_save_info_0;
15700         TALLOC_CTX *_mem_save_parm_error_0;
15701         if (flags & NDR_IN) {
15702                 ZERO_STRUCT(r->out);
15703
15704                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
15705                 if (_ptr_server_unc) {
15706                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
15707                 } else {
15708                         r->in.server_unc = NULL;
15709                 }
15710                 if (r->in.server_unc) {
15711                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
15712                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
15713                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
15714                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
15715                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
15716                                 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));
15717                         }
15718                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
15719                         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));
15720                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
15721                 }
15722                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.share_name));
15723                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.share_name));
15724                 if (ndr_get_array_length(ndr, &r->in.share_name) > ndr_get_array_size(ndr, &r->in.share_name)) {
15725                         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));
15726                 }
15727                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.share_name), sizeof(uint16_t)));
15728                 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));
15729                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15730                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15731                         NDR_PULL_ALLOC(ndr, r->in.info);
15732                 }
15733                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15734                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
15735                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
15736                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
15737                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
15738                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_error));
15739                 if (_ptr_parm_error) {
15740                         NDR_PULL_ALLOC(ndr, r->in.parm_error);
15741                 } else {
15742                         r->in.parm_error = NULL;
15743                 }
15744                 if (r->in.parm_error) {
15745                         _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
15746                         NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_error, 0);
15747                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_error));
15748                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, 0);
15749                 }
15750         }
15751         if (flags & NDR_OUT) {
15752                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_error));
15753                 if (_ptr_parm_error) {
15754                         NDR_PULL_ALLOC(ndr, r->out.parm_error);
15755                 } else {
15756                         r->out.parm_error = NULL;
15757                 }
15758                 if (r->out.parm_error) {
15759                         _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
15760                         NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_error, 0);
15761                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_error));
15762                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, 0);
15763                 }
15764                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15765         }
15766         return NDR_ERR_SUCCESS;
15767 }
15768
15769 _PUBLIC_ void ndr_print_srvsvc_NetShareSetInfo(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareSetInfo *r)
15770 {
15771         ndr_print_struct(ndr, name, "srvsvc_NetShareSetInfo");
15772         ndr->depth++;
15773         if (flags & NDR_SET_VALUES) {
15774                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15775         }
15776         if (flags & NDR_IN) {
15777                 ndr_print_struct(ndr, "in", "srvsvc_NetShareSetInfo");
15778                 ndr->depth++;
15779                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
15780                 ndr->depth++;
15781                 if (r->in.server_unc) {
15782                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
15783                 }
15784                 ndr->depth--;
15785                 ndr_print_string(ndr, "share_name", r->in.share_name);
15786                 ndr_print_uint32(ndr, "level", r->in.level);
15787                 ndr_print_ptr(ndr, "info", r->in.info);
15788                 ndr->depth++;
15789                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
15790                 ndr_print_srvsvc_NetShareInfo(ndr, "info", r->in.info);
15791                 ndr->depth--;
15792                 ndr_print_ptr(ndr, "parm_error", r->in.parm_error);
15793                 ndr->depth++;
15794                 if (r->in.parm_error) {
15795                         ndr_print_uint32(ndr, "parm_error", *r->in.parm_error);
15796                 }
15797                 ndr->depth--;
15798                 ndr->depth--;
15799         }
15800         if (flags & NDR_OUT) {
15801                 ndr_print_struct(ndr, "out", "srvsvc_NetShareSetInfo");
15802                 ndr->depth++;
15803                 ndr_print_ptr(ndr, "parm_error", r->out.parm_error);
15804                 ndr->depth++;
15805                 if (r->out.parm_error) {
15806                         ndr_print_uint32(ndr, "parm_error", *r->out.parm_error);
15807                 }
15808                 ndr->depth--;
15809                 ndr_print_WERROR(ndr, "result", r->out.result);
15810                 ndr->depth--;
15811         }
15812         ndr->depth--;
15813 }
15814
15815 static enum ndr_err_code ndr_push_srvsvc_NetShareDel(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareDel *r)
15816 {
15817         if (flags & NDR_IN) {
15818                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
15819                 if (r->in.server_unc) {
15820                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15821                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15822                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15823                         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));
15824                 }
15825                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share_name, CH_UTF16)));
15826                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15827                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share_name, CH_UTF16)));
15828                 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));
15829                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reserved));
15830         }
15831         if (flags & NDR_OUT) {
15832                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15833         }
15834         return NDR_ERR_SUCCESS;
15835 }
15836
15837 static enum ndr_err_code ndr_pull_srvsvc_NetShareDel(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareDel *r)
15838 {
15839         uint32_t _ptr_server_unc;
15840         TALLOC_CTX *_mem_save_server_unc_0;
15841         if (flags & NDR_IN) {
15842                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
15843                 if (_ptr_server_unc) {
15844                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
15845                 } else {
15846                         r->in.server_unc = NULL;
15847                 }
15848                 if (r->in.server_unc) {
15849                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
15850                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
15851                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
15852                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
15853                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
15854                                 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));
15855                         }
15856                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
15857                         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));
15858                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
15859                 }
15860                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.share_name));
15861                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.share_name));
15862                 if (ndr_get_array_length(ndr, &r->in.share_name) > ndr_get_array_size(ndr, &r->in.share_name)) {
15863                         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));
15864                 }
15865                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.share_name), sizeof(uint16_t)));
15866                 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));
15867                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reserved));
15868         }
15869         if (flags & NDR_OUT) {
15870                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15871         }
15872         return NDR_ERR_SUCCESS;
15873 }
15874
15875 _PUBLIC_ void ndr_print_srvsvc_NetShareDel(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareDel *r)
15876 {
15877         ndr_print_struct(ndr, name, "srvsvc_NetShareDel");
15878         ndr->depth++;
15879         if (flags & NDR_SET_VALUES) {
15880                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15881         }
15882         if (flags & NDR_IN) {
15883                 ndr_print_struct(ndr, "in", "srvsvc_NetShareDel");
15884                 ndr->depth++;
15885                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
15886                 ndr->depth++;
15887                 if (r->in.server_unc) {
15888                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
15889                 }
15890                 ndr->depth--;
15891                 ndr_print_string(ndr, "share_name", r->in.share_name);
15892                 ndr_print_uint32(ndr, "reserved", r->in.reserved);
15893                 ndr->depth--;
15894         }
15895         if (flags & NDR_OUT) {
15896                 ndr_print_struct(ndr, "out", "srvsvc_NetShareDel");
15897                 ndr->depth++;
15898                 ndr_print_WERROR(ndr, "result", r->out.result);
15899                 ndr->depth--;
15900         }
15901         ndr->depth--;
15902 }
15903
15904 static enum ndr_err_code ndr_push_srvsvc_NetShareDelSticky(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareDelSticky *r)
15905 {
15906         if (flags & NDR_IN) {
15907                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
15908                 if (r->in.server_unc) {
15909                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15910                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15911                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15912                         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));
15913                 }
15914                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share_name, CH_UTF16)));
15915                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15916                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share_name, CH_UTF16)));
15917                 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));
15918                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reserved));
15919         }
15920         if (flags & NDR_OUT) {
15921                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15922         }
15923         return NDR_ERR_SUCCESS;
15924 }
15925
15926 static enum ndr_err_code ndr_pull_srvsvc_NetShareDelSticky(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareDelSticky *r)
15927 {
15928         uint32_t _ptr_server_unc;
15929         TALLOC_CTX *_mem_save_server_unc_0;
15930         if (flags & NDR_IN) {
15931                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
15932                 if (_ptr_server_unc) {
15933                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
15934                 } else {
15935                         r->in.server_unc = NULL;
15936                 }
15937                 if (r->in.server_unc) {
15938                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
15939                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
15940                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
15941                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
15942                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
15943                                 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));
15944                         }
15945                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
15946                         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));
15947                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
15948                 }
15949                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.share_name));
15950                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.share_name));
15951                 if (ndr_get_array_length(ndr, &r->in.share_name) > ndr_get_array_size(ndr, &r->in.share_name)) {
15952                         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));
15953                 }
15954                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.share_name), sizeof(uint16_t)));
15955                 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));
15956                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reserved));
15957         }
15958         if (flags & NDR_OUT) {
15959                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15960         }
15961         return NDR_ERR_SUCCESS;
15962 }
15963
15964 _PUBLIC_ void ndr_print_srvsvc_NetShareDelSticky(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareDelSticky *r)
15965 {
15966         ndr_print_struct(ndr, name, "srvsvc_NetShareDelSticky");
15967         ndr->depth++;
15968         if (flags & NDR_SET_VALUES) {
15969                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15970         }
15971         if (flags & NDR_IN) {
15972                 ndr_print_struct(ndr, "in", "srvsvc_NetShareDelSticky");
15973                 ndr->depth++;
15974                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
15975                 ndr->depth++;
15976                 if (r->in.server_unc) {
15977                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
15978                 }
15979                 ndr->depth--;
15980                 ndr_print_string(ndr, "share_name", r->in.share_name);
15981                 ndr_print_uint32(ndr, "reserved", r->in.reserved);
15982                 ndr->depth--;
15983         }
15984         if (flags & NDR_OUT) {
15985                 ndr_print_struct(ndr, "out", "srvsvc_NetShareDelSticky");
15986                 ndr->depth++;
15987                 ndr_print_WERROR(ndr, "result", r->out.result);
15988                 ndr->depth--;
15989         }
15990         ndr->depth--;
15991 }
15992
15993 static enum ndr_err_code ndr_push_srvsvc_NetShareCheck(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareCheck *r)
15994 {
15995         if (flags & NDR_IN) {
15996                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
15997                 if (r->in.server_unc) {
15998                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15999                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16000                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16001                         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));
16002                 }
16003                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.device_name, CH_UTF16)));
16004                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16005                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.device_name, CH_UTF16)));
16006                 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));
16007         }
16008         if (flags & NDR_OUT) {
16009                 if (r->out.type == NULL) {
16010                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16011                 }
16012                 NDR_CHECK(ndr_push_srvsvc_ShareType(ndr, NDR_SCALARS, *r->out.type));
16013                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16014         }
16015         return NDR_ERR_SUCCESS;
16016 }
16017
16018 static enum ndr_err_code ndr_pull_srvsvc_NetShareCheck(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareCheck *r)
16019 {
16020         uint32_t _ptr_server_unc;
16021         TALLOC_CTX *_mem_save_server_unc_0;
16022         TALLOC_CTX *_mem_save_type_0;
16023         if (flags & NDR_IN) {
16024                 ZERO_STRUCT(r->out);
16025
16026                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
16027                 if (_ptr_server_unc) {
16028                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
16029                 } else {
16030                         r->in.server_unc = NULL;
16031                 }
16032                 if (r->in.server_unc) {
16033                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
16034                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
16035                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
16036                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
16037                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
16038                                 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));
16039                         }
16040                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
16041                         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));
16042                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
16043                 }
16044                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.device_name));
16045                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.device_name));
16046                 if (ndr_get_array_length(ndr, &r->in.device_name) > ndr_get_array_size(ndr, &r->in.device_name)) {
16047                         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));
16048                 }
16049                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.device_name), sizeof(uint16_t)));
16050                 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));
16051                 NDR_PULL_ALLOC(ndr, r->out.type);
16052                 ZERO_STRUCTP(r->out.type);
16053         }
16054         if (flags & NDR_OUT) {
16055                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16056                         NDR_PULL_ALLOC(ndr, r->out.type);
16057                 }
16058                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
16059                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
16060                 NDR_CHECK(ndr_pull_srvsvc_ShareType(ndr, NDR_SCALARS, r->out.type));
16061                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
16062                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16063         }
16064         return NDR_ERR_SUCCESS;
16065 }
16066
16067 _PUBLIC_ void ndr_print_srvsvc_NetShareCheck(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareCheck *r)
16068 {
16069         ndr_print_struct(ndr, name, "srvsvc_NetShareCheck");
16070         ndr->depth++;
16071         if (flags & NDR_SET_VALUES) {
16072                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16073         }
16074         if (flags & NDR_IN) {
16075                 ndr_print_struct(ndr, "in", "srvsvc_NetShareCheck");
16076                 ndr->depth++;
16077                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
16078                 ndr->depth++;
16079                 if (r->in.server_unc) {
16080                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
16081                 }
16082                 ndr->depth--;
16083                 ndr_print_string(ndr, "device_name", r->in.device_name);
16084                 ndr->depth--;
16085         }
16086         if (flags & NDR_OUT) {
16087                 ndr_print_struct(ndr, "out", "srvsvc_NetShareCheck");
16088                 ndr->depth++;
16089                 ndr_print_ptr(ndr, "type", r->out.type);
16090                 ndr->depth++;
16091                 ndr_print_srvsvc_ShareType(ndr, "type", *r->out.type);
16092                 ndr->depth--;
16093                 ndr_print_WERROR(ndr, "result", r->out.result);
16094                 ndr->depth--;
16095         }
16096         ndr->depth--;
16097 }
16098
16099 static enum ndr_err_code ndr_push_srvsvc_NetSrvGetInfo(struct ndr_push *ndr, int flags, const struct srvsvc_NetSrvGetInfo *r)
16100 {
16101         if (flags & NDR_IN) {
16102                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
16103                 if (r->in.server_unc) {
16104                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16105                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16106                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16107                         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));
16108                 }
16109                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16110         }
16111         if (flags & NDR_OUT) {
16112                 if (r->out.info == NULL) {
16113                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16114                 }
16115                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
16116                 NDR_CHECK(ndr_push_srvsvc_NetSrvInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
16117                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16118         }
16119         return NDR_ERR_SUCCESS;
16120 }
16121
16122 static enum ndr_err_code ndr_pull_srvsvc_NetSrvGetInfo(struct ndr_pull *ndr, int flags, struct srvsvc_NetSrvGetInfo *r)
16123 {
16124         uint32_t _ptr_server_unc;
16125         TALLOC_CTX *_mem_save_server_unc_0;
16126         TALLOC_CTX *_mem_save_info_0;
16127         if (flags & NDR_IN) {
16128                 ZERO_STRUCT(r->out);
16129
16130                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
16131                 if (_ptr_server_unc) {
16132                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
16133                 } else {
16134                         r->in.server_unc = NULL;
16135                 }
16136                 if (r->in.server_unc) {
16137                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
16138                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
16139                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
16140                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
16141                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
16142                                 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));
16143                         }
16144                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
16145                         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));
16146                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
16147                 }
16148                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16149                 NDR_PULL_ALLOC(ndr, r->out.info);
16150                 ZERO_STRUCTP(r->out.info);
16151         }
16152         if (flags & NDR_OUT) {
16153                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16154                         NDR_PULL_ALLOC(ndr, r->out.info);
16155                 }
16156                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16157                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
16158                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
16159                 NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
16160                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
16161                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16162         }
16163         return NDR_ERR_SUCCESS;
16164 }
16165
16166 _PUBLIC_ void ndr_print_srvsvc_NetSrvGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetSrvGetInfo *r)
16167 {
16168         ndr_print_struct(ndr, name, "srvsvc_NetSrvGetInfo");
16169         ndr->depth++;
16170         if (flags & NDR_SET_VALUES) {
16171                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16172         }
16173         if (flags & NDR_IN) {
16174                 ndr_print_struct(ndr, "in", "srvsvc_NetSrvGetInfo");
16175                 ndr->depth++;
16176                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
16177                 ndr->depth++;
16178                 if (r->in.server_unc) {
16179                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
16180                 }
16181                 ndr->depth--;
16182                 ndr_print_uint32(ndr, "level", r->in.level);
16183                 ndr->depth--;
16184         }
16185         if (flags & NDR_OUT) {
16186                 ndr_print_struct(ndr, "out", "srvsvc_NetSrvGetInfo");
16187                 ndr->depth++;
16188                 ndr_print_ptr(ndr, "info", r->out.info);
16189                 ndr->depth++;
16190                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
16191                 ndr_print_srvsvc_NetSrvInfo(ndr, "info", r->out.info);
16192                 ndr->depth--;
16193                 ndr_print_WERROR(ndr, "result", r->out.result);
16194                 ndr->depth--;
16195         }
16196         ndr->depth--;
16197 }
16198
16199 static enum ndr_err_code ndr_push_srvsvc_NetSrvSetInfo(struct ndr_push *ndr, int flags, const struct srvsvc_NetSrvSetInfo *r)
16200 {
16201         if (flags & NDR_IN) {
16202                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
16203                 if (r->in.server_unc) {
16204                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16205                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16206                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16207                         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));
16208                 }
16209                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16210                 if (r->in.info == NULL) {
16211                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16212                 }
16213                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
16214                 NDR_CHECK(ndr_push_srvsvc_NetSrvInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
16215                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_error));
16216                 if (r->in.parm_error) {
16217                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_error));
16218                 }
16219         }
16220         if (flags & NDR_OUT) {
16221                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_error));
16222                 if (r->out.parm_error) {
16223                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_error));
16224                 }
16225                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16226         }
16227         return NDR_ERR_SUCCESS;
16228 }
16229
16230 static enum ndr_err_code ndr_pull_srvsvc_NetSrvSetInfo(struct ndr_pull *ndr, int flags, struct srvsvc_NetSrvSetInfo *r)
16231 {
16232         uint32_t _ptr_server_unc;
16233         uint32_t _ptr_parm_error;
16234         TALLOC_CTX *_mem_save_server_unc_0;
16235         TALLOC_CTX *_mem_save_info_0;
16236         TALLOC_CTX *_mem_save_parm_error_0;
16237         if (flags & NDR_IN) {
16238                 ZERO_STRUCT(r->out);
16239
16240                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
16241                 if (_ptr_server_unc) {
16242                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
16243                 } else {
16244                         r->in.server_unc = NULL;
16245                 }
16246                 if (r->in.server_unc) {
16247                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
16248                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
16249                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
16250                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
16251                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
16252                                 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));
16253                         }
16254                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
16255                         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));
16256                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
16257                 }
16258                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16259                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16260                         NDR_PULL_ALLOC(ndr, r->in.info);
16261                 }
16262                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16263                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
16264                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
16265                 NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
16266                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
16267                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_error));
16268                 if (_ptr_parm_error) {
16269                         NDR_PULL_ALLOC(ndr, r->in.parm_error);
16270                 } else {
16271                         r->in.parm_error = NULL;
16272                 }
16273                 if (r->in.parm_error) {
16274                         _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
16275                         NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_error, 0);
16276                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_error));
16277                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, 0);
16278                 }
16279         }
16280         if (flags & NDR_OUT) {
16281                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_error));
16282                 if (_ptr_parm_error) {
16283                         NDR_PULL_ALLOC(ndr, r->out.parm_error);
16284                 } else {
16285                         r->out.parm_error = NULL;
16286                 }
16287                 if (r->out.parm_error) {
16288                         _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
16289                         NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_error, 0);
16290                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_error));
16291                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, 0);
16292                 }
16293                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16294         }
16295         return NDR_ERR_SUCCESS;
16296 }
16297
16298 _PUBLIC_ void ndr_print_srvsvc_NetSrvSetInfo(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetSrvSetInfo *r)
16299 {
16300         ndr_print_struct(ndr, name, "srvsvc_NetSrvSetInfo");
16301         ndr->depth++;
16302         if (flags & NDR_SET_VALUES) {
16303                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16304         }
16305         if (flags & NDR_IN) {
16306                 ndr_print_struct(ndr, "in", "srvsvc_NetSrvSetInfo");
16307                 ndr->depth++;
16308                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
16309                 ndr->depth++;
16310                 if (r->in.server_unc) {
16311                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
16312                 }
16313                 ndr->depth--;
16314                 ndr_print_uint32(ndr, "level", r->in.level);
16315                 ndr_print_ptr(ndr, "info", r->in.info);
16316                 ndr->depth++;
16317                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
16318                 ndr_print_srvsvc_NetSrvInfo(ndr, "info", r->in.info);
16319                 ndr->depth--;
16320                 ndr_print_ptr(ndr, "parm_error", r->in.parm_error);
16321                 ndr->depth++;
16322                 if (r->in.parm_error) {
16323                         ndr_print_uint32(ndr, "parm_error", *r->in.parm_error);
16324                 }
16325                 ndr->depth--;
16326                 ndr->depth--;
16327         }
16328         if (flags & NDR_OUT) {
16329                 ndr_print_struct(ndr, "out", "srvsvc_NetSrvSetInfo");
16330                 ndr->depth++;
16331                 ndr_print_ptr(ndr, "parm_error", r->out.parm_error);
16332                 ndr->depth++;
16333                 if (r->out.parm_error) {
16334                         ndr_print_uint32(ndr, "parm_error", *r->out.parm_error);
16335                 }
16336                 ndr->depth--;
16337                 ndr_print_WERROR(ndr, "result", r->out.result);
16338                 ndr->depth--;
16339         }
16340         ndr->depth--;
16341 }
16342
16343 static enum ndr_err_code ndr_push_srvsvc_NetDiskEnum(struct ndr_push *ndr, int flags, const struct srvsvc_NetDiskEnum *r)
16344 {
16345         if (flags & NDR_IN) {
16346                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
16347                 if (r->in.server_unc) {
16348                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16349                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16350                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16351                         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));
16352                 }
16353                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16354                 if (r->in.info == NULL) {
16355                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16356                 }
16357                 NDR_CHECK(ndr_push_srvsvc_NetDiskInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
16358                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.maxlen));
16359                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
16360                 if (r->in.resume_handle) {
16361                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
16362                 }
16363         }
16364         if (flags & NDR_OUT) {
16365                 if (r->out.info == NULL) {
16366                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16367                 }
16368                 NDR_CHECK(ndr_push_srvsvc_NetDiskInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
16369                 if (r->out.totalentries == NULL) {
16370                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16371                 }
16372                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
16373                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
16374                 if (r->out.resume_handle) {
16375                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
16376                 }
16377                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16378         }
16379         return NDR_ERR_SUCCESS;
16380 }
16381
16382 static enum ndr_err_code ndr_pull_srvsvc_NetDiskEnum(struct ndr_pull *ndr, int flags, struct srvsvc_NetDiskEnum *r)
16383 {
16384         uint32_t _ptr_server_unc;
16385         uint32_t _ptr_resume_handle;
16386         TALLOC_CTX *_mem_save_server_unc_0;
16387         TALLOC_CTX *_mem_save_info_0;
16388         TALLOC_CTX *_mem_save_totalentries_0;
16389         TALLOC_CTX *_mem_save_resume_handle_0;
16390         if (flags & NDR_IN) {
16391                 ZERO_STRUCT(r->out);
16392
16393                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
16394                 if (_ptr_server_unc) {
16395                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
16396                 } else {
16397                         r->in.server_unc = NULL;
16398                 }
16399                 if (r->in.server_unc) {
16400                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
16401                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
16402                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
16403                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
16404                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
16405                                 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));
16406                         }
16407                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
16408                         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));
16409                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
16410                 }
16411                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16412                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16413                         NDR_PULL_ALLOC(ndr, r->in.info);
16414                 }
16415                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16416                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
16417                 NDR_CHECK(ndr_pull_srvsvc_NetDiskInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
16418                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
16419                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.maxlen));
16420                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
16421                 if (_ptr_resume_handle) {
16422                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
16423                 } else {
16424                         r->in.resume_handle = NULL;
16425                 }
16426                 if (r->in.resume_handle) {
16427                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16428                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
16429                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
16430                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
16431                 }
16432                 NDR_PULL_ALLOC(ndr, r->out.info);
16433                 *r->out.info = *r->in.info;
16434                 NDR_PULL_ALLOC(ndr, r->out.totalentries);
16435                 ZERO_STRUCTP(r->out.totalentries);
16436         }
16437         if (flags & NDR_OUT) {
16438                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16439                         NDR_PULL_ALLOC(ndr, r->out.info);
16440                 }
16441                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16442                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
16443                 NDR_CHECK(ndr_pull_srvsvc_NetDiskInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
16444                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
16445                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16446                         NDR_PULL_ALLOC(ndr, r->out.totalentries);
16447                 }
16448                 _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
16449                 NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);
16450                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
16451                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);
16452                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
16453                 if (_ptr_resume_handle) {
16454                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
16455                 } else {
16456                         r->out.resume_handle = NULL;
16457                 }
16458                 if (r->out.resume_handle) {
16459                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16460                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
16461                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
16462                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
16463                 }
16464                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16465         }
16466         return NDR_ERR_SUCCESS;
16467 }
16468
16469 _PUBLIC_ void ndr_print_srvsvc_NetDiskEnum(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetDiskEnum *r)
16470 {
16471         ndr_print_struct(ndr, name, "srvsvc_NetDiskEnum");
16472         ndr->depth++;
16473         if (flags & NDR_SET_VALUES) {
16474                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16475         }
16476         if (flags & NDR_IN) {
16477                 ndr_print_struct(ndr, "in", "srvsvc_NetDiskEnum");
16478                 ndr->depth++;
16479                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
16480                 ndr->depth++;
16481                 if (r->in.server_unc) {
16482                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
16483                 }
16484                 ndr->depth--;
16485                 ndr_print_uint32(ndr, "level", r->in.level);
16486                 ndr_print_ptr(ndr, "info", r->in.info);
16487                 ndr->depth++;
16488                 ndr_print_srvsvc_NetDiskInfo(ndr, "info", r->in.info);
16489                 ndr->depth--;
16490                 ndr_print_uint32(ndr, "maxlen", r->in.maxlen);
16491                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
16492                 ndr->depth++;
16493                 if (r->in.resume_handle) {
16494                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
16495                 }
16496                 ndr->depth--;
16497                 ndr->depth--;
16498         }
16499         if (flags & NDR_OUT) {
16500                 ndr_print_struct(ndr, "out", "srvsvc_NetDiskEnum");
16501                 ndr->depth++;
16502                 ndr_print_ptr(ndr, "info", r->out.info);
16503                 ndr->depth++;
16504                 ndr_print_srvsvc_NetDiskInfo(ndr, "info", r->out.info);
16505                 ndr->depth--;
16506                 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
16507                 ndr->depth++;
16508                 ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
16509                 ndr->depth--;
16510                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
16511                 ndr->depth++;
16512                 if (r->out.resume_handle) {
16513                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
16514                 }
16515                 ndr->depth--;
16516                 ndr_print_WERROR(ndr, "result", r->out.result);
16517                 ndr->depth--;
16518         }
16519         ndr->depth--;
16520 }
16521
16522 static enum ndr_err_code ndr_push_srvsvc_NetServerStatisticsGet(struct ndr_push *ndr, int flags, const struct srvsvc_NetServerStatisticsGet *r)
16523 {
16524         if (flags & NDR_IN) {
16525                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
16526                 if (r->in.server_unc) {
16527                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16528                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16529                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16530                         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));
16531                 }
16532                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service));
16533                 if (r->in.service) {
16534                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service, CH_UTF16)));
16535                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16536                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service, CH_UTF16)));
16537                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.service, ndr_charset_length(r->in.service, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16538                 }
16539                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16540                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
16541         }
16542         if (flags & NDR_OUT) {
16543                 if (r->out.stats == NULL) {
16544                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16545                 }
16546                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.stats));
16547                 if (*r->out.stats) {
16548                         NDR_CHECK(ndr_push_srvsvc_Statistics(ndr, NDR_SCALARS, *r->out.stats));
16549                 }
16550                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16551         }
16552         return NDR_ERR_SUCCESS;
16553 }
16554
16555 static enum ndr_err_code ndr_pull_srvsvc_NetServerStatisticsGet(struct ndr_pull *ndr, int flags, struct srvsvc_NetServerStatisticsGet *r)
16556 {
16557         uint32_t _ptr_server_unc;
16558         uint32_t _ptr_service;
16559         uint32_t _ptr_stats;
16560         TALLOC_CTX *_mem_save_server_unc_0;
16561         TALLOC_CTX *_mem_save_service_0;
16562         TALLOC_CTX *_mem_save_stats_0;
16563         TALLOC_CTX *_mem_save_stats_1;
16564         if (flags & NDR_IN) {
16565                 ZERO_STRUCT(r->out);
16566
16567                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
16568                 if (_ptr_server_unc) {
16569                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
16570                 } else {
16571                         r->in.server_unc = NULL;
16572                 }
16573                 if (r->in.server_unc) {
16574                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
16575                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
16576                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
16577                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
16578                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
16579                                 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));
16580                         }
16581                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
16582                         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));
16583                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
16584                 }
16585                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service));
16586                 if (_ptr_service) {
16587                         NDR_PULL_ALLOC(ndr, r->in.service);
16588                 } else {
16589                         r->in.service = NULL;
16590                 }
16591                 if (r->in.service) {
16592                         _mem_save_service_0 = NDR_PULL_GET_MEM_CTX(ndr);
16593                         NDR_PULL_SET_MEM_CTX(ndr, r->in.service, 0);
16594                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service));
16595                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service));
16596                         if (ndr_get_array_length(ndr, &r->in.service) > ndr_get_array_size(ndr, &r->in.service)) {
16597                                 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));
16598                         }
16599                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.service), sizeof(uint16_t)));
16600                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service, ndr_get_array_length(ndr, &r->in.service), sizeof(uint16_t), CH_UTF16));
16601                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_0, 0);
16602                 }
16603                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16604                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
16605                 NDR_PULL_ALLOC(ndr, r->out.stats);
16606                 ZERO_STRUCTP(r->out.stats);
16607         }
16608         if (flags & NDR_OUT) {
16609                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16610                         NDR_PULL_ALLOC(ndr, r->out.stats);
16611                 }
16612                 _mem_save_stats_0 = NDR_PULL_GET_MEM_CTX(ndr);
16613                 NDR_PULL_SET_MEM_CTX(ndr, r->out.stats, LIBNDR_FLAG_REF_ALLOC);
16614                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_stats));
16615                 if (_ptr_stats) {
16616                         NDR_PULL_ALLOC(ndr, *r->out.stats);
16617                 } else {
16618                         *r->out.stats = NULL;
16619                 }
16620                 if (*r->out.stats) {
16621                         _mem_save_stats_1 = NDR_PULL_GET_MEM_CTX(ndr);
16622                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.stats, 0);
16623                         NDR_CHECK(ndr_pull_srvsvc_Statistics(ndr, NDR_SCALARS, *r->out.stats));
16624                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_stats_1, 0);
16625                 }
16626                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_stats_0, LIBNDR_FLAG_REF_ALLOC);
16627                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16628         }
16629         return NDR_ERR_SUCCESS;
16630 }
16631
16632 _PUBLIC_ void ndr_print_srvsvc_NetServerStatisticsGet(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetServerStatisticsGet *r)
16633 {
16634         ndr_print_struct(ndr, name, "srvsvc_NetServerStatisticsGet");
16635         ndr->depth++;
16636         if (flags & NDR_SET_VALUES) {
16637                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16638         }
16639         if (flags & NDR_IN) {
16640                 ndr_print_struct(ndr, "in", "srvsvc_NetServerStatisticsGet");
16641                 ndr->depth++;
16642                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
16643                 ndr->depth++;
16644                 if (r->in.server_unc) {
16645                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
16646                 }
16647                 ndr->depth--;
16648                 ndr_print_ptr(ndr, "service", r->in.service);
16649                 ndr->depth++;
16650                 if (r->in.service) {
16651                         ndr_print_string(ndr, "service", r->in.service);
16652                 }
16653                 ndr->depth--;
16654                 ndr_print_uint32(ndr, "level", r->in.level);
16655                 ndr_print_uint32(ndr, "options", r->in.options);
16656                 ndr->depth--;
16657         }
16658         if (flags & NDR_OUT) {
16659                 ndr_print_struct(ndr, "out", "srvsvc_NetServerStatisticsGet");
16660                 ndr->depth++;
16661                 ndr_print_ptr(ndr, "stats", r->out.stats);
16662                 ndr->depth++;
16663                 ndr_print_ptr(ndr, "stats", *r->out.stats);
16664                 ndr->depth++;
16665                 if (*r->out.stats) {
16666                         ndr_print_srvsvc_Statistics(ndr, "stats", *r->out.stats);
16667                 }
16668                 ndr->depth--;
16669                 ndr->depth--;
16670                 ndr_print_WERROR(ndr, "result", r->out.result);
16671                 ndr->depth--;
16672         }
16673         ndr->depth--;
16674 }
16675
16676 static enum ndr_err_code ndr_push_srvsvc_NetTransportAdd(struct ndr_push *ndr, int flags, const struct srvsvc_NetTransportAdd *r)
16677 {
16678         if (flags & NDR_IN) {
16679                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
16680                 if (r->in.server_unc) {
16681                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16682                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16683                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16684                         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));
16685                 }
16686                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16687                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
16688                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
16689         }
16690         if (flags & NDR_OUT) {
16691                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16692         }
16693         return NDR_ERR_SUCCESS;
16694 }
16695
16696 static enum ndr_err_code ndr_pull_srvsvc_NetTransportAdd(struct ndr_pull *ndr, int flags, struct srvsvc_NetTransportAdd *r)
16697 {
16698         uint32_t _ptr_server_unc;
16699         TALLOC_CTX *_mem_save_server_unc_0;
16700         if (flags & NDR_IN) {
16701                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
16702                 if (_ptr_server_unc) {
16703                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
16704                 } else {
16705                         r->in.server_unc = NULL;
16706                 }
16707                 if (r->in.server_unc) {
16708                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
16709                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
16710                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
16711                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
16712                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
16713                                 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));
16714                         }
16715                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
16716                         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));
16717                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
16718                 }
16719                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16720                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
16721                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
16722         }
16723         if (flags & NDR_OUT) {
16724                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16725         }
16726         return NDR_ERR_SUCCESS;
16727 }
16728
16729 _PUBLIC_ void ndr_print_srvsvc_NetTransportAdd(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetTransportAdd *r)
16730 {
16731         ndr_print_struct(ndr, name, "srvsvc_NetTransportAdd");
16732         ndr->depth++;
16733         if (flags & NDR_SET_VALUES) {
16734                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16735         }
16736         if (flags & NDR_IN) {
16737                 ndr_print_struct(ndr, "in", "srvsvc_NetTransportAdd");
16738                 ndr->depth++;
16739                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
16740                 ndr->depth++;
16741                 if (r->in.server_unc) {
16742                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
16743                 }
16744                 ndr->depth--;
16745                 ndr_print_uint32(ndr, "level", r->in.level);
16746                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
16747                 ndr_print_srvsvc_NetTransportInfo(ndr, "info", &r->in.info);
16748                 ndr->depth--;
16749         }
16750         if (flags & NDR_OUT) {
16751                 ndr_print_struct(ndr, "out", "srvsvc_NetTransportAdd");
16752                 ndr->depth++;
16753                 ndr_print_WERROR(ndr, "result", r->out.result);
16754                 ndr->depth--;
16755         }
16756         ndr->depth--;
16757 }
16758
16759 static enum ndr_err_code ndr_push_srvsvc_NetTransportEnum(struct ndr_push *ndr, int flags, const struct srvsvc_NetTransportEnum *r)
16760 {
16761         if (flags & NDR_IN) {
16762                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
16763                 if (r->in.server_unc) {
16764                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16765                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16766                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16767                         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));
16768                 }
16769                 if (r->in.transports == NULL) {
16770                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16771                 }
16772                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.transports));
16773                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));
16774                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
16775                 if (r->in.resume_handle) {
16776                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
16777                 }
16778         }
16779         if (flags & NDR_OUT) {
16780                 if (r->out.transports == NULL) {
16781                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16782                 }
16783                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.transports));
16784                 if (r->out.totalentries == NULL) {
16785                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16786                 }
16787                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
16788                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
16789                 if (r->out.resume_handle) {
16790                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
16791                 }
16792                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16793         }
16794         return NDR_ERR_SUCCESS;
16795 }
16796
16797 static enum ndr_err_code ndr_pull_srvsvc_NetTransportEnum(struct ndr_pull *ndr, int flags, struct srvsvc_NetTransportEnum *r)
16798 {
16799         uint32_t _ptr_server_unc;
16800         uint32_t _ptr_resume_handle;
16801         TALLOC_CTX *_mem_save_server_unc_0;
16802         TALLOC_CTX *_mem_save_transports_0;
16803         TALLOC_CTX *_mem_save_totalentries_0;
16804         TALLOC_CTX *_mem_save_resume_handle_0;
16805         if (flags & NDR_IN) {
16806                 ZERO_STRUCT(r->out);
16807
16808                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
16809                 if (_ptr_server_unc) {
16810                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
16811                 } else {
16812                         r->in.server_unc = NULL;
16813                 }
16814                 if (r->in.server_unc) {
16815                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
16816                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
16817                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
16818                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
16819                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
16820                                 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));
16821                         }
16822                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
16823                         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));
16824                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
16825                 }
16826                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16827                         NDR_PULL_ALLOC(ndr, r->in.transports);
16828                 }
16829                 _mem_save_transports_0 = NDR_PULL_GET_MEM_CTX(ndr);
16830                 NDR_PULL_SET_MEM_CTX(ndr, r->in.transports, LIBNDR_FLAG_REF_ALLOC);
16831                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.transports));
16832                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transports_0, LIBNDR_FLAG_REF_ALLOC);
16833                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));
16834                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
16835                 if (_ptr_resume_handle) {
16836                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
16837                 } else {
16838                         r->in.resume_handle = NULL;
16839                 }
16840                 if (r->in.resume_handle) {
16841                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16842                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
16843                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
16844                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
16845                 }
16846                 NDR_PULL_ALLOC(ndr, r->out.transports);
16847                 *r->out.transports = *r->in.transports;
16848                 NDR_PULL_ALLOC(ndr, r->out.totalentries);
16849                 ZERO_STRUCTP(r->out.totalentries);
16850         }
16851         if (flags & NDR_OUT) {
16852                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16853                         NDR_PULL_ALLOC(ndr, r->out.transports);
16854                 }
16855                 _mem_save_transports_0 = NDR_PULL_GET_MEM_CTX(ndr);
16856                 NDR_PULL_SET_MEM_CTX(ndr, r->out.transports, LIBNDR_FLAG_REF_ALLOC);
16857                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.transports));
16858                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transports_0, LIBNDR_FLAG_REF_ALLOC);
16859                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16860                         NDR_PULL_ALLOC(ndr, r->out.totalentries);
16861                 }
16862                 _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
16863                 NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);
16864                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
16865                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);
16866                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
16867                 if (_ptr_resume_handle) {
16868                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
16869                 } else {
16870                         r->out.resume_handle = NULL;
16871                 }
16872                 if (r->out.resume_handle) {
16873                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16874                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
16875                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
16876                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
16877                 }
16878                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16879         }
16880         return NDR_ERR_SUCCESS;
16881 }
16882
16883 _PUBLIC_ void ndr_print_srvsvc_NetTransportEnum(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetTransportEnum *r)
16884 {
16885         ndr_print_struct(ndr, name, "srvsvc_NetTransportEnum");
16886         ndr->depth++;
16887         if (flags & NDR_SET_VALUES) {
16888                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16889         }
16890         if (flags & NDR_IN) {
16891                 ndr_print_struct(ndr, "in", "srvsvc_NetTransportEnum");
16892                 ndr->depth++;
16893                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
16894                 ndr->depth++;
16895                 if (r->in.server_unc) {
16896                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
16897                 }
16898                 ndr->depth--;
16899                 ndr_print_ptr(ndr, "transports", r->in.transports);
16900                 ndr->depth++;
16901                 ndr_print_srvsvc_NetTransportInfoCtr(ndr, "transports", r->in.transports);
16902                 ndr->depth--;
16903                 ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);
16904                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
16905                 ndr->depth++;
16906                 if (r->in.resume_handle) {
16907                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
16908                 }
16909                 ndr->depth--;
16910                 ndr->depth--;
16911         }
16912         if (flags & NDR_OUT) {
16913                 ndr_print_struct(ndr, "out", "srvsvc_NetTransportEnum");
16914                 ndr->depth++;
16915                 ndr_print_ptr(ndr, "transports", r->out.transports);
16916                 ndr->depth++;
16917                 ndr_print_srvsvc_NetTransportInfoCtr(ndr, "transports", r->out.transports);
16918                 ndr->depth--;
16919                 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
16920                 ndr->depth++;
16921                 ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
16922                 ndr->depth--;
16923                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
16924                 ndr->depth++;
16925                 if (r->out.resume_handle) {
16926                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
16927                 }
16928                 ndr->depth--;
16929                 ndr_print_WERROR(ndr, "result", r->out.result);
16930                 ndr->depth--;
16931         }
16932         ndr->depth--;
16933 }
16934
16935 static enum ndr_err_code ndr_push_srvsvc_NetTransportDel(struct ndr_push *ndr, int flags, const struct srvsvc_NetTransportDel *r)
16936 {
16937         if (flags & NDR_IN) {
16938                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
16939                 if (r->in.server_unc) {
16940                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16941                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16942                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16943                         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));
16944                 }
16945                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16946                 if (r->in.info0 == NULL) {
16947                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16948                 }
16949                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info0));
16950         }
16951         if (flags & NDR_OUT) {
16952                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16953         }
16954         return NDR_ERR_SUCCESS;
16955 }
16956
16957 static enum ndr_err_code ndr_pull_srvsvc_NetTransportDel(struct ndr_pull *ndr, int flags, struct srvsvc_NetTransportDel *r)
16958 {
16959         uint32_t _ptr_server_unc;
16960         TALLOC_CTX *_mem_save_server_unc_0;
16961         TALLOC_CTX *_mem_save_info0_0;
16962         if (flags & NDR_IN) {
16963                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
16964                 if (_ptr_server_unc) {
16965                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
16966                 } else {
16967                         r->in.server_unc = NULL;
16968                 }
16969                 if (r->in.server_unc) {
16970                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
16971                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
16972                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
16973                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
16974                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
16975                                 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));
16976                         }
16977                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
16978                         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));
16979                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
16980                 }
16981                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16982                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16983                         NDR_PULL_ALLOC(ndr, r->in.info0);
16984                 }
16985                 _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
16986                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info0, LIBNDR_FLAG_REF_ALLOC);
16987                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info0));
16988                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, LIBNDR_FLAG_REF_ALLOC);
16989         }
16990         if (flags & NDR_OUT) {
16991                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16992         }
16993         return NDR_ERR_SUCCESS;
16994 }
16995
16996 _PUBLIC_ void ndr_print_srvsvc_NetTransportDel(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetTransportDel *r)
16997 {
16998         ndr_print_struct(ndr, name, "srvsvc_NetTransportDel");
16999         ndr->depth++;
17000         if (flags & NDR_SET_VALUES) {
17001                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17002         }
17003         if (flags & NDR_IN) {
17004                 ndr_print_struct(ndr, "in", "srvsvc_NetTransportDel");
17005                 ndr->depth++;
17006                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
17007                 ndr->depth++;
17008                 if (r->in.server_unc) {
17009                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
17010                 }
17011                 ndr->depth--;
17012                 ndr_print_uint32(ndr, "level", r->in.level);
17013                 ndr_print_ptr(ndr, "info0", r->in.info0);
17014                 ndr->depth++;
17015                 ndr_print_srvsvc_NetTransportInfo0(ndr, "info0", r->in.info0);
17016                 ndr->depth--;
17017                 ndr->depth--;
17018         }
17019         if (flags & NDR_OUT) {
17020                 ndr_print_struct(ndr, "out", "srvsvc_NetTransportDel");
17021                 ndr->depth++;
17022                 ndr_print_WERROR(ndr, "result", r->out.result);
17023                 ndr->depth--;
17024         }
17025         ndr->depth--;
17026 }
17027
17028 static enum ndr_err_code ndr_push_srvsvc_NetRemoteTOD(struct ndr_push *ndr, int flags, const struct srvsvc_NetRemoteTOD *r)
17029 {
17030         if (flags & NDR_IN) {
17031                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
17032                 if (r->in.server_unc) {
17033                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17034                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17035                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17036                         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));
17037                 }
17038         }
17039         if (flags & NDR_OUT) {
17040                 if (r->out.info == NULL) {
17041                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17042                 }
17043                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
17044                 if (*r->out.info) {
17045                         NDR_CHECK(ndr_push_srvsvc_NetRemoteTODInfo(ndr, NDR_SCALARS, *r->out.info));
17046                 }
17047                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17048         }
17049         return NDR_ERR_SUCCESS;
17050 }
17051
17052 static enum ndr_err_code ndr_pull_srvsvc_NetRemoteTOD(struct ndr_pull *ndr, int flags, struct srvsvc_NetRemoteTOD *r)
17053 {
17054         uint32_t _ptr_server_unc;
17055         uint32_t _ptr_info;
17056         TALLOC_CTX *_mem_save_server_unc_0;
17057         TALLOC_CTX *_mem_save_info_0;
17058         TALLOC_CTX *_mem_save_info_1;
17059         if (flags & NDR_IN) {
17060                 ZERO_STRUCT(r->out);
17061
17062                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
17063                 if (_ptr_server_unc) {
17064                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
17065                 } else {
17066                         r->in.server_unc = NULL;
17067                 }
17068                 if (r->in.server_unc) {
17069                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
17070                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
17071                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
17072                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
17073                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
17074                                 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));
17075                         }
17076                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
17077                         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));
17078                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
17079                 }
17080                 NDR_PULL_ALLOC(ndr, r->out.info);
17081                 ZERO_STRUCTP(r->out.info);
17082         }
17083         if (flags & NDR_OUT) {
17084                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17085                         NDR_PULL_ALLOC(ndr, r->out.info);
17086                 }
17087                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
17088                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
17089                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
17090                 if (_ptr_info) {
17091                         NDR_PULL_ALLOC(ndr, *r->out.info);
17092                 } else {
17093                         *r->out.info = NULL;
17094                 }
17095                 if (*r->out.info) {
17096                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
17097                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
17098                         NDR_CHECK(ndr_pull_srvsvc_NetRemoteTODInfo(ndr, NDR_SCALARS, *r->out.info));
17099                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
17100                 }
17101                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
17102                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17103         }
17104         return NDR_ERR_SUCCESS;
17105 }
17106
17107 _PUBLIC_ void ndr_print_srvsvc_NetRemoteTOD(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetRemoteTOD *r)
17108 {
17109         ndr_print_struct(ndr, name, "srvsvc_NetRemoteTOD");
17110         ndr->depth++;
17111         if (flags & NDR_SET_VALUES) {
17112                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17113         }
17114         if (flags & NDR_IN) {
17115                 ndr_print_struct(ndr, "in", "srvsvc_NetRemoteTOD");
17116                 ndr->depth++;
17117                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
17118                 ndr->depth++;
17119                 if (r->in.server_unc) {
17120                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
17121                 }
17122                 ndr->depth--;
17123                 ndr->depth--;
17124         }
17125         if (flags & NDR_OUT) {
17126                 ndr_print_struct(ndr, "out", "srvsvc_NetRemoteTOD");
17127                 ndr->depth++;
17128                 ndr_print_ptr(ndr, "info", r->out.info);
17129                 ndr->depth++;
17130                 ndr_print_ptr(ndr, "info", *r->out.info);
17131                 ndr->depth++;
17132                 if (*r->out.info) {
17133                         ndr_print_srvsvc_NetRemoteTODInfo(ndr, "info", *r->out.info);
17134                 }
17135                 ndr->depth--;
17136                 ndr->depth--;
17137                 ndr_print_WERROR(ndr, "result", r->out.result);
17138                 ndr->depth--;
17139         }
17140         ndr->depth--;
17141 }
17142
17143 static enum ndr_err_code ndr_push_srvsvc_NetSetServiceBits(struct ndr_push *ndr, int flags, const struct srvsvc_NetSetServiceBits *r)
17144 {
17145         if (flags & NDR_IN) {
17146                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
17147                 if (r->in.server_unc) {
17148                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17149                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17150                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17151                         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));
17152                 }
17153                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.transport));
17154                 if (r->in.transport) {
17155                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.transport, CH_UTF16)));
17156                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17157                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.transport, CH_UTF16)));
17158                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.transport, ndr_charset_length(r->in.transport, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17159                 }
17160                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.servicebits));
17161                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.updateimmediately));
17162         }
17163         if (flags & NDR_OUT) {
17164                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17165         }
17166         return NDR_ERR_SUCCESS;
17167 }
17168
17169 static enum ndr_err_code ndr_pull_srvsvc_NetSetServiceBits(struct ndr_pull *ndr, int flags, struct srvsvc_NetSetServiceBits *r)
17170 {
17171         uint32_t _ptr_server_unc;
17172         uint32_t _ptr_transport;
17173         TALLOC_CTX *_mem_save_server_unc_0;
17174         TALLOC_CTX *_mem_save_transport_0;
17175         if (flags & NDR_IN) {
17176                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
17177                 if (_ptr_server_unc) {
17178                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
17179                 } else {
17180                         r->in.server_unc = NULL;
17181                 }
17182                 if (r->in.server_unc) {
17183                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
17184                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
17185                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
17186                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
17187                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
17188                                 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));
17189                         }
17190                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
17191                         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));
17192                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
17193                 }
17194                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport));
17195                 if (_ptr_transport) {
17196                         NDR_PULL_ALLOC(ndr, r->in.transport);
17197                 } else {
17198                         r->in.transport = NULL;
17199                 }
17200                 if (r->in.transport) {
17201                         _mem_save_transport_0 = NDR_PULL_GET_MEM_CTX(ndr);
17202                         NDR_PULL_SET_MEM_CTX(ndr, r->in.transport, 0);
17203                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.transport));
17204                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.transport));
17205                         if (ndr_get_array_length(ndr, &r->in.transport) > ndr_get_array_size(ndr, &r->in.transport)) {
17206                                 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));
17207                         }
17208                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.transport), sizeof(uint16_t)));
17209                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.transport, ndr_get_array_length(ndr, &r->in.transport), sizeof(uint16_t), CH_UTF16));
17210                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_0, 0);
17211                 }
17212                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.servicebits));
17213                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.updateimmediately));
17214         }
17215         if (flags & NDR_OUT) {
17216                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17217         }
17218         return NDR_ERR_SUCCESS;
17219 }
17220
17221 _PUBLIC_ void ndr_print_srvsvc_NetSetServiceBits(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetSetServiceBits *r)
17222 {
17223         ndr_print_struct(ndr, name, "srvsvc_NetSetServiceBits");
17224         ndr->depth++;
17225         if (flags & NDR_SET_VALUES) {
17226                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17227         }
17228         if (flags & NDR_IN) {
17229                 ndr_print_struct(ndr, "in", "srvsvc_NetSetServiceBits");
17230                 ndr->depth++;
17231                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
17232                 ndr->depth++;
17233                 if (r->in.server_unc) {
17234                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
17235                 }
17236                 ndr->depth--;
17237                 ndr_print_ptr(ndr, "transport", r->in.transport);
17238                 ndr->depth++;
17239                 if (r->in.transport) {
17240                         ndr_print_string(ndr, "transport", r->in.transport);
17241                 }
17242                 ndr->depth--;
17243                 ndr_print_uint32(ndr, "servicebits", r->in.servicebits);
17244                 ndr_print_uint32(ndr, "updateimmediately", r->in.updateimmediately);
17245                 ndr->depth--;
17246         }
17247         if (flags & NDR_OUT) {
17248                 ndr_print_struct(ndr, "out", "srvsvc_NetSetServiceBits");
17249                 ndr->depth++;
17250                 ndr_print_WERROR(ndr, "result", r->out.result);
17251                 ndr->depth--;
17252         }
17253         ndr->depth--;
17254 }
17255
17256 static enum ndr_err_code ndr_push_srvsvc_NetPathType(struct ndr_push *ndr, int flags, const struct srvsvc_NetPathType *r)
17257 {
17258         if (flags & NDR_IN) {
17259                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
17260                 if (r->in.server_unc) {
17261                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17262                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17263                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17264                         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));
17265                 }
17266                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));
17267                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17268                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));
17269                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.path, ndr_charset_length(r->in.path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17270                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.pathflags));
17271         }
17272         if (flags & NDR_OUT) {
17273                 if (r->out.pathtype == NULL) {
17274                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17275                 }
17276                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.pathtype));
17277                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17278         }
17279         return NDR_ERR_SUCCESS;
17280 }
17281
17282 static enum ndr_err_code ndr_pull_srvsvc_NetPathType(struct ndr_pull *ndr, int flags, struct srvsvc_NetPathType *r)
17283 {
17284         uint32_t _ptr_server_unc;
17285         TALLOC_CTX *_mem_save_server_unc_0;
17286         TALLOC_CTX *_mem_save_pathtype_0;
17287         if (flags & NDR_IN) {
17288                 ZERO_STRUCT(r->out);
17289
17290                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
17291                 if (_ptr_server_unc) {
17292                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
17293                 } else {
17294                         r->in.server_unc = NULL;
17295                 }
17296                 if (r->in.server_unc) {
17297                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
17298                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
17299                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
17300                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
17301                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
17302                                 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));
17303                         }
17304                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
17305                         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));
17306                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
17307                 }
17308                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path));
17309                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path));
17310                 if (ndr_get_array_length(ndr, &r->in.path) > ndr_get_array_size(ndr, &r->in.path)) {
17311                         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));
17312                 }
17313                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path), sizeof(uint16_t)));
17314                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.path, ndr_get_array_length(ndr, &r->in.path), sizeof(uint16_t), CH_UTF16));
17315                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.pathflags));
17316                 NDR_PULL_ALLOC(ndr, r->out.pathtype);
17317                 ZERO_STRUCTP(r->out.pathtype);
17318         }
17319         if (flags & NDR_OUT) {
17320                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17321                         NDR_PULL_ALLOC(ndr, r->out.pathtype);
17322                 }
17323                 _mem_save_pathtype_0 = NDR_PULL_GET_MEM_CTX(ndr);
17324                 NDR_PULL_SET_MEM_CTX(ndr, r->out.pathtype, LIBNDR_FLAG_REF_ALLOC);
17325                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.pathtype));
17326                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pathtype_0, LIBNDR_FLAG_REF_ALLOC);
17327                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17328         }
17329         return NDR_ERR_SUCCESS;
17330 }
17331
17332 _PUBLIC_ void ndr_print_srvsvc_NetPathType(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetPathType *r)
17333 {
17334         ndr_print_struct(ndr, name, "srvsvc_NetPathType");
17335         ndr->depth++;
17336         if (flags & NDR_SET_VALUES) {
17337                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17338         }
17339         if (flags & NDR_IN) {
17340                 ndr_print_struct(ndr, "in", "srvsvc_NetPathType");
17341                 ndr->depth++;
17342                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
17343                 ndr->depth++;
17344                 if (r->in.server_unc) {
17345                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
17346                 }
17347                 ndr->depth--;
17348                 ndr_print_string(ndr, "path", r->in.path);
17349                 ndr_print_uint32(ndr, "pathflags", r->in.pathflags);
17350                 ndr->depth--;
17351         }
17352         if (flags & NDR_OUT) {
17353                 ndr_print_struct(ndr, "out", "srvsvc_NetPathType");
17354                 ndr->depth++;
17355                 ndr_print_ptr(ndr, "pathtype", r->out.pathtype);
17356                 ndr->depth++;
17357                 ndr_print_uint32(ndr, "pathtype", *r->out.pathtype);
17358                 ndr->depth--;
17359                 ndr_print_WERROR(ndr, "result", r->out.result);
17360                 ndr->depth--;
17361         }
17362         ndr->depth--;
17363 }
17364
17365 static enum ndr_err_code ndr_push_srvsvc_NetPathCanonicalize(struct ndr_push *ndr, int flags, const struct srvsvc_NetPathCanonicalize *r)
17366 {
17367         if (flags & NDR_IN) {
17368                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
17369                 if (r->in.server_unc) {
17370                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17371                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17372                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17373                         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));
17374                 }
17375                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));
17376                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17377                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));
17378                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.path, ndr_charset_length(r->in.path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17379                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.maxbuf));
17380                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.prefix, CH_UTF16)));
17381                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17382                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.prefix, CH_UTF16)));
17383                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.prefix, ndr_charset_length(r->in.prefix, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17384                 if (r->in.pathtype == NULL) {
17385                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17386                 }
17387                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.pathtype));
17388                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.pathflags));
17389         }
17390         if (flags & NDR_OUT) {
17391                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.maxbuf));
17392                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.can_path, r->in.maxbuf));
17393                 if (r->out.pathtype == NULL) {
17394                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17395                 }
17396                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.pathtype));
17397                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17398         }
17399         return NDR_ERR_SUCCESS;
17400 }
17401
17402 static enum ndr_err_code ndr_pull_srvsvc_NetPathCanonicalize(struct ndr_pull *ndr, int flags, struct srvsvc_NetPathCanonicalize *r)
17403 {
17404         uint32_t _ptr_server_unc;
17405         TALLOC_CTX *_mem_save_server_unc_0;
17406         TALLOC_CTX *_mem_save_pathtype_0;
17407         if (flags & NDR_IN) {
17408                 ZERO_STRUCT(r->out);
17409
17410                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
17411                 if (_ptr_server_unc) {
17412                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
17413                 } else {
17414                         r->in.server_unc = NULL;
17415                 }
17416                 if (r->in.server_unc) {
17417                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
17418                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
17419                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
17420                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
17421                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
17422                                 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));
17423                         }
17424                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
17425                         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));
17426                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
17427                 }
17428                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path));
17429                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path));
17430                 if (ndr_get_array_length(ndr, &r->in.path) > ndr_get_array_size(ndr, &r->in.path)) {
17431                         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));
17432                 }
17433                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path), sizeof(uint16_t)));
17434                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.path, ndr_get_array_length(ndr, &r->in.path), sizeof(uint16_t), CH_UTF16));
17435                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.maxbuf));
17436                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.prefix));
17437                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.prefix));
17438                 if (ndr_get_array_length(ndr, &r->in.prefix) > ndr_get_array_size(ndr, &r->in.prefix)) {
17439                         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));
17440                 }
17441                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.prefix), sizeof(uint16_t)));
17442                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.prefix, ndr_get_array_length(ndr, &r->in.prefix), sizeof(uint16_t), CH_UTF16));
17443                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17444                         NDR_PULL_ALLOC(ndr, r->in.pathtype);
17445                 }
17446                 _mem_save_pathtype_0 = NDR_PULL_GET_MEM_CTX(ndr);
17447                 NDR_PULL_SET_MEM_CTX(ndr, r->in.pathtype, LIBNDR_FLAG_REF_ALLOC);
17448                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.pathtype));
17449                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pathtype_0, LIBNDR_FLAG_REF_ALLOC);
17450                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.pathflags));
17451                 NDR_PULL_ALLOC(ndr, r->out.pathtype);
17452                 *r->out.pathtype = *r->in.pathtype;
17453         }
17454         if (flags & NDR_OUT) {
17455                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.can_path));
17456                 NDR_PULL_ALLOC_N(ndr, r->out.can_path, ndr_get_array_size(ndr, &r->out.can_path));
17457                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.can_path, ndr_get_array_size(ndr, &r->out.can_path)));
17458                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17459                         NDR_PULL_ALLOC(ndr, r->out.pathtype);
17460                 }
17461                 _mem_save_pathtype_0 = NDR_PULL_GET_MEM_CTX(ndr);
17462                 NDR_PULL_SET_MEM_CTX(ndr, r->out.pathtype, LIBNDR_FLAG_REF_ALLOC);
17463                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.pathtype));
17464                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pathtype_0, LIBNDR_FLAG_REF_ALLOC);
17465                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17466                 if (r->out.can_path) {
17467                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.can_path, r->in.maxbuf));
17468                 }
17469         }
17470         return NDR_ERR_SUCCESS;
17471 }
17472
17473 _PUBLIC_ void ndr_print_srvsvc_NetPathCanonicalize(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetPathCanonicalize *r)
17474 {
17475         ndr_print_struct(ndr, name, "srvsvc_NetPathCanonicalize");
17476         ndr->depth++;
17477         if (flags & NDR_SET_VALUES) {
17478                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17479         }
17480         if (flags & NDR_IN) {
17481                 ndr_print_struct(ndr, "in", "srvsvc_NetPathCanonicalize");
17482                 ndr->depth++;
17483                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
17484                 ndr->depth++;
17485                 if (r->in.server_unc) {
17486                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
17487                 }
17488                 ndr->depth--;
17489                 ndr_print_string(ndr, "path", r->in.path);
17490                 ndr_print_uint32(ndr, "maxbuf", r->in.maxbuf);
17491                 ndr_print_string(ndr, "prefix", r->in.prefix);
17492                 ndr_print_ptr(ndr, "pathtype", r->in.pathtype);
17493                 ndr->depth++;
17494                 ndr_print_uint32(ndr, "pathtype", *r->in.pathtype);
17495                 ndr->depth--;
17496                 ndr_print_uint32(ndr, "pathflags", r->in.pathflags);
17497                 ndr->depth--;
17498         }
17499         if (flags & NDR_OUT) {
17500                 ndr_print_struct(ndr, "out", "srvsvc_NetPathCanonicalize");
17501                 ndr->depth++;
17502                 ndr_print_array_uint8(ndr, "can_path", r->out.can_path, r->in.maxbuf);
17503                 ndr_print_ptr(ndr, "pathtype", r->out.pathtype);
17504                 ndr->depth++;
17505                 ndr_print_uint32(ndr, "pathtype", *r->out.pathtype);
17506                 ndr->depth--;
17507                 ndr_print_WERROR(ndr, "result", r->out.result);
17508                 ndr->depth--;
17509         }
17510         ndr->depth--;
17511 }
17512
17513 static enum ndr_err_code ndr_push_srvsvc_NetPathCompare(struct ndr_push *ndr, int flags, const struct srvsvc_NetPathCompare *r)
17514 {
17515         if (flags & NDR_IN) {
17516                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
17517                 if (r->in.server_unc) {
17518                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17519                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17520                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17521                         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));
17522                 }
17523                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path1, CH_UTF16)));
17524                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17525                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path1, CH_UTF16)));
17526                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.path1, ndr_charset_length(r->in.path1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17527                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path2, CH_UTF16)));
17528                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17529                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path2, CH_UTF16)));
17530                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.path2, ndr_charset_length(r->in.path2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17531                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.pathtype));
17532                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.pathflags));
17533         }
17534         if (flags & NDR_OUT) {
17535                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17536         }
17537         return NDR_ERR_SUCCESS;
17538 }
17539
17540 static enum ndr_err_code ndr_pull_srvsvc_NetPathCompare(struct ndr_pull *ndr, int flags, struct srvsvc_NetPathCompare *r)
17541 {
17542         uint32_t _ptr_server_unc;
17543         TALLOC_CTX *_mem_save_server_unc_0;
17544         if (flags & NDR_IN) {
17545                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
17546                 if (_ptr_server_unc) {
17547                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
17548                 } else {
17549                         r->in.server_unc = NULL;
17550                 }
17551                 if (r->in.server_unc) {
17552                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
17553                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
17554                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
17555                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
17556                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
17557                                 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));
17558                         }
17559                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
17560                         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));
17561                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
17562                 }
17563                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path1));
17564                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path1));
17565                 if (ndr_get_array_length(ndr, &r->in.path1) > ndr_get_array_size(ndr, &r->in.path1)) {
17566                         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));
17567                 }
17568                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path1), sizeof(uint16_t)));
17569                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.path1, ndr_get_array_length(ndr, &r->in.path1), sizeof(uint16_t), CH_UTF16));
17570                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path2));
17571                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path2));
17572                 if (ndr_get_array_length(ndr, &r->in.path2) > ndr_get_array_size(ndr, &r->in.path2)) {
17573                         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));
17574                 }
17575                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path2), sizeof(uint16_t)));
17576                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.path2, ndr_get_array_length(ndr, &r->in.path2), sizeof(uint16_t), CH_UTF16));
17577                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.pathtype));
17578                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.pathflags));
17579         }
17580         if (flags & NDR_OUT) {
17581                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17582         }
17583         return NDR_ERR_SUCCESS;
17584 }
17585
17586 _PUBLIC_ void ndr_print_srvsvc_NetPathCompare(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetPathCompare *r)
17587 {
17588         ndr_print_struct(ndr, name, "srvsvc_NetPathCompare");
17589         ndr->depth++;
17590         if (flags & NDR_SET_VALUES) {
17591                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17592         }
17593         if (flags & NDR_IN) {
17594                 ndr_print_struct(ndr, "in", "srvsvc_NetPathCompare");
17595                 ndr->depth++;
17596                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
17597                 ndr->depth++;
17598                 if (r->in.server_unc) {
17599                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
17600                 }
17601                 ndr->depth--;
17602                 ndr_print_string(ndr, "path1", r->in.path1);
17603                 ndr_print_string(ndr, "path2", r->in.path2);
17604                 ndr_print_uint32(ndr, "pathtype", r->in.pathtype);
17605                 ndr_print_uint32(ndr, "pathflags", r->in.pathflags);
17606                 ndr->depth--;
17607         }
17608         if (flags & NDR_OUT) {
17609                 ndr_print_struct(ndr, "out", "srvsvc_NetPathCompare");
17610                 ndr->depth++;
17611                 ndr_print_WERROR(ndr, "result", r->out.result);
17612                 ndr->depth--;
17613         }
17614         ndr->depth--;
17615 }
17616
17617 static enum ndr_err_code ndr_push_srvsvc_NetNameValidate(struct ndr_push *ndr, int flags, const struct srvsvc_NetNameValidate *r)
17618 {
17619         if (flags & NDR_IN) {
17620                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
17621                 if (r->in.server_unc) {
17622                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17623                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17624                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17625                         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));
17626                 }
17627                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF16)));
17628                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17629                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF16)));
17630                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.name, ndr_charset_length(r->in.name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17631                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.name_type));
17632                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
17633         }
17634         if (flags & NDR_OUT) {
17635                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17636         }
17637         return NDR_ERR_SUCCESS;
17638 }
17639
17640 static enum ndr_err_code ndr_pull_srvsvc_NetNameValidate(struct ndr_pull *ndr, int flags, struct srvsvc_NetNameValidate *r)
17641 {
17642         uint32_t _ptr_server_unc;
17643         TALLOC_CTX *_mem_save_server_unc_0;
17644         if (flags & NDR_IN) {
17645                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
17646                 if (_ptr_server_unc) {
17647                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
17648                 } else {
17649                         r->in.server_unc = NULL;
17650                 }
17651                 if (r->in.server_unc) {
17652                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
17653                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
17654                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
17655                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
17656                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
17657                                 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));
17658                         }
17659                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
17660                         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));
17661                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
17662                 }
17663                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.name));
17664                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.name));
17665                 if (ndr_get_array_length(ndr, &r->in.name) > ndr_get_array_size(ndr, &r->in.name)) {
17666                         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));
17667                 }
17668                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.name), sizeof(uint16_t)));
17669                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.name, ndr_get_array_length(ndr, &r->in.name), sizeof(uint16_t), CH_UTF16));
17670                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.name_type));
17671                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
17672         }
17673         if (flags & NDR_OUT) {
17674                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17675         }
17676         return NDR_ERR_SUCCESS;
17677 }
17678
17679 _PUBLIC_ void ndr_print_srvsvc_NetNameValidate(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetNameValidate *r)
17680 {
17681         ndr_print_struct(ndr, name, "srvsvc_NetNameValidate");
17682         ndr->depth++;
17683         if (flags & NDR_SET_VALUES) {
17684                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17685         }
17686         if (flags & NDR_IN) {
17687                 ndr_print_struct(ndr, "in", "srvsvc_NetNameValidate");
17688                 ndr->depth++;
17689                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
17690                 ndr->depth++;
17691                 if (r->in.server_unc) {
17692                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
17693                 }
17694                 ndr->depth--;
17695                 ndr_print_string(ndr, "name", r->in.name);
17696                 ndr_print_uint32(ndr, "name_type", r->in.name_type);
17697                 ndr_print_uint32(ndr, "flags", r->in.flags);
17698                 ndr->depth--;
17699         }
17700         if (flags & NDR_OUT) {
17701                 ndr_print_struct(ndr, "out", "srvsvc_NetNameValidate");
17702                 ndr->depth++;
17703                 ndr_print_WERROR(ndr, "result", r->out.result);
17704                 ndr->depth--;
17705         }
17706         ndr->depth--;
17707 }
17708
17709 static enum ndr_err_code ndr_push_srvsvc_NETRPRNAMECANONICALIZE(struct ndr_push *ndr, int flags, const struct srvsvc_NETRPRNAMECANONICALIZE *r)
17710 {
17711         if (flags & NDR_IN) {
17712         }
17713         if (flags & NDR_OUT) {
17714                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17715         }
17716         return NDR_ERR_SUCCESS;
17717 }
17718
17719 static enum ndr_err_code ndr_pull_srvsvc_NETRPRNAMECANONICALIZE(struct ndr_pull *ndr, int flags, struct srvsvc_NETRPRNAMECANONICALIZE *r)
17720 {
17721         if (flags & NDR_IN) {
17722         }
17723         if (flags & NDR_OUT) {
17724                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17725         }
17726         return NDR_ERR_SUCCESS;
17727 }
17728
17729 _PUBLIC_ void ndr_print_srvsvc_NETRPRNAMECANONICALIZE(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRPRNAMECANONICALIZE *r)
17730 {
17731         ndr_print_struct(ndr, name, "srvsvc_NETRPRNAMECANONICALIZE");
17732         ndr->depth++;
17733         if (flags & NDR_SET_VALUES) {
17734                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17735         }
17736         if (flags & NDR_IN) {
17737                 ndr_print_struct(ndr, "in", "srvsvc_NETRPRNAMECANONICALIZE");
17738                 ndr->depth++;
17739                 ndr->depth--;
17740         }
17741         if (flags & NDR_OUT) {
17742                 ndr_print_struct(ndr, "out", "srvsvc_NETRPRNAMECANONICALIZE");
17743                 ndr->depth++;
17744                 ndr_print_WERROR(ndr, "result", r->out.result);
17745                 ndr->depth--;
17746         }
17747         ndr->depth--;
17748 }
17749
17750 static enum ndr_err_code ndr_push_srvsvc_NetPRNameCompare(struct ndr_push *ndr, int flags, const struct srvsvc_NetPRNameCompare *r)
17751 {
17752         if (flags & NDR_IN) {
17753                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
17754                 if (r->in.server_unc) {
17755                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17756                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17757                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17758                         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));
17759                 }
17760                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name1, CH_UTF16)));
17761                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17762                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name1, CH_UTF16)));
17763                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.name1, ndr_charset_length(r->in.name1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17764                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name2, CH_UTF16)));
17765                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17766                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name2, CH_UTF16)));
17767                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.name2, ndr_charset_length(r->in.name2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17768                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.name_type));
17769                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
17770         }
17771         if (flags & NDR_OUT) {
17772                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17773         }
17774         return NDR_ERR_SUCCESS;
17775 }
17776
17777 static enum ndr_err_code ndr_pull_srvsvc_NetPRNameCompare(struct ndr_pull *ndr, int flags, struct srvsvc_NetPRNameCompare *r)
17778 {
17779         uint32_t _ptr_server_unc;
17780         TALLOC_CTX *_mem_save_server_unc_0;
17781         if (flags & NDR_IN) {
17782                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
17783                 if (_ptr_server_unc) {
17784                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
17785                 } else {
17786                         r->in.server_unc = NULL;
17787                 }
17788                 if (r->in.server_unc) {
17789                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
17790                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
17791                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
17792                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
17793                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
17794                                 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));
17795                         }
17796                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
17797                         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));
17798                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
17799                 }
17800                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.name1));
17801                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.name1));
17802                 if (ndr_get_array_length(ndr, &r->in.name1) > ndr_get_array_size(ndr, &r->in.name1)) {
17803                         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));
17804                 }
17805                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.name1), sizeof(uint16_t)));
17806                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.name1, ndr_get_array_length(ndr, &r->in.name1), sizeof(uint16_t), CH_UTF16));
17807                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.name2));
17808                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.name2));
17809                 if (ndr_get_array_length(ndr, &r->in.name2) > ndr_get_array_size(ndr, &r->in.name2)) {
17810                         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));
17811                 }
17812                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.name2), sizeof(uint16_t)));
17813                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.name2, ndr_get_array_length(ndr, &r->in.name2), sizeof(uint16_t), CH_UTF16));
17814                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.name_type));
17815                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
17816         }
17817         if (flags & NDR_OUT) {
17818                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17819         }
17820         return NDR_ERR_SUCCESS;
17821 }
17822
17823 _PUBLIC_ void ndr_print_srvsvc_NetPRNameCompare(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetPRNameCompare *r)
17824 {
17825         ndr_print_struct(ndr, name, "srvsvc_NetPRNameCompare");
17826         ndr->depth++;
17827         if (flags & NDR_SET_VALUES) {
17828                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17829         }
17830         if (flags & NDR_IN) {
17831                 ndr_print_struct(ndr, "in", "srvsvc_NetPRNameCompare");
17832                 ndr->depth++;
17833                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
17834                 ndr->depth++;
17835                 if (r->in.server_unc) {
17836                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
17837                 }
17838                 ndr->depth--;
17839                 ndr_print_string(ndr, "name1", r->in.name1);
17840                 ndr_print_string(ndr, "name2", r->in.name2);
17841                 ndr_print_uint32(ndr, "name_type", r->in.name_type);
17842                 ndr_print_uint32(ndr, "flags", r->in.flags);
17843                 ndr->depth--;
17844         }
17845         if (flags & NDR_OUT) {
17846                 ndr_print_struct(ndr, "out", "srvsvc_NetPRNameCompare");
17847                 ndr->depth++;
17848                 ndr_print_WERROR(ndr, "result", r->out.result);
17849                 ndr->depth--;
17850         }
17851         ndr->depth--;
17852 }
17853
17854 static enum ndr_err_code ndr_push_srvsvc_NetShareEnum(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareEnum *r)
17855 {
17856         if (flags & NDR_IN) {
17857                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
17858                 if (r->in.server_unc) {
17859                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17860                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17861                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17862                         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));
17863                 }
17864                 if (r->in.info_ctr == NULL) {
17865                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17866                 }
17867                 NDR_CHECK(ndr_push_srvsvc_NetShareInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
17868                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));
17869                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
17870                 if (r->in.resume_handle) {
17871                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
17872                 }
17873         }
17874         if (flags & NDR_OUT) {
17875                 if (r->out.info_ctr == NULL) {
17876                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17877                 }
17878                 NDR_CHECK(ndr_push_srvsvc_NetShareInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));
17879                 if (r->out.totalentries == NULL) {
17880                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17881                 }
17882                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
17883                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
17884                 if (r->out.resume_handle) {
17885                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
17886                 }
17887                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17888         }
17889         return NDR_ERR_SUCCESS;
17890 }
17891
17892 static enum ndr_err_code ndr_pull_srvsvc_NetShareEnum(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareEnum *r)
17893 {
17894         uint32_t _ptr_server_unc;
17895         uint32_t _ptr_resume_handle;
17896         TALLOC_CTX *_mem_save_server_unc_0;
17897         TALLOC_CTX *_mem_save_info_ctr_0;
17898         TALLOC_CTX *_mem_save_totalentries_0;
17899         TALLOC_CTX *_mem_save_resume_handle_0;
17900         if (flags & NDR_IN) {
17901                 ZERO_STRUCT(r->out);
17902
17903                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
17904                 if (_ptr_server_unc) {
17905                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
17906                 } else {
17907                         r->in.server_unc = NULL;
17908                 }
17909                 if (r->in.server_unc) {
17910                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
17911                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
17912                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
17913                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
17914                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
17915                                 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));
17916                         }
17917                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
17918                         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));
17919                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
17920                 }
17921                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17922                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
17923                 }
17924                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
17925                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
17926                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
17927                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
17928                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));
17929                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
17930                 if (_ptr_resume_handle) {
17931                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
17932                 } else {
17933                         r->in.resume_handle = NULL;
17934                 }
17935                 if (r->in.resume_handle) {
17936                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17937                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
17938                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
17939                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
17940                 }
17941                 NDR_PULL_ALLOC(ndr, r->out.info_ctr);
17942                 *r->out.info_ctr = *r->in.info_ctr;
17943                 NDR_PULL_ALLOC(ndr, r->out.totalentries);
17944                 ZERO_STRUCTP(r->out.totalentries);
17945         }
17946         if (flags & NDR_OUT) {
17947                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17948                         NDR_PULL_ALLOC(ndr, r->out.info_ctr);
17949                 }
17950                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
17951                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_ctr, LIBNDR_FLAG_REF_ALLOC);
17952                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));
17953                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
17954                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17955                         NDR_PULL_ALLOC(ndr, r->out.totalentries);
17956                 }
17957                 _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
17958                 NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);
17959                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
17960                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);
17961                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
17962                 if (_ptr_resume_handle) {
17963                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
17964                 } else {
17965                         r->out.resume_handle = NULL;
17966                 }
17967                 if (r->out.resume_handle) {
17968                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17969                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
17970                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
17971                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
17972                 }
17973                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17974         }
17975         return NDR_ERR_SUCCESS;
17976 }
17977
17978 _PUBLIC_ void ndr_print_srvsvc_NetShareEnum(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareEnum *r)
17979 {
17980         ndr_print_struct(ndr, name, "srvsvc_NetShareEnum");
17981         ndr->depth++;
17982         if (flags & NDR_SET_VALUES) {
17983                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17984         }
17985         if (flags & NDR_IN) {
17986                 ndr_print_struct(ndr, "in", "srvsvc_NetShareEnum");
17987                 ndr->depth++;
17988                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
17989                 ndr->depth++;
17990                 if (r->in.server_unc) {
17991                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
17992                 }
17993                 ndr->depth--;
17994                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
17995                 ndr->depth++;
17996                 ndr_print_srvsvc_NetShareInfoCtr(ndr, "info_ctr", r->in.info_ctr);
17997                 ndr->depth--;
17998                 ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);
17999                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
18000                 ndr->depth++;
18001                 if (r->in.resume_handle) {
18002                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
18003                 }
18004                 ndr->depth--;
18005                 ndr->depth--;
18006         }
18007         if (flags & NDR_OUT) {
18008                 ndr_print_struct(ndr, "out", "srvsvc_NetShareEnum");
18009                 ndr->depth++;
18010                 ndr_print_ptr(ndr, "info_ctr", r->out.info_ctr);
18011                 ndr->depth++;
18012                 ndr_print_srvsvc_NetShareInfoCtr(ndr, "info_ctr", r->out.info_ctr);
18013                 ndr->depth--;
18014                 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
18015                 ndr->depth++;
18016                 ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
18017                 ndr->depth--;
18018                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
18019                 ndr->depth++;
18020                 if (r->out.resume_handle) {
18021                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
18022                 }
18023                 ndr->depth--;
18024                 ndr_print_WERROR(ndr, "result", r->out.result);
18025                 ndr->depth--;
18026         }
18027         ndr->depth--;
18028 }
18029
18030 static enum ndr_err_code ndr_push_srvsvc_NetShareDelStart(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareDelStart *r)
18031 {
18032         if (flags & NDR_IN) {
18033                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
18034                 if (r->in.server_unc) {
18035                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18036                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18037                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18038                         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));
18039                 }
18040                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share, CH_UTF16)));
18041                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18042                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share, CH_UTF16)));
18043                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.share, ndr_charset_length(r->in.share, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18044                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reserved));
18045         }
18046         if (flags & NDR_OUT) {
18047                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.hnd));
18048                 if (r->out.hnd) {
18049                         NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.hnd));
18050                 }
18051                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18052         }
18053         return NDR_ERR_SUCCESS;
18054 }
18055
18056 static enum ndr_err_code ndr_pull_srvsvc_NetShareDelStart(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareDelStart *r)
18057 {
18058         uint32_t _ptr_server_unc;
18059         uint32_t _ptr_hnd;
18060         TALLOC_CTX *_mem_save_server_unc_0;
18061         TALLOC_CTX *_mem_save_hnd_0;
18062         if (flags & NDR_IN) {
18063                 ZERO_STRUCT(r->out);
18064
18065                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
18066                 if (_ptr_server_unc) {
18067                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
18068                 } else {
18069                         r->in.server_unc = NULL;
18070                 }
18071                 if (r->in.server_unc) {
18072                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
18073                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
18074                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
18075                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
18076                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
18077                                 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));
18078                         }
18079                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
18080                         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));
18081                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
18082                 }
18083                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.share));
18084                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.share));
18085                 if (ndr_get_array_length(ndr, &r->in.share) > ndr_get_array_size(ndr, &r->in.share)) {
18086                         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));
18087                 }
18088                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.share), sizeof(uint16_t)));
18089                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.share, ndr_get_array_length(ndr, &r->in.share), sizeof(uint16_t), CH_UTF16));
18090                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reserved));
18091         }
18092         if (flags & NDR_OUT) {
18093                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hnd));
18094                 if (_ptr_hnd) {
18095                         NDR_PULL_ALLOC(ndr, r->out.hnd);
18096                 } else {
18097                         r->out.hnd = NULL;
18098                 }
18099                 if (r->out.hnd) {
18100                         _mem_save_hnd_0 = NDR_PULL_GET_MEM_CTX(ndr);
18101                         NDR_PULL_SET_MEM_CTX(ndr, r->out.hnd, 0);
18102                         NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.hnd));
18103                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hnd_0, 0);
18104                 }
18105                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18106         }
18107         return NDR_ERR_SUCCESS;
18108 }
18109
18110 _PUBLIC_ void ndr_print_srvsvc_NetShareDelStart(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareDelStart *r)
18111 {
18112         ndr_print_struct(ndr, name, "srvsvc_NetShareDelStart");
18113         ndr->depth++;
18114         if (flags & NDR_SET_VALUES) {
18115                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18116         }
18117         if (flags & NDR_IN) {
18118                 ndr_print_struct(ndr, "in", "srvsvc_NetShareDelStart");
18119                 ndr->depth++;
18120                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
18121                 ndr->depth++;
18122                 if (r->in.server_unc) {
18123                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
18124                 }
18125                 ndr->depth--;
18126                 ndr_print_string(ndr, "share", r->in.share);
18127                 ndr_print_uint32(ndr, "reserved", r->in.reserved);
18128                 ndr->depth--;
18129         }
18130         if (flags & NDR_OUT) {
18131                 ndr_print_struct(ndr, "out", "srvsvc_NetShareDelStart");
18132                 ndr->depth++;
18133                 ndr_print_ptr(ndr, "hnd", r->out.hnd);
18134                 ndr->depth++;
18135                 if (r->out.hnd) {
18136                         ndr_print_policy_handle(ndr, "hnd", r->out.hnd);
18137                 }
18138                 ndr->depth--;
18139                 ndr_print_WERROR(ndr, "result", r->out.result);
18140                 ndr->depth--;
18141         }
18142         ndr->depth--;
18143 }
18144
18145 static enum ndr_err_code ndr_push_srvsvc_NetShareDelCommit(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareDelCommit *r)
18146 {
18147         if (flags & NDR_IN) {
18148                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.hnd));
18149                 if (r->in.hnd) {
18150                         NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.hnd));
18151                 }
18152         }
18153         if (flags & NDR_OUT) {
18154                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.hnd));
18155                 if (r->out.hnd) {
18156                         NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.hnd));
18157                 }
18158                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18159         }
18160         return NDR_ERR_SUCCESS;
18161 }
18162
18163 static enum ndr_err_code ndr_pull_srvsvc_NetShareDelCommit(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareDelCommit *r)
18164 {
18165         uint32_t _ptr_hnd;
18166         TALLOC_CTX *_mem_save_hnd_0;
18167         if (flags & NDR_IN) {
18168                 ZERO_STRUCT(r->out);
18169
18170                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hnd));
18171                 if (_ptr_hnd) {
18172                         NDR_PULL_ALLOC(ndr, r->in.hnd);
18173                 } else {
18174                         r->in.hnd = NULL;
18175                 }
18176                 if (r->in.hnd) {
18177                         _mem_save_hnd_0 = NDR_PULL_GET_MEM_CTX(ndr);
18178                         NDR_PULL_SET_MEM_CTX(ndr, r->in.hnd, 0);
18179                         NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.hnd));
18180                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hnd_0, 0);
18181                 }
18182         }
18183         if (flags & NDR_OUT) {
18184                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hnd));
18185                 if (_ptr_hnd) {
18186                         NDR_PULL_ALLOC(ndr, r->out.hnd);
18187                 } else {
18188                         r->out.hnd = NULL;
18189                 }
18190                 if (r->out.hnd) {
18191                         _mem_save_hnd_0 = NDR_PULL_GET_MEM_CTX(ndr);
18192                         NDR_PULL_SET_MEM_CTX(ndr, r->out.hnd, 0);
18193                         NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.hnd));
18194                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hnd_0, 0);
18195                 }
18196                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18197         }
18198         return NDR_ERR_SUCCESS;
18199 }
18200
18201 _PUBLIC_ void ndr_print_srvsvc_NetShareDelCommit(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareDelCommit *r)
18202 {
18203         ndr_print_struct(ndr, name, "srvsvc_NetShareDelCommit");
18204         ndr->depth++;
18205         if (flags & NDR_SET_VALUES) {
18206                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18207         }
18208         if (flags & NDR_IN) {
18209                 ndr_print_struct(ndr, "in", "srvsvc_NetShareDelCommit");
18210                 ndr->depth++;
18211                 ndr_print_ptr(ndr, "hnd", r->in.hnd);
18212                 ndr->depth++;
18213                 if (r->in.hnd) {
18214                         ndr_print_policy_handle(ndr, "hnd", r->in.hnd);
18215                 }
18216                 ndr->depth--;
18217                 ndr->depth--;
18218         }
18219         if (flags & NDR_OUT) {
18220                 ndr_print_struct(ndr, "out", "srvsvc_NetShareDelCommit");
18221                 ndr->depth++;
18222                 ndr_print_ptr(ndr, "hnd", r->out.hnd);
18223                 ndr->depth++;
18224                 if (r->out.hnd) {
18225                         ndr_print_policy_handle(ndr, "hnd", r->out.hnd);
18226                 }
18227                 ndr->depth--;
18228                 ndr_print_WERROR(ndr, "result", r->out.result);
18229                 ndr->depth--;
18230         }
18231         ndr->depth--;
18232 }
18233
18234 static enum ndr_err_code ndr_push_srvsvc_NetGetFileSecurity(struct ndr_push *ndr, int flags, const struct srvsvc_NetGetFileSecurity *r)
18235 {
18236         if (flags & NDR_IN) {
18237                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
18238                 if (r->in.server_unc) {
18239                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18240                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18241                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18242                         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));
18243                 }
18244                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.share));
18245                 if (r->in.share) {
18246                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share, CH_UTF16)));
18247                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18248                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share, CH_UTF16)));
18249                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.share, ndr_charset_length(r->in.share, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18250                 }
18251                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.file, CH_UTF16)));
18252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18253                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.file, CH_UTF16)));
18254                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.file, ndr_charset_length(r->in.file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18255                 NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.securityinformation));
18256         }
18257         if (flags & NDR_OUT) {
18258                 if (r->out.sd_buf == NULL) {
18259                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18260                 }
18261                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sd_buf));
18262                 if (*r->out.sd_buf) {
18263                         NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sd_buf));
18264                 }
18265                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18266         }
18267         return NDR_ERR_SUCCESS;
18268 }
18269
18270 static enum ndr_err_code ndr_pull_srvsvc_NetGetFileSecurity(struct ndr_pull *ndr, int flags, struct srvsvc_NetGetFileSecurity *r)
18271 {
18272         uint32_t _ptr_server_unc;
18273         uint32_t _ptr_share;
18274         uint32_t _ptr_sd_buf;
18275         TALLOC_CTX *_mem_save_server_unc_0;
18276         TALLOC_CTX *_mem_save_share_0;
18277         TALLOC_CTX *_mem_save_sd_buf_0;
18278         TALLOC_CTX *_mem_save_sd_buf_1;
18279         if (flags & NDR_IN) {
18280                 ZERO_STRUCT(r->out);
18281
18282                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
18283                 if (_ptr_server_unc) {
18284                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
18285                 } else {
18286                         r->in.server_unc = NULL;
18287                 }
18288                 if (r->in.server_unc) {
18289                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
18290                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
18291                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
18292                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
18293                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
18294                                 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));
18295                         }
18296                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
18297                         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));
18298                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
18299                 }
18300                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_share));
18301                 if (_ptr_share) {
18302                         NDR_PULL_ALLOC(ndr, r->in.share);
18303                 } else {
18304                         r->in.share = NULL;
18305                 }
18306                 if (r->in.share) {
18307                         _mem_save_share_0 = NDR_PULL_GET_MEM_CTX(ndr);
18308                         NDR_PULL_SET_MEM_CTX(ndr, r->in.share, 0);
18309                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.share));
18310                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.share));
18311                         if (ndr_get_array_length(ndr, &r->in.share) > ndr_get_array_size(ndr, &r->in.share)) {
18312                                 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));
18313                         }
18314                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.share), sizeof(uint16_t)));
18315                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.share, ndr_get_array_length(ndr, &r->in.share), sizeof(uint16_t), CH_UTF16));
18316                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_share_0, 0);
18317                 }
18318                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.file));
18319                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.file));
18320                 if (ndr_get_array_length(ndr, &r->in.file) > ndr_get_array_size(ndr, &r->in.file)) {
18321                         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));
18322                 }
18323                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.file), sizeof(uint16_t)));
18324                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.file, ndr_get_array_length(ndr, &r->in.file), sizeof(uint16_t), CH_UTF16));
18325                 NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.securityinformation));
18326                 NDR_PULL_ALLOC(ndr, r->out.sd_buf);
18327                 ZERO_STRUCTP(r->out.sd_buf);
18328         }
18329         if (flags & NDR_OUT) {
18330                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18331                         NDR_PULL_ALLOC(ndr, r->out.sd_buf);
18332                 }
18333                 _mem_save_sd_buf_0 = NDR_PULL_GET_MEM_CTX(ndr);
18334                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sd_buf, LIBNDR_FLAG_REF_ALLOC);
18335                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sd_buf));
18336                 if (_ptr_sd_buf) {
18337                         NDR_PULL_ALLOC(ndr, *r->out.sd_buf);
18338                 } else {
18339                         *r->out.sd_buf = NULL;
18340                 }
18341                 if (*r->out.sd_buf) {
18342                         _mem_save_sd_buf_1 = NDR_PULL_GET_MEM_CTX(ndr);
18343                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sd_buf, 0);
18344                         NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sd_buf));
18345                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_buf_1, 0);
18346                 }
18347                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_buf_0, LIBNDR_FLAG_REF_ALLOC);
18348                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18349         }
18350         return NDR_ERR_SUCCESS;
18351 }
18352
18353 _PUBLIC_ void ndr_print_srvsvc_NetGetFileSecurity(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetGetFileSecurity *r)
18354 {
18355         ndr_print_struct(ndr, name, "srvsvc_NetGetFileSecurity");
18356         ndr->depth++;
18357         if (flags & NDR_SET_VALUES) {
18358                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18359         }
18360         if (flags & NDR_IN) {
18361                 ndr_print_struct(ndr, "in", "srvsvc_NetGetFileSecurity");
18362                 ndr->depth++;
18363                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
18364                 ndr->depth++;
18365                 if (r->in.server_unc) {
18366                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
18367                 }
18368                 ndr->depth--;
18369                 ndr_print_ptr(ndr, "share", r->in.share);
18370                 ndr->depth++;
18371                 if (r->in.share) {
18372                         ndr_print_string(ndr, "share", r->in.share);
18373                 }
18374                 ndr->depth--;
18375                 ndr_print_string(ndr, "file", r->in.file);
18376                 ndr_print_security_secinfo(ndr, "securityinformation", r->in.securityinformation);
18377                 ndr->depth--;
18378         }
18379         if (flags & NDR_OUT) {
18380                 ndr_print_struct(ndr, "out", "srvsvc_NetGetFileSecurity");
18381                 ndr->depth++;
18382                 ndr_print_ptr(ndr, "sd_buf", r->out.sd_buf);
18383                 ndr->depth++;
18384                 ndr_print_ptr(ndr, "sd_buf", *r->out.sd_buf);
18385                 ndr->depth++;
18386                 if (*r->out.sd_buf) {
18387                         ndr_print_sec_desc_buf(ndr, "sd_buf", *r->out.sd_buf);
18388                 }
18389                 ndr->depth--;
18390                 ndr->depth--;
18391                 ndr_print_WERROR(ndr, "result", r->out.result);
18392                 ndr->depth--;
18393         }
18394         ndr->depth--;
18395 }
18396
18397 static enum ndr_err_code ndr_push_srvsvc_NetSetFileSecurity(struct ndr_push *ndr, int flags, const struct srvsvc_NetSetFileSecurity *r)
18398 {
18399         if (flags & NDR_IN) {
18400                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
18401                 if (r->in.server_unc) {
18402                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18403                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18404                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18405                         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));
18406                 }
18407                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.share));
18408                 if (r->in.share) {
18409                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share, CH_UTF16)));
18410                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18411                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share, CH_UTF16)));
18412                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.share, ndr_charset_length(r->in.share, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18413                 }
18414                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.file, CH_UTF16)));
18415                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18416                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.file, CH_UTF16)));
18417                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.file, ndr_charset_length(r->in.file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18418                 NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.securityinformation));
18419                 if (r->in.sd_buf == NULL) {
18420                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18421                 }
18422                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sd_buf));
18423         }
18424         if (flags & NDR_OUT) {
18425                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18426         }
18427         return NDR_ERR_SUCCESS;
18428 }
18429
18430 static enum ndr_err_code ndr_pull_srvsvc_NetSetFileSecurity(struct ndr_pull *ndr, int flags, struct srvsvc_NetSetFileSecurity *r)
18431 {
18432         uint32_t _ptr_server_unc;
18433         uint32_t _ptr_share;
18434         TALLOC_CTX *_mem_save_server_unc_0;
18435         TALLOC_CTX *_mem_save_share_0;
18436         TALLOC_CTX *_mem_save_sd_buf_0;
18437         if (flags & NDR_IN) {
18438                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
18439                 if (_ptr_server_unc) {
18440                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
18441                 } else {
18442                         r->in.server_unc = NULL;
18443                 }
18444                 if (r->in.server_unc) {
18445                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
18446                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
18447                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
18448                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
18449                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
18450                                 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));
18451                         }
18452                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
18453                         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));
18454                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
18455                 }
18456                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_share));
18457                 if (_ptr_share) {
18458                         NDR_PULL_ALLOC(ndr, r->in.share);
18459                 } else {
18460                         r->in.share = NULL;
18461                 }
18462                 if (r->in.share) {
18463                         _mem_save_share_0 = NDR_PULL_GET_MEM_CTX(ndr);
18464                         NDR_PULL_SET_MEM_CTX(ndr, r->in.share, 0);
18465                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.share));
18466                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.share));
18467                         if (ndr_get_array_length(ndr, &r->in.share) > ndr_get_array_size(ndr, &r->in.share)) {
18468                                 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));
18469                         }
18470                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.share), sizeof(uint16_t)));
18471                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.share, ndr_get_array_length(ndr, &r->in.share), sizeof(uint16_t), CH_UTF16));
18472                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_share_0, 0);
18473                 }
18474                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.file));
18475                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.file));
18476                 if (ndr_get_array_length(ndr, &r->in.file) > ndr_get_array_size(ndr, &r->in.file)) {
18477                         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));
18478                 }
18479                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.file), sizeof(uint16_t)));
18480                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.file, ndr_get_array_length(ndr, &r->in.file), sizeof(uint16_t), CH_UTF16));
18481                 NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.securityinformation));
18482                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18483                         NDR_PULL_ALLOC(ndr, r->in.sd_buf);
18484                 }
18485                 _mem_save_sd_buf_0 = NDR_PULL_GET_MEM_CTX(ndr);
18486                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sd_buf, LIBNDR_FLAG_REF_ALLOC);
18487                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sd_buf));
18488                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_buf_0, LIBNDR_FLAG_REF_ALLOC);
18489         }
18490         if (flags & NDR_OUT) {
18491                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18492         }
18493         return NDR_ERR_SUCCESS;
18494 }
18495
18496 _PUBLIC_ void ndr_print_srvsvc_NetSetFileSecurity(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetSetFileSecurity *r)
18497 {
18498         ndr_print_struct(ndr, name, "srvsvc_NetSetFileSecurity");
18499         ndr->depth++;
18500         if (flags & NDR_SET_VALUES) {
18501                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18502         }
18503         if (flags & NDR_IN) {
18504                 ndr_print_struct(ndr, "in", "srvsvc_NetSetFileSecurity");
18505                 ndr->depth++;
18506                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
18507                 ndr->depth++;
18508                 if (r->in.server_unc) {
18509                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
18510                 }
18511                 ndr->depth--;
18512                 ndr_print_ptr(ndr, "share", r->in.share);
18513                 ndr->depth++;
18514                 if (r->in.share) {
18515                         ndr_print_string(ndr, "share", r->in.share);
18516                 }
18517                 ndr->depth--;
18518                 ndr_print_string(ndr, "file", r->in.file);
18519                 ndr_print_security_secinfo(ndr, "securityinformation", r->in.securityinformation);
18520                 ndr_print_ptr(ndr, "sd_buf", r->in.sd_buf);
18521                 ndr->depth++;
18522                 ndr_print_sec_desc_buf(ndr, "sd_buf", r->in.sd_buf);
18523                 ndr->depth--;
18524                 ndr->depth--;
18525         }
18526         if (flags & NDR_OUT) {
18527                 ndr_print_struct(ndr, "out", "srvsvc_NetSetFileSecurity");
18528                 ndr->depth++;
18529                 ndr_print_WERROR(ndr, "result", r->out.result);
18530                 ndr->depth--;
18531         }
18532         ndr->depth--;
18533 }
18534
18535 static enum ndr_err_code ndr_push_srvsvc_NetServerTransportAddEx(struct ndr_push *ndr, int flags, const struct srvsvc_NetServerTransportAddEx *r)
18536 {
18537         if (flags & NDR_IN) {
18538                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
18539                 if (r->in.server_unc) {
18540                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18541                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18542                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18543                         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));
18544                 }
18545                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18546                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
18547                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
18548         }
18549         if (flags & NDR_OUT) {
18550                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18551         }
18552         return NDR_ERR_SUCCESS;
18553 }
18554
18555 static enum ndr_err_code ndr_pull_srvsvc_NetServerTransportAddEx(struct ndr_pull *ndr, int flags, struct srvsvc_NetServerTransportAddEx *r)
18556 {
18557         uint32_t _ptr_server_unc;
18558         TALLOC_CTX *_mem_save_server_unc_0;
18559         if (flags & NDR_IN) {
18560                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
18561                 if (_ptr_server_unc) {
18562                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
18563                 } else {
18564                         r->in.server_unc = NULL;
18565                 }
18566                 if (r->in.server_unc) {
18567                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
18568                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
18569                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
18570                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
18571                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
18572                                 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));
18573                         }
18574                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
18575                         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));
18576                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
18577                 }
18578                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18579                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
18580                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
18581         }
18582         if (flags & NDR_OUT) {
18583                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18584         }
18585         return NDR_ERR_SUCCESS;
18586 }
18587
18588 _PUBLIC_ void ndr_print_srvsvc_NetServerTransportAddEx(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetServerTransportAddEx *r)
18589 {
18590         ndr_print_struct(ndr, name, "srvsvc_NetServerTransportAddEx");
18591         ndr->depth++;
18592         if (flags & NDR_SET_VALUES) {
18593                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18594         }
18595         if (flags & NDR_IN) {
18596                 ndr_print_struct(ndr, "in", "srvsvc_NetServerTransportAddEx");
18597                 ndr->depth++;
18598                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
18599                 ndr->depth++;
18600                 if (r->in.server_unc) {
18601                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
18602                 }
18603                 ndr->depth--;
18604                 ndr_print_uint32(ndr, "level", r->in.level);
18605                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
18606                 ndr_print_srvsvc_NetTransportInfo(ndr, "info", &r->in.info);
18607                 ndr->depth--;
18608         }
18609         if (flags & NDR_OUT) {
18610                 ndr_print_struct(ndr, "out", "srvsvc_NetServerTransportAddEx");
18611                 ndr->depth++;
18612                 ndr_print_WERROR(ndr, "result", r->out.result);
18613                 ndr->depth--;
18614         }
18615         ndr->depth--;
18616 }
18617
18618 static enum ndr_err_code ndr_push_srvsvc_NetServerSetServiceBitsEx(struct ndr_push *ndr, int flags, const struct srvsvc_NetServerSetServiceBitsEx *r)
18619 {
18620         if (flags & NDR_IN) {
18621                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
18622                 if (r->in.server_unc) {
18623                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18624                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18625                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18626                         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));
18627                 }
18628                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.emulated_server_unc));
18629                 if (r->in.emulated_server_unc) {
18630                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.emulated_server_unc, CH_UTF16)));
18631                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18632                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.emulated_server_unc, CH_UTF16)));
18633                         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));
18634                 }
18635                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.transport));
18636                 if (r->in.transport) {
18637                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.transport, CH_UTF16)));
18638                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18639                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.transport, CH_UTF16)));
18640                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.transport, ndr_charset_length(r->in.transport, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18641                 }
18642                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.servicebitsofinterest));
18643                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.servicebits));
18644                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.updateimmediately));
18645         }
18646         if (flags & NDR_OUT) {
18647                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18648         }
18649         return NDR_ERR_SUCCESS;
18650 }
18651
18652 static enum ndr_err_code ndr_pull_srvsvc_NetServerSetServiceBitsEx(struct ndr_pull *ndr, int flags, struct srvsvc_NetServerSetServiceBitsEx *r)
18653 {
18654         uint32_t _ptr_server_unc;
18655         uint32_t _ptr_emulated_server_unc;
18656         uint32_t _ptr_transport;
18657         TALLOC_CTX *_mem_save_server_unc_0;
18658         TALLOC_CTX *_mem_save_emulated_server_unc_0;
18659         TALLOC_CTX *_mem_save_transport_0;
18660         if (flags & NDR_IN) {
18661                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
18662                 if (_ptr_server_unc) {
18663                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
18664                 } else {
18665                         r->in.server_unc = NULL;
18666                 }
18667                 if (r->in.server_unc) {
18668                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
18669                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
18670                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
18671                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
18672                         if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {
18673                                 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));
18674                         }
18675                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));
18676                         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));
18677                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
18678                 }
18679                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_emulated_server_unc));
18680                 if (_ptr_emulated_server_unc) {
18681                         NDR_PULL_ALLOC(ndr, r->in.emulated_server_unc);
18682                 } else {
18683                         r->in.emulated_server_unc = NULL;
18684                 }
18685                 if (r->in.emulated_server_unc) {
18686                         _mem_save_emulated_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
18687                         NDR_PULL_SET_MEM_CTX(ndr, r->in.emulated_server_unc, 0);
18688                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.emulated_server_unc));
18689                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.emulated_server_unc));
18690                         if (ndr_get_array_length(ndr, &r->in.emulated_server_unc) > ndr_get_array_size(ndr, &r->in.emulated_server_unc)) {
18691                                 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));
18692                         }
18693                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.emulated_server_unc), sizeof(uint16_t)));
18694                         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));
18695                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_emulated_server_unc_0, 0);
18696                 }
18697                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport));
18698                 if (_ptr_transport) {
18699                         NDR_PULL_ALLOC(ndr, r->in.transport);
18700                 } else {
18701                         r->in.transport = NULL;
18702                 }
18703                 if (r->in.transport) {
18704                         _mem_save_transport_0 = NDR_PULL_GET_MEM_CTX(ndr);
18705                         NDR_PULL_SET_MEM_CTX(ndr, r->in.transport, 0);
18706                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.transport));
18707                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.transport));
18708                         if (ndr_get_array_length(ndr, &r->in.transport) > ndr_get_array_size(ndr, &r->in.transport)) {
18709                                 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));
18710                         }
18711                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.transport), sizeof(uint16_t)));
18712                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.transport, ndr_get_array_length(ndr, &r->in.transport), sizeof(uint16_t), CH_UTF16));
18713                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_0, 0);
18714                 }
18715                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.servicebitsofinterest));
18716                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.servicebits));
18717                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.updateimmediately));
18718         }
18719         if (flags & NDR_OUT) {
18720                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18721         }
18722         return NDR_ERR_SUCCESS;
18723 }
18724
18725 _PUBLIC_ void ndr_print_srvsvc_NetServerSetServiceBitsEx(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetServerSetServiceBitsEx *r)
18726 {
18727         ndr_print_struct(ndr, name, "srvsvc_NetServerSetServiceBitsEx");
18728         ndr->depth++;
18729         if (flags & NDR_SET_VALUES) {
18730                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18731         }
18732         if (flags & NDR_IN) {
18733                 ndr_print_struct(ndr, "in", "srvsvc_NetServerSetServiceBitsEx");
18734                 ndr->depth++;
18735                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
18736                 ndr->depth++;
18737                 if (r->in.server_unc) {
18738                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
18739                 }
18740                 ndr->depth--;
18741                 ndr_print_ptr(ndr, "emulated_server_unc", r->in.emulated_server_unc);
18742                 ndr->depth++;
18743                 if (r->in.emulated_server_unc) {
18744                         ndr_print_string(ndr, "emulated_server_unc", r->in.emulated_server_unc);
18745                 }
18746                 ndr->depth--;
18747                 ndr_print_ptr(ndr, "transport", r->in.transport);
18748                 ndr->depth++;
18749                 if (r->in.transport) {
18750                         ndr_print_string(ndr, "transport", r->in.transport);
18751                 }
18752                 ndr->depth--;
18753                 ndr_print_uint32(ndr, "servicebitsofinterest", r->in.servicebitsofinterest);
18754                 ndr_print_uint32(ndr, "servicebits", r->in.servicebits);
18755                 ndr_print_uint32(ndr, "updateimmediately", r->in.updateimmediately);
18756                 ndr->depth--;
18757         }
18758         if (flags & NDR_OUT) {
18759                 ndr_print_struct(ndr, "out", "srvsvc_NetServerSetServiceBitsEx");
18760                 ndr->depth++;
18761                 ndr_print_WERROR(ndr, "result", r->out.result);
18762                 ndr->depth--;
18763         }
18764         ndr->depth--;
18765 }
18766
18767 static enum ndr_err_code ndr_push_srvsvc_NETRDFSGETVERSION(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSGETVERSION *r)
18768 {
18769         if (flags & NDR_IN) {
18770         }
18771         if (flags & NDR_OUT) {
18772                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18773         }
18774         return NDR_ERR_SUCCESS;
18775 }
18776
18777 static enum ndr_err_code ndr_pull_srvsvc_NETRDFSGETVERSION(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSGETVERSION *r)
18778 {
18779         if (flags & NDR_IN) {
18780         }
18781         if (flags & NDR_OUT) {
18782                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18783         }
18784         return NDR_ERR_SUCCESS;
18785 }
18786
18787 _PUBLIC_ void ndr_print_srvsvc_NETRDFSGETVERSION(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSGETVERSION *r)
18788 {
18789         ndr_print_struct(ndr, name, "srvsvc_NETRDFSGETVERSION");
18790         ndr->depth++;
18791         if (flags & NDR_SET_VALUES) {
18792                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18793         }
18794         if (flags & NDR_IN) {
18795                 ndr_print_struct(ndr, "in", "srvsvc_NETRDFSGETVERSION");
18796                 ndr->depth++;
18797                 ndr->depth--;
18798         }
18799         if (flags & NDR_OUT) {
18800                 ndr_print_struct(ndr, "out", "srvsvc_NETRDFSGETVERSION");
18801                 ndr->depth++;
18802                 ndr_print_WERROR(ndr, "result", r->out.result);
18803                 ndr->depth--;
18804         }
18805         ndr->depth--;
18806 }
18807
18808 static enum ndr_err_code ndr_push_srvsvc_NETRDFSCREATELOCALPARTITION(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSCREATELOCALPARTITION *r)
18809 {
18810         if (flags & NDR_IN) {
18811         }
18812         if (flags & NDR_OUT) {
18813                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18814         }
18815         return NDR_ERR_SUCCESS;
18816 }
18817
18818 static enum ndr_err_code ndr_pull_srvsvc_NETRDFSCREATELOCALPARTITION(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSCREATELOCALPARTITION *r)
18819 {
18820         if (flags & NDR_IN) {
18821         }
18822         if (flags & NDR_OUT) {
18823                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18824         }
18825         return NDR_ERR_SUCCESS;
18826 }
18827
18828 _PUBLIC_ void ndr_print_srvsvc_NETRDFSCREATELOCALPARTITION(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSCREATELOCALPARTITION *r)
18829 {
18830         ndr_print_struct(ndr, name, "srvsvc_NETRDFSCREATELOCALPARTITION");
18831         ndr->depth++;
18832         if (flags & NDR_SET_VALUES) {
18833                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18834         }
18835         if (flags & NDR_IN) {
18836                 ndr_print_struct(ndr, "in", "srvsvc_NETRDFSCREATELOCALPARTITION");
18837                 ndr->depth++;
18838                 ndr->depth--;
18839         }
18840         if (flags & NDR_OUT) {
18841                 ndr_print_struct(ndr, "out", "srvsvc_NETRDFSCREATELOCALPARTITION");
18842                 ndr->depth++;
18843                 ndr_print_WERROR(ndr, "result", r->out.result);
18844                 ndr->depth--;
18845         }
18846         ndr->depth--;
18847 }
18848
18849 static enum ndr_err_code ndr_push_srvsvc_NETRDFSDELETELOCALPARTITION(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSDELETELOCALPARTITION *r)
18850 {
18851         if (flags & NDR_IN) {
18852         }
18853         if (flags & NDR_OUT) {
18854                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18855         }
18856         return NDR_ERR_SUCCESS;
18857 }
18858
18859 static enum ndr_err_code ndr_pull_srvsvc_NETRDFSDELETELOCALPARTITION(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSDELETELOCALPARTITION *r)
18860 {
18861         if (flags & NDR_IN) {
18862         }
18863         if (flags & NDR_OUT) {
18864                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18865         }
18866         return NDR_ERR_SUCCESS;
18867 }
18868
18869 _PUBLIC_ void ndr_print_srvsvc_NETRDFSDELETELOCALPARTITION(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSDELETELOCALPARTITION *r)
18870 {
18871         ndr_print_struct(ndr, name, "srvsvc_NETRDFSDELETELOCALPARTITION");
18872         ndr->depth++;
18873         if (flags & NDR_SET_VALUES) {
18874                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18875         }
18876         if (flags & NDR_IN) {
18877                 ndr_print_struct(ndr, "in", "srvsvc_NETRDFSDELETELOCALPARTITION");
18878                 ndr->depth++;
18879                 ndr->depth--;
18880         }
18881         if (flags & NDR_OUT) {
18882                 ndr_print_struct(ndr, "out", "srvsvc_NETRDFSDELETELOCALPARTITION");
18883                 ndr->depth++;
18884                 ndr_print_WERROR(ndr, "result", r->out.result);
18885                 ndr->depth--;
18886         }
18887         ndr->depth--;
18888 }
18889
18890 static enum ndr_err_code ndr_push_srvsvc_NETRDFSSETLOCALVOLUMESTATE(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *r)
18891 {
18892         if (flags & NDR_IN) {
18893         }
18894         if (flags & NDR_OUT) {
18895                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18896         }
18897         return NDR_ERR_SUCCESS;
18898 }
18899
18900 static enum ndr_err_code ndr_pull_srvsvc_NETRDFSSETLOCALVOLUMESTATE(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *r)
18901 {
18902         if (flags & NDR_IN) {
18903         }
18904         if (flags & NDR_OUT) {
18905                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18906         }
18907         return NDR_ERR_SUCCESS;
18908 }
18909
18910 _PUBLIC_ void ndr_print_srvsvc_NETRDFSSETLOCALVOLUMESTATE(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *r)
18911 {
18912         ndr_print_struct(ndr, name, "srvsvc_NETRDFSSETLOCALVOLUMESTATE");
18913         ndr->depth++;
18914         if (flags & NDR_SET_VALUES) {
18915                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18916         }
18917         if (flags & NDR_IN) {
18918                 ndr_print_struct(ndr, "in", "srvsvc_NETRDFSSETLOCALVOLUMESTATE");
18919                 ndr->depth++;
18920                 ndr->depth--;
18921         }
18922         if (flags & NDR_OUT) {
18923                 ndr_print_struct(ndr, "out", "srvsvc_NETRDFSSETLOCALVOLUMESTATE");
18924                 ndr->depth++;
18925                 ndr_print_WERROR(ndr, "result", r->out.result);
18926                 ndr->depth--;
18927         }
18928         ndr->depth--;
18929 }
18930
18931 static enum ndr_err_code ndr_push_srvsvc_NETRDFSSETSERVERINFO(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSSETSERVERINFO *r)
18932 {
18933         if (flags & NDR_IN) {
18934         }
18935         if (flags & NDR_OUT) {
18936                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18937         }
18938         return NDR_ERR_SUCCESS;
18939 }
18940
18941 static enum ndr_err_code ndr_pull_srvsvc_NETRDFSSETSERVERINFO(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSSETSERVERINFO *r)
18942 {
18943         if (flags & NDR_IN) {
18944         }
18945         if (flags & NDR_OUT) {
18946                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18947         }
18948         return NDR_ERR_SUCCESS;
18949 }
18950
18951 _PUBLIC_ void ndr_print_srvsvc_NETRDFSSETSERVERINFO(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSSETSERVERINFO *r)
18952 {
18953         ndr_print_struct(ndr, name, "srvsvc_NETRDFSSETSERVERINFO");
18954         ndr->depth++;
18955         if (flags & NDR_SET_VALUES) {
18956                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18957         }
18958         if (flags & NDR_IN) {
18959                 ndr_print_struct(ndr, "in", "srvsvc_NETRDFSSETSERVERINFO");
18960                 ndr->depth++;
18961                 ndr->depth--;
18962         }
18963         if (flags & NDR_OUT) {
18964                 ndr_print_struct(ndr, "out", "srvsvc_NETRDFSSETSERVERINFO");
18965                 ndr->depth++;
18966                 ndr_print_WERROR(ndr, "result", r->out.result);
18967                 ndr->depth--;
18968         }
18969         ndr->depth--;
18970 }
18971
18972 static enum ndr_err_code ndr_push_srvsvc_NETRDFSCREATEEXITPOINT(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSCREATEEXITPOINT *r)
18973 {
18974         if (flags & NDR_IN) {
18975         }
18976         if (flags & NDR_OUT) {
18977                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18978         }
18979         return NDR_ERR_SUCCESS;
18980 }
18981
18982 static enum ndr_err_code ndr_pull_srvsvc_NETRDFSCREATEEXITPOINT(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSCREATEEXITPOINT *r)
18983 {
18984         if (flags & NDR_IN) {
18985         }
18986         if (flags & NDR_OUT) {
18987                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18988         }
18989         return NDR_ERR_SUCCESS;
18990 }
18991
18992 _PUBLIC_ void ndr_print_srvsvc_NETRDFSCREATEEXITPOINT(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSCREATEEXITPOINT *r)
18993 {
18994         ndr_print_struct(ndr, name, "srvsvc_NETRDFSCREATEEXITPOINT");
18995         ndr->depth++;
18996         if (flags & NDR_SET_VALUES) {
18997                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18998         }
18999         if (flags & NDR_IN) {
19000                 ndr_print_struct(ndr, "in", "srvsvc_NETRDFSCREATEEXITPOINT");
19001                 ndr->depth++;
19002                 ndr->depth--;
19003         }
19004         if (flags & NDR_OUT) {
19005                 ndr_print_struct(ndr, "out", "srvsvc_NETRDFSCREATEEXITPOINT");
19006                 ndr->depth++;
19007                 ndr_print_WERROR(ndr, "result", r->out.result);
19008                 ndr->depth--;
19009         }
19010         ndr->depth--;
19011 }
19012
19013 static enum ndr_err_code ndr_push_srvsvc_NETRDFSDELETEEXITPOINT(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSDELETEEXITPOINT *r)
19014 {
19015         if (flags & NDR_IN) {
19016         }
19017         if (flags & NDR_OUT) {
19018                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19019         }
19020         return NDR_ERR_SUCCESS;
19021 }
19022
19023 static enum ndr_err_code ndr_pull_srvsvc_NETRDFSDELETEEXITPOINT(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSDELETEEXITPOINT *r)
19024 {
19025         if (flags & NDR_IN) {
19026         }
19027         if (flags & NDR_OUT) {
19028                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19029         }
19030         return NDR_ERR_SUCCESS;
19031 }
19032
19033 _PUBLIC_ void ndr_print_srvsvc_NETRDFSDELETEEXITPOINT(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSDELETEEXITPOINT *r)
19034 {
19035         ndr_print_struct(ndr, name, "srvsvc_NETRDFSDELETEEXITPOINT");
19036         ndr->depth++;
19037         if (flags & NDR_SET_VALUES) {
19038                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19039         }
19040         if (flags & NDR_IN) {
19041                 ndr_print_struct(ndr, "in", "srvsvc_NETRDFSDELETEEXITPOINT");
19042                 ndr->depth++;
19043                 ndr->depth--;
19044         }
19045         if (flags & NDR_OUT) {
19046                 ndr_print_struct(ndr, "out", "srvsvc_NETRDFSDELETEEXITPOINT");
19047                 ndr->depth++;
19048                 ndr_print_WERROR(ndr, "result", r->out.result);
19049                 ndr->depth--;
19050         }
19051         ndr->depth--;
19052 }
19053
19054 static enum ndr_err_code ndr_push_srvsvc_NETRDFSMODIFYPREFIX(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSMODIFYPREFIX *r)
19055 {
19056         if (flags & NDR_IN) {
19057         }
19058         if (flags & NDR_OUT) {
19059                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19060         }
19061         return NDR_ERR_SUCCESS;
19062 }
19063
19064 static enum ndr_err_code ndr_pull_srvsvc_NETRDFSMODIFYPREFIX(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSMODIFYPREFIX *r)
19065 {
19066         if (flags & NDR_IN) {
19067         }
19068         if (flags & NDR_OUT) {
19069                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19070         }
19071         return NDR_ERR_SUCCESS;
19072 }
19073
19074 _PUBLIC_ void ndr_print_srvsvc_NETRDFSMODIFYPREFIX(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSMODIFYPREFIX *r)
19075 {
19076         ndr_print_struct(ndr, name, "srvsvc_NETRDFSMODIFYPREFIX");
19077         ndr->depth++;
19078         if (flags & NDR_SET_VALUES) {
19079                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19080         }
19081         if (flags & NDR_IN) {
19082                 ndr_print_struct(ndr, "in", "srvsvc_NETRDFSMODIFYPREFIX");
19083                 ndr->depth++;
19084                 ndr->depth--;
19085         }
19086         if (flags & NDR_OUT) {
19087                 ndr_print_struct(ndr, "out", "srvsvc_NETRDFSMODIFYPREFIX");
19088                 ndr->depth++;
19089                 ndr_print_WERROR(ndr, "result", r->out.result);
19090                 ndr->depth--;
19091         }
19092         ndr->depth--;
19093 }
19094
19095 static enum ndr_err_code ndr_push_srvsvc_NETRDFSFIXLOCALVOLUME(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSFIXLOCALVOLUME *r)
19096 {
19097         if (flags & NDR_IN) {
19098         }
19099         if (flags & NDR_OUT) {
19100                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19101         }
19102         return NDR_ERR_SUCCESS;
19103 }
19104
19105 static enum ndr_err_code ndr_pull_srvsvc_NETRDFSFIXLOCALVOLUME(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSFIXLOCALVOLUME *r)
19106 {
19107         if (flags & NDR_IN) {
19108         }
19109         if (flags & NDR_OUT) {
19110                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19111         }
19112         return NDR_ERR_SUCCESS;
19113 }
19114
19115 _PUBLIC_ void ndr_print_srvsvc_NETRDFSFIXLOCALVOLUME(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSFIXLOCALVOLUME *r)
19116 {
19117         ndr_print_struct(ndr, name, "srvsvc_NETRDFSFIXLOCALVOLUME");
19118         ndr->depth++;
19119         if (flags & NDR_SET_VALUES) {
19120                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19121         }
19122         if (flags & NDR_IN) {
19123                 ndr_print_struct(ndr, "in", "srvsvc_NETRDFSFIXLOCALVOLUME");
19124                 ndr->depth++;
19125                 ndr->depth--;
19126         }
19127         if (flags & NDR_OUT) {
19128                 ndr_print_struct(ndr, "out", "srvsvc_NETRDFSFIXLOCALVOLUME");
19129                 ndr->depth++;
19130                 ndr_print_WERROR(ndr, "result", r->out.result);
19131                 ndr->depth--;
19132         }
19133         ndr->depth--;
19134 }
19135
19136 static enum ndr_err_code ndr_push_srvsvc_NETRDFSMANAGERREPORTSITEINFO(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *r)
19137 {
19138         if (flags & NDR_IN) {
19139         }
19140         if (flags & NDR_OUT) {
19141                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19142         }
19143         return NDR_ERR_SUCCESS;
19144 }
19145
19146 static enum ndr_err_code ndr_pull_srvsvc_NETRDFSMANAGERREPORTSITEINFO(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *r)
19147 {
19148         if (flags & NDR_IN) {
19149         }
19150         if (flags & NDR_OUT) {
19151                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19152         }
19153         return NDR_ERR_SUCCESS;
19154 }
19155
19156 _PUBLIC_ void ndr_print_srvsvc_NETRDFSMANAGERREPORTSITEINFO(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *r)
19157 {
19158         ndr_print_struct(ndr, name, "srvsvc_NETRDFSMANAGERREPORTSITEINFO");
19159         ndr->depth++;
19160         if (flags & NDR_SET_VALUES) {
19161                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19162         }
19163         if (flags & NDR_IN) {
19164                 ndr_print_struct(ndr, "in", "srvsvc_NETRDFSMANAGERREPORTSITEINFO");
19165                 ndr->depth++;
19166                 ndr->depth--;
19167         }
19168         if (flags & NDR_OUT) {
19169                 ndr_print_struct(ndr, "out", "srvsvc_NETRDFSMANAGERREPORTSITEINFO");
19170                 ndr->depth++;
19171                 ndr_print_WERROR(ndr, "result", r->out.result);
19172                 ndr->depth--;
19173         }
19174         ndr->depth--;
19175 }
19176
19177 static enum ndr_err_code ndr_push_srvsvc_NETRSERVERTRANSPORTDELEX(struct ndr_push *ndr, int flags, const struct srvsvc_NETRSERVERTRANSPORTDELEX *r)
19178 {
19179         if (flags & NDR_IN) {
19180         }
19181         if (flags & NDR_OUT) {
19182                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19183         }
19184         return NDR_ERR_SUCCESS;
19185 }
19186
19187 static enum ndr_err_code ndr_pull_srvsvc_NETRSERVERTRANSPORTDELEX(struct ndr_pull *ndr, int flags, struct srvsvc_NETRSERVERTRANSPORTDELEX *r)
19188 {
19189         if (flags & NDR_IN) {
19190         }
19191         if (flags & NDR_OUT) {
19192                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19193         }
19194         return NDR_ERR_SUCCESS;
19195 }
19196
19197 _PUBLIC_ void ndr_print_srvsvc_NETRSERVERTRANSPORTDELEX(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRSERVERTRANSPORTDELEX *r)
19198 {
19199         ndr_print_struct(ndr, name, "srvsvc_NETRSERVERTRANSPORTDELEX");
19200         ndr->depth++;
19201         if (flags & NDR_SET_VALUES) {
19202                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19203         }
19204         if (flags & NDR_IN) {
19205                 ndr_print_struct(ndr, "in", "srvsvc_NETRSERVERTRANSPORTDELEX");
19206                 ndr->depth++;
19207                 ndr->depth--;
19208         }
19209         if (flags & NDR_OUT) {
19210                 ndr_print_struct(ndr, "out", "srvsvc_NETRSERVERTRANSPORTDELEX");
19211                 ndr->depth++;
19212                 ndr_print_WERROR(ndr, "result", r->out.result);
19213                 ndr->depth--;
19214         }
19215         ndr->depth--;
19216 }
19217
19218 static const struct ndr_interface_call srvsvc_calls[] = {
19219         {
19220                 "srvsvc_NetCharDevEnum",
19221                 sizeof(struct srvsvc_NetCharDevEnum),
19222                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetCharDevEnum,
19223                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetCharDevEnum,
19224                 (ndr_print_function_t) ndr_print_srvsvc_NetCharDevEnum,
19225                 false,
19226         },
19227         {
19228                 "srvsvc_NetCharDevGetInfo",
19229                 sizeof(struct srvsvc_NetCharDevGetInfo),
19230                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetCharDevGetInfo,
19231                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetCharDevGetInfo,
19232                 (ndr_print_function_t) ndr_print_srvsvc_NetCharDevGetInfo,
19233                 false,
19234         },
19235         {
19236                 "srvsvc_NetCharDevControl",
19237                 sizeof(struct srvsvc_NetCharDevControl),
19238                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetCharDevControl,
19239                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetCharDevControl,
19240                 (ndr_print_function_t) ndr_print_srvsvc_NetCharDevControl,
19241                 false,
19242         },
19243         {
19244                 "srvsvc_NetCharDevQEnum",
19245                 sizeof(struct srvsvc_NetCharDevQEnum),
19246                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetCharDevQEnum,
19247                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetCharDevQEnum,
19248                 (ndr_print_function_t) ndr_print_srvsvc_NetCharDevQEnum,
19249                 false,
19250         },
19251         {
19252                 "srvsvc_NetCharDevQGetInfo",
19253                 sizeof(struct srvsvc_NetCharDevQGetInfo),
19254                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetCharDevQGetInfo,
19255                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetCharDevQGetInfo,
19256                 (ndr_print_function_t) ndr_print_srvsvc_NetCharDevQGetInfo,
19257                 false,
19258         },
19259         {
19260                 "srvsvc_NetCharDevQSetInfo",
19261                 sizeof(struct srvsvc_NetCharDevQSetInfo),
19262                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetCharDevQSetInfo,
19263                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetCharDevQSetInfo,
19264                 (ndr_print_function_t) ndr_print_srvsvc_NetCharDevQSetInfo,
19265                 false,
19266         },
19267         {
19268                 "srvsvc_NetCharDevQPurge",
19269                 sizeof(struct srvsvc_NetCharDevQPurge),
19270                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetCharDevQPurge,
19271                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetCharDevQPurge,
19272                 (ndr_print_function_t) ndr_print_srvsvc_NetCharDevQPurge,
19273                 false,
19274         },
19275         {
19276                 "srvsvc_NetCharDevQPurgeSelf",
19277                 sizeof(struct srvsvc_NetCharDevQPurgeSelf),
19278                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetCharDevQPurgeSelf,
19279                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetCharDevQPurgeSelf,
19280                 (ndr_print_function_t) ndr_print_srvsvc_NetCharDevQPurgeSelf,
19281                 false,
19282         },
19283         {
19284                 "srvsvc_NetConnEnum",
19285                 sizeof(struct srvsvc_NetConnEnum),
19286                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetConnEnum,
19287                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetConnEnum,
19288                 (ndr_print_function_t) ndr_print_srvsvc_NetConnEnum,
19289                 false,
19290         },
19291         {
19292                 "srvsvc_NetFileEnum",
19293                 sizeof(struct srvsvc_NetFileEnum),
19294                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetFileEnum,
19295                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetFileEnum,
19296                 (ndr_print_function_t) ndr_print_srvsvc_NetFileEnum,
19297                 false,
19298         },
19299         {
19300                 "srvsvc_NetFileGetInfo",
19301                 sizeof(struct srvsvc_NetFileGetInfo),
19302                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetFileGetInfo,
19303                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetFileGetInfo,
19304                 (ndr_print_function_t) ndr_print_srvsvc_NetFileGetInfo,
19305                 false,
19306         },
19307         {
19308                 "srvsvc_NetFileClose",
19309                 sizeof(struct srvsvc_NetFileClose),
19310                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetFileClose,
19311                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetFileClose,
19312                 (ndr_print_function_t) ndr_print_srvsvc_NetFileClose,
19313                 false,
19314         },
19315         {
19316                 "srvsvc_NetSessEnum",
19317                 sizeof(struct srvsvc_NetSessEnum),
19318                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetSessEnum,
19319                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetSessEnum,
19320                 (ndr_print_function_t) ndr_print_srvsvc_NetSessEnum,
19321                 false,
19322         },
19323         {
19324                 "srvsvc_NetSessDel",
19325                 sizeof(struct srvsvc_NetSessDel),
19326                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetSessDel,
19327                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetSessDel,
19328                 (ndr_print_function_t) ndr_print_srvsvc_NetSessDel,
19329                 false,
19330         },
19331         {
19332                 "srvsvc_NetShareAdd",
19333                 sizeof(struct srvsvc_NetShareAdd),
19334                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareAdd,
19335                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareAdd,
19336                 (ndr_print_function_t) ndr_print_srvsvc_NetShareAdd,
19337                 false,
19338         },
19339         {
19340                 "srvsvc_NetShareEnumAll",
19341                 sizeof(struct srvsvc_NetShareEnumAll),
19342                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareEnumAll,
19343                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareEnumAll,
19344                 (ndr_print_function_t) ndr_print_srvsvc_NetShareEnumAll,
19345                 false,
19346         },
19347         {
19348                 "srvsvc_NetShareGetInfo",
19349                 sizeof(struct srvsvc_NetShareGetInfo),
19350                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareGetInfo,
19351                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareGetInfo,
19352                 (ndr_print_function_t) ndr_print_srvsvc_NetShareGetInfo,
19353                 false,
19354         },
19355         {
19356                 "srvsvc_NetShareSetInfo",
19357                 sizeof(struct srvsvc_NetShareSetInfo),
19358                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareSetInfo,
19359                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareSetInfo,
19360                 (ndr_print_function_t) ndr_print_srvsvc_NetShareSetInfo,
19361                 false,
19362         },
19363         {
19364                 "srvsvc_NetShareDel",
19365                 sizeof(struct srvsvc_NetShareDel),
19366                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareDel,
19367                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareDel,
19368                 (ndr_print_function_t) ndr_print_srvsvc_NetShareDel,
19369                 false,
19370         },
19371         {
19372                 "srvsvc_NetShareDelSticky",
19373                 sizeof(struct srvsvc_NetShareDelSticky),
19374                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareDelSticky,
19375                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareDelSticky,
19376                 (ndr_print_function_t) ndr_print_srvsvc_NetShareDelSticky,
19377                 false,
19378         },
19379         {
19380                 "srvsvc_NetShareCheck",
19381                 sizeof(struct srvsvc_NetShareCheck),
19382                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareCheck,
19383                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareCheck,
19384                 (ndr_print_function_t) ndr_print_srvsvc_NetShareCheck,
19385                 false,
19386         },
19387         {
19388                 "srvsvc_NetSrvGetInfo",
19389                 sizeof(struct srvsvc_NetSrvGetInfo),
19390                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetSrvGetInfo,
19391                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetSrvGetInfo,
19392                 (ndr_print_function_t) ndr_print_srvsvc_NetSrvGetInfo,
19393                 false,
19394         },
19395         {
19396                 "srvsvc_NetSrvSetInfo",
19397                 sizeof(struct srvsvc_NetSrvSetInfo),
19398                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetSrvSetInfo,
19399                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetSrvSetInfo,
19400                 (ndr_print_function_t) ndr_print_srvsvc_NetSrvSetInfo,
19401                 false,
19402         },
19403         {
19404                 "srvsvc_NetDiskEnum",
19405                 sizeof(struct srvsvc_NetDiskEnum),
19406                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetDiskEnum,
19407                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetDiskEnum,
19408                 (ndr_print_function_t) ndr_print_srvsvc_NetDiskEnum,
19409                 false,
19410         },
19411         {
19412                 "srvsvc_NetServerStatisticsGet",
19413                 sizeof(struct srvsvc_NetServerStatisticsGet),
19414                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetServerStatisticsGet,
19415                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetServerStatisticsGet,
19416                 (ndr_print_function_t) ndr_print_srvsvc_NetServerStatisticsGet,
19417                 false,
19418         },
19419         {
19420                 "srvsvc_NetTransportAdd",
19421                 sizeof(struct srvsvc_NetTransportAdd),
19422                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetTransportAdd,
19423                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetTransportAdd,
19424                 (ndr_print_function_t) ndr_print_srvsvc_NetTransportAdd,
19425                 false,
19426         },
19427         {
19428                 "srvsvc_NetTransportEnum",
19429                 sizeof(struct srvsvc_NetTransportEnum),
19430                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetTransportEnum,
19431                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetTransportEnum,
19432                 (ndr_print_function_t) ndr_print_srvsvc_NetTransportEnum,
19433                 false,
19434         },
19435         {
19436                 "srvsvc_NetTransportDel",
19437                 sizeof(struct srvsvc_NetTransportDel),
19438                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetTransportDel,
19439                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetTransportDel,
19440                 (ndr_print_function_t) ndr_print_srvsvc_NetTransportDel,
19441                 false,
19442         },
19443         {
19444                 "srvsvc_NetRemoteTOD",
19445                 sizeof(struct srvsvc_NetRemoteTOD),
19446                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetRemoteTOD,
19447                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetRemoteTOD,
19448                 (ndr_print_function_t) ndr_print_srvsvc_NetRemoteTOD,
19449                 false,
19450         },
19451         {
19452                 "srvsvc_NetSetServiceBits",
19453                 sizeof(struct srvsvc_NetSetServiceBits),
19454                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetSetServiceBits,
19455                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetSetServiceBits,
19456                 (ndr_print_function_t) ndr_print_srvsvc_NetSetServiceBits,
19457                 false,
19458         },
19459         {
19460                 "srvsvc_NetPathType",
19461                 sizeof(struct srvsvc_NetPathType),
19462                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetPathType,
19463                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetPathType,
19464                 (ndr_print_function_t) ndr_print_srvsvc_NetPathType,
19465                 false,
19466         },
19467         {
19468                 "srvsvc_NetPathCanonicalize",
19469                 sizeof(struct srvsvc_NetPathCanonicalize),
19470                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetPathCanonicalize,
19471                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetPathCanonicalize,
19472                 (ndr_print_function_t) ndr_print_srvsvc_NetPathCanonicalize,
19473                 false,
19474         },
19475         {
19476                 "srvsvc_NetPathCompare",
19477                 sizeof(struct srvsvc_NetPathCompare),
19478                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetPathCompare,
19479                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetPathCompare,
19480                 (ndr_print_function_t) ndr_print_srvsvc_NetPathCompare,
19481                 false,
19482         },
19483         {
19484                 "srvsvc_NetNameValidate",
19485                 sizeof(struct srvsvc_NetNameValidate),
19486                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetNameValidate,
19487                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetNameValidate,
19488                 (ndr_print_function_t) ndr_print_srvsvc_NetNameValidate,
19489                 false,
19490         },
19491         {
19492                 "srvsvc_NETRPRNAMECANONICALIZE",
19493                 sizeof(struct srvsvc_NETRPRNAMECANONICALIZE),
19494                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRPRNAMECANONICALIZE,
19495                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRPRNAMECANONICALIZE,
19496                 (ndr_print_function_t) ndr_print_srvsvc_NETRPRNAMECANONICALIZE,
19497                 false,
19498         },
19499         {
19500                 "srvsvc_NetPRNameCompare",
19501                 sizeof(struct srvsvc_NetPRNameCompare),
19502                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetPRNameCompare,
19503                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetPRNameCompare,
19504                 (ndr_print_function_t) ndr_print_srvsvc_NetPRNameCompare,
19505                 false,
19506         },
19507         {
19508                 "srvsvc_NetShareEnum",
19509                 sizeof(struct srvsvc_NetShareEnum),
19510                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareEnum,
19511                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareEnum,
19512                 (ndr_print_function_t) ndr_print_srvsvc_NetShareEnum,
19513                 false,
19514         },
19515         {
19516                 "srvsvc_NetShareDelStart",
19517                 sizeof(struct srvsvc_NetShareDelStart),
19518                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareDelStart,
19519                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareDelStart,
19520                 (ndr_print_function_t) ndr_print_srvsvc_NetShareDelStart,
19521                 false,
19522         },
19523         {
19524                 "srvsvc_NetShareDelCommit",
19525                 sizeof(struct srvsvc_NetShareDelCommit),
19526                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareDelCommit,
19527                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareDelCommit,
19528                 (ndr_print_function_t) ndr_print_srvsvc_NetShareDelCommit,
19529                 false,
19530         },
19531         {
19532                 "srvsvc_NetGetFileSecurity",
19533                 sizeof(struct srvsvc_NetGetFileSecurity),
19534                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetGetFileSecurity,
19535                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetGetFileSecurity,
19536                 (ndr_print_function_t) ndr_print_srvsvc_NetGetFileSecurity,
19537                 false,
19538         },
19539         {
19540                 "srvsvc_NetSetFileSecurity",
19541                 sizeof(struct srvsvc_NetSetFileSecurity),
19542                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetSetFileSecurity,
19543                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetSetFileSecurity,
19544                 (ndr_print_function_t) ndr_print_srvsvc_NetSetFileSecurity,
19545                 false,
19546         },
19547         {
19548                 "srvsvc_NetServerTransportAddEx",
19549                 sizeof(struct srvsvc_NetServerTransportAddEx),
19550                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetServerTransportAddEx,
19551                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetServerTransportAddEx,
19552                 (ndr_print_function_t) ndr_print_srvsvc_NetServerTransportAddEx,
19553                 false,
19554         },
19555         {
19556                 "srvsvc_NetServerSetServiceBitsEx",
19557                 sizeof(struct srvsvc_NetServerSetServiceBitsEx),
19558                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetServerSetServiceBitsEx,
19559                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetServerSetServiceBitsEx,
19560                 (ndr_print_function_t) ndr_print_srvsvc_NetServerSetServiceBitsEx,
19561                 false,
19562         },
19563         {
19564                 "srvsvc_NETRDFSGETVERSION",
19565                 sizeof(struct srvsvc_NETRDFSGETVERSION),
19566                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSGETVERSION,
19567                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSGETVERSION,
19568                 (ndr_print_function_t) ndr_print_srvsvc_NETRDFSGETVERSION,
19569                 false,
19570         },
19571         {
19572                 "srvsvc_NETRDFSCREATELOCALPARTITION",
19573                 sizeof(struct srvsvc_NETRDFSCREATELOCALPARTITION),
19574                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSCREATELOCALPARTITION,
19575                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSCREATELOCALPARTITION,
19576                 (ndr_print_function_t) ndr_print_srvsvc_NETRDFSCREATELOCALPARTITION,
19577                 false,
19578         },
19579         {
19580                 "srvsvc_NETRDFSDELETELOCALPARTITION",
19581                 sizeof(struct srvsvc_NETRDFSDELETELOCALPARTITION),
19582                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSDELETELOCALPARTITION,
19583                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSDELETELOCALPARTITION,
19584                 (ndr_print_function_t) ndr_print_srvsvc_NETRDFSDELETELOCALPARTITION,
19585                 false,
19586         },
19587         {
19588                 "srvsvc_NETRDFSSETLOCALVOLUMESTATE",
19589                 sizeof(struct srvsvc_NETRDFSSETLOCALVOLUMESTATE),
19590                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSSETLOCALVOLUMESTATE,
19591                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSSETLOCALVOLUMESTATE,
19592                 (ndr_print_function_t) ndr_print_srvsvc_NETRDFSSETLOCALVOLUMESTATE,
19593                 false,
19594         },
19595         {
19596                 "srvsvc_NETRDFSSETSERVERINFO",
19597                 sizeof(struct srvsvc_NETRDFSSETSERVERINFO),
19598                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSSETSERVERINFO,
19599                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSSETSERVERINFO,
19600                 (ndr_print_function_t) ndr_print_srvsvc_NETRDFSSETSERVERINFO,
19601                 false,
19602         },
19603         {
19604                 "srvsvc_NETRDFSCREATEEXITPOINT",
19605                 sizeof(struct srvsvc_NETRDFSCREATEEXITPOINT),
19606                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSCREATEEXITPOINT,
19607                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSCREATEEXITPOINT,
19608                 (ndr_print_function_t) ndr_print_srvsvc_NETRDFSCREATEEXITPOINT,
19609                 false,
19610         },
19611         {
19612                 "srvsvc_NETRDFSDELETEEXITPOINT",
19613                 sizeof(struct srvsvc_NETRDFSDELETEEXITPOINT),
19614                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSDELETEEXITPOINT,
19615                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSDELETEEXITPOINT,
19616                 (ndr_print_function_t) ndr_print_srvsvc_NETRDFSDELETEEXITPOINT,
19617                 false,
19618         },
19619         {
19620                 "srvsvc_NETRDFSMODIFYPREFIX",
19621                 sizeof(struct srvsvc_NETRDFSMODIFYPREFIX),
19622                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSMODIFYPREFIX,
19623                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSMODIFYPREFIX,
19624                 (ndr_print_function_t) ndr_print_srvsvc_NETRDFSMODIFYPREFIX,
19625                 false,
19626         },
19627         {
19628                 "srvsvc_NETRDFSFIXLOCALVOLUME",
19629                 sizeof(struct srvsvc_NETRDFSFIXLOCALVOLUME),
19630                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSFIXLOCALVOLUME,
19631                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSFIXLOCALVOLUME,
19632                 (ndr_print_function_t) ndr_print_srvsvc_NETRDFSFIXLOCALVOLUME,
19633                 false,
19634         },
19635         {
19636                 "srvsvc_NETRDFSMANAGERREPORTSITEINFO",
19637                 sizeof(struct srvsvc_NETRDFSMANAGERREPORTSITEINFO),
19638                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSMANAGERREPORTSITEINFO,
19639                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSMANAGERREPORTSITEINFO,
19640                 (ndr_print_function_t) ndr_print_srvsvc_NETRDFSMANAGERREPORTSITEINFO,
19641                 false,
19642         },
19643         {
19644                 "srvsvc_NETRSERVERTRANSPORTDELEX",
19645                 sizeof(struct srvsvc_NETRSERVERTRANSPORTDELEX),
19646                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRSERVERTRANSPORTDELEX,
19647                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRSERVERTRANSPORTDELEX,
19648                 (ndr_print_function_t) ndr_print_srvsvc_NETRSERVERTRANSPORTDELEX,
19649                 false,
19650         },
19651         { NULL, 0, NULL, NULL, NULL, false }
19652 };
19653
19654 static const char * const srvsvc_endpoint_strings[] = {
19655         "ncacn_np:[\\pipe\\srvsvc]",
19656         "ncacn_ip_tcp:",
19657         "ncalrpc:",
19658 };
19659
19660 static const struct ndr_interface_string_array srvsvc_endpoints = {
19661         .count  = 3,
19662         .names  = srvsvc_endpoint_strings
19663 };
19664
19665 static const char * const srvsvc_authservice_strings[] = {
19666         "host",
19667 };
19668
19669 static const struct ndr_interface_string_array srvsvc_authservices = {
19670         .count  = 1,
19671         .names  = srvsvc_authservice_strings
19672 };
19673
19674
19675 const struct ndr_interface_table ndr_table_srvsvc = {
19676         .name           = "srvsvc",
19677         .syntax_id      = {
19678                 {0x4b324fc8,0x1670,0x01d3,{0x12,0x78},{0x5a,0x47,0xbf,0x6e,0xe1,0x88}},
19679                 NDR_SRVSVC_VERSION
19680         },
19681         .helpstring     = NDR_SRVSVC_HELPSTRING,
19682         .num_calls      = 54,
19683         .calls          = srvsvc_calls,
19684         .endpoints      = &srvsvc_endpoints,
19685         .authservices   = &srvsvc_authservices
19686 };
19687